diff --git a/CHANGELOG.md b/CHANGELOG.md index 05a914d9a..aa4398f2a 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,3 +1,107 @@ +# 2024-11-02 version 7.0.0 + * Refine build system (#1133) + * Refine CI (#1122) + * Refine documents (#1117) +## << breaking changes >> + * Revert double and fload packing behavior (#1144) + * If below decimal point is zero (e.g. 2.00), + * Before: pack as int format family `0x02` + * After : pack as float format family `0xcb 0x40 0x00 0x00 0x00 0x00 0x00 0x00 0x00` + +# 2024-04-02 version 6.1.1 + * Fix compilation error when std::variant has the same types (#1112) + * Improve CI (#1090, #1110) + * Fix to avoid common function name's (has_as::check) ambiguity/conflict with other libraries' macros (#1085) + +# 2023-07-08 version 6.1.0 + * Remove dependency on boost in chrono.hpp (#1076) + * Add support for std::variant behavior (#1075) + * Fix msgpack::type::variant behavior to respect MessagePack format (#1071) + * Add rebind allocators (#1065) + +# 2023-03-02 version 6.0.0 +## << breaking changes >> + * Change CMake package name of C++ library to msgpack-cxx (#1054) + Unified all C++ package, library, cmake, tarball name become msgpack-cxx. + +# 2023-01-10 version 5.0.0 for C++ + * Fix config for new MSVC preprocessor (#1040) +## << breaking changes >> + * Change CMake package name of C++ library to msgpackc-cxx (#1045, #1048) + +# 2022-11-02 version 4.1.3 for C++ + * Fix compile error that direct inclusion of chrono with `MSGPACK_NO_BOOST` (#1038)) + +# 2022-09-07 version 4.1.2 for C++ + * Fix noexcept on zone (#1030) + * Improve cmake support (#1028, #1032) + * Improve CI (#1023) + * Improve supporting platform (#1021) + * Refine double/float packing (#1018) + * Refine include files dependency (#1011) + +# 2022-03-09 version 4.1.1 for C++ + * Remove chrono support on `MSGPACK_NO_BOOST` to fix compile error. + * Improve build system (#1003) + +# 2022-02-12 version 4.1.0 for C++ + * Add experimental support for no boost dependency (#1001) + * For cmake, add `-DMSGPACK_USE_BOOST=OFF`. For C++ compiler add `-DMSGPACK_NO_BOOST`. + * Improve BIN console output (#995) + * Fix include notation (#991) + +# 2021-10-23 version 4.0.3 for C++ + * Remove Enabler2 template parameter from object adaptor (#987) + * Add MSGPACK_BUILD_DOCS cmake option (#983, #984) + +# 2021-08-31 version 4.0.2 for C++ + * Fix fuzzer interface function name (#972) + * Fix boost test link error and support both dynamin(default) and static link boost (#971) + +# 2021-08-30 version 4.0.1 for C++ + * Fix release tarball and its generation script (#967) + +# 2021-08-29 version 4.0.0 for C++ + * Improve zone alignment logic (#965) + * Fix v1 unpack logic for STR and BIN (#957, #951) + * Fix UB on memcmp with size 0 (#954) + * Fix `iovec` name conflict (#952) + * Add `std::array` `std::span` `std::span` `std::span` adaptors (#951) + * Improve documents (#918, #919, #951) + * Improve tests (#916) + * Introduce BOOST_ASSERT (#898) + * Improve build system (#897, #905, #924, #951) + * Improve Boost.Fusion support (#894) + * Check nullptr before call memcpy (#891) + * Refine and bugfix `std::chrono::time_point` adaptor (#888, #893) + * Improve CI (#884, #892, #895, #951, #955) +## << breaking changes >> + * Separate C++ part of the msgpack-c from C/C++ mixed msgpack-c (#876, #878) + * Require boost libraries. See README.md Dependency(#912) + +# 2020-06-05 version 3.3.0 + * Add json example for C (#870) + * Add both header and body packing functions for C (#870) + * Set default ref_size and chunk_size to vrefbuffer (#865) + * Add examples (#861) + * Improve build system (#839, #842) + * Improve tests (#829) + * Improve documents (#828) + * Remove some warnings (#827, #851, #871) + * Improve CI environment (#824, #831, #833, #834, #846, #860, 874) + +# 2019-12-10 version 3.2.1 + * Fix snprintf return value checking (#821) + * Remove some warnings (#819) + * Fix fbuffer result checking (#812) + * Fix temporary object handling (#807) + * Improve cmake support (#804) + * Fix invalid `int main` parameter (#800) + * Improve supporting platform (#797, #817) + * Fix ZLIB error handling (#795) + * Remove unused variable (#793) + * Improve integer overflow checking (#792) + # 2019-05-27 version 3.2.0 * Fix invalid include (#783) diff --git a/CMakeLists.txt b/CMakeLists.txt index 36236370b..a6dd2bcd1 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -1,13 +1,18 @@ -CMAKE_MINIMUM_REQUIRED (VERSION 2.8.12) +if(${CMAKE_VERSION} VERSION_GREATER "3.4") + CMAKE_MINIMUM_REQUIRED (VERSION 3.5) +else() + CMAKE_MINIMUM_REQUIRED (VERSION 2.8.12) + IF ((CMAKE_VERSION VERSION_GREATER 3.1) OR + (CMAKE_VERSION VERSION_EQUAL 3.1)) + CMAKE_POLICY(SET CMP0054 NEW) + ENDIF () +endif() -IF ((CMAKE_VERSION VERSION_GREATER 3.1) OR - (CMAKE_VERSION VERSION_EQUAL 3.1)) - CMAKE_POLICY(SET CMP0054 NEW) -ENDIF () +PROJECT (msgpack-cxx LANGUAGES CXX) -PROJECT (msgpack) +ADD_LIBRARY (msgpack-cxx INTERFACE) -FILE (READ ${CMAKE_CURRENT_SOURCE_DIR}/include/msgpack/version_master.h contents) +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}) SET (VERSION_MAJOR ${CMAKE_MATCH_1}) STRING (REGEX MATCH "#define MSGPACK_VERSION_MINOR *([0-9a-zA-Z_]*)" NULL_OUT ${contents}) @@ -16,177 +21,96 @@ STRING (REGEX MATCH "#define MSGPACK_VERSION_REVISION *([0-9a-zA-Z_]*)" NULL_OUT SET (VERSION_REVISION ${CMAKE_MATCH_1}) SET (VERSION ${VERSION_MAJOR}.${VERSION_MINOR}.${VERSION_REVISION}) -SET (prefix ${CMAKE_INSTALL_PREFIX}) -SET (exec_prefix "\${prefix}") -SET (libdir "\${exec_prefix}/lib") -SET (includedir "\${prefix}/include") +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_BOOST "Using boost libraries" OFF) - -IF (APPLE) - SET(CMAKE_MACOSX_RPATH ON) - SET(CMAKE_SKIP_BUILD_RPATH FALSE) - SET(CMAKE_BUILD_WITH_INSTALL_RPATH FALSE) - SET(CMAKE_INSTALL_RPATH "${CMAKE_INSTALL_PREFIX}/lib") - SET(CMAKE_INSTALL_RPATH_USE_LINK_PATH TRUE) - LIST(FIND CMAKE_PLATFORM_IMPLICIT_LINK_DIRECTORIES "${CMAKE_INSTALL_PREFIX}/lib" isSystemDir) - IF ("${isSystemDir}" STREQUAL "-1") - SET(CMAKE_INSTALL_RPATH "${CMAKE_INSTALL_PREFIX}/lib") +OPTION (MSGPACK_CXX11 "Using c++11 compiler" ON) +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_BOOST "Use Boost libraried" ON) +OPTION (MSGPACK_USE_X3_PARSE "Use Boost X3 parse" OFF) +OPTION (MSGPACK_BUILD_TESTS "Build tests" OFF) +OPTION (MSGPACK_BUILD_DOCS "Build Doxygen documentation" ON) +OPTION (MSGPACK_FUZZ_REGRESSION "Enable regression testing" OFF) +OPTION (MSGPACK_BUILD_EXAMPLES "Build msgpack examples" OFF) +OPTION (MSGPACK_GEN_COVERAGE "Generate coverage report" OFF) +OPTION (MSGPACK_USE_STATIC_BOOST "Statically link with boost libraries" OFF) +OPTION (MSGPACK_CHAR_SIGN "Char sign to use (signed or unsigned)") +OPTION (MSGPACK_USE_STD_VARIANT_ADAPTOR "Enable the adaptor for std::variant" OFF) + +SET (CMAKE_CXX_STANDARD_REQUIRED ON) + +IF (MSGPACK_USE_X3_PARSE) + 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_USE_X3_PARSE) - IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU") - SET (CMAKE_CXX_FLAGS "-DMSGPACK_USE_X3_PARSE -std=c++14 ${CMAKE_CXX_FLAGS}") - ELSEIF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "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 (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}" STREQUAL "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}" STREQUAL "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}" STREQUAL "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_C_FLAGS "-m32 ${CMAKE_C_FLAGS}") - SET (CMAKE_EXE_LINKER_FLAGS "-m32 ${CMAKE_EXE_LINKER_FLAGS}") - ELSEIF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang") - SET (CMAKE_CXX_FLAGS "-m32 ${CMAKE_CXX_FLAGS}") - SET (CMAKE_C_FLAGS "-m32 ${CMAKE_C_FLAGS}") - SET (CMAKE_EXE_LINKER_FLAGS "-m32 ${CMAKE_EXE_LINKER_FLAGS}") - ENDIF () + IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU") + TARGET_COMPILE_OPTIONS(msgpack-cxx INTERFACE -m32) + TARGET_LINK_OPTIONS(msgpack-cxx INTERFACE -m32) + ELSEIF ("${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang") + TARGET_COMPILE_OPTIONS(msgpack-cxx INTERFACE -m32) + TARGET_LINK_OPTIONS(msgpack-cxx INTERFACE -m32) + ENDIF () ENDIF () -OPTION (MSGPACK_BUILD_EXAMPLES "Build msgpack examples." ON) - -IF (MSGPACK_BOOST) - SET (CMAKE_CXX_FLAGS "-DMSGPACK_USE_BOOST ${CMAKE_CXX_FLAGS}") - SET (Boost_USE_MULTITHREADED ON) - SET (Boost_USE_STATIC_RUNTIME OFF) - FIND_PACKAGE (Boost REQUIRED COMPONENTS chrono context system timer) - INCLUDE_DIRECTORIES ( - ${Boost_INCLUDE_DIRS} - ) - LINK_DIRECTORIES ( - ${Boost_LIBRARY_DIRS} - ) - IF (MSGPACK_BOOST_DIR) - INCLUDE_DIRECTORIES ( - ${MSGPACK_BOOST_DIR} - ) - ENDIF () -ENDIF () +IF (MSGPACK_USE_BOOST) + IF ((CMAKE_VERSION VERSION_GREATER 3.30) OR + (CMAKE_VERSION VERSION_EQUAL 3.30)) + CMAKE_POLICY(SET CMP0167 NEW) + ENDIF () + SET (Boost_USE_MULTITHREADED ON) -IF (MSGPACK_CHAR_SIGN) - SET (CMAKE_C_FLAGS "-f${MSGPACK_CHAR_SIGN}-char ${CMAKE_C_FLAGS}") - SET (CMAKE_CXX_FLAGS "-f${MSGPACK_CHAR_SIGN}-char ${CMAKE_CXX_FLAGS}") -ENDIF () + IF (MSGPACK_USE_STATIC_BOOST) + MESSAGE (STATUS "Staticly linking with Boost") + SET (Boost_USE_STATIC_LIBS TRUE) + ELSE () + MESSAGE (STATUS "Dynamically linking with Boost") + SET (Boost_USE_STATIC_LIBS FALSE) + ENDIF () -IF (MSGPACK_DEFAULT_API_VERSION) - SET (CMAKE_CXX_FLAGS "-DMSGPACK_DEFAULT_API_VERSION=${MSGPACK_DEFAULT_API_VERSION} ${CMAKE_CXX_FLAGS}") + FIND_PACKAGE (Boost REQUIRED) ELSE () - SET (CMAKE_CXX_FLAGS "-DMSGPACK_DEFAULT_API_VERSION=3 ${CMAKE_CXX_FLAGS}") + TARGET_COMPILE_DEFINITIONS(msgpack-cxx INTERFACE MSGPACK_NO_BOOST) ENDIF () -FILE (GLOB_RECURSE PREDEF_FILES RELATIVE ${CMAKE_CURRENT_SOURCE_DIR}/external/boost/predef/include/boost ${CMAKE_CURRENT_SOURCE_DIR}/external/boost/predef/include/boost/*.h) -FOREACH (F ${PREDEF_FILES}) - SET(M "Converting ${F}") - MESSAGE(STATUS ${M}) - FILE (READ ${CMAKE_CURRENT_SOURCE_DIR}/external/boost/predef/include/boost/${F} CONTENT) - STRING(REPLACE "BOOST_" "MSGPACK_" CONTENT ${CONTENT}) - STRING(REPLACE "boost/" "msgpack/" CONTENT ${CONTENT}) - FILE (GENERATE OUTPUT ${CMAKE_CURRENT_SOURCE_DIR}/include/msgpack/${F} CONTENT ${CONTENT}) -ENDFOREACH () - -FILE (GLOB_RECURSE PREPROCESSOR_FILES RELATIVE ${CMAKE_CURRENT_SOURCE_DIR}/external/boost/preprocessor/include/boost ${CMAKE_CURRENT_SOURCE_DIR}/external/boost/preprocessor/include/boost/*.hpp) -FOREACH (F ${PREPROCESSOR_FILES}) - SET(M "Converting ${F}") - MESSAGE(STATUS ${M}) - FILE (READ ${CMAKE_CURRENT_SOURCE_DIR}/external/boost/preprocessor/include/boost/${F} CONTENT) - STRING(REPLACE "BOOST_" "MSGPACK_" CONTENT ${CONTENT}) - STRING(REPLACE "boost/" "msgpack/" CONTENT ${CONTENT}) - FILE (GENERATE OUTPUT ${CMAKE_CURRENT_SOURCE_DIR}/include/msgpack/${F} CONTENT ${CONTENT}) -ENDFOREACH () - -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) +IF (MSGPACK_CHAR_SIGN) + TARGET_COMPILE_OPTIONS(msgpack-cxx INTERFACE -f${MSGPACK_CHAR_SIGN}-char) ENDIF () -IF (DEFINED BUILD_SHARED_LIBS) - IF (BUILD_SHARED_LIBS) - IF (DEFINED MSGPACK_ENABLE_SHARED AND NOT MSGPACK_ENABLE_SHARED) - MESSAGE(WARNING "MSGPACK_ENABLE_SHARED is overridden to ON by BUILD_SHARED_LIBS") - ENDIF () - SET (MSGPACK_ENABLE_SHARED ON) - IF (DEFINED MSGPACK_ENABLE_STATIC AND MSGPACK_ENABLE_STATIC) - MESSAGE(WARNING "MSGPACK_ENABLE_STATIC is overridden to OFF by BUILD_SHARED_LIBS") - ENDIF () - SET (MSGPACK_ENABLE_STATIC OFF) - ELSE () - IF (DEFINED MSGPACK_ENABLE_SHARED AND MSGPACK_ENABLE_SHARED) - MESSAGE(WARNING "MSGPACK_ENABLE_SHARED is overridden to OFF by BUILD_SHARED_LIBS") - ENDIF () - SET (MSGPACK_ENABLE_SHARED OFF) - IF (DEFINED MSGPACK_ENABLE_STATIC AND NOT MSGPACK_ENABLE_STATIC) - MESSAGE(WARNING "MSGPACK_ENABLE_STATIC is overridden to ON by BUILD_SHARED_LIBS") - ENDIF () - SET (MSGPACK_ENABLE_STATIC ON) - ENDIF () +IF (MSGPACK_DEFAULT_API_VERSION) + TARGET_COMPILE_DEFINITIONS(msgpack-cxx INTERFACE MSGPACK_DEFAULT_API_VERSION=${MSGPACK_DEFAULT_API_VERSION}) ELSE () - IF (NOT DEFINED MSGPACK_ENABLE_SHARED) - SET (MSGPACK_ENABLE_SHARED ON) - ENDIF () - IF (NOT DEFINED MSGPACK_ENABLE_STATIC) - SET (MSGPACK_ENABLE_STATIC ON) - ENDIF () + SET (MSGPACK_DEFAULT_API_VERSION 3) + TARGET_COMPILE_DEFINITIONS(msgpack-cxx INTERFACE MSGPACK_DEFAULT_API_VERSION=3) ENDIF () -OPTION (MSGPACK_ENABLE_CXX "Enable C++ interface." ON) +IF (MSGPACK_USE_STD_VARIANT_ADAPTOR) + TARGET_COMPILE_DEFINITIONS(msgpack-cxx INTERFACE MSGPACK_USE_STD_VARIANT_ADAPTOR) +ENDIF () -INCLUDE (CheckCXXSourceCompiles) -CHECK_CXX_SOURCE_COMPILES (" +IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU") + IF (CMAKE_CXX_COMPILER_VERSION VERSION_LESS 4.1) + INCLUDE (CheckCXXSourceCompiles) + CHECK_CXX_SOURCE_COMPILES (" #include int atomic_sub(int i) { return __gnu_cxx::__exchange_and_add(&i, -1) - 1; } int atomic_add(int i) { return __gnu_cxx::__exchange_and_add(&i, 1) + 1; } @@ -195,256 +119,150 @@ int main(int argc, char * argv[]) atomic_sub(1); atomic_add(1); } -" MSGPACK_ENABLE_GCC_CXX_ATOMIC) +" + MSGPACK_ENABLE_GCC_CXX_ATOMIC) + ENDIF () +ENDIF () -INCLUDE (Files.cmake) -EXECUTE_PROCESS ( - COMMAND ${CMAKE_COMMAND} -E make_directory ${CMAKE_CURRENT_BINARY_DIR}/src/msgpack -) +INCLUDE (Files.cmake) -CONFIGURE_FILE ( - msgpack.pc.in - msgpack.pc - @ONLY +TARGET_INCLUDE_DIRECTORIES (msgpack-cxx + INTERFACE + $ + $ + $ ) -IF (MSGPACK_ENABLE_SHARED) - ADD_LIBRARY (msgpackc SHARED - ${msgpackc_SOURCES} - ${msgpackc_HEADERS} - ) - - SET_TARGET_PROPERTIES (msgpackc PROPERTIES SOVERSION 2 VERSION 2.0.0) - - TARGET_INCLUDE_DIRECTORIES (msgpackc - PUBLIC - $ - $ - $ - PRIVATE - ${CMAKE_CURRENT_SOURCE_DIR} - ) -ENDIF () - -IF (MSGPACK_ENABLE_CXX AND ((CMAKE_VERSION VERSION_GREATER 3.0) OR (CMAKE_VERSION VERSION_EQUAL 3.0))) - ADD_LIBRARY (msgpackc-cxx INTERFACE) - - TARGET_INCLUDE_DIRECTORIES (msgpackc-cxx - INTERFACE - $ - $ - $ - ) +IF (MSGPACK_USE_BOOST) + TARGET_LINK_LIBRARIES (msgpack-cxx INTERFACE Boost::boost) ENDIF () -IF (MSGPACK_ENABLE_STATIC) - ADD_LIBRARY (msgpackc-static STATIC - ${msgpackc_SOURCES} - ${msgpackc_HEADERS} - ) - - TARGET_INCLUDE_DIRECTORIES (msgpackc-static - PUBLIC - $ - $ - $ - PRIVATE - ${CMAKE_CURRENT_SOURCE_DIR} - ) - - IF (NOT MSGPACK_ENABLE_SHARED) - # Add alias for subdirectories - ADD_LIBRARY (msgpackc ALIAS msgpackc-static) +IF (MSGPACK_GEN_COVERAGE) + IF (NOT MSGPACK_BUILD_TESTS) + MESSAGE(FATAL_ERROR "Coverage requires -DMSGPACK_BUILD_TESTS=ON") ENDIF () - - SET_TARGET_PROPERTIES (msgpackc-static PROPERTIES OUTPUT_NAME "msgpackc") - - IF (MSGPACK_ENABLE_SHARED) - IF (MSVC) - SET_TARGET_PROPERTIES (msgpackc PROPERTIES IMPORT_SUFFIX "_import.lib") - ELSEIF (MINGW) - SET_TARGET_PROPERTIES (msgpackc PROPERTIES IMPORT_SUFFIX ".dll.a") - ENDIF () + 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") ENDIF () -ENDIF () -# enable regression testing -IF ("${MSGPACK_FUZZ_REGRESSION}" STREQUAL "ON" AND "${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang") - SET (CMAKE_CXX_FLAGS "-DMSGPACK_USE_BOOST ${CMAKE_CXX_FLAGS}") - SET (Boost_USE_MULTITHREADED ON) - SET (Boost_USE_STATIC_RUNTIME OFF) - - enable_testing () - ADD_SUBDIRECTORY (fuzz) - SET (MSGPACK_BUILD_EXAMPLES OFF) + INCLUDE (CodeCoverage) + SET (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${COVERAGE_FLAGS}") + SETUP_TARGET_FOR_COVERAGE(coverage make coverage test) ENDIF () - IF (MSGPACK_BUILD_TESTS) + IF (${CMAKE_CXX_STANDARD} EQUAL 98) + MESSAGE (FATAL_ERROR "Tests requires C++11 or newer") + ENDIF () + IF ((CMAKE_VERSION VERSION_GREATER 3.27) OR + (CMAKE_VERSION VERSION_EQUAL 3.27)) + CMAKE_POLICY(SET CMP0145 OLD) + ENDIF () + IF (NOT MSGPACK_USE_BOOST) + MESSAGE(FATAL_ERROR "Test requires -DMSGPACK_USE_BOOST=ON") + ENDIF () 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 "Clang" OR "${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU") - IF (MSGPACK_ENABLE_SHARED) - SET_PROPERTY (TARGET msgpackc APPEND_STRING PROPERTY COMPILE_FLAGS " -Wall -Wextra -DPIC") - ENDIF () - IF (MSGPACK_ENABLE_STATIC) - SET_PROPERTY (TARGET msgpackc-static APPEND_STRING PROPERTY COMPILE_FLAGS " -Wall -Wextra" ) - ENDIF () -ENDIF () - -IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang") - IF (MSGPACK_ENABLE_SHARED) - SET_PROPERTY (TARGET msgpackc APPEND_STRING PROPERTY COMPILE_FLAGS " -Wno-mismatched-tags") - ENDIF () - IF (MSGPACK_ENABLE_STATIC) - SET_PROPERTY (TARGET msgpackc-static APPEND_STRING PROPERTY COMPILE_FLAGS " -Wno-mismatched-tags") - ENDIF () -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 () -ENDIF () - -IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC90" OR "${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC10") - SET_SOURCE_FILES_PROPERTIES(${msgpackc_SOURCES} PROPERTIES LANGUAGE CXX) +# enable regression testing +IF (MSGPACK_FUZZ_REGRESSION) + ENABLE_TESTING () + ADD_SUBDIRECTORY (fuzz) ENDIF () IF ("${CMAKE_SYSTEM_PROCESSOR}" STREQUAL "sparc") - SET (CMAKE_C_FLAGS "-DMSGPACK_ZONE_ALIGN=8 ${CMAKE_C_FLAGS}") - SET (CMAKE_CXX_FLAGS "-DMSGPACK_ZONE_ALIGN=8 ${CMAKE_CXX_FLAGS}") -ENDIF () - -IF (NOT DEFINED CMAKE_INSTALL_BINDIR) - SET(CMAKE_INSTALL_BINDIR bin) -ENDIF () - -IF (NOT DEFINED CMAKE_INSTALL_LIBDIR) - SET(CMAKE_INSTALL_LIBDIR lib) + TARGET_COMPILE_DEFINITIONS(msgpack-cxx INTERFACE MSGPACK_ZONE_ALIGN=8) ENDIF () IF (MSGPACK_BUILD_EXAMPLES) ADD_SUBDIRECTORY (example) ENDIF () -IF (MSGPACK_ENABLE_SHARED) - SET (MSGPACK_INSTALLTARGETS msgpackc) -ENDIF () - -IF (MSGPACK_ENABLE_CXX AND ((CMAKE_VERSION VERSION_GREATER 3.0) OR (CMAKE_VERSION VERSION_EQUAL 3.0))) - LIST (APPEND MSGPACK_INSTALLTARGETS msgpackc-cxx) -ENDIF () - -IF (MSGPACK_ENABLE_STATIC) - LIST (APPEND MSGPACK_INSTALLTARGETS msgpackc-static) -ENDIF () - -INSTALL (TARGETS ${MSGPACK_INSTALLTARGETS} EXPORT msgpack-targets - RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR} - LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR} - ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR} -) -FOREACH (file ${msgpackc_HEADERS}) - GET_FILENAME_COMPONENT (dir ${file} PATH) - INSTALL (FILES ${file} DESTINATION ${CMAKE_INSTALL_PREFIX}/${dir}) -ENDFOREACH () -IF (NOT MSVC) - INSTALL (FILES ${CMAKE_CURRENT_BINARY_DIR}/msgpack.pc DESTINATION ${CMAKE_INSTALL_LIBDIR}/pkgconfig) -ENDIF () - # Doxygen -FIND_PACKAGE (Doxygen) -IF (DOXYGEN_FOUND) - LIST (APPEND Doxyfile_c_CONTENT - COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_CURRENT_SOURCE_DIR}/Doxyfile ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile_c - COMMAND ${CMAKE_COMMAND} -E echo "FILE_PATTERNS = *.h" >> ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile_c - COMMAND ${CMAKE_COMMAND} -E echo "OUTPUT_DIRECTORY = doc_c" >> ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile_c - COMMAND ${CMAKE_COMMAND} -E echo "INPUT = ${CMAKE_CURRENT_SOURCE_DIR}/include" >> ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile_c - COMMAND ${CMAKE_COMMAND} -E echo "EXTRACT_ALL = YES" >> ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile_c - COMMAND ${CMAKE_COMMAND} -E echo "PROJECT_NAME = \"MessagePack for C\"" >> ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile_c - COMMAND ${CMAKE_COMMAND} -E echo "STRIP_FROM_PATH = ${CMAKE_CURRENT_SOURCE_DIR}/include" >> ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile_c - ) - IF (DOXYGEN_DOT_FOUND) - LIST (APPEND Doxyfile_c_CONTENT - COMMAND ${CMAKE_COMMAND} -E echo "HAVE_DOT = YES" >> ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile_c - ) - ENDIF () - ADD_CUSTOM_TARGET ( - doxygen_c - ${Doxyfile_c_CONTENT} - COMMAND ${DOXYGEN_EXECUTABLE} ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile_c - VERBATIM - ) - LIST (APPEND Doxyfile_cpp_CONTENT - COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_CURRENT_SOURCE_DIR}/Doxyfile ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile_cpp - COMMAND ${CMAKE_COMMAND} -E echo "FILE_PATTERNS = *.hpp" >> ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile_cpp - COMMAND ${CMAKE_COMMAND} -E echo "OUTPUT_DIRECTORY = doc_cpp" >> ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile_cpp - COMMAND ${CMAKE_COMMAND} -E echo "INPUT = ${CMAKE_CURRENT_SOURCE_DIR}/include" >> ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile_cpp - COMMAND ${CMAKE_COMMAND} -E echo "EXTRACT_ALL = YES" >> ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile_cpp - COMMAND ${CMAKE_COMMAND} -E echo "STRIP_FROM_PATH = ${CMAKE_CURRENT_SOURCE_DIR}/include" >> ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile_cpp - ) - IF (DOXYGEN_DOT_FOUND) +IF (MSGPACK_BUILD_DOCS) + FIND_PACKAGE (Doxygen) + IF (DOXYGEN_FOUND) LIST (APPEND Doxyfile_cpp_CONTENT - COMMAND ${CMAKE_COMMAND} -E echo "HAVE_DOT = YES" >> ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile_cpp + COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_CURRENT_SOURCE_DIR}/Doxyfile ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile_cpp + COMMAND ${CMAKE_COMMAND} -E echo "FILE_PATTERNS = *.hpp" >> ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile_cpp + COMMAND ${CMAKE_COMMAND} -E echo "OUTPUT_DIRECTORY = doc_cpp" >> ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile_cpp + COMMAND ${CMAKE_COMMAND} -E echo "INPUT = ${CMAKE_CURRENT_SOURCE_DIR}/include" >> ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile_cpp + COMMAND ${CMAKE_COMMAND} -E echo "EXTRACT_ALL = YES" >> ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile_cpp + COMMAND ${CMAKE_COMMAND} -E echo "STRIP_FROM_PATH = ${CMAKE_CURRENT_SOURCE_DIR}/include" >> ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile_cpp + ) + IF (DOXYGEN_DOT_FOUND) + LIST (APPEND Doxyfile_cpp_CONTENT + COMMAND ${CMAKE_COMMAND} -E echo "HAVE_DOT = YES" >> ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile_cpp + ) + ENDIF () + ADD_CUSTOM_TARGET ( + doxygen + ${Doxyfile_cpp_CONTENT} + COMMAND ${CMAKE_COMMAND} -E echo "PROJECT_NAME = \"MessagePack for C++\"" >> ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile_cpp + COMMAND ${DOXYGEN_EXECUTABLE} ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile_cpp + VERBATIM ) ENDIF () - ADD_CUSTOM_TARGET ( - doxygen_cpp - ${Doxyfile_cpp_CONTENT} - COMMAND ${CMAKE_COMMAND} -E echo "PROJECT_NAME = \"MessagePack for C++\"" >> ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile_cpp - COMMAND ${DOXYGEN_EXECUTABLE} ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile_cpp - VERBATIM - ) - ADD_CUSTOM_TARGET ( - doxygen - DEPENDS doxygen_c doxygen_cpp - ) ENDIF () +include (GNUInstallDirs) + +# Install library. +INSTALL (TARGETS msgpack-cxx + EXPORT msgpack-cxx-targets + COMPONENT msgpack-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 msgpack-cxx +) + INCLUDE (CMakePackageConfigHelpers) -SET (CMAKE_INSTALL_CMAKEDIR "${CMAKE_INSTALL_LIBDIR}/cmake/msgpack") +IF (NOT (CMAKE_VERSION VERSION_LESS 3.14)) + SET (extra_version_file_args ARCH_INDEPENDENT) +ENDIF () +SET (cmake_config_path "${CMAKE_INSTALL_LIBDIR}/cmake/msgpack-cxx") + +# Configure the main package file from source tree. +CONFIGURE_PACKAGE_CONFIG_FILE ( + msgpack-cxx-config.cmake.in + "${CMAKE_CURRENT_BINARY_DIR}/msgpack-cxx-config.cmake" + INSTALL_DESTINATION "${cmake_config_path}" +) +# Write package version file. WRITE_BASIC_PACKAGE_VERSION_FILE ( - msgpack-config-version.cmake + msgpack-cxx-config-version.cmake VERSION ${VERSION} COMPATIBILITY SameMajorVersion + ${extra_version_file_args} ) -# IF (NOT CMAKE_VERSION VERSION_LESS 3.0) -# EXPORT (EXPORT msgpack-targets -# NAMESPACE Msgpack:: -# FILE "${CMAKE_CURRENT_BINARY_DIR}/msgpack-targets.cmake" -# ) -# ENDIF () - -CONFIGURE_PACKAGE_CONFIG_FILE (msgpack-config.cmake.in - msgpack-config.cmake - INSTALL_DESTINATION "${CMAKE_INSTALL_CMAKEDIR}" -) - -INSTALL (EXPORT msgpack-targets - NAMESPACE Msgpack:: - FILE - msgpack-targets.cmake - DESTINATION - "${CMAKE_INSTALL_CMAKEDIR}" +# Install the generated package version file and the main package file. +INSTALL (FILES + "${CMAKE_CURRENT_BINARY_DIR}/msgpack-cxx-config.cmake" + "${CMAKE_CURRENT_BINARY_DIR}/msgpack-cxx-config-version.cmake" + DESTINATION "${cmake_config_path}" + COMPONENT msgpack-cxx ) +# This installs package in install tree for using installed targets. INSTALL ( - FILES - "${CMAKE_CURRENT_BINARY_DIR}/msgpack-config.cmake" - "${CMAKE_CURRENT_BINARY_DIR}/msgpack-config-version.cmake" - DESTINATION - "${CMAKE_INSTALL_CMAKEDIR}" + EXPORT msgpack-cxx-targets + FILE msgpack-cxx-targets.cmake + DESTINATION "${cmake_config_path}" + COMPONENT msgpack-cxx ) diff --git a/Files.cmake b/Files.cmake index e23a18d10..721a31fbf 100644 --- a/Files.cmake +++ b/Files.cmake @@ -1,18 +1,98 @@ -LIST (APPEND msgpackc_SOURCES - src/objectc.c - src/unpack.c - src/version.c - src/vrefbuffer.c - src/zone.c -) -LIST (APPEND msgpackc_HEADERS - include/msgpack.h - include/msgpack/fbuffer.h - include/msgpack/gcc_atomic.h - include/msgpack/object.h - include/msgpack/pack.h - include/msgpack/pack_define.h - include/msgpack/pack_template.h +SET (msgpack-cxx_HEADERS + include/msgpack.hpp + include/msgpack/adaptor/adaptor_base.hpp + include/msgpack/adaptor/adaptor_base_decl.hpp + include/msgpack/adaptor/array_ref.hpp + include/msgpack/adaptor/array_ref_decl.hpp + include/msgpack/adaptor/bool.hpp + include/msgpack/adaptor/boost/fusion.hpp + include/msgpack/adaptor/boost/msgpack_variant.hpp + include/msgpack/adaptor/boost/msgpack_variant_decl.hpp + include/msgpack/adaptor/boost/optional.hpp + include/msgpack/adaptor/boost/string_ref.hpp + include/msgpack/adaptor/boost/string_view.hpp + include/msgpack/adaptor/carray.hpp + include/msgpack/adaptor/char_ptr.hpp + include/msgpack/adaptor/check_container_size.hpp + include/msgpack/adaptor/check_container_size_decl.hpp + include/msgpack/adaptor/complex.hpp + include/msgpack/adaptor/cpp11/array.hpp + include/msgpack/adaptor/cpp11/array_char.hpp + include/msgpack/adaptor/cpp11/array_unsigned_char.hpp + include/msgpack/adaptor/cpp11/chrono.hpp + include/msgpack/adaptor/cpp11/forward_list.hpp + include/msgpack/adaptor/cpp11/reference_wrapper.hpp + include/msgpack/adaptor/cpp11/shared_ptr.hpp + include/msgpack/adaptor/cpp11/timespec.hpp + include/msgpack/adaptor/cpp11/tuple.hpp + 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/variant.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 + include/msgpack/adaptor/ext.hpp + include/msgpack/adaptor/ext_decl.hpp + include/msgpack/adaptor/fixint.hpp + include/msgpack/adaptor/fixint_decl.hpp + include/msgpack/adaptor/float.hpp + include/msgpack/adaptor/int.hpp + include/msgpack/adaptor/int_decl.hpp + include/msgpack/adaptor/list.hpp + include/msgpack/adaptor/map.hpp + include/msgpack/adaptor/map_decl.hpp + include/msgpack/adaptor/msgpack_tuple.hpp + include/msgpack/adaptor/msgpack_tuple_decl.hpp + include/msgpack/adaptor/nil.hpp + include/msgpack/adaptor/nil_decl.hpp + include/msgpack/adaptor/pair.hpp + include/msgpack/adaptor/raw.hpp + include/msgpack/adaptor/raw_decl.hpp + include/msgpack/adaptor/set.hpp + include/msgpack/adaptor/size_equal_only.hpp + include/msgpack/adaptor/size_equal_only_decl.hpp + include/msgpack/adaptor/string.hpp + include/msgpack/adaptor/tr1/unordered_map.hpp + include/msgpack/adaptor/tr1/unordered_set.hpp + include/msgpack/adaptor/v4raw.hpp + include/msgpack/adaptor/v4raw_decl.hpp + include/msgpack/adaptor/vector.hpp + include/msgpack/adaptor/vector_bool.hpp + include/msgpack/adaptor/vector_char.hpp + include/msgpack/adaptor/vector_unsigned_char.hpp + include/msgpack/adaptor/wstring.hpp + include/msgpack/assert.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 + include/msgpack/fbuffer_decl.hpp + include/msgpack/gcc_atomic.hpp + include/msgpack/iterator.hpp + include/msgpack/iterator_decl.hpp + include/msgpack/meta.hpp + include/msgpack/meta_decl.hpp + include/msgpack/null_visitor.hpp + include/msgpack/null_visitor_decl.hpp + include/msgpack/object.hpp + include/msgpack/object_decl.hpp + include/msgpack/object_fwd.hpp + include/msgpack/object_fwd_decl.hpp + include/msgpack/pack.hpp + include/msgpack/pack_decl.hpp + include/msgpack/parse.hpp + include/msgpack/parse_decl.hpp + include/msgpack/parse_return.hpp include/msgpack/predef.h include/msgpack/predef/architecture.h include/msgpack/predef/architecture/alpha.h @@ -152,601 +232,503 @@ LIST (APPEND msgpackc_HEADERS include/msgpack/predef/platform/windows_uwp.h include/msgpack/predef/version.h include/msgpack/predef/version_number.h - include/msgpack/sbuffer.h - include/msgpack/sysdep.h - include/msgpack/timestamp.h - include/msgpack/unpack.h - include/msgpack/unpack_define.h - include/msgpack/unpack_template.h - include/msgpack/util.h - include/msgpack/version.h - include/msgpack/version_master.h - include/msgpack/vrefbuffer.h - include/msgpack/zbuffer.h - include/msgpack/zone.h + include/msgpack/preprocessor.hpp + include/msgpack/preprocessor/arithmetic.hpp + include/msgpack/preprocessor/arithmetic/add.hpp + include/msgpack/preprocessor/arithmetic/dec.hpp + include/msgpack/preprocessor/arithmetic/detail/div_base.hpp + include/msgpack/preprocessor/arithmetic/div.hpp + include/msgpack/preprocessor/arithmetic/inc.hpp + include/msgpack/preprocessor/arithmetic/mod.hpp + include/msgpack/preprocessor/arithmetic/mul.hpp + include/msgpack/preprocessor/arithmetic/sub.hpp + include/msgpack/preprocessor/array.hpp + include/msgpack/preprocessor/array/data.hpp + include/msgpack/preprocessor/array/detail/get_data.hpp + include/msgpack/preprocessor/array/elem.hpp + include/msgpack/preprocessor/array/enum.hpp + include/msgpack/preprocessor/array/insert.hpp + include/msgpack/preprocessor/array/pop_back.hpp + include/msgpack/preprocessor/array/pop_front.hpp + include/msgpack/preprocessor/array/push_back.hpp + include/msgpack/preprocessor/array/push_front.hpp + include/msgpack/preprocessor/array/remove.hpp + include/msgpack/preprocessor/array/replace.hpp + include/msgpack/preprocessor/array/reverse.hpp + include/msgpack/preprocessor/array/size.hpp + include/msgpack/preprocessor/array/to_list.hpp + include/msgpack/preprocessor/array/to_seq.hpp + include/msgpack/preprocessor/array/to_tuple.hpp + include/msgpack/preprocessor/assert_msg.hpp + include/msgpack/preprocessor/cat.hpp + include/msgpack/preprocessor/comma.hpp + include/msgpack/preprocessor/comma_if.hpp + include/msgpack/preprocessor/comparison.hpp + include/msgpack/preprocessor/comparison/equal.hpp + include/msgpack/preprocessor/comparison/greater.hpp + include/msgpack/preprocessor/comparison/greater_equal.hpp + include/msgpack/preprocessor/comparison/less.hpp + include/msgpack/preprocessor/comparison/less_equal.hpp + include/msgpack/preprocessor/comparison/not_equal.hpp + include/msgpack/preprocessor/config/config.hpp + include/msgpack/preprocessor/config/limits.hpp + include/msgpack/preprocessor/control.hpp + include/msgpack/preprocessor/control/deduce_d.hpp + include/msgpack/preprocessor/control/detail/dmc/while.hpp + include/msgpack/preprocessor/control/detail/edg/while.hpp + include/msgpack/preprocessor/control/detail/msvc/while.hpp + include/msgpack/preprocessor/control/detail/while.hpp + include/msgpack/preprocessor/control/expr_if.hpp + include/msgpack/preprocessor/control/expr_iif.hpp + include/msgpack/preprocessor/control/if.hpp + include/msgpack/preprocessor/control/iif.hpp + include/msgpack/preprocessor/control/while.hpp + include/msgpack/preprocessor/debug.hpp + include/msgpack/preprocessor/debug/assert.hpp + include/msgpack/preprocessor/debug/error.hpp + include/msgpack/preprocessor/debug/line.hpp + include/msgpack/preprocessor/dec.hpp + include/msgpack/preprocessor/detail/auto_rec.hpp + include/msgpack/preprocessor/detail/check.hpp + include/msgpack/preprocessor/detail/dmc/auto_rec.hpp + include/msgpack/preprocessor/detail/is_binary.hpp + include/msgpack/preprocessor/detail/is_nullary.hpp + include/msgpack/preprocessor/detail/is_unary.hpp + include/msgpack/preprocessor/detail/null.hpp + include/msgpack/preprocessor/detail/split.hpp + include/msgpack/preprocessor/empty.hpp + include/msgpack/preprocessor/enum.hpp + include/msgpack/preprocessor/enum_params.hpp + include/msgpack/preprocessor/enum_params_with_a_default.hpp + include/msgpack/preprocessor/enum_params_with_defaults.hpp + include/msgpack/preprocessor/enum_shifted.hpp + include/msgpack/preprocessor/enum_shifted_params.hpp + include/msgpack/preprocessor/expand.hpp + include/msgpack/preprocessor/expr_if.hpp + include/msgpack/preprocessor/facilities.hpp + include/msgpack/preprocessor/facilities/apply.hpp + include/msgpack/preprocessor/facilities/detail/is_empty.hpp + include/msgpack/preprocessor/facilities/empty.hpp + include/msgpack/preprocessor/facilities/expand.hpp + include/msgpack/preprocessor/facilities/identity.hpp + include/msgpack/preprocessor/facilities/intercept.hpp + include/msgpack/preprocessor/facilities/is_1.hpp + include/msgpack/preprocessor/facilities/is_empty.hpp + include/msgpack/preprocessor/facilities/is_empty_or_1.hpp + include/msgpack/preprocessor/facilities/is_empty_variadic.hpp + include/msgpack/preprocessor/facilities/overload.hpp + include/msgpack/preprocessor/for.hpp + include/msgpack/preprocessor/identity.hpp + include/msgpack/preprocessor/if.hpp + include/msgpack/preprocessor/inc.hpp + include/msgpack/preprocessor/iterate.hpp + include/msgpack/preprocessor/iteration.hpp + include/msgpack/preprocessor/iteration/detail/bounds/lower1.hpp + include/msgpack/preprocessor/iteration/detail/bounds/lower2.hpp + include/msgpack/preprocessor/iteration/detail/bounds/lower3.hpp + include/msgpack/preprocessor/iteration/detail/bounds/lower4.hpp + include/msgpack/preprocessor/iteration/detail/bounds/lower5.hpp + include/msgpack/preprocessor/iteration/detail/bounds/upper1.hpp + include/msgpack/preprocessor/iteration/detail/bounds/upper2.hpp + include/msgpack/preprocessor/iteration/detail/bounds/upper3.hpp + include/msgpack/preprocessor/iteration/detail/bounds/upper4.hpp + include/msgpack/preprocessor/iteration/detail/bounds/upper5.hpp + include/msgpack/preprocessor/iteration/detail/finish.hpp + include/msgpack/preprocessor/iteration/detail/iter/forward1.hpp + include/msgpack/preprocessor/iteration/detail/iter/forward2.hpp + include/msgpack/preprocessor/iteration/detail/iter/forward3.hpp + include/msgpack/preprocessor/iteration/detail/iter/forward4.hpp + include/msgpack/preprocessor/iteration/detail/iter/forward5.hpp + include/msgpack/preprocessor/iteration/detail/iter/reverse1.hpp + include/msgpack/preprocessor/iteration/detail/iter/reverse2.hpp + include/msgpack/preprocessor/iteration/detail/iter/reverse3.hpp + include/msgpack/preprocessor/iteration/detail/iter/reverse4.hpp + include/msgpack/preprocessor/iteration/detail/iter/reverse5.hpp + include/msgpack/preprocessor/iteration/detail/local.hpp + include/msgpack/preprocessor/iteration/detail/rlocal.hpp + include/msgpack/preprocessor/iteration/detail/self.hpp + include/msgpack/preprocessor/iteration/detail/start.hpp + include/msgpack/preprocessor/iteration/iterate.hpp + include/msgpack/preprocessor/iteration/local.hpp + include/msgpack/preprocessor/iteration/self.hpp + include/msgpack/preprocessor/library.hpp + include/msgpack/preprocessor/limits.hpp + include/msgpack/preprocessor/list.hpp + include/msgpack/preprocessor/list/adt.hpp + include/msgpack/preprocessor/list/append.hpp + include/msgpack/preprocessor/list/at.hpp + include/msgpack/preprocessor/list/cat.hpp + include/msgpack/preprocessor/list/detail/dmc/fold_left.hpp + include/msgpack/preprocessor/list/detail/edg/fold_left.hpp + include/msgpack/preprocessor/list/detail/edg/fold_right.hpp + include/msgpack/preprocessor/list/detail/fold_left.hpp + include/msgpack/preprocessor/list/detail/fold_right.hpp + include/msgpack/preprocessor/list/enum.hpp + include/msgpack/preprocessor/list/filter.hpp + include/msgpack/preprocessor/list/first_n.hpp + include/msgpack/preprocessor/list/fold_left.hpp + include/msgpack/preprocessor/list/fold_right.hpp + include/msgpack/preprocessor/list/for_each.hpp + include/msgpack/preprocessor/list/for_each_i.hpp + include/msgpack/preprocessor/list/for_each_product.hpp + include/msgpack/preprocessor/list/rest_n.hpp + include/msgpack/preprocessor/list/reverse.hpp + include/msgpack/preprocessor/list/size.hpp + include/msgpack/preprocessor/list/to_array.hpp + include/msgpack/preprocessor/list/to_seq.hpp + include/msgpack/preprocessor/list/to_tuple.hpp + include/msgpack/preprocessor/list/transform.hpp + include/msgpack/preprocessor/logical.hpp + include/msgpack/preprocessor/logical/and.hpp + include/msgpack/preprocessor/logical/bitand.hpp + include/msgpack/preprocessor/logical/bitnor.hpp + include/msgpack/preprocessor/logical/bitor.hpp + include/msgpack/preprocessor/logical/bitxor.hpp + include/msgpack/preprocessor/logical/bool.hpp + include/msgpack/preprocessor/logical/compl.hpp + include/msgpack/preprocessor/logical/nor.hpp + include/msgpack/preprocessor/logical/not.hpp + include/msgpack/preprocessor/logical/or.hpp + include/msgpack/preprocessor/logical/xor.hpp + include/msgpack/preprocessor/max.hpp + include/msgpack/preprocessor/min.hpp + include/msgpack/preprocessor/punctuation.hpp + include/msgpack/preprocessor/punctuation/comma.hpp + include/msgpack/preprocessor/punctuation/comma_if.hpp + include/msgpack/preprocessor/punctuation/detail/is_begin_parens.hpp + include/msgpack/preprocessor/punctuation/is_begin_parens.hpp + include/msgpack/preprocessor/punctuation/paren.hpp + include/msgpack/preprocessor/punctuation/paren_if.hpp + include/msgpack/preprocessor/punctuation/remove_parens.hpp + include/msgpack/preprocessor/repeat.hpp + include/msgpack/preprocessor/repeat_2nd.hpp + include/msgpack/preprocessor/repeat_3rd.hpp + include/msgpack/preprocessor/repeat_from_to.hpp + include/msgpack/preprocessor/repeat_from_to_2nd.hpp + include/msgpack/preprocessor/repeat_from_to_3rd.hpp + include/msgpack/preprocessor/repetition.hpp + include/msgpack/preprocessor/repetition/deduce_r.hpp + include/msgpack/preprocessor/repetition/deduce_z.hpp + include/msgpack/preprocessor/repetition/detail/dmc/for.hpp + include/msgpack/preprocessor/repetition/detail/edg/for.hpp + include/msgpack/preprocessor/repetition/detail/for.hpp + include/msgpack/preprocessor/repetition/detail/msvc/for.hpp + include/msgpack/preprocessor/repetition/enum.hpp + include/msgpack/preprocessor/repetition/enum_binary_params.hpp + include/msgpack/preprocessor/repetition/enum_params.hpp + include/msgpack/preprocessor/repetition/enum_params_with_a_default.hpp + include/msgpack/preprocessor/repetition/enum_params_with_defaults.hpp + include/msgpack/preprocessor/repetition/enum_shifted.hpp + include/msgpack/preprocessor/repetition/enum_shifted_binary_params.hpp + include/msgpack/preprocessor/repetition/enum_shifted_params.hpp + include/msgpack/preprocessor/repetition/enum_trailing.hpp + include/msgpack/preprocessor/repetition/enum_trailing_binary_params.hpp + include/msgpack/preprocessor/repetition/enum_trailing_params.hpp + include/msgpack/preprocessor/repetition/for.hpp + include/msgpack/preprocessor/repetition/repeat.hpp + include/msgpack/preprocessor/repetition/repeat_from_to.hpp + include/msgpack/preprocessor/selection.hpp + include/msgpack/preprocessor/selection/max.hpp + include/msgpack/preprocessor/selection/min.hpp + include/msgpack/preprocessor/seq.hpp + include/msgpack/preprocessor/seq/cat.hpp + include/msgpack/preprocessor/seq/detail/binary_transform.hpp + include/msgpack/preprocessor/seq/detail/is_empty.hpp + include/msgpack/preprocessor/seq/detail/split.hpp + include/msgpack/preprocessor/seq/detail/to_list_msvc.hpp + include/msgpack/preprocessor/seq/elem.hpp + include/msgpack/preprocessor/seq/enum.hpp + include/msgpack/preprocessor/seq/filter.hpp + include/msgpack/preprocessor/seq/first_n.hpp + include/msgpack/preprocessor/seq/fold_left.hpp + include/msgpack/preprocessor/seq/fold_right.hpp + include/msgpack/preprocessor/seq/for_each.hpp + include/msgpack/preprocessor/seq/for_each_i.hpp + include/msgpack/preprocessor/seq/for_each_product.hpp + include/msgpack/preprocessor/seq/insert.hpp + include/msgpack/preprocessor/seq/pop_back.hpp + include/msgpack/preprocessor/seq/pop_front.hpp + include/msgpack/preprocessor/seq/push_back.hpp + include/msgpack/preprocessor/seq/push_front.hpp + include/msgpack/preprocessor/seq/remove.hpp + include/msgpack/preprocessor/seq/replace.hpp + include/msgpack/preprocessor/seq/rest_n.hpp + include/msgpack/preprocessor/seq/reverse.hpp + include/msgpack/preprocessor/seq/seq.hpp + include/msgpack/preprocessor/seq/size.hpp + include/msgpack/preprocessor/seq/subseq.hpp + include/msgpack/preprocessor/seq/to_array.hpp + include/msgpack/preprocessor/seq/to_list.hpp + include/msgpack/preprocessor/seq/to_tuple.hpp + include/msgpack/preprocessor/seq/transform.hpp + include/msgpack/preprocessor/seq/variadic_seq_to_seq.hpp + include/msgpack/preprocessor/slot.hpp + include/msgpack/preprocessor/slot/counter.hpp + include/msgpack/preprocessor/slot/detail/counter.hpp + include/msgpack/preprocessor/slot/detail/def.hpp + include/msgpack/preprocessor/slot/detail/shared.hpp + include/msgpack/preprocessor/slot/detail/slot1.hpp + include/msgpack/preprocessor/slot/detail/slot2.hpp + include/msgpack/preprocessor/slot/detail/slot3.hpp + include/msgpack/preprocessor/slot/detail/slot4.hpp + include/msgpack/preprocessor/slot/detail/slot5.hpp + include/msgpack/preprocessor/slot/slot.hpp + include/msgpack/preprocessor/stringize.hpp + include/msgpack/preprocessor/tuple.hpp + include/msgpack/preprocessor/tuple/detail/is_single_return.hpp + include/msgpack/preprocessor/tuple/eat.hpp + include/msgpack/preprocessor/tuple/elem.hpp + include/msgpack/preprocessor/tuple/enum.hpp + include/msgpack/preprocessor/tuple/insert.hpp + include/msgpack/preprocessor/tuple/pop_back.hpp + include/msgpack/preprocessor/tuple/pop_front.hpp + include/msgpack/preprocessor/tuple/push_back.hpp + include/msgpack/preprocessor/tuple/push_front.hpp + include/msgpack/preprocessor/tuple/rem.hpp + include/msgpack/preprocessor/tuple/remove.hpp + include/msgpack/preprocessor/tuple/replace.hpp + include/msgpack/preprocessor/tuple/reverse.hpp + include/msgpack/preprocessor/tuple/size.hpp + include/msgpack/preprocessor/tuple/to_array.hpp + include/msgpack/preprocessor/tuple/to_list.hpp + include/msgpack/preprocessor/tuple/to_seq.hpp + include/msgpack/preprocessor/variadic.hpp + include/msgpack/preprocessor/variadic/detail/is_single_return.hpp + include/msgpack/preprocessor/variadic/elem.hpp + include/msgpack/preprocessor/variadic/size.hpp + include/msgpack/preprocessor/variadic/to_array.hpp + include/msgpack/preprocessor/variadic/to_list.hpp + include/msgpack/preprocessor/variadic/to_seq.hpp + include/msgpack/preprocessor/variadic/to_tuple.hpp + include/msgpack/preprocessor/while.hpp + include/msgpack/preprocessor/wstringize.hpp + include/msgpack/sbuffer.hpp + include/msgpack/sbuffer_decl.hpp + include/msgpack/sysdep.hpp + include/msgpack/type.hpp + include/msgpack/unpack.hpp + include/msgpack/unpack_decl.hpp + include/msgpack/unpack_define.hpp + include/msgpack/unpack_exception.hpp + include/msgpack/v1/adaptor/adaptor_base.hpp + include/msgpack/v1/adaptor/adaptor_base_decl.hpp + include/msgpack/v1/adaptor/array_ref.hpp + include/msgpack/v1/adaptor/array_ref_decl.hpp + include/msgpack/v1/adaptor/bool.hpp + include/msgpack/v1/adaptor/boost/fusion.hpp + include/msgpack/v1/adaptor/boost/msgpack_variant.hpp + include/msgpack/v1/adaptor/boost/msgpack_variant_decl.hpp + include/msgpack/v1/adaptor/boost/optional.hpp + include/msgpack/v1/adaptor/boost/string_ref.hpp + include/msgpack/v1/adaptor/boost/string_view.hpp + include/msgpack/v1/adaptor/carray.hpp + include/msgpack/v1/adaptor/char_ptr.hpp + include/msgpack/v1/adaptor/check_container_size.hpp + include/msgpack/v1/adaptor/check_container_size_decl.hpp + include/msgpack/v1/adaptor/complex.hpp + include/msgpack/v1/adaptor/cpp11/array.hpp + include/msgpack/v1/adaptor/cpp11/array_char.hpp + include/msgpack/v1/adaptor/cpp11/array_unsigned_char.hpp + include/msgpack/v1/adaptor/cpp11/chrono.hpp + include/msgpack/v1/adaptor/cpp11/forward_list.hpp + include/msgpack/v1/adaptor/cpp11/reference_wrapper.hpp + include/msgpack/v1/adaptor/cpp11/shared_ptr.hpp + include/msgpack/v1/adaptor/cpp11/timespec.hpp + include/msgpack/v1/adaptor/cpp11/tuple.hpp + 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/variant.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 + include/msgpack/v1/adaptor/detail/cpp03_define_array.hpp + include/msgpack/v1/adaptor/detail/cpp03_define_array_decl.hpp + include/msgpack/v1/adaptor/detail/cpp03_define_map.hpp + include/msgpack/v1/adaptor/detail/cpp03_define_map_decl.hpp + include/msgpack/v1/adaptor/detail/cpp03_msgpack_tuple.hpp + include/msgpack/v1/adaptor/detail/cpp03_msgpack_tuple_decl.hpp + include/msgpack/v1/adaptor/detail/cpp11_convert_helper.hpp + include/msgpack/v1/adaptor/detail/cpp11_define_array.hpp + include/msgpack/v1/adaptor/detail/cpp11_define_array_decl.hpp + include/msgpack/v1/adaptor/detail/cpp11_define_map.hpp + include/msgpack/v1/adaptor/detail/cpp11_define_map_decl.hpp + include/msgpack/v1/adaptor/detail/cpp11_msgpack_tuple.hpp + include/msgpack/v1/adaptor/detail/cpp11_msgpack_tuple_decl.hpp + include/msgpack/v1/adaptor/ext.hpp + include/msgpack/v1/adaptor/ext_decl.hpp + include/msgpack/v1/adaptor/fixint.hpp + include/msgpack/v1/adaptor/fixint_decl.hpp + include/msgpack/v1/adaptor/float.hpp + include/msgpack/v1/adaptor/int.hpp + include/msgpack/v1/adaptor/int_decl.hpp + include/msgpack/v1/adaptor/list.hpp + include/msgpack/v1/adaptor/map.hpp + include/msgpack/v1/adaptor/map_decl.hpp + include/msgpack/v1/adaptor/msgpack_tuple.hpp + include/msgpack/v1/adaptor/msgpack_tuple_decl.hpp + include/msgpack/v1/adaptor/nil.hpp + include/msgpack/v1/adaptor/nil_decl.hpp + include/msgpack/v1/adaptor/pair.hpp + include/msgpack/v1/adaptor/raw.hpp + include/msgpack/v1/adaptor/raw_decl.hpp + include/msgpack/v1/adaptor/set.hpp + include/msgpack/v1/adaptor/size_equal_only.hpp + include/msgpack/v1/adaptor/size_equal_only_decl.hpp + include/msgpack/v1/adaptor/string.hpp + include/msgpack/v1/adaptor/tr1/unordered_map.hpp + include/msgpack/v1/adaptor/tr1/unordered_set.hpp + include/msgpack/v1/adaptor/v4raw.hpp + include/msgpack/v1/adaptor/v4raw_decl.hpp + include/msgpack/v1/adaptor/vector.hpp + include/msgpack/v1/adaptor/vector_bool.hpp + include/msgpack/v1/adaptor/vector_char.hpp + include/msgpack/v1/adaptor/vector_unsigned_char.hpp + include/msgpack/v1/adaptor/wstring.hpp + include/msgpack/v1/cpp_config.hpp + include/msgpack/v1/cpp_config_decl.hpp + include/msgpack/v1/detail/cpp03_zone.hpp + include/msgpack/v1/detail/cpp03_zone_decl.hpp + include/msgpack/v1/detail/cpp11_zone.hpp + include/msgpack/v1/detail/cpp11_zone_decl.hpp + include/msgpack/v1/fbuffer.hpp + include/msgpack/v1/fbuffer_decl.hpp + include/msgpack/v1/iterator.hpp + include/msgpack/v1/iterator_decl.hpp + include/msgpack/v1/meta.hpp + include/msgpack/v1/meta_decl.hpp + include/msgpack/v1/object.hpp + include/msgpack/v1/object_decl.hpp + include/msgpack/v1/object_fwd.hpp + include/msgpack/v1/object_fwd_decl.hpp + include/msgpack/v1/pack.hpp + include/msgpack/v1/pack_decl.hpp + include/msgpack/v1/parse_return.hpp + include/msgpack/v1/sbuffer.hpp + include/msgpack/v1/sbuffer_decl.hpp + include/msgpack/v1/unpack.hpp + include/msgpack/v1/unpack_decl.hpp + include/msgpack/v1/unpack_exception.hpp + include/msgpack/v1/version.hpp + include/msgpack/v1/versioning.hpp + include/msgpack/v1/vrefbuffer.hpp + include/msgpack/v1/vrefbuffer_decl.hpp + include/msgpack/v1/zbuffer.hpp + include/msgpack/v1/zbuffer_decl.hpp + include/msgpack/v1/zone.hpp + include/msgpack/v1/zone_decl.hpp + include/msgpack/v2/adaptor/adaptor_base.hpp + include/msgpack/v2/adaptor/adaptor_base_decl.hpp + include/msgpack/v2/adaptor/array_ref_decl.hpp + include/msgpack/v2/adaptor/boost/msgpack_variant_decl.hpp + include/msgpack/v2/adaptor/check_container_size_decl.hpp + include/msgpack/v2/adaptor/define_decl.hpp + include/msgpack/v2/adaptor/detail/cpp03_define_array_decl.hpp + include/msgpack/v2/adaptor/detail/cpp03_define_map_decl.hpp + include/msgpack/v2/adaptor/detail/cpp03_msgpack_tuple_decl.hpp + include/msgpack/v2/adaptor/detail/cpp11_define_array_decl.hpp + include/msgpack/v2/adaptor/detail/cpp11_define_map_decl.hpp + include/msgpack/v2/adaptor/detail/cpp11_msgpack_tuple_decl.hpp + include/msgpack/v2/adaptor/ext_decl.hpp + include/msgpack/v2/adaptor/fixint_decl.hpp + include/msgpack/v2/adaptor/int_decl.hpp + include/msgpack/v2/adaptor/map_decl.hpp + include/msgpack/v2/adaptor/msgpack_tuple_decl.hpp + include/msgpack/v2/adaptor/nil_decl.hpp + include/msgpack/v2/adaptor/raw_decl.hpp + include/msgpack/v2/adaptor/size_equal_only_decl.hpp + include/msgpack/v2/adaptor/v4raw_decl.hpp + include/msgpack/v2/cpp_config_decl.hpp + include/msgpack/v2/create_object_visitor.hpp + include/msgpack/v2/create_object_visitor_decl.hpp + include/msgpack/v2/detail/cpp03_zone_decl.hpp + include/msgpack/v2/detail/cpp11_zone_decl.hpp + include/msgpack/v2/fbuffer_decl.hpp + include/msgpack/v2/iterator_decl.hpp + include/msgpack/v2/meta_decl.hpp + include/msgpack/v2/null_visitor.hpp + include/msgpack/v2/null_visitor_decl.hpp + include/msgpack/v2/object.hpp + include/msgpack/v2/object_decl.hpp + include/msgpack/v2/object_fwd.hpp + include/msgpack/v2/object_fwd_decl.hpp + include/msgpack/v2/pack_decl.hpp + include/msgpack/v2/parse.hpp + include/msgpack/v2/parse_decl.hpp + include/msgpack/v2/parse_return.hpp + include/msgpack/v2/sbuffer_decl.hpp + include/msgpack/v2/unpack.hpp + include/msgpack/v2/unpack_decl.hpp + include/msgpack/v2/vrefbuffer_decl.hpp + include/msgpack/v2/x3_parse.hpp + include/msgpack/v2/x3_parse_decl.hpp + include/msgpack/v2/x3_unpack.hpp + include/msgpack/v2/x3_unpack_decl.hpp + include/msgpack/v2/zbuffer_decl.hpp + include/msgpack/v2/zone_decl.hpp + include/msgpack/v3/adaptor/adaptor_base.hpp + include/msgpack/v3/adaptor/adaptor_base_decl.hpp + include/msgpack/v3/adaptor/array_ref_decl.hpp + include/msgpack/v3/adaptor/boost/msgpack_variant_decl.hpp + include/msgpack/v3/adaptor/check_container_size_decl.hpp + include/msgpack/v3/adaptor/define_decl.hpp + include/msgpack/v3/adaptor/detail/cpp03_define_array_decl.hpp + include/msgpack/v3/adaptor/detail/cpp03_define_map_decl.hpp + include/msgpack/v3/adaptor/detail/cpp03_msgpack_tuple_decl.hpp + include/msgpack/v3/adaptor/detail/cpp11_define_array_decl.hpp + include/msgpack/v3/adaptor/detail/cpp11_define_map_decl.hpp + include/msgpack/v3/adaptor/detail/cpp11_msgpack_tuple_decl.hpp + include/msgpack/v3/adaptor/ext_decl.hpp + include/msgpack/v3/adaptor/fixint_decl.hpp + include/msgpack/v3/adaptor/int_decl.hpp + include/msgpack/v3/adaptor/map_decl.hpp + include/msgpack/v3/adaptor/msgpack_tuple_decl.hpp + include/msgpack/v3/adaptor/nil_decl.hpp + include/msgpack/v3/adaptor/raw_decl.hpp + include/msgpack/v3/adaptor/size_equal_only_decl.hpp + include/msgpack/v3/adaptor/v4raw_decl.hpp + include/msgpack/v3/cpp_config_decl.hpp + include/msgpack/v3/create_object_visitor_decl.hpp + include/msgpack/v3/detail/cpp03_zone_decl.hpp + include/msgpack/v3/detail/cpp11_zone_decl.hpp + include/msgpack/v3/fbuffer_decl.hpp + include/msgpack/v3/iterator_decl.hpp + include/msgpack/v3/meta_decl.hpp + include/msgpack/v3/null_visitor_decl.hpp + include/msgpack/v3/object_decl.hpp + include/msgpack/v3/object_fwd.hpp + include/msgpack/v3/object_fwd_decl.hpp + include/msgpack/v3/pack_decl.hpp + include/msgpack/v3/parse.hpp + include/msgpack/v3/parse_decl.hpp + include/msgpack/v3/parse_return.hpp + include/msgpack/v3/sbuffer_decl.hpp + include/msgpack/v3/unpack.hpp + include/msgpack/v3/unpack_decl.hpp + include/msgpack/v3/vrefbuffer_decl.hpp + include/msgpack/v3/x3_parse_decl.hpp + include/msgpack/v3/x3_unpack.hpp + include/msgpack/v3/x3_unpack_decl.hpp + include/msgpack/v3/zbuffer_decl.hpp + include/msgpack/v3/zone_decl.hpp + include/msgpack/version.hpp + include/msgpack/version_master.hpp + include/msgpack/versioning.hpp + include/msgpack/vrefbuffer.hpp + include/msgpack/vrefbuffer_decl.hpp + include/msgpack/x3_parse.hpp + include/msgpack/x3_parse_decl.hpp + include/msgpack/x3_unpack.hpp + include/msgpack/x3_unpack_decl.hpp + include/msgpack/zbuffer.hpp + include/msgpack/zbuffer_decl.hpp + include/msgpack/zone.hpp + include/msgpack/zone_decl.hpp ) -IF (MSGPACK_ENABLE_CXX) - LIST (APPEND msgpackc_HEADERS - include/msgpack.hpp - include/msgpack/adaptor/adaptor_base.hpp - include/msgpack/adaptor/adaptor_base_decl.hpp - include/msgpack/adaptor/array_ref.hpp - include/msgpack/adaptor/array_ref_decl.hpp - include/msgpack/adaptor/bool.hpp - include/msgpack/adaptor/boost/fusion.hpp - include/msgpack/adaptor/boost/msgpack_variant.hpp - include/msgpack/adaptor/boost/msgpack_variant_decl.hpp - include/msgpack/adaptor/boost/optional.hpp - include/msgpack/adaptor/boost/string_ref.hpp - include/msgpack/adaptor/boost/string_view.hpp - include/msgpack/adaptor/carray.hpp - include/msgpack/adaptor/char_ptr.hpp - include/msgpack/adaptor/check_container_size.hpp - include/msgpack/adaptor/check_container_size_decl.hpp - include/msgpack/adaptor/cpp11/array.hpp - include/msgpack/adaptor/cpp11/array_char.hpp - include/msgpack/adaptor/cpp11/array_unsigned_char.hpp - include/msgpack/adaptor/cpp11/chrono.hpp - include/msgpack/adaptor/cpp11/forward_list.hpp - include/msgpack/adaptor/cpp11/reference_wrapper.hpp - include/msgpack/adaptor/cpp11/shared_ptr.hpp - include/msgpack/adaptor/cpp11/timespec.hpp - include/msgpack/adaptor/cpp11/tuple.hpp - 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/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/define.hpp - include/msgpack/adaptor/define_decl.hpp - include/msgpack/adaptor/deque.hpp - include/msgpack/adaptor/ext.hpp - include/msgpack/adaptor/ext_decl.hpp - include/msgpack/adaptor/fixint.hpp - include/msgpack/adaptor/fixint_decl.hpp - include/msgpack/adaptor/float.hpp - include/msgpack/adaptor/int.hpp - include/msgpack/adaptor/int_decl.hpp - include/msgpack/adaptor/list.hpp - include/msgpack/adaptor/map.hpp - include/msgpack/adaptor/map_decl.hpp - include/msgpack/adaptor/msgpack_tuple.hpp - include/msgpack/adaptor/msgpack_tuple_decl.hpp - include/msgpack/adaptor/nil.hpp - include/msgpack/adaptor/nil_decl.hpp - include/msgpack/adaptor/pair.hpp - include/msgpack/adaptor/raw.hpp - include/msgpack/adaptor/raw_decl.hpp - include/msgpack/adaptor/set.hpp - include/msgpack/adaptor/size_equal_only.hpp - include/msgpack/adaptor/size_equal_only_decl.hpp - include/msgpack/adaptor/string.hpp - include/msgpack/adaptor/tr1/unordered_map.hpp - include/msgpack/adaptor/tr1/unordered_set.hpp - include/msgpack/adaptor/v4raw.hpp - include/msgpack/adaptor/v4raw_decl.hpp - include/msgpack/adaptor/vector.hpp - include/msgpack/adaptor/vector_bool.hpp - include/msgpack/adaptor/vector_char.hpp - include/msgpack/adaptor/vector_unsigned_char.hpp - include/msgpack/adaptor/wstring.hpp - include/msgpack/cpp_config.hpp - include/msgpack/cpp_config_decl.hpp - include/msgpack/create_object_visitor.hpp - include/msgpack/create_object_visitor_decl.hpp - include/msgpack/fbuffer.hpp - include/msgpack/fbuffer_decl.hpp - include/msgpack/gcc_atomic.hpp - include/msgpack/iterator.hpp - include/msgpack/iterator_decl.hpp - include/msgpack/meta.hpp - include/msgpack/meta_decl.hpp - include/msgpack/null_visitor.hpp - include/msgpack/null_visitor_decl.hpp - include/msgpack/object.hpp - include/msgpack/object_decl.hpp - include/msgpack/object_fwd.hpp - include/msgpack/object_fwd_decl.hpp - include/msgpack/pack.hpp - include/msgpack/pack_decl.hpp - include/msgpack/parse.hpp - include/msgpack/parse_decl.hpp - include/msgpack/parse_return.hpp - include/msgpack/preprocessor.hpp - include/msgpack/preprocessor/arithmetic.hpp - include/msgpack/preprocessor/arithmetic/add.hpp - include/msgpack/preprocessor/arithmetic/dec.hpp - include/msgpack/preprocessor/arithmetic/detail/div_base.hpp - include/msgpack/preprocessor/arithmetic/div.hpp - include/msgpack/preprocessor/arithmetic/inc.hpp - include/msgpack/preprocessor/arithmetic/mod.hpp - include/msgpack/preprocessor/arithmetic/mul.hpp - include/msgpack/preprocessor/arithmetic/sub.hpp - include/msgpack/preprocessor/array.hpp - include/msgpack/preprocessor/array/data.hpp - include/msgpack/preprocessor/array/detail/get_data.hpp - include/msgpack/preprocessor/array/elem.hpp - include/msgpack/preprocessor/array/enum.hpp - include/msgpack/preprocessor/array/insert.hpp - include/msgpack/preprocessor/array/pop_back.hpp - include/msgpack/preprocessor/array/pop_front.hpp - include/msgpack/preprocessor/array/push_back.hpp - include/msgpack/preprocessor/array/push_front.hpp - include/msgpack/preprocessor/array/remove.hpp - include/msgpack/preprocessor/array/replace.hpp - include/msgpack/preprocessor/array/reverse.hpp - include/msgpack/preprocessor/array/size.hpp - include/msgpack/preprocessor/array/to_list.hpp - include/msgpack/preprocessor/array/to_seq.hpp - include/msgpack/preprocessor/array/to_tuple.hpp - include/msgpack/preprocessor/assert_msg.hpp - include/msgpack/preprocessor/cat.hpp - include/msgpack/preprocessor/comma.hpp - include/msgpack/preprocessor/comma_if.hpp - include/msgpack/preprocessor/comparison.hpp - include/msgpack/preprocessor/comparison/equal.hpp - include/msgpack/preprocessor/comparison/greater.hpp - include/msgpack/preprocessor/comparison/greater_equal.hpp - include/msgpack/preprocessor/comparison/less.hpp - include/msgpack/preprocessor/comparison/less_equal.hpp - include/msgpack/preprocessor/comparison/not_equal.hpp - include/msgpack/preprocessor/config/config.hpp - include/msgpack/preprocessor/config/limits.hpp - include/msgpack/preprocessor/control.hpp - include/msgpack/preprocessor/control/deduce_d.hpp - include/msgpack/preprocessor/control/detail/dmc/while.hpp - include/msgpack/preprocessor/control/detail/edg/while.hpp - include/msgpack/preprocessor/control/detail/msvc/while.hpp - include/msgpack/preprocessor/control/detail/while.hpp - include/msgpack/preprocessor/control/expr_if.hpp - include/msgpack/preprocessor/control/expr_iif.hpp - include/msgpack/preprocessor/control/if.hpp - include/msgpack/preprocessor/control/iif.hpp - include/msgpack/preprocessor/control/while.hpp - include/msgpack/preprocessor/debug.hpp - include/msgpack/preprocessor/debug/assert.hpp - include/msgpack/preprocessor/debug/error.hpp - include/msgpack/preprocessor/debug/line.hpp - include/msgpack/preprocessor/dec.hpp - include/msgpack/preprocessor/detail/auto_rec.hpp - include/msgpack/preprocessor/detail/check.hpp - include/msgpack/preprocessor/detail/dmc/auto_rec.hpp - include/msgpack/preprocessor/detail/is_binary.hpp - include/msgpack/preprocessor/detail/is_nullary.hpp - include/msgpack/preprocessor/detail/is_unary.hpp - include/msgpack/preprocessor/detail/null.hpp - include/msgpack/preprocessor/detail/split.hpp - include/msgpack/preprocessor/empty.hpp - include/msgpack/preprocessor/enum.hpp - include/msgpack/preprocessor/enum_params.hpp - include/msgpack/preprocessor/enum_params_with_a_default.hpp - include/msgpack/preprocessor/enum_params_with_defaults.hpp - include/msgpack/preprocessor/enum_shifted.hpp - include/msgpack/preprocessor/enum_shifted_params.hpp - include/msgpack/preprocessor/expand.hpp - include/msgpack/preprocessor/expr_if.hpp - include/msgpack/preprocessor/facilities.hpp - include/msgpack/preprocessor/facilities/apply.hpp - include/msgpack/preprocessor/facilities/detail/is_empty.hpp - include/msgpack/preprocessor/facilities/empty.hpp - include/msgpack/preprocessor/facilities/expand.hpp - include/msgpack/preprocessor/facilities/identity.hpp - include/msgpack/preprocessor/facilities/intercept.hpp - include/msgpack/preprocessor/facilities/is_1.hpp - include/msgpack/preprocessor/facilities/is_empty.hpp - include/msgpack/preprocessor/facilities/is_empty_or_1.hpp - include/msgpack/preprocessor/facilities/is_empty_variadic.hpp - include/msgpack/preprocessor/facilities/overload.hpp - include/msgpack/preprocessor/for.hpp - include/msgpack/preprocessor/identity.hpp - include/msgpack/preprocessor/if.hpp - include/msgpack/preprocessor/inc.hpp - include/msgpack/preprocessor/iterate.hpp - include/msgpack/preprocessor/iteration.hpp - include/msgpack/preprocessor/iteration/detail/bounds/lower1.hpp - include/msgpack/preprocessor/iteration/detail/bounds/lower2.hpp - include/msgpack/preprocessor/iteration/detail/bounds/lower3.hpp - include/msgpack/preprocessor/iteration/detail/bounds/lower4.hpp - include/msgpack/preprocessor/iteration/detail/bounds/lower5.hpp - include/msgpack/preprocessor/iteration/detail/bounds/upper1.hpp - include/msgpack/preprocessor/iteration/detail/bounds/upper2.hpp - include/msgpack/preprocessor/iteration/detail/bounds/upper3.hpp - include/msgpack/preprocessor/iteration/detail/bounds/upper4.hpp - include/msgpack/preprocessor/iteration/detail/bounds/upper5.hpp - include/msgpack/preprocessor/iteration/detail/finish.hpp - include/msgpack/preprocessor/iteration/detail/iter/forward1.hpp - include/msgpack/preprocessor/iteration/detail/iter/forward2.hpp - include/msgpack/preprocessor/iteration/detail/iter/forward3.hpp - include/msgpack/preprocessor/iteration/detail/iter/forward4.hpp - include/msgpack/preprocessor/iteration/detail/iter/forward5.hpp - include/msgpack/preprocessor/iteration/detail/iter/reverse1.hpp - include/msgpack/preprocessor/iteration/detail/iter/reverse2.hpp - include/msgpack/preprocessor/iteration/detail/iter/reverse3.hpp - include/msgpack/preprocessor/iteration/detail/iter/reverse4.hpp - include/msgpack/preprocessor/iteration/detail/iter/reverse5.hpp - include/msgpack/preprocessor/iteration/detail/local.hpp - include/msgpack/preprocessor/iteration/detail/rlocal.hpp - include/msgpack/preprocessor/iteration/detail/self.hpp - include/msgpack/preprocessor/iteration/detail/start.hpp - include/msgpack/preprocessor/iteration/iterate.hpp - include/msgpack/preprocessor/iteration/local.hpp - include/msgpack/preprocessor/iteration/self.hpp - include/msgpack/preprocessor/library.hpp - include/msgpack/preprocessor/limits.hpp - include/msgpack/preprocessor/list.hpp - include/msgpack/preprocessor/list/adt.hpp - include/msgpack/preprocessor/list/append.hpp - include/msgpack/preprocessor/list/at.hpp - include/msgpack/preprocessor/list/cat.hpp - include/msgpack/preprocessor/list/detail/dmc/fold_left.hpp - include/msgpack/preprocessor/list/detail/edg/fold_left.hpp - include/msgpack/preprocessor/list/detail/edg/fold_right.hpp - include/msgpack/preprocessor/list/detail/fold_left.hpp - include/msgpack/preprocessor/list/detail/fold_right.hpp - include/msgpack/preprocessor/list/enum.hpp - include/msgpack/preprocessor/list/filter.hpp - include/msgpack/preprocessor/list/first_n.hpp - include/msgpack/preprocessor/list/fold_left.hpp - include/msgpack/preprocessor/list/fold_right.hpp - include/msgpack/preprocessor/list/for_each.hpp - include/msgpack/preprocessor/list/for_each_i.hpp - include/msgpack/preprocessor/list/for_each_product.hpp - include/msgpack/preprocessor/list/rest_n.hpp - include/msgpack/preprocessor/list/reverse.hpp - include/msgpack/preprocessor/list/size.hpp - include/msgpack/preprocessor/list/to_array.hpp - include/msgpack/preprocessor/list/to_seq.hpp - include/msgpack/preprocessor/list/to_tuple.hpp - include/msgpack/preprocessor/list/transform.hpp - include/msgpack/preprocessor/logical.hpp - include/msgpack/preprocessor/logical/and.hpp - include/msgpack/preprocessor/logical/bitand.hpp - include/msgpack/preprocessor/logical/bitnor.hpp - include/msgpack/preprocessor/logical/bitor.hpp - include/msgpack/preprocessor/logical/bitxor.hpp - include/msgpack/preprocessor/logical/bool.hpp - include/msgpack/preprocessor/logical/compl.hpp - include/msgpack/preprocessor/logical/nor.hpp - include/msgpack/preprocessor/logical/not.hpp - include/msgpack/preprocessor/logical/or.hpp - include/msgpack/preprocessor/logical/xor.hpp - include/msgpack/preprocessor/max.hpp - include/msgpack/preprocessor/min.hpp - include/msgpack/preprocessor/punctuation.hpp - include/msgpack/preprocessor/punctuation/comma.hpp - include/msgpack/preprocessor/punctuation/comma_if.hpp - include/msgpack/preprocessor/punctuation/detail/is_begin_parens.hpp - include/msgpack/preprocessor/punctuation/is_begin_parens.hpp - include/msgpack/preprocessor/punctuation/paren.hpp - include/msgpack/preprocessor/punctuation/paren_if.hpp - include/msgpack/preprocessor/punctuation/remove_parens.hpp - include/msgpack/preprocessor/repeat.hpp - include/msgpack/preprocessor/repeat_2nd.hpp - include/msgpack/preprocessor/repeat_3rd.hpp - include/msgpack/preprocessor/repeat_from_to.hpp - include/msgpack/preprocessor/repeat_from_to_2nd.hpp - include/msgpack/preprocessor/repeat_from_to_3rd.hpp - include/msgpack/preprocessor/repetition.hpp - include/msgpack/preprocessor/repetition/deduce_r.hpp - include/msgpack/preprocessor/repetition/deduce_z.hpp - include/msgpack/preprocessor/repetition/detail/dmc/for.hpp - include/msgpack/preprocessor/repetition/detail/edg/for.hpp - include/msgpack/preprocessor/repetition/detail/for.hpp - include/msgpack/preprocessor/repetition/detail/msvc/for.hpp - include/msgpack/preprocessor/repetition/enum.hpp - include/msgpack/preprocessor/repetition/enum_binary_params.hpp - include/msgpack/preprocessor/repetition/enum_params.hpp - include/msgpack/preprocessor/repetition/enum_params_with_a_default.hpp - include/msgpack/preprocessor/repetition/enum_params_with_defaults.hpp - include/msgpack/preprocessor/repetition/enum_shifted.hpp - include/msgpack/preprocessor/repetition/enum_shifted_binary_params.hpp - include/msgpack/preprocessor/repetition/enum_shifted_params.hpp - include/msgpack/preprocessor/repetition/enum_trailing.hpp - include/msgpack/preprocessor/repetition/enum_trailing_binary_params.hpp - include/msgpack/preprocessor/repetition/enum_trailing_params.hpp - include/msgpack/preprocessor/repetition/for.hpp - include/msgpack/preprocessor/repetition/repeat.hpp - include/msgpack/preprocessor/repetition/repeat_from_to.hpp - include/msgpack/preprocessor/selection.hpp - include/msgpack/preprocessor/selection/max.hpp - include/msgpack/preprocessor/selection/min.hpp - include/msgpack/preprocessor/seq.hpp - include/msgpack/preprocessor/seq/cat.hpp - include/msgpack/preprocessor/seq/detail/binary_transform.hpp - include/msgpack/preprocessor/seq/detail/is_empty.hpp - include/msgpack/preprocessor/seq/detail/split.hpp - include/msgpack/preprocessor/seq/detail/to_list_msvc.hpp - include/msgpack/preprocessor/seq/elem.hpp - include/msgpack/preprocessor/seq/enum.hpp - include/msgpack/preprocessor/seq/filter.hpp - include/msgpack/preprocessor/seq/first_n.hpp - include/msgpack/preprocessor/seq/fold_left.hpp - include/msgpack/preprocessor/seq/fold_right.hpp - include/msgpack/preprocessor/seq/for_each.hpp - include/msgpack/preprocessor/seq/for_each_i.hpp - include/msgpack/preprocessor/seq/for_each_product.hpp - include/msgpack/preprocessor/seq/insert.hpp - include/msgpack/preprocessor/seq/pop_back.hpp - include/msgpack/preprocessor/seq/pop_front.hpp - include/msgpack/preprocessor/seq/push_back.hpp - include/msgpack/preprocessor/seq/push_front.hpp - include/msgpack/preprocessor/seq/remove.hpp - include/msgpack/preprocessor/seq/replace.hpp - include/msgpack/preprocessor/seq/rest_n.hpp - include/msgpack/preprocessor/seq/reverse.hpp - include/msgpack/preprocessor/seq/seq.hpp - include/msgpack/preprocessor/seq/size.hpp - include/msgpack/preprocessor/seq/subseq.hpp - include/msgpack/preprocessor/seq/to_array.hpp - include/msgpack/preprocessor/seq/to_list.hpp - include/msgpack/preprocessor/seq/to_tuple.hpp - include/msgpack/preprocessor/seq/transform.hpp - include/msgpack/preprocessor/seq/variadic_seq_to_seq.hpp - include/msgpack/preprocessor/slot.hpp - include/msgpack/preprocessor/slot/counter.hpp - include/msgpack/preprocessor/slot/detail/counter.hpp - include/msgpack/preprocessor/slot/detail/def.hpp - include/msgpack/preprocessor/slot/detail/shared.hpp - include/msgpack/preprocessor/slot/detail/slot1.hpp - include/msgpack/preprocessor/slot/detail/slot2.hpp - include/msgpack/preprocessor/slot/detail/slot3.hpp - include/msgpack/preprocessor/slot/detail/slot4.hpp - include/msgpack/preprocessor/slot/detail/slot5.hpp - include/msgpack/preprocessor/slot/slot.hpp - include/msgpack/preprocessor/stringize.hpp - include/msgpack/preprocessor/tuple.hpp - include/msgpack/preprocessor/tuple/detail/is_single_return.hpp - include/msgpack/preprocessor/tuple/eat.hpp - include/msgpack/preprocessor/tuple/elem.hpp - include/msgpack/preprocessor/tuple/enum.hpp - include/msgpack/preprocessor/tuple/insert.hpp - include/msgpack/preprocessor/tuple/pop_back.hpp - include/msgpack/preprocessor/tuple/pop_front.hpp - include/msgpack/preprocessor/tuple/push_back.hpp - include/msgpack/preprocessor/tuple/push_front.hpp - include/msgpack/preprocessor/tuple/rem.hpp - include/msgpack/preprocessor/tuple/remove.hpp - include/msgpack/preprocessor/tuple/replace.hpp - include/msgpack/preprocessor/tuple/reverse.hpp - include/msgpack/preprocessor/tuple/size.hpp - include/msgpack/preprocessor/tuple/to_array.hpp - include/msgpack/preprocessor/tuple/to_list.hpp - include/msgpack/preprocessor/tuple/to_seq.hpp - include/msgpack/preprocessor/variadic.hpp - include/msgpack/preprocessor/variadic/detail/is_single_return.hpp - include/msgpack/preprocessor/variadic/elem.hpp - include/msgpack/preprocessor/variadic/size.hpp - include/msgpack/preprocessor/variadic/to_array.hpp - include/msgpack/preprocessor/variadic/to_list.hpp - include/msgpack/preprocessor/variadic/to_seq.hpp - include/msgpack/preprocessor/variadic/to_tuple.hpp - include/msgpack/preprocessor/while.hpp - include/msgpack/preprocessor/wstringize.hpp - include/msgpack/sbuffer.hpp - include/msgpack/sbuffer_decl.hpp - include/msgpack/type.hpp - include/msgpack/unpack.hpp - include/msgpack/unpack_decl.hpp - include/msgpack/unpack_exception.hpp - include/msgpack/v1/adaptor/adaptor_base.hpp - include/msgpack/v1/adaptor/adaptor_base_decl.hpp - include/msgpack/v1/adaptor/array_ref.hpp - include/msgpack/v1/adaptor/array_ref_decl.hpp - include/msgpack/v1/adaptor/bool.hpp - include/msgpack/v1/adaptor/boost/fusion.hpp - include/msgpack/v1/adaptor/boost/msgpack_variant.hpp - include/msgpack/v1/adaptor/boost/msgpack_variant_decl.hpp - include/msgpack/v1/adaptor/boost/optional.hpp - include/msgpack/v1/adaptor/boost/string_ref.hpp - include/msgpack/v1/adaptor/boost/string_view.hpp - include/msgpack/v1/adaptor/carray.hpp - include/msgpack/v1/adaptor/char_ptr.hpp - include/msgpack/v1/adaptor/check_container_size.hpp - include/msgpack/v1/adaptor/check_container_size_decl.hpp - include/msgpack/v1/adaptor/cpp11/array.hpp - include/msgpack/v1/adaptor/cpp11/array_char.hpp - include/msgpack/v1/adaptor/cpp11/array_unsigned_char.hpp - include/msgpack/v1/adaptor/cpp11/chrono.hpp - include/msgpack/v1/adaptor/cpp11/forward_list.hpp - include/msgpack/v1/adaptor/cpp11/reference_wrapper.hpp - include/msgpack/v1/adaptor/cpp11/shared_ptr.hpp - include/msgpack/v1/adaptor/cpp11/timespec.hpp - include/msgpack/v1/adaptor/cpp11/tuple.hpp - 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/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/define.hpp - include/msgpack/v1/adaptor/define_decl.hpp - include/msgpack/v1/adaptor/deque.hpp - include/msgpack/v1/adaptor/detail/cpp03_define_array.hpp - include/msgpack/v1/adaptor/detail/cpp03_define_array_decl.hpp - include/msgpack/v1/adaptor/detail/cpp03_define_map.hpp - include/msgpack/v1/adaptor/detail/cpp03_define_map_decl.hpp - include/msgpack/v1/adaptor/detail/cpp03_msgpack_tuple.hpp - include/msgpack/v1/adaptor/detail/cpp03_msgpack_tuple_decl.hpp - include/msgpack/v1/adaptor/detail/cpp11_convert_helper.hpp - include/msgpack/v1/adaptor/detail/cpp11_define_array.hpp - include/msgpack/v1/adaptor/detail/cpp11_define_array_decl.hpp - include/msgpack/v1/adaptor/detail/cpp11_define_map.hpp - include/msgpack/v1/adaptor/detail/cpp11_define_map_decl.hpp - include/msgpack/v1/adaptor/detail/cpp11_msgpack_tuple.hpp - include/msgpack/v1/adaptor/detail/cpp11_msgpack_tuple_decl.hpp - include/msgpack/v1/adaptor/ext.hpp - include/msgpack/v1/adaptor/ext_decl.hpp - include/msgpack/v1/adaptor/fixint.hpp - include/msgpack/v1/adaptor/fixint_decl.hpp - include/msgpack/v1/adaptor/float.hpp - include/msgpack/v1/adaptor/int.hpp - include/msgpack/v1/adaptor/int_decl.hpp - include/msgpack/v1/adaptor/list.hpp - include/msgpack/v1/adaptor/map.hpp - include/msgpack/v1/adaptor/map_decl.hpp - include/msgpack/v1/adaptor/msgpack_tuple.hpp - include/msgpack/v1/adaptor/msgpack_tuple_decl.hpp - include/msgpack/v1/adaptor/nil.hpp - include/msgpack/v1/adaptor/nil_decl.hpp - include/msgpack/v1/adaptor/pair.hpp - include/msgpack/v1/adaptor/raw.hpp - include/msgpack/v1/adaptor/raw_decl.hpp - include/msgpack/v1/adaptor/set.hpp - include/msgpack/v1/adaptor/size_equal_only.hpp - include/msgpack/v1/adaptor/size_equal_only_decl.hpp - include/msgpack/v1/adaptor/string.hpp - include/msgpack/v1/adaptor/tr1/unordered_map.hpp - include/msgpack/v1/adaptor/tr1/unordered_set.hpp - include/msgpack/v1/adaptor/v4raw.hpp - include/msgpack/v1/adaptor/v4raw_decl.hpp - include/msgpack/v1/adaptor/vector.hpp - include/msgpack/v1/adaptor/vector_bool.hpp - include/msgpack/v1/adaptor/vector_char.hpp - include/msgpack/v1/adaptor/vector_unsigned_char.hpp - include/msgpack/v1/adaptor/wstring.hpp - include/msgpack/v1/cpp_config.hpp - include/msgpack/v1/cpp_config_decl.hpp - include/msgpack/v1/detail/cpp03_zone.hpp - include/msgpack/v1/detail/cpp03_zone_decl.hpp - include/msgpack/v1/detail/cpp11_zone.hpp - include/msgpack/v1/detail/cpp11_zone_decl.hpp - include/msgpack/v1/fbuffer.hpp - include/msgpack/v1/fbuffer_decl.hpp - include/msgpack/v1/iterator.hpp - include/msgpack/v1/iterator_decl.hpp - include/msgpack/v1/meta.hpp - include/msgpack/v1/meta_decl.hpp - include/msgpack/v1/object.hpp - include/msgpack/v1/object_decl.hpp - include/msgpack/v1/object_fwd.hpp - include/msgpack/v1/object_fwd_decl.hpp - include/msgpack/v1/pack.hpp - include/msgpack/v1/pack_decl.hpp - include/msgpack/v1/parse_return.hpp - include/msgpack/v1/preprocessor.hpp - include/msgpack/v1/sbuffer.hpp - include/msgpack/v1/sbuffer_decl.hpp - include/msgpack/v1/unpack.hpp - include/msgpack/v1/unpack_decl.hpp - include/msgpack/v1/unpack_exception.hpp - include/msgpack/v1/version.hpp - include/msgpack/v1/versioning.hpp - include/msgpack/v1/vrefbuffer.hpp - include/msgpack/v1/vrefbuffer_decl.hpp - include/msgpack/v1/zbuffer.hpp - include/msgpack/v1/zbuffer_decl.hpp - include/msgpack/v1/zone.hpp - include/msgpack/v1/zone_decl.hpp - include/msgpack/v2/adaptor/adaptor_base.hpp - include/msgpack/v2/adaptor/adaptor_base_decl.hpp - include/msgpack/v2/adaptor/array_ref_decl.hpp - include/msgpack/v2/adaptor/boost/msgpack_variant_decl.hpp - include/msgpack/v2/adaptor/check_container_size_decl.hpp - include/msgpack/v2/adaptor/define_decl.hpp - include/msgpack/v2/adaptor/detail/cpp03_define_array_decl.hpp - include/msgpack/v2/adaptor/detail/cpp03_define_map_decl.hpp - include/msgpack/v2/adaptor/detail/cpp03_msgpack_tuple_decl.hpp - include/msgpack/v2/adaptor/detail/cpp11_define_array_decl.hpp - include/msgpack/v2/adaptor/detail/cpp11_define_map_decl.hpp - include/msgpack/v2/adaptor/detail/cpp11_msgpack_tuple_decl.hpp - include/msgpack/v2/adaptor/ext_decl.hpp - include/msgpack/v2/adaptor/fixint_decl.hpp - include/msgpack/v2/adaptor/int_decl.hpp - include/msgpack/v2/adaptor/map_decl.hpp - include/msgpack/v2/adaptor/msgpack_tuple_decl.hpp - include/msgpack/v2/adaptor/nil_decl.hpp - include/msgpack/v2/adaptor/raw_decl.hpp - include/msgpack/v2/adaptor/size_equal_only_decl.hpp - include/msgpack/v2/adaptor/v4raw_decl.hpp - include/msgpack/v2/cpp_config_decl.hpp - include/msgpack/v2/create_object_visitor.hpp - include/msgpack/v2/create_object_visitor_decl.hpp - include/msgpack/v2/detail/cpp03_zone_decl.hpp - include/msgpack/v2/detail/cpp11_zone_decl.hpp - include/msgpack/v2/fbuffer_decl.hpp - include/msgpack/v2/iterator_decl.hpp - include/msgpack/v2/meta_decl.hpp - include/msgpack/v2/null_visitor.hpp - include/msgpack/v2/null_visitor_decl.hpp - include/msgpack/v2/object.hpp - include/msgpack/v2/object_decl.hpp - include/msgpack/v2/object_fwd.hpp - include/msgpack/v2/object_fwd_decl.hpp - include/msgpack/v2/pack_decl.hpp - include/msgpack/v2/parse.hpp - include/msgpack/v2/parse_decl.hpp - include/msgpack/v2/parse_return.hpp - include/msgpack/v2/sbuffer_decl.hpp - include/msgpack/v2/unpack.hpp - include/msgpack/v2/unpack_decl.hpp - include/msgpack/v2/vrefbuffer_decl.hpp - include/msgpack/v2/x3_parse.hpp - include/msgpack/v2/x3_parse_decl.hpp - include/msgpack/v2/x3_unpack.hpp - include/msgpack/v2/x3_unpack_decl.hpp - include/msgpack/v2/zbuffer_decl.hpp - include/msgpack/v2/zone_decl.hpp - include/msgpack/v3/adaptor/adaptor_base.hpp - include/msgpack/v3/adaptor/adaptor_base_decl.hpp - include/msgpack/v3/adaptor/array_ref_decl.hpp - include/msgpack/v3/adaptor/boost/msgpack_variant_decl.hpp - include/msgpack/v3/adaptor/check_container_size_decl.hpp - include/msgpack/v3/adaptor/define_decl.hpp - include/msgpack/v3/adaptor/detail/cpp03_define_array_decl.hpp - include/msgpack/v3/adaptor/detail/cpp03_define_map_decl.hpp - include/msgpack/v3/adaptor/detail/cpp03_msgpack_tuple_decl.hpp - include/msgpack/v3/adaptor/detail/cpp11_define_array_decl.hpp - include/msgpack/v3/adaptor/detail/cpp11_define_map_decl.hpp - include/msgpack/v3/adaptor/detail/cpp11_msgpack_tuple_decl.hpp - include/msgpack/v3/adaptor/ext_decl.hpp - include/msgpack/v3/adaptor/fixint_decl.hpp - include/msgpack/v3/adaptor/int_decl.hpp - include/msgpack/v3/adaptor/map_decl.hpp - include/msgpack/v3/adaptor/msgpack_tuple_decl.hpp - include/msgpack/v3/adaptor/nil_decl.hpp - include/msgpack/v3/adaptor/raw_decl.hpp - include/msgpack/v3/adaptor/size_equal_only_decl.hpp - include/msgpack/v3/adaptor/v4raw_decl.hpp - include/msgpack/v3/cpp_config_decl.hpp - include/msgpack/v3/create_object_visitor_decl.hpp - include/msgpack/v3/detail/cpp03_zone_decl.hpp - include/msgpack/v3/detail/cpp11_zone_decl.hpp - include/msgpack/v3/fbuffer_decl.hpp - include/msgpack/v3/iterator_decl.hpp - include/msgpack/v3/meta_decl.hpp - include/msgpack/v3/null_visitor_decl.hpp - include/msgpack/v3/object_decl.hpp - include/msgpack/v3/object_fwd.hpp - include/msgpack/v3/object_fwd_decl.hpp - include/msgpack/v3/pack_decl.hpp - include/msgpack/v3/parse.hpp - include/msgpack/v3/parse_decl.hpp - include/msgpack/v3/parse_return.hpp - include/msgpack/v3/sbuffer_decl.hpp - include/msgpack/v3/unpack.hpp - include/msgpack/v3/unpack_decl.hpp - include/msgpack/v3/vrefbuffer_decl.hpp - include/msgpack/v3/x3_parse_decl.hpp - include/msgpack/v3/x3_unpack.hpp - include/msgpack/v3/x3_unpack_decl.hpp - include/msgpack/v3/zbuffer_decl.hpp - include/msgpack/v3/zone_decl.hpp - include/msgpack/version.hpp - include/msgpack/versioning.hpp - include/msgpack/vrefbuffer.hpp - include/msgpack/vrefbuffer_decl.hpp - include/msgpack/x3_parse.hpp - include/msgpack/x3_parse_decl.hpp - include/msgpack/x3_unpack.hpp - include/msgpack/x3_unpack_decl.hpp - include/msgpack/zbuffer.hpp - include/msgpack/zbuffer_decl.hpp - include/msgpack/zone.hpp - include/msgpack/zone_decl.hpp - ) -ENDIF () diff --git a/QUICKSTART-C.md b/QUICKSTART-C.md deleted file mode 100644 index d777a84f8..000000000 --- a/QUICKSTART-C.md +++ /dev/null @@ -1,194 +0,0 @@ -# Implementation Status - -The serialization library is production-ready. - -Currently, RPC implementation is not available. - -# Install - - -## Mac OS X with MacPorts - -On Mac OS X, you can install MessagePack for C using MacPorts. - -``` -$ sudo port install msgpack -``` - -You might need to run `sudo port selfupdate` before installing to update the package repository. - -You can also install via Homebrew. - -``` -$ brew install msgpack -``` - -## FreeBSD with Ports Collection - -On FreeBSD, you can use Ports Collection. Install [net/msgpack|http://www.freebsd.org/cgi/cvsweb.cgi/ports/devel/msgpack/] package. - -## Gentoo Linux with Portage - -On Gentoo Linux, you can use emerge. Install [dev-libs/msgpack|http://gentoo-portage.com/dev-libs/msgpack] package. - -## Other UNIX-like platform with ./configure - -On the other UNIX-like platforms, download source package from [Releases|http://msgpack.org/releases/cpp/] and run `./configure && make && make install`. - -``` -$ wget http://msgpack.org/releases/cpp/msgpack-1.3.0.tar.gz -$ tar zxvf msgpack-1.3.0.tar.gz -$ cd msgpack-1.3.0 -$ ./configure -$ make -$ sudo make install -``` - -## Windows - -On Windows, download source package from [here|https://sourceforge.net/projects/msgpack/files/] and extract it. -Then open `msgpack_vc8.vcproj` file and build it using batch build. It builds libraries on `lib/` folder and header files on `include/` folder. - -You can build using command line as follows: - -``` -> vcbuild msgpack_vc2008.vcproj -> dir lib % DLL files are here -> dir include % header files are here -``` - -## Install from git repository - -You need to install gcc (4.1.0 or higher), autotools. - -``` -$ git clone git@github.com:msgpack/msgpack.git -$ cd msgpack/cpp -$ ./bootstrap -$ ./configure -$ make -$ sudo make install -``` - -# Serialization QuickStart for C - -## First program - -Include `msgpack.h` header and link `msgpack` library to use MessagePack on your program. - -```c -#include -#include - -int main(void) { - - /* creates buffer and serializer instance. */ - msgpack_sbuffer* buffer = msgpack_sbuffer_new(); - msgpack_packer* pk = msgpack_packer_new(buffer, msgpack_sbuffer_write); - - /* serializes ["Hello", "MessagePack"]. */ - msgpack_pack_array(pk, 2); - msgpack_pack_bin(pk, 5); - msgpack_pack_bin_body(pk, "Hello", 5); - msgpack_pack_bin(pk, 11); - msgpack_pack_bin_body(pk, "MessagePack", 11); - - /* deserializes it. */ - msgpack_unpacked msg; - msgpack_unpacked_init(&msg); - msgpack_unpack_return ret = msgpack_unpack_next(&msg, buffer->data, buffer->size, NULL); - - /* prints the deserialized object. */ - msgpack_object obj = msg.data; - msgpack_object_print(stdout, obj); /*=> ["Hello", "MessagePack"] */ - - /* cleaning */ - msgpack_sbuffer_free(buffer); - msgpack_packer_free(pk); -} -``` - -## Simple program with a loop - -```c -#include -#include - -int main(void) { - - /* creates buffer and serializer instance. */ - msgpack_sbuffer* buffer = msgpack_sbuffer_new(); - msgpack_packer* pk = msgpack_packer_new(buffer, msgpack_sbuffer_write); - - int j; - - for(j = 0; j<23; j++) { - /* NB: the buffer needs to be cleared on each iteration */ - msgpack_sbuffer_clear(buffer); - - /* serializes ["Hello", "MessagePack"]. */ - msgpack_pack_array(pk, 3); - msgpack_pack_bin(pk, 5); - msgpack_pack_bin_body(pk, "Hello", 5); - msgpack_pack_bin(pk, 11); - msgpack_pack_bin_body(pk, "MessagePack", 11); - msgpack_pack_int(pk, j); - - /* deserializes it. */ - msgpack_unpacked msg; - msgpack_unpacked_init(&msg); - msgpack_unpack_return ret = msgpack_unpack_next(&msg, buffer->data, buffer->size, NULL); - - /* prints the deserialized object. */ - msgpack_object obj = msg.data; - msgpack_object_print(stdout, obj); /*=> ["Hello", "MessagePack"] */ - puts(""); - } - - /* cleaning */ - msgpack_sbuffer_free(buffer); - msgpack_packer_free(pk); -} -``` - -## Streaming feature - -```c -#include -#include - -int main(void) { - /* serializes multiple objects using msgpack_packer. */ - msgpack_sbuffer* buffer = msgpack_sbuffer_new(); - msgpack_packer* pk = msgpack_packer_new(buffer, msgpack_sbuffer_write); - msgpack_pack_int(pk, 1); - msgpack_pack_int(pk, 2); - msgpack_pack_int(pk, 3); - - /* deserializes these objects using msgpack_unpacker. */ - msgpack_unpacker pac; - msgpack_unpacker_init(&pac, MSGPACK_UNPACKER_INIT_BUFFER_SIZE); - - /* feeds the buffer. */ - msgpack_unpacker_reserve_buffer(&pac, buffer->size); - memcpy(msgpack_unpacker_buffer(&pac), buffer->data, buffer->size); - msgpack_unpacker_buffer_consumed(&pac, buffer->size); - - /* now starts streaming deserialization. */ - msgpack_unpacked result; - msgpack_unpacked_init(&result); - - while(msgpack_unpacker_next(&pac, &result)) { - msgpack_object_print(stdout, result.data); - puts(""); - } - - /* results: - * $ gcc stream.cc -lmsgpackc -o stream - * $ ./stream - * 1 - * 2 - * 3 - */ -} -``` diff --git a/QUICKSTART-CPP.md b/QUICKSTART-CPP.md index fd4fadbc3..a9dc8fd8d 100644 --- a/QUICKSTART-CPP.md +++ b/QUICKSTART-CPP.md @@ -12,7 +12,7 @@ Same as QuickStart for C Language. ## First program -Include `msgpack.hpp` header and link `msgpack` library to use MessagePack on your program. +Include `msgpack.hpp` header to use MessagePack on your program. ```cpp #include diff --git a/README.md b/README.md index 149e33714..f76a265c7 100644 --- a/README.md +++ b/README.md @@ -1,7 +1,8 @@ -`msgpack` for C/C++ +`msgpack` for C++ =================== -Version 3.2.0 [![Build Status](https://travis-ci.org/msgpack/msgpack-c.svg?branch=master)](https://travis-ci.org/msgpack/msgpack-c) [![Build status](https://ci.appveyor.com/api/projects/status/8kstcgt79qj123mw/branch/master?svg=true)](https://ci.appveyor.com/project/redboltz/msgpack-c/branch/master) +Version 7.0.0 [![Build Status](https://github.com/msgpack/msgpack-c/workflows/CI/badge.svg?branch=cpp_master)](https://github.com/msgpack/msgpack-c/actions) [![Build status](https://ci.appveyor.com/api/projects/status/8kstcgt79qj123mw/branch/cpp_master?svg=true)](https://ci.appveyor.com/project/redboltz/msgpack-c/branch/cpp_master) +[![codecov](https://codecov.io/gh/msgpack/msgpack-c/branch/cpp_master/graph/badge.svg)](https://codecov.io/gh/msgpack/msgpack-c/branch/cpp_master) It's like JSON but smaller and faster. @@ -17,51 +18,6 @@ addition to the strings themselves. Example ------- -In C: - -```c -#include -#include - -int main(void) -{ - /* msgpack::sbuffer is a simple buffer implementation. */ - msgpack_sbuffer sbuf; - msgpack_sbuffer_init(&sbuf); - - /* serialize values into the buffer using msgpack_sbuffer_write callback function. */ - msgpack_packer pk; - msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write); - - msgpack_pack_array(&pk, 3); - msgpack_pack_int(&pk, 1); - msgpack_pack_true(&pk); - msgpack_pack_str(&pk, 7); - msgpack_pack_str_body(&pk, "example", 7); - - /* deserialize the buffer into msgpack_object instance. */ - /* deserialized object is valid during the msgpack_zone instance alive. */ - msgpack_zone mempool; - msgpack_zone_init(&mempool, 2048); - - msgpack_object deserialized; - msgpack_unpack(sbuf.data, sbuf.size, NULL, &mempool, &deserialized); - - /* print the deserialized object. */ - msgpack_object_print(stdout, deserialized); - puts(""); - - msgpack_zone_destroy(&mempool); - msgpack_sbuffer_destroy(&sbuf); - - return 0; -} -``` - -See [`QUICKSTART-C.md`](./QUICKSTART-C.md) for more details. - -In C++: - ```c++ #include #include @@ -107,76 +63,145 @@ int main() See [`QUICKSTART-CPP.md`](./QUICKSTART-CPP.md) for more details. +Dependency +---------- + +msgpack-c requires [boost library](https://www.boost.org/). +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. + +Experimental support for removing boost dependency + +For cmake: + +``` +cmake -DMSGPACK_USE_BOOST=OFF .. +``` + +NOTE: `-DMSGPACK_BUILD_TESTS=ON` doesn't work with `-DMSGPACK_USE_BOOST=OFF`. + +For C++ compiler + +``` +clang++ -DMSGPACK_NO_BOOST your_code.cpp +``` + + Usage ----- -### C++ Header Only Library +- If you build your project with cmake, you can find msgpack-c with a + canonical cmake-way: + + ```cmake + # ... + find_package(msgpack REQUIRED) + # ... + target_link_libraries(your_target_name msgpack-cxx) + # ... + ``` -When you use msgpack on C++, you can just add -msgpack-c/include to your include path: + 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. - g++ -I msgpack-c/include your_source_file.cpp + A usage example can be found at [test-install](test-install) directory. -If you want to use C version of msgpack, you need to build it. You can -also install the C and C++ versions of msgpack. +- If you do not use cmake, you can just add path yo msgpack-c and boost + headers to your include path: -### Building and Installing + ```bash + g++ -I msgpack-c/include -I path_to_boost your_source_file.cpp + ``` -#### Install from git repository +Building and Installing +----------------------- -##### Using the Terminal (CLI) +### Install from git repository + +#### Using the Terminal (CLI) You will need: - - `gcc >= 4.1.0` - - `cmake >= 2.8.0` +- `gcc >= 4.1.0` +- `cmake >= 3.1.0` -C and C++03: +C++03: - $ git clone https://github.com/msgpack/msgpack-c.git - $ cd msgpack-c - $ 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++11 or 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 - $ cmake -DMSGPACK_CXX[11|17]=ON . - $ sudo make install +```bash +cmake . +``` + +with a line like that: + +```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. -`MSGPACK_CXX[11|17]` flags are not affected to installing files. Just switching 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: -When you use the C part of `msgpack-c`, you need to build and link the library. By default, both static/shared libraries are built. If you want to build only static library, set `BUILD_SHARED_LIBS=OFF` to cmake. If you want to build only shared library, set `BUILD_SHARED_L +```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) +- `MSGPACK_CHAR_SIGN` (not set explicitly by default): char sign to use (signed or unsigned) +- `MSGPACK_USE_STATIC_BOOST` (default `OFF`): statically link with boost libraries #### 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. Launch [cmake GUI client](http://www.cmake.org/cmake/resources/software.html). +2. Launch [cmake GUI client](http://www.cmake.org/cmake/resources/software.html). -2. 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. -3. Click 'Configure' button. +4. Click 'Configure' button. -4. Choose your Visual Studio version. +5. Choose your Visual Studio version. -5. Click 'Generate' button. +6. Click 'Generate' button. -6. Open the created msgpack.sln on Visual Studio. +7. Open the created msgpack.sln on Visual Studio. -7. Build all. +8. Build all. -### Documentation +Documentation +------------- You can get additional information including the tutorial on the [wiki](https://github.com/msgpack/msgpack-c/wiki). diff --git a/appveyor.yml b/appveyor.yml index c2c00b532..3385097ad 100644 --- a/appveyor.yml +++ b/appveyor.yml @@ -1,58 +1,56 @@ -version: 3.2.0.{build} +version: 7.0.0.{build} + +branches: + only: + - cpp_master -image: -- Visual Studio 2015 environment: - global: - BOOST_ROOT: C:\Libraries\boost_1_67_0 matrix: - - cpp11: -DMSGPACK_CXX11=OFF - boost: -DMSGPACK_BOOST=OFF - msvc: '"Visual Studio 10 2010"' - - cpp11: -DMSGPACK_CXX11=OFF - boost: -DMSGPACK_BOOST=OFF - msvc: '"Visual Studio 11 2012"' - - cpp11: -DMSGPACK_CXX11=OFF - boost: -DMSGPACK_BOOST=OFF - msvc: '"Visual Studio 12 2013"' - - cpp11: -DMSGPACK_CXX11=ON - boost: -DMSGPACK_BOOST=ON - msvc: '"Visual Studio 14 2015"' - - cpp11: -DMSGPACK_CXX11=OFF - boost: -DMSGPACK_BOOST=ON - msvc: '"Visual Studio 14 2015"' - - cpp11: -DMSGPACK_CXX11=ON - boost: -DMSGPACK_BOOST=OFF - msvc: '"Visual Studio 14 2015"' - - cpp11: -DMSGPACK_CXX11=OFF - boost: -DMSGPACK_BOOST=OFF + - 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: -- 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 > NUL -- cd googletest-release-1.7.0 -- md build -- cd build -- cmake -G %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 > NUL -- 7z x zlib-1.2.11.tar > NUL -- cd zlib-1.2.11 -- md build -- cd build -- cmake -G %msvc% .. -- cmake --build . --config Release -- copy zconf.h .. -- cd .. -- cd .. -- md build -- cd build -- cmake -G %msvc% %cpp11% %boost% %x3_parse% -DGTEST_LIBRARY=%APPVEYOR_BUILD_FOLDER%\googletest-release-1.7.0\build\Release\gtest.lib -DGTEST_MAIN_LIBRARY=%APPVEYOR_BUILD_FOLDER%\googletest-release-1.7.0\build\Release\gtest_main.lib -DGTEST_INCLUDE_DIR=%APPVEYOR_BUILD_FOLDER%\googletest-release-1.7.0\include -DZLIB_LIBRARY=%APPVEYOR_BUILD_FOLDER%\zlib-1.2.11\build\Release\zlib.lib -DZLIB_INCLUDE_DIR=%APPVEYOR_BUILD_FOLDER%\zlib-1.2.11 -DCMAKE_CXX_FLAGS='"/D_VARIADIC_MAX=10 /EHsc"' .. -- cmake --build . --config Release + - ps: | + appveyor DownloadFile http://zlib.net/zlib-1.3.1.tar.gz -FileName zlib-1.3.1.tar.gz + 7z x zlib-1.3.1.tar.gz 2> $null + 7z x zlib-1.3.1.tar 2> $null + cd zlib-1.3.1 + + md build + md prefix + cd build + + cmake ` + -G $env:msvc ` + -D CMAKE_INSTALL_PREFIX="$env:APPVEYOR_BUILD_FOLDER\zlib-1.3.1\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.3.1\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 + 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.3.1\build\Release;%APPVEYOR_BUILD_FOLDER%\build\release;%boost_prefix%\%boost_subdir% +- ctest -VV -C Release diff --git a/ci/build_cmake.sh b/ci/build_cmake.sh index 820ec5437..b6ad78c50 100755 --- a/ci/build_cmake.sh +++ b/ci/build_cmake.sh @@ -1,63 +1,38 @@ #!/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" else export BIT32="OFF" + export ARCH_FLAG="-m64" fi -cmake -DMSGPACK_CXX11=${CXX11} -DMSGPACK_CXX17=${CXX17} -DMSGPACK_32BIT=${BIT32} -DMSGPACK_BOOST=${BOOST} -DBUILD_SHARED_LIBS=${SHARED} -DMSGPACK_CHAR_SIGN=${CHAR_SIGN} -DMSGPACK_DEFAULT_API_VERSION=${API_VERSION} -DMSGPACK_USE_X3_PARSE=${X3_PARSE} .. +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 MSGPACK_USE_STD_VARIANT_ADAPTOR=${STD_VARIANT_ADAPTOR} \ + -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 - -make +cmake --build $build_dir --target install || exit 1 -ret=$? -if [ $ret -ne 0 ] -then - exit $ret -fi +ctest -VV --test-dir $build_dir || exit 1 -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 ] @@ -72,4 +47,15 @@ then fi fi -exit 0 +if [ "${ARCH}" != "32" ]; then + cd test-install || exit 1 + + 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 + + $build_dir/test-install || exit 1 +fi diff --git a/ci/build_regression.sh b/ci/build_regression.sh index 1cd3f1753..0d4b94b39 100755 --- a/ci/build_regression.sh +++ b/ci/build_regression.sh @@ -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_BOOST=${BOOST} -DMSGPACK_SAN=${MSGPACK_SAN} -v .. +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 - -make - -ret=$? -if [ $ret -ne 0 ] -then - exit $ret -fi - -make test - -ret=$? -if [ $ret -ne 0 ] -then - exit $ret -fi +cmake --build $build_dir --target all || exit 1 -exit 0 +ctest -VV --test-dir $build_dir || exit 1 diff --git a/ci/set_gcc_10.sh b/ci/set_gcc_10.sh new file mode 100755 index 000000000..dd47d049a --- /dev/null +++ b/ci/set_gcc_10.sh @@ -0,0 +1,17 @@ +#!/bin/bash + +version=10 +priority=100 + +sudo update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-${version} ${priority} +sudo update-alternatives --install /usr/bin/gcc-ar gcc-ar /usr/bin/gcc-ar-${version} ${priority} +sudo update-alternatives --install /usr/bin/gcc-nm gcc-nm /usr/bin/gcc-nm-${version} ${priority} +sudo update-alternatives --install /usr/bin/gcc-ranlib gcc-ranlib /usr/bin/gcc-ranlib-${version} ${priority} +sudo update-alternatives --install /usr/bin/gcov gcov /usr/bin/gcov-${version} ${priority} +sudo update-alternatives --install /usr/bin/gcov-dump gcov-dump /usr/bin/gcov-dump-${version} ${priority} +sudo update-alternatives --install /usr/bin/gcov-tool gcov-tool /usr/bin/gcov-tool-${version} ${priority} +sudo update-alternatives --install /usr/bin/lto-dump lto-dump /usr/bin/lto-dump-${version} ${priority} +sudo update-alternatives --install /usr/bin/g++ g++ /usr/bin/g++-${version} ${priority} + +sudo update-alternatives --install /usr/bin/cc cc /usr/bin/gcc-${version} ${priority} +sudo update-alternatives --install /usr/bin/c++ c++ /usr/bin/g++-${version} ${priority} diff --git a/cmake/CodeCoverage.cmake b/cmake/CodeCoverage.cmake new file mode 100644 index 000000000..d24c2b586 --- /dev/null +++ b/cmake/CodeCoverage.cmake @@ -0,0 +1,55 @@ +# Check prereqs +FIND_PROGRAM(GCOV_PATH gcov) +FIND_PROGRAM(LCOV_PATH lcov) +FIND_PROGRAM(GENHTML_PATH genhtml) + +IF(NOT GCOV_PATH) + MESSAGE(FATAL_ERROR "gcov not found! Aborting...") +ENDIF() + +IF(NOT CMAKE_COMPILER_IS_GNUCC AND NOT CMAKE_COMPILER_IS_GNUCXX) + # Clang version 3.0.0 and greater now supports gcov as well. + MESSAGE(STATUS "Compiler is not GNU gcc! Clang Version 3.0.0 and greater supports gcov as well, but older versions don't.") + IF(NOT "${CMAKE_C_COMPILER_ID}" MATCHES "Clang" AND NOT "${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang") + MESSAGE(FATAL_ERROR "Compiler is not GNU gcc! Aborting...") + ENDIF() +ENDIF() + +SET(COVERAGE_FLAGS "-g -O0 --coverage") + +FUNCTION(SETUP_TARGET_FOR_COVERAGE _targetname _testrunner _outputname) + + IF(NOT LCOV_PATH) + MESSAGE(FATAL_ERROR "lcov not found! Aborting...") + ENDIF() + + IF(NOT GENHTML_PATH) + MESSAGE(FATAL_ERROR "genhtml not found! Aborting...") + ENDIF() + + # Setup target + ADD_CUSTOM_TARGET(${_targetname} + + # Cleanup lcov + ${LCOV_PATH} --directory . --zerocounters + + # Run tests + COMMAND ${_testrunner} ${ARGV3} + + # Capturing lcov counters and generating report + COMMAND ${LCOV_PATH} --directory . --capture --output-file ${_outputname}.info --base-directory ${CMAKE_SOURCE_DIR} --no-external --quiet + COMMAND ${LCOV_PATH} --remove ${_outputname}.info '*/test/*' '*/fuzz/*' --output-file ${_outputname}.info.cleaned --quiet + COMMAND ${GENHTML_PATH} -o ${_outputname} ${_outputname}.info.cleaned --prefix ${CMAKE_SOURCE_DIR} + # COMMAND ${CMAKE_COMMAND} -E remove ${_outputname}.info ${_outputname}.info.cleaned + + WORKING_DIRECTORY ${CMAKE_BINARY_DIR} + COMMENT "Resetting code coverage counters to zero.\nProcessing code coverage counters and generating report." + ) + + # Show info where to find the report + ADD_CUSTOM_COMMAND(TARGET ${_targetname} POST_BUILD + COMMAND ; + COMMENT "Open ./${_outputname}/index.html in your browser to view the coverage report." + ) + +ENDFUNCTION() diff --git a/codecov.yml b/codecov.yml new file mode 100644 index 000000000..caa300582 --- /dev/null +++ b/codecov.yml @@ -0,0 +1,36 @@ +codecov: + notify: + require_ci_to_pass: yes + +coverage: + precision: 2 + round: down + range: "70...100" + + status: + project: yes + patch: yes + changes: no + +parsers: + gcov: + branch_detection: + conditional: yes + loop: yes + method: no + macro: no + +comment: + layout: "header, diff" + behavior: default + require_changes: no + +ignore: + - "test" + - "fuzz" + - "erb" + - "ci" + - "cmake" + - "examle" + - "external" + - "usr" diff --git a/erb/v1/cpp03_zone.hpp.erb b/erb/v1/cpp03_zone.hpp.erb index 7dfc35c05..6b3a57d3e 100644 --- a/erb/v1/cpp03_zone.hpp.erb +++ b/erb/v1/cpp03_zone.hpp.erb @@ -10,7 +10,15 @@ #ifndef MSGPACK_V1_CPP03_ZONE_HPP #define MSGPACK_V1_CPP03_ZONE_HPP +#include "msgpack/versioning.hpp" +#include "msgpack/cpp_config.hpp" #include "msgpack/zone_decl.hpp" +#include "msgpack/assert.hpp" + +#include +#include +#include +#include <% GENERATION_LIMIT = 15 %> namespace msgpack { @@ -130,7 +138,7 @@ class zone { finalizer_array m_finalizer_array; public: - zone(size_t chunk_size = MSGPACK_ZONE_CHUNK_SIZE) /* throw() */; + zone(size_t chunk_size = MSGPACK_ZONE_CHUNK_SIZE); public: void* allocate_align(size_t size, size_t align = MSGPACK_ZONE_ALIGN); @@ -186,16 +194,17 @@ private: zone& operator=(const zone&); }; -inline zone::zone(size_t chunk_size) /* throw() */ :m_chunk_size(chunk_size), m_chunk_list(m_chunk_size) +inline zone::zone(size_t chunk_size):m_chunk_size(chunk_size), m_chunk_list(m_chunk_size) { } inline char* zone::get_aligned(char* ptr, size_t align) { + MSGPACK_ASSERT(align != 0 && (align & (align - 1)) == 0); // align must be 2^n (n >= 0) return reinterpret_cast( - reinterpret_cast( - (ptr + (align - 1))) / align * align); + reinterpret_cast(ptr + (align - 1)) & ~static_cast(align - 1) + ); } inline void* zone::allocate_align(size_t size, size_t align) diff --git a/example/CMakeLists.txt b/example/CMakeLists.txt index ea3c7db2e..bcc0b16d0 100644 --- a/example/CMakeLists.txt +++ b/example/CMakeLists.txt @@ -1,5 +1,9 @@ -ADD_SUBDIRECTORY (c) ADD_SUBDIRECTORY (cpp03) ADD_SUBDIRECTORY (cpp11) -ADD_SUBDIRECTORY (boost) -ADD_SUBDIRECTORY (x3) + +IF (MSGPACK_USE_BOOST) + ADD_SUBDIRECTORY (boost) + IF (MSGPACK_USE_X3_PARSE) + ADD_SUBDIRECTORY (x3) + ENDIF () +ENDIF () diff --git a/example/boost/CMakeLists.txt b/example/boost/CMakeLists.txt index cf7f4f86e..6464513b3 100644 --- a/example/boost/CMakeLists.txt +++ b/example/boost/CMakeLists.txt @@ -1,21 +1,16 @@ -IF (MSGPACK_BOOST) - 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 (ZLIB_FOUND) - INCLUDE_DIRECTORIES ( - ${ZLIB_INCLUDE_DIRS} - ) - LIST (APPEND exec_PROGRAMS - asio_send_recv_zlib.cpp - ) - ENDIF () +FIND_PACKAGE (Boost REQUIRED) +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_CXX14 OR MSGPACK_CXX17 OR MSGPACK_CXX20) + LIST (APPEND exec_PROGRAMS asio_send_recv.cpp) + IF (ZLIB_FOUND) + LIST (APPEND exec_PROGRAMS asio_send_recv_zlib.cpp) ENDIF () ENDIF () @@ -25,24 +20,18 @@ FOREACH (source_file ${exec_PROGRAMS}) ${source_file_we} ${source_file} ) - TARGET_INCLUDE_DIRECTORIES (${source_file_we} - PRIVATE - $ - ) - TARGET_LINK_LIBRARIES (${source_file_we} - ${Boost_SYSTEM_LIBRARY} - ${CMAKE_THREAD_LIBS_INIT} + TARGET_LINK_LIBRARIES (${source_file_we} PRIVATE + msgpack-cxx + Threads::Threads ) IF (ZLIB_FOUND) - TARGET_LINK_LIBRARIES (${source_file_we} - ${ZLIB_LIBRARIES} - ) - ENDIF() - IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang" OR "${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU") + 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 () - IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang") + IF ("${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang") SET_PROPERTY (TARGET ${source_file_we} APPEND_STRING PROPERTY COMPILE_FLAGS " -Wno-mismatched-tags") ENDIF () diff --git a/example/boost/asio_send_recv_zlib.cpp b/example/boost/asio_send_recv_zlib.cpp index 885e8807b..cffff2b20 100644 --- a/example/boost/asio_send_recv_zlib.cpp +++ b/example/boost/asio_send_recv_zlib.cpp @@ -85,12 +85,12 @@ int main() { } std::cout << bytes_transferred << " bytes read." << std::endl; print(std::string(std::string(&buf[0], buf.size()))); - strm.avail_in = bytes_transferred; + strm.avail_in = static_cast(bytes_transferred); do { strm.next_in = reinterpret_cast(&buf[0]) + (bytes_transferred - strm.avail_in); int zret; unp.reserve_buffer(window_size); - strm.avail_out = window_size; + strm.avail_out = static_cast(window_size); strm.next_out = reinterpret_cast(unp.buffer()); do { zret = inflate(&strm, Z_NO_FLUSH); diff --git a/example/c/CMakeLists.txt b/example/c/CMakeLists.txt deleted file mode 100644 index eee47a609..000000000 --- a/example/c/CMakeLists.txt +++ /dev/null @@ -1,42 +0,0 @@ -IF (MSGPACK_ENABLE_SHARED) - SET (MSGPACK_LIB msgpackc) -ENDIF () - -IF (MSGPACK_ENABLE_STATIC) - SET (MSGPACK_LIB msgpackc-static) -ENDIF () - - -LIST (APPEND exec_PROGRAMS - lib_buffer_unpack.c - simple_c.c - speed_test_uint32_array.c - speed_test_uint64_array.c - user_buffer_unpack.c -) - -FOREACH (source_file ${exec_PROGRAMS}) - GET_FILENAME_COMPONENT (source_file_we ${source_file} NAME_WE) - ADD_EXECUTABLE ( - ${source_file_we} - ${source_file} - ) - TARGET_LINK_LIBRARIES (${source_file_we} - ${MSGPACK_LIB} - ) - IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang" OR "${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU") - SET_PROPERTY (TARGET ${source_file_we} APPEND_STRING PROPERTY COMPILE_FLAGS " -Wall -Wextra") - ENDIF () - - IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang") - SET_PROPERTY (TARGET ${source_file_we} APPEND_STRING PROPERTY COMPILE_FLAGS " -Wno-mismatched-tags") - 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 () - ENDIF () -ENDFOREACH () diff --git a/example/c/lib_buffer_unpack.c b/example/c/lib_buffer_unpack.c deleted file mode 100644 index 4c7b69a99..000000000 --- a/example/c/lib_buffer_unpack.c +++ /dev/null @@ -1,127 +0,0 @@ -#include -#include -#include - - -typedef struct receiver { - msgpack_sbuffer sbuf; - size_t rest; -} receiver; - -void receiver_init(receiver *r) { - msgpack_packer pk; - - msgpack_sbuffer_init(&r->sbuf); - msgpack_packer_init(&pk, &r->sbuf, msgpack_sbuffer_write); - /* 1st object */ - msgpack_pack_array(&pk, 3); - msgpack_pack_int(&pk, 1); - msgpack_pack_true(&pk); - msgpack_pack_str(&pk, 7); - msgpack_pack_str_body(&pk, "example", 7); - /* 2nd object */ - msgpack_pack_str(&pk, 6); - msgpack_pack_str_body(&pk, "second", 6); - /* 3rd object */ - msgpack_pack_array(&pk, 2); - msgpack_pack_int(&pk, 42); - msgpack_pack_false(&pk); - r->rest = r->sbuf.size; -} - -size_t receiver_recv(receiver *r, char* buf, size_t try_size) { - size_t off = r->sbuf.size - r->rest; - - size_t actual_size = try_size; - if (actual_size > r->rest) actual_size = r->rest; - - memcpy(buf, r->sbuf.data + off, actual_size); - r->rest -= actual_size; - - return actual_size; -} - -size_t receiver_to_unpacker(receiver* r, size_t request_size, - msgpack_unpacker *unpacker) -{ - size_t recv_len; - // make sure there's enough room, or expand the unpacker accordingly - if (msgpack_unpacker_buffer_capacity(unpacker) < request_size) { - msgpack_unpacker_reserve_buffer(unpacker, request_size); - assert(msgpack_unpacker_buffer_capacity(unpacker) >= request_size); - } - recv_len = receiver_recv(r, msgpack_unpacker_buffer(unpacker), - request_size); - msgpack_unpacker_buffer_consumed(unpacker, recv_len); - return recv_len; -} - -#define EACH_RECV_SIZE 4 - -void unpack(receiver* r) { - /* buf is allocated by unpacker. */ - msgpack_unpacker* unp = msgpack_unpacker_new(100); - msgpack_unpacked result; - msgpack_unpack_return ret; - size_t recv_len; - int recv_count = 0; - int i = 0; - - msgpack_unpacked_init(&result); - while (true) { - recv_len = receiver_to_unpacker(r, EACH_RECV_SIZE, unp); - if (recv_len == 0) break; // (reached end of input) -#if defined(_MSC_VER) || defined(__MINGW32__) - printf("receive count: %d %Id bytes received.\n", recv_count++, recv_len); -#else // defined(_MSC_VER) || defined(__MINGW32__) - printf("receive count: %d %zd bytes received.\n", recv_count++, recv_len); -#endif // defined(_MSC_VER) || defined(__MINGW32__) - ret = msgpack_unpacker_next(unp, &result); - while (ret == MSGPACK_UNPACK_SUCCESS) { - msgpack_object obj = result.data; - - /* Use obj. */ - printf("Object no %d:\n", ++i); - msgpack_object_print(stdout, obj); - printf("\n"); - /* If you want to allocate something on the zone, you can use zone. */ - /* msgpack_zone* zone = result.zone; */ - /* The lifetime of the obj and the zone, */ - - ret = msgpack_unpacker_next(unp, &result); - } - if (ret == MSGPACK_UNPACK_PARSE_ERROR) { - printf("The data in the buf is invalid format.\n"); - msgpack_unpacked_destroy(&result); - return; - } - } - msgpack_unpacked_destroy(&result); - msgpack_unpacker_free(unp); -} - -int main(void) { - receiver r; - receiver_init(&r); - - unpack(&r); - - return 0; -} - -/* Output */ - -/* -receive count: 0 4 bytes received. -receive count: 1 4 bytes received. -receive count: 2 4 bytes received. -Object no 1: -[1, true, "example"] -receive count: 3 4 bytes received. -receive count: 4 4 bytes received. -Object no 2: -"second" -receive count: 5 1 bytes received. -Object no 3: -[42, false] -*/ diff --git a/example/c/simple_c.c b/example/c/simple_c.c deleted file mode 100644 index b3bd09022..000000000 --- a/example/c/simple_c.c +++ /dev/null @@ -1,47 +0,0 @@ -#include -#include - -void print(char const* buf, unsigned int len) -{ - size_t i = 0; - for(; i < len ; ++i) - printf("%02x ", 0xff & buf[i]); - printf("\n"); -} - -int main(void) -{ - msgpack_sbuffer sbuf; - msgpack_packer pk; - msgpack_zone mempool; - msgpack_object deserialized; - - /* msgpack::sbuffer is a simple buffer implementation. */ - msgpack_sbuffer_init(&sbuf); - - /* serialize values into the buffer using msgpack_sbuffer_write callback function. */ - msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write); - - msgpack_pack_array(&pk, 3); - msgpack_pack_int(&pk, 1); - msgpack_pack_true(&pk); - msgpack_pack_str(&pk, 7); - msgpack_pack_str_body(&pk, "example", 7); - - print(sbuf.data, sbuf.size); - - /* deserialize the buffer into msgpack_object instance. */ - /* deserialized object is valid during the msgpack_zone instance alive. */ - msgpack_zone_init(&mempool, 2048); - - msgpack_unpack(sbuf.data, sbuf.size, NULL, &mempool, &deserialized); - - /* print the deserialized object. */ - msgpack_object_print(stdout, deserialized); - puts(""); - - msgpack_zone_destroy(&mempool); - msgpack_sbuffer_destroy(&sbuf); - - return 0; -} diff --git a/example/c/speed_test_uint32_array.c b/example/c/speed_test_uint32_array.c deleted file mode 100644 index b07cd9189..000000000 --- a/example/c/speed_test_uint32_array.c +++ /dev/null @@ -1,36 +0,0 @@ -#include - -void test() -{ - size_t size = 10000000; - msgpack_sbuffer buf; - msgpack_packer * pk; - size_t upk_pos = 0; - msgpack_unpacked msg; - - msgpack_sbuffer_init(&buf); - - pk = msgpack_packer_new(&buf, msgpack_sbuffer_write); - - msgpack_pack_array(pk, size); - { - size_t idx = 0; - for (; idx < size; ++idx) - msgpack_pack_uint32(pk, 1); - } - msgpack_packer_free(pk); - - msgpack_unpacked_init(&msg); - - while (msgpack_unpack_next(&msg, buf.data, buf.size, &upk_pos) == MSGPACK_UNPACK_SUCCESS) { - } - - msgpack_sbuffer_destroy(&buf); -} - -int main(void) -{ - int i = 0; - for (; i < 10; ++i) test(); - return 0; -} diff --git a/example/c/speed_test_uint64_array.c b/example/c/speed_test_uint64_array.c deleted file mode 100644 index 88cc82226..000000000 --- a/example/c/speed_test_uint64_array.c +++ /dev/null @@ -1,37 +0,0 @@ -#include - -void test() -{ - uint64_t test_u64 = 0xFFF0000000000001LL; - size_t size = 10000000; - msgpack_sbuffer buf; - msgpack_packer * pk; - size_t upk_pos = 0; - msgpack_unpacked msg; - - msgpack_sbuffer_init(&buf); - - pk = msgpack_packer_new(&buf, msgpack_sbuffer_write); - - msgpack_pack_array(pk, size); - { - size_t idx = 0; - for (; idx < size; ++idx) - msgpack_pack_uint64(pk, test_u64); - } - msgpack_packer_free(pk); - - msgpack_unpacked_init(&msg); - - while (msgpack_unpack_next(&msg, buf.data, buf.size, &upk_pos) == MSGPACK_UNPACK_SUCCESS) { - } - - msgpack_sbuffer_destroy(&buf); -} - -int main(void) -{ - int i = 0; - for (; i < 10; ++i) test(); - return 0; -} diff --git a/example/c/user_buffer_unpack.c b/example/c/user_buffer_unpack.c deleted file mode 100644 index 646a9f67b..000000000 --- a/example/c/user_buffer_unpack.c +++ /dev/null @@ -1,81 +0,0 @@ -#include -#include -#include - -#define UNPACKED_BUFFER_SIZE 2048 - -void prepare(msgpack_sbuffer* sbuf) { - msgpack_packer pk; - - msgpack_packer_init(&pk, sbuf, msgpack_sbuffer_write); - /* 1st object */ - msgpack_pack_array(&pk, 3); - msgpack_pack_int(&pk, 1); - msgpack_pack_true(&pk); - msgpack_pack_str(&pk, 7); - msgpack_pack_str_body(&pk, "example", 7); - /* 2nd object */ - msgpack_pack_str(&pk, 6); - msgpack_pack_str_body(&pk, "second", 6); - /* 3rd object */ - msgpack_pack_array(&pk, 2); - msgpack_pack_int(&pk, 42); - msgpack_pack_false(&pk); -} - -void unpack(char const* buf, size_t len) { - /* buf is allocated by client. */ - msgpack_unpacked result; - size_t off = 0; - msgpack_unpack_return ret; - int i = 0; - char unpacked_buffer[UNPACKED_BUFFER_SIZE]; - msgpack_unpacked_init(&result); - ret = msgpack_unpack_next(&result, buf, len, &off); - while (ret == MSGPACK_UNPACK_SUCCESS) { - msgpack_object obj = result.data; - - /* Use obj. */ - printf("Object no %d:\n", ++i); - msgpack_object_print(stdout, obj); - printf("\n"); - msgpack_object_print_buffer(unpacked_buffer, UNPACKED_BUFFER_SIZE, obj); - printf("%s\n", unpacked_buffer); - /* If you want to allocate something on the zone, you can use zone. */ - /* msgpack_zone* zone = result.zone; */ - /* The lifetime of the obj and the zone, */ - - ret = msgpack_unpack_next(&result, buf, len, &off); - } - msgpack_unpacked_destroy(&result); - - if (ret == MSGPACK_UNPACK_CONTINUE) { - printf("All msgpack_object in the buffer is consumed.\n"); - } - else if (ret == MSGPACK_UNPACK_PARSE_ERROR) { - printf("The data in the buf is invalid format.\n"); - } -} - -int main(void) { - msgpack_sbuffer sbuf; - msgpack_sbuffer_init(&sbuf); - - prepare(&sbuf); - unpack(sbuf.data, sbuf.size); - - msgpack_sbuffer_destroy(&sbuf); - return 0; -} - -/* Output */ - -/* -Object no 1: -[1, true, "example"] -Object no 2: -"second" -Object no 3: -[42, false] -All msgpack_object in the buffer is consumed. -*/ diff --git a/example/cpp03/CMakeLists.txt b/example/cpp03/CMakeLists.txt index 4af7f6d1a..90c493f04 100644 --- a/example/cpp03/CMakeLists.txt +++ b/example/cpp03/CMakeLists.txt @@ -1,3 +1,7 @@ +FIND_PACKAGE (Threads REQUIRED) + +FIND_PACKAGE (Boost COMPONENTS timer) + LIST (APPEND exec_PROGRAMS class_intrusive.cpp class_intrusive_map.cpp @@ -22,11 +26,14 @@ IF (NOT MSVC) ) ENDIF () -IF (MSGPACK_BOOST) - LIST (APPEND with_boost_lib_PROGRAMS - speed_test.cpp - speed_test_nested_array.cpp - ) + +IF (MSGPACK_USE_BOOST) + IF (Boost_TIMER_LIBRARY) + LIST (APPEND with_boost_lib_PROGRAMS + speed_test.cpp + speed_test_nested_array.cpp + ) + ENDIF () ENDIF () FOREACH (source_file ${exec_PROGRAMS}) @@ -35,11 +42,10 @@ FOREACH (source_file ${exec_PROGRAMS}) ${source_file_we} ${source_file} ) - TARGET_INCLUDE_DIRECTORIES (${source_file_we} - PRIVATE - $ + TARGET_LINK_LIBRARIES (${source_file_we} PRIVATE + msgpack-cxx ) - IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang" OR "${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU") + 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 () IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC") @@ -57,14 +63,11 @@ FOREACH (source_file ${with_pthread_PROGRAMS}) ${source_file_we} ${source_file} ) - TARGET_INCLUDE_DIRECTORIES (${source_file_we} - PRIVATE - $ - ) - TARGET_LINK_LIBRARIES (${source_file_we} - ${CMAKE_THREAD_LIBS_INIT} + TARGET_LINK_LIBRARIES (${source_file_we} PRIVATE + msgpack-cxx + Threads::Threads ) - IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang" OR "${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU") + 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 () IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC") @@ -77,36 +80,26 @@ 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 - $ - ) - 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 + msgpack-cxx + Boost::timer ) IF (NOT MSVC AND NOT APPLE) - TARGET_LINK_LIBRARIES (${source_file_we} + TARGET_LINK_LIBRARIES (${source_file_we} PRIVATE rt ) ENDIF () - IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang" OR "${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU") + 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 -Werror -O3") ENDIF () - IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang") + IF ("${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang") SET_PROPERTY (TARGET ${source_file_we} APPEND_STRING PROPERTY COMPILE_FLAGS " -Wno-mismatched-tags") ENDIF () diff --git a/example/cpp11/CMakeLists.txt b/example/cpp11/CMakeLists.txt index c932a6035..be16d118d 100644 --- a/example/cpp11/CMakeLists.txt +++ b/example/cpp11/CMakeLists.txt @@ -1,8 +1,4 @@ -IF (MSGPACK_CXX11) - INCLUDE_DIRECTORIES ( - ../include - ) - +IF (MSGPACK_CXX11 OR MSGPACK_CXX14 OR MSGPACK_CXX17) LIST (APPEND exec_PROGRAMS container.cpp non_def_con_class.cpp @@ -20,15 +16,14 @@ IF (MSGPACK_CXX11) ${source_file_we} ${source_file} ) - TARGET_INCLUDE_DIRECTORIES (${source_file_we} - PRIVATE - $ + TARGET_LINK_LIBRARIES (${source_file_we} PRIVATE + msgpack-cxx ) - IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang" OR "${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU") + 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 () - IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang") + IF ("${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang") SET_PROPERTY (TARGET ${source_file_we} APPEND_STRING PROPERTY COMPILE_FLAGS " -Wno-mismatched-tags") ENDIF () diff --git a/example/cpp11/container.cpp b/example/cpp11/container.cpp index 59806d83a..60b5d4b81 100644 --- a/example/cpp11/container.cpp +++ b/example/cpp11/container.cpp @@ -25,8 +25,9 @@ void array() { std::stringstream ss; msgpack::pack(ss, a); - msgpack::object_handle oh = msgpack::unpack(ss.str().data(), ss.str().size()); - msgpack::object obj = oh.get(); + auto const& str = ss.str(); + auto oh = msgpack::unpack(str.data(), str.size()); + auto obj = oh.get(); std::cout << obj << std::endl; assert((obj.as>()) == a); diff --git a/example/x3/CMakeLists.txt b/example/x3/CMakeLists.txt index 05725fb11..963d6da4f 100644 --- a/example/x3/CMakeLists.txt +++ b/example/x3/CMakeLists.txt @@ -1,32 +1,27 @@ IF (MSGPACK_USE_X3_PARSE AND MSGPACK_DEFAULT_API_VERSION VERSION_GREATER 1) - INCLUDE_DIRECTORIES ( - ../include - ) + FIND_PACKAGE (Boost REQUIRED COMPONENTS context) + FIND_PACKAGE (Threads REQUIRED) LIST (APPEND exec_PROGRAMS unpack.cpp parse.cpp ) - IF (MSGPACK_BOOST) - LIST (APPEND with_boost_PROGRAMS - stream_unpack.cpp - ) - ENDIF () + LIST (APPEND with_boost_PROGRAMS + stream_unpack.cpp + ) FOREACH (source_file ${exec_PROGRAMS}) GET_FILENAME_COMPONENT (source_file_we ${source_file} NAME_WE) ADD_EXECUTABLE ( ${source_file_we} ${source_file} ) - TARGET_INCLUDE_DIRECTORIES (${source_file_we} - PRIVATE - $ - ) - IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang" OR "${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU") + TARGET_LINK_LIBRARIES (${source_file_we} PRIVATE msgpack-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 () - IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang") + IF ("${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang") SET_PROPERTY (TARGET ${source_file_we} APPEND_STRING PROPERTY COMPILE_FLAGS " -Wno-mismatched-tags") ENDIF () @@ -44,20 +39,16 @@ 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_LINK_LIBRARIES (${source_file_we} - ${Boost_CONTEXT_LIBRARY} - ${Boost_SYSTEM_LIBRARY} - ${CMAKE_THREAD_LIBS_INIT} + TARGET_LINK_LIBRARIES (${source_file_we} PRIVATE + msgpack-cxx + Boost::context + Threads::Threads ) - IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang" OR "${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU") + 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 () - IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang") + IF ("${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang") SET_PROPERTY (TARGET ${source_file_we} APPEND_STRING PROPERTY COMPILE_FLAGS " -Wno-mismatched-tags") ENDIF () diff --git a/external/boost/predef b/external/boost/predef deleted file mode 160000 index 560ff5298..000000000 --- a/external/boost/predef +++ /dev/null @@ -1 +0,0 @@ -Subproject commit 560ff5298ead78276872604f1ee6523e63a4fa90 diff --git a/external/boost/preprocessor b/external/boost/preprocessor deleted file mode 160000 index 56090c56b..000000000 --- a/external/boost/preprocessor +++ /dev/null @@ -1 +0,0 @@ -Subproject commit 56090c56b5c78418b6dbe8c3c2ba576395152f83 diff --git a/fuzz/CMakeLists.txt b/fuzz/CMakeLists.txt index efa036f3f..977968741 100644 --- a/fuzz/CMakeLists.txt +++ b/fuzz/CMakeLists.txt @@ -1,36 +1,30 @@ -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 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 ( ${source_file_we} ${source_file} ) + + TARGET_COMPILE_DEFINITIONS (${source_file_we} PRIVATE + $,,BOOST_TEST_DYN_LINK>) + TARGET_LINK_LIBRARIES (${source_file_we} - msgpackc - ${GTEST_BOTH_LIBRARIES} - ${ZLIB_LIBRARIES} - ${CMAKE_THREAD_LIBS_INIT} - ${Boost_LIBRARIES} + msgpack-cxx + Threads::Threads + Boost::filesystem + Boost::unit_test_framework ) + ADD_TEST (${source_file_we} ${source_file_we}) - IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang") + + IF ("${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang") SET_PROPERTY (TARGET ${source_file_we} APPEND_STRING PROPERTY COMPILE_FLAGS "-Wall -Wextra -Wno-mismatched-tags -g") IF ("${MSGPACK_SAN}" STREQUAL "ASAN") SET (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fno-omit-frame-pointer -fsanitize=address") diff --git a/fuzz/regression_runner.cpp b/fuzz/regression_runner.cpp index 7b67222cb..3f423beaf 100644 --- a/fuzz/regression_runner.cpp +++ b/fuzz/regression_runner.cpp @@ -1,50 +1,49 @@ #include -#include + +// 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 +#include #include -#include +#include #include #include "unpack_pack_fuzzer.cpp" -using ::testing::TestWithParam; -using ::testing::ValuesIn; - - std::vector ListDirectory(const std::string& path) { std::vector 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 { -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 bytes(length); in.read(bytes.data(), bytes.size()); - assert(in); - EXPECT_EQ(0, LLVMFuzzerTestOneInput(reinterpret_cast(bytes.data()), - bytes.size())); + BOOST_REQUIRE(in); + BOOST_REQUIRE_EQUAL(0, LLVMFuzzerTestOneInput(reinterpret_cast(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 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; +} diff --git a/fuzz/unpack_pack_fuzzer.cpp b/fuzz/unpack_pack_fuzzer.cpp index c0467610d..b74f2cb34 100644 --- a/fuzz/unpack_pack_fuzzer.cpp +++ b/fuzz/unpack_pack_fuzzer.cpp @@ -1,5 +1,9 @@ #include +// The function's signature must NOT be changed since other projects rely on it: +// - libFuzzer +// - AFL++ +// - Google's oss-fuzz (uses the previous two ones) extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) { try { // NOTE(derwolfe): by default the limits are set at 2^32-1 length. I'm @@ -7,8 +11,8 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) { const int test_limit = 1000; msgpack::object_handle unpacked = msgpack::unpack(reinterpret_cast(data), size, - nullptr, - nullptr, + MSGPACK_NULLPTR, + MSGPACK_NULLPTR, msgpack::unpack_limit(test_limit, test_limit, test_limit, diff --git a/include/msgpack.h b/include/msgpack.h deleted file mode 100644 index af557a5cd..000000000 --- a/include/msgpack.h +++ /dev/null @@ -1,24 +0,0 @@ -/* - * MessagePack for C - * - * Copyright (C) 2008-2009 FURUHASHI Sadayuki - * - * 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) - */ -/** - * @defgroup msgpack MessagePack C - * @{ - * @} - */ - -#include "msgpack/util.h" -#include "msgpack/object.h" -#include "msgpack/zone.h" -#include "msgpack/pack.h" -#include "msgpack/unpack.h" -#include "msgpack/sbuffer.h" -#include "msgpack/vrefbuffer.h" -#include "msgpack/version.h" - diff --git a/include/msgpack.hpp b/include/msgpack.hpp index 21f8bc1e3..74ae1f663 100644 --- a/include/msgpack.hpp +++ b/include/msgpack.hpp @@ -11,8 +11,12 @@ #include "msgpack/iterator.hpp" #include "msgpack/zone.hpp" #include "msgpack/pack.hpp" +#include "msgpack/null_visitor.hpp" #include "msgpack/parse.hpp" #include "msgpack/unpack.hpp" +#include "msgpack/x3_parse.hpp" +#include "msgpack/x3_unpack.hpp" #include "msgpack/sbuffer.hpp" +#include "msgpack/vrefbuffer.hpp" #include "msgpack/version.hpp" #include "msgpack/type.hpp" diff --git a/include/msgpack/adaptor/complex.hpp b/include/msgpack/adaptor/complex.hpp new file mode 100644 index 000000000..34d578e99 --- /dev/null +++ b/include/msgpack/adaptor/complex.hpp @@ -0,0 +1,15 @@ +// +// MessagePack for C++ static resolution routine +// +// Copyright (C) 2020 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_COMPLEX_HPP +#define MSGPACK_TYPE_COMPLEX_HPP + +#include "msgpack/v1/adaptor/complex.hpp" + +#endif // MSGPACK_TYPE_COMPLEX_HPP diff --git a/include/msgpack/adaptor/cpp17/array_byte.hpp b/include/msgpack/adaptor/cpp17/array_byte.hpp new file mode 100644 index 000000000..069f36eed --- /dev/null +++ b/include/msgpack/adaptor/cpp17/array_byte.hpp @@ -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 diff --git a/include/msgpack/adaptor/cpp17/variant.hpp b/include/msgpack/adaptor/cpp17/variant.hpp new file mode 100644 index 000000000..bd73ff9ae --- /dev/null +++ b/include/msgpack/adaptor/cpp17/variant.hpp @@ -0,0 +1,16 @@ +// +// MessagePack for C++ static resolution routine +// +// Copyright (C) 2023 Uy Ha +// +// 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_VARIANT_HPP +#define MSGPACK_TYPE_CPP17_VARIANT_HPP + +#include "msgpack/v1/adaptor/cpp17/variant.hpp" + +#endif // MSGPACK_TYPE_CPP17_VARIANT_HPP diff --git a/include/msgpack/adaptor/cpp20/span.hpp b/include/msgpack/adaptor/cpp20/span.hpp new file mode 100644 index 000000000..b779b47e2 --- /dev/null +++ b/include/msgpack/adaptor/cpp20/span.hpp @@ -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 diff --git a/include/msgpack/adaptor/define_decl.hpp b/include/msgpack/adaptor/define_decl.hpp index 1880a8616..4d3f6b2ea 100644 --- a/include/msgpack/adaptor/define_decl.hpp +++ b/include/msgpack/adaptor/define_decl.hpp @@ -10,53 +10,90 @@ #ifndef MSGPACK_DEFINE_DECL_HPP #define MSGPACK_DEFINE_DECL_HPP -// BOOST_PP_VARIADICS is defined in boost/preprocessor/config/config.hpp +#if defined(MSGPACK_NO_BOOST) + +// MSGPACK_PP_VARIADICS is defined in msgpack/preprocessor/config/config.hpp // http://www.boost.org/libs/preprocessor/doc/ref/variadics.html // However, supporting compiler detection is not complete. msgpack-c requires -// variadic macro arguments support. So BOOST_PP_VARIADICS is defined here explicitly. +// variadic macro arguments support. So MSGPACK_PP_VARIADICS is defined here explicitly. #if !defined(MSGPACK_PP_VARIADICS) #define MSGPACK_PP_VARIADICS #endif #include -#include "msgpack/versioning.hpp" +#define MSGPACK_BASE_ARRAY(base) (*const_cast(static_cast(this))) +#define MSGPACK_NVP(name, value) (name) (value) -// for MSGPACK_ADD_ENUM -#include "msgpack/adaptor/int.hpp" +#define MSGPACK_DEFINE_MAP_EACH_PROC(r, data, elem) \ + MSGPACK_PP_IF( \ + MSGPACK_PP_IS_BEGIN_PARENS(elem), \ + elem, \ + (MSGPACK_PP_STRINGIZE(elem))(elem) \ + ) -#define MSGPACK_DEFINE_ARRAY(...) \ +#define MSGPACK_DEFINE_MAP_IMPL(...) \ + MSGPACK_PP_SEQ_TO_TUPLE( \ + MSGPACK_PP_SEQ_FOR_EACH( \ + MSGPACK_DEFINE_MAP_EACH_PROC, \ + 0, \ + MSGPACK_PP_VARIADIC_TO_SEQ(__VA_ARGS__) \ + ) \ + ) + +#define MSGPACK_DEFINE_MAP(...) \ template \ void msgpack_pack(Packer& msgpack_pk) const \ { \ - msgpack::type::make_define_array(__VA_ARGS__).msgpack_pack(msgpack_pk); \ + msgpack::type::make_define_map \ + MSGPACK_DEFINE_MAP_IMPL(__VA_ARGS__) \ + .msgpack_pack(msgpack_pk); \ } \ void msgpack_unpack(msgpack::object const& msgpack_o) \ { \ - msgpack::type::make_define_array(__VA_ARGS__).msgpack_unpack(msgpack_o); \ + msgpack::type::make_define_map \ + MSGPACK_DEFINE_MAP_IMPL(__VA_ARGS__) \ + .msgpack_unpack(msgpack_o); \ }\ template \ void msgpack_object(MSGPACK_OBJECT* msgpack_o, msgpack::zone& msgpack_z) const \ { \ - msgpack::type::make_define_array(__VA_ARGS__).msgpack_object(msgpack_o, msgpack_z); \ + msgpack::type::make_define_map \ + MSGPACK_DEFINE_MAP_IMPL(__VA_ARGS__) \ + .msgpack_object(msgpack_o, msgpack_z); \ } +#define MSGPACK_BASE_MAP(base) \ + (MSGPACK_PP_STRINGIZE(base))(*const_cast(static_cast(this))) + +#else // defined(MSGPACK_NO_BOOST) + +// BOOST_PP_VARIADICS is defined in boost/preprocessor/config/config.hpp +// http://www.boost.org/libs/preprocessor/doc/ref/variadics.html +// However, supporting compiler detection is not complete. msgpack-c requires +// variadic macro arguments support. So BOOST_PP_VARIADICS is defined here explicitly. +#if !defined(BOOST_PP_VARIADICS) +#define BOOST_PP_VARIADICS +#endif + +#include + #define MSGPACK_BASE_ARRAY(base) (*const_cast(static_cast(this))) #define MSGPACK_NVP(name, value) (name) (value) #define MSGPACK_DEFINE_MAP_EACH_PROC(r, data, elem) \ - MSGPACK_PP_IF( \ - MSGPACK_PP_IS_BEGIN_PARENS(elem), \ + BOOST_PP_IF( \ + BOOST_PP_IS_BEGIN_PARENS(elem), \ elem, \ - (MSGPACK_PP_STRINGIZE(elem))(elem) \ + (BOOST_PP_STRINGIZE(elem))(elem) \ ) #define MSGPACK_DEFINE_MAP_IMPL(...) \ - MSGPACK_PP_SEQ_TO_TUPLE( \ - MSGPACK_PP_SEQ_FOR_EACH( \ + BOOST_PP_SEQ_TO_TUPLE( \ + BOOST_PP_SEQ_FOR_EACH( \ MSGPACK_DEFINE_MAP_EACH_PROC, \ 0, \ - MSGPACK_PP_VARIADIC_TO_SEQ(__VA_ARGS__) \ + BOOST_PP_VARIADIC_TO_SEQ(__VA_ARGS__) \ ) \ ) @@ -83,7 +120,30 @@ } #define MSGPACK_BASE_MAP(base) \ - (MSGPACK_PP_STRINGIZE(base))(*const_cast(static_cast(this))) + (BOOST_PP_STRINGIZE(base))(*const_cast(static_cast(this))) + +#endif // defined(MSGPACK_NO_BOOST) + +#include "msgpack/versioning.hpp" + +// for MSGPACK_ADD_ENUM +#include "msgpack/adaptor/int.hpp" + +#define MSGPACK_DEFINE_ARRAY(...) \ + template \ + void msgpack_pack(Packer& msgpack_pk) const \ + { \ + msgpack::type::make_define_array(__VA_ARGS__).msgpack_pack(msgpack_pk); \ + } \ + void msgpack_unpack(msgpack::object const& msgpack_o) \ + { \ + msgpack::type::make_define_array(__VA_ARGS__).msgpack_unpack(msgpack_o); \ + }\ + template \ + void msgpack_object(MSGPACK_OBJECT* msgpack_o, msgpack::zone& msgpack_z) const \ + { \ + msgpack::type::make_define_array(__VA_ARGS__).msgpack_object(msgpack_o, msgpack_z); \ + } // MSGPACK_ADD_ENUM must be used in the global namespace. #define MSGPACK_ADD_ENUM(enum_name) \ diff --git a/include/msgpack/adaptor/tr1/unordered_map.hpp b/include/msgpack/adaptor/tr1/unordered_map.hpp index 9c8190e85..b24ac2319 100644 --- a/include/msgpack/adaptor/tr1/unordered_map.hpp +++ b/include/msgpack/adaptor/tr1/unordered_map.hpp @@ -12,6 +12,7 @@ #include "msgpack/versioning.hpp" #include "msgpack/adaptor/adaptor_base.hpp" +#include "msgpack/object.hpp" #include "msgpack/adaptor/check_container_size.hpp" #if defined(_LIBCPP_VERSION) || (_MSC_VER >= 1700) diff --git a/include/msgpack/adaptor/tr1/unordered_set.hpp b/include/msgpack/adaptor/tr1/unordered_set.hpp index dd6c0448f..9c92c2108 100644 --- a/include/msgpack/adaptor/tr1/unordered_set.hpp +++ b/include/msgpack/adaptor/tr1/unordered_set.hpp @@ -12,6 +12,7 @@ #include "msgpack/versioning.hpp" #include "msgpack/adaptor/adaptor_base.hpp" +#include "msgpack/object.hpp" #include "msgpack/adaptor/check_container_size.hpp" #if defined(_LIBCPP_VERSION) || (_MSC_VER >= 1700) diff --git a/include/msgpack/assert.hpp b/include/msgpack/assert.hpp new file mode 100644 index 000000000..8eeccf820 --- /dev/null +++ b/include/msgpack/assert.hpp @@ -0,0 +1,26 @@ +// +// MessagePack for C++ static resolution routine +// +// Copyright (C) 2022 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_ASSERT_HPP +#define MSGPACK_ASSERT_HPP + +#if defined(MSGPACK_NO_BOOST) + +#include +#define MSGPACK_ASSERT assert + +#else // defined(MSGPACK_NO_BOOST) + +#include +#define MSGPACK_ASSERT BOOST_ASSERT + +#endif // defined(MSGPACK_NO_BOOST) + +#endif // MSGPACK_ASSERT_HPP diff --git a/include/msgpack/cpp_version.hpp b/include/msgpack/cpp_version.hpp new file mode 100644 index 000000000..f3d072c93 --- /dev/null +++ b/include/msgpack/cpp_version.hpp @@ -0,0 +1,18 @@ +#ifndef MSGPACK_CPP_VERSION_HPP +#define MSGPACK_CPP_VERSION_HPP + +#if defined(_MSC_VER) +# if _MSC_VER < 1900 +# define MSGPACK_USE_CPP03 +# endif +#elif (__cplusplus < 201103L) +# define MSGPACK_USE_CPP03 +#endif + +#if defined(_MSVC_LANG) +# define MSGPACK_CPP_VERSION _MSVC_LANG +#else +# define MSGPACK_CPP_VERSION __cplusplus +#endif + +#endif // MSGPACK_CPP_VERSION_HPP diff --git a/include/msgpack/fbuffer.h b/include/msgpack/fbuffer.h deleted file mode 100644 index d478008c8..000000000 --- a/include/msgpack/fbuffer.h +++ /dev/null @@ -1,38 +0,0 @@ -/* - * MessagePack for C FILE* buffer adaptor - * - * Copyright (C) 2013 Vladimir Volodko - * - * 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_FBUFFER_H -#define MSGPACK_FBUFFER_H - -#include - -#ifdef __cplusplus -extern "C" { -#endif - - -/** - * @defgroup msgpack_fbuffer FILE* buffer - * @ingroup msgpack_buffer - * @{ - */ - -static inline int msgpack_fbuffer_write(void* data, const char* buf, size_t len) -{ - return (1 == fwrite(buf, len, 1, (FILE *)data)) ? 0 : -1; -} - -/** @} */ - - -#ifdef __cplusplus -} -#endif - -#endif /* msgpack/fbuffer.h */ diff --git a/include/msgpack/gcc_atomic.h b/include/msgpack/gcc_atomic.h deleted file mode 100644 index 6b1b1a799..000000000 --- a/include/msgpack/gcc_atomic.h +++ /dev/null @@ -1,25 +0,0 @@ -/* - * 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_GCC_ATOMIC_H -#define MSGPACK_GCC_ATOMIC_H - -#if defined(__cplusplus) -extern "C" { -#endif - -typedef int _msgpack_atomic_counter_t; - -int _msgpack_sync_decr_and_fetch(volatile _msgpack_atomic_counter_t* ptr); -int _msgpack_sync_incr_and_fetch(volatile _msgpack_atomic_counter_t* ptr); - - -#if defined(__cplusplus) -} -#endif - - -#endif // MSGPACK_GCC_ATOMIC_H diff --git a/include/msgpack/gcc_atomic.hpp b/include/msgpack/gcc_atomic.hpp index 9656e5331..186cf1996 100644 --- a/include/msgpack/gcc_atomic.hpp +++ b/include/msgpack/gcc_atomic.hpp @@ -13,7 +13,6 @@ #if defined(__GNUC__) && ((__GNUC__*10 + __GNUC_MINOR__) < 41) -#include "msgpack/gcc_atomic.h" #include int _msgpack_sync_decr_and_fetch(volatile _msgpack_atomic_counter_t* ptr) diff --git a/include/msgpack/iterator.hpp b/include/msgpack/iterator.hpp index a118b5925..0f532a4ae 100644 --- a/include/msgpack/iterator.hpp +++ b/include/msgpack/iterator.hpp @@ -11,8 +11,8 @@ #ifndef MSGPACK_ITERATOR_HPP #define MSGPACK_ITERATOR_HPP -#include +#include "msgpack/iterator_decl.hpp" -#include +#include "msgpack/v1/iterator.hpp" #endif // MSGPACK_ITERATOR_HPP diff --git a/include/msgpack/iterator_decl.hpp b/include/msgpack/iterator_decl.hpp index 5bf28cb10..dc3205c82 100644 --- a/include/msgpack/iterator_decl.hpp +++ b/include/msgpack/iterator_decl.hpp @@ -11,8 +11,8 @@ #ifndef MSGPACK_ITERATOR_DECL_HPP #define MSGPACK_ITERATOR_DECL_HPP -#include -#include -#include +#include "msgpack/v1/iterator_decl.hpp" +#include "msgpack/v2/iterator_decl.hpp" +#include "msgpack/v3/iterator_decl.hpp" #endif // MSGPACK_ITERATOR_DECL_HPP diff --git a/include/msgpack/object.h b/include/msgpack/object.h deleted file mode 100644 index e9431744b..000000000 --- a/include/msgpack/object.h +++ /dev/null @@ -1,118 +0,0 @@ -/* - * MessagePack for C dynamic typing routine - * - * Copyright (C) 2008-2009 FURUHASHI Sadayuki - * - * 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_OBJECT_H -#define MSGPACK_OBJECT_H - -#include "zone.h" -#include - -#ifdef __cplusplus -extern "C" { -#endif - - -/** - * @defgroup msgpack_object Dynamically typed object - * @ingroup msgpack - * @{ - */ - -typedef enum { - MSGPACK_OBJECT_NIL = 0x00, - MSGPACK_OBJECT_BOOLEAN = 0x01, - MSGPACK_OBJECT_POSITIVE_INTEGER = 0x02, - MSGPACK_OBJECT_NEGATIVE_INTEGER = 0x03, - MSGPACK_OBJECT_FLOAT32 = 0x0a, - MSGPACK_OBJECT_FLOAT64 = 0x04, - MSGPACK_OBJECT_FLOAT = 0x04, -#if defined(MSGPACK_USE_LEGACY_NAME_AS_FLOAT) - MSGPACK_OBJECT_DOUBLE = MSGPACK_OBJECT_FLOAT, /* obsolete */ -#endif /* MSGPACK_USE_LEGACY_NAME_AS_FLOAT */ - MSGPACK_OBJECT_STR = 0x05, - MSGPACK_OBJECT_ARRAY = 0x06, - MSGPACK_OBJECT_MAP = 0x07, - MSGPACK_OBJECT_BIN = 0x08, - MSGPACK_OBJECT_EXT = 0x09 -} msgpack_object_type; - - -struct msgpack_object; -struct msgpack_object_kv; - -typedef struct { - uint32_t size; - struct msgpack_object* ptr; -} msgpack_object_array; - -typedef struct { - uint32_t size; - struct msgpack_object_kv* ptr; -} msgpack_object_map; - -typedef struct { - uint32_t size; - const char* ptr; -} msgpack_object_str; - -typedef struct { - uint32_t size; - const char* ptr; -} msgpack_object_bin; - -typedef struct { - int8_t type; - uint32_t size; - const char* ptr; -} msgpack_object_ext; - -typedef union { - bool boolean; - uint64_t u64; - int64_t i64; -#if defined(MSGPACK_USE_LEGACY_NAME_AS_FLOAT) - double dec; /* obsolete*/ -#endif /* MSGPACK_USE_LEGACY_NAME_AS_FLOAT */ - double f64; - msgpack_object_array array; - msgpack_object_map map; - msgpack_object_str str; - msgpack_object_bin bin; - msgpack_object_ext ext; -} msgpack_object_union; - -typedef struct msgpack_object { - msgpack_object_type type; - msgpack_object_union via; -} msgpack_object; - -typedef struct msgpack_object_kv { - msgpack_object key; - msgpack_object val; -} msgpack_object_kv; - -#if !defined(_KERNEL_MODE) -MSGPACK_DLLEXPORT -void msgpack_object_print(FILE* out, msgpack_object o); -#endif - -MSGPACK_DLLEXPORT -int msgpack_object_print_buffer(char *buffer, size_t buffer_size, msgpack_object o); - -MSGPACK_DLLEXPORT -bool msgpack_object_equal(const msgpack_object x, const msgpack_object y); - -/** @} */ - - -#ifdef __cplusplus -} -#endif - -#endif /* msgpack/object.h */ diff --git a/include/msgpack/pack.h b/include/msgpack/pack.h deleted file mode 100644 index f2dddb3c5..000000000 --- a/include/msgpack/pack.h +++ /dev/null @@ -1,151 +0,0 @@ -/* - * MessagePack for C packing routine - * - * Copyright (C) 2008-2009 FURUHASHI Sadayuki - * - * 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_PACK_H -#define MSGPACK_PACK_H - -#include "pack_define.h" -#include "object.h" -#include "timestamp.h" -#include - -#ifdef __cplusplus -extern "C" { -#endif - - -/** - * @defgroup msgpack_buffer Buffers - * @ingroup msgpack - * @{ - * @} - */ - -/** - * @defgroup msgpack_pack Serializer - * @ingroup msgpack - * @{ - */ - -typedef int (*msgpack_packer_write)(void* data, const char* buf, size_t len); - -typedef struct msgpack_packer { - void* data; - msgpack_packer_write callback; -} msgpack_packer; - -static void msgpack_packer_init(msgpack_packer* pk, void* data, msgpack_packer_write callback); - -static msgpack_packer* msgpack_packer_new(void* data, msgpack_packer_write callback); -static void msgpack_packer_free(msgpack_packer* pk); - -static int msgpack_pack_char(msgpack_packer* pk, char d); - -static int msgpack_pack_signed_char(msgpack_packer* pk, signed char d); -static int msgpack_pack_short(msgpack_packer* pk, short d); -static int msgpack_pack_int(msgpack_packer* pk, int d); -static int msgpack_pack_long(msgpack_packer* pk, long d); -static int msgpack_pack_long_long(msgpack_packer* pk, long long d); -static int msgpack_pack_unsigned_char(msgpack_packer* pk, unsigned char d); -static int msgpack_pack_unsigned_short(msgpack_packer* pk, unsigned short d); -static int msgpack_pack_unsigned_int(msgpack_packer* pk, unsigned int d); -static int msgpack_pack_unsigned_long(msgpack_packer* pk, unsigned long d); -static int msgpack_pack_unsigned_long_long(msgpack_packer* pk, unsigned long long d); - -static int msgpack_pack_uint8(msgpack_packer* pk, uint8_t d); -static int msgpack_pack_uint16(msgpack_packer* pk, uint16_t d); -static int msgpack_pack_uint32(msgpack_packer* pk, uint32_t d); -static int msgpack_pack_uint64(msgpack_packer* pk, uint64_t d); -static int msgpack_pack_int8(msgpack_packer* pk, int8_t d); -static int msgpack_pack_int16(msgpack_packer* pk, int16_t d); -static int msgpack_pack_int32(msgpack_packer* pk, int32_t d); -static int msgpack_pack_int64(msgpack_packer* pk, int64_t d); - -static int msgpack_pack_fix_uint8(msgpack_packer* pk, uint8_t d); -static int msgpack_pack_fix_uint16(msgpack_packer* pk, uint16_t d); -static int msgpack_pack_fix_uint32(msgpack_packer* pk, uint32_t d); -static int msgpack_pack_fix_uint64(msgpack_packer* pk, uint64_t d); -static int msgpack_pack_fix_int8(msgpack_packer* pk, int8_t d); -static int msgpack_pack_fix_int16(msgpack_packer* pk, int16_t d); -static int msgpack_pack_fix_int32(msgpack_packer* pk, int32_t d); -static int msgpack_pack_fix_int64(msgpack_packer* pk, int64_t d); - -static int msgpack_pack_float(msgpack_packer* pk, float d); -static int msgpack_pack_double(msgpack_packer* pk, double d); - -static int msgpack_pack_nil(msgpack_packer* pk); -static int msgpack_pack_true(msgpack_packer* pk); -static int msgpack_pack_false(msgpack_packer* pk); - -static int msgpack_pack_array(msgpack_packer* pk, size_t n); - -static int msgpack_pack_map(msgpack_packer* pk, size_t n); - -static int msgpack_pack_str(msgpack_packer* pk, size_t l); -static int msgpack_pack_str_body(msgpack_packer* pk, const void* b, size_t l); - -static int msgpack_pack_v4raw(msgpack_packer* pk, size_t l); -static int msgpack_pack_v4raw_body(msgpack_packer* pk, const void* b, size_t l); - -static int msgpack_pack_bin(msgpack_packer* pk, size_t l); -static int msgpack_pack_bin_body(msgpack_packer* pk, const void* b, size_t l); - -static int msgpack_pack_ext(msgpack_packer* pk, size_t l, int8_t type); -static int msgpack_pack_ext_body(msgpack_packer* pk, const void* b, size_t l); - -static int msgpack_pack_timestamp(msgpack_packer* pk, const msgpack_timestamp* d); - -MSGPACK_DLLEXPORT -int msgpack_pack_object(msgpack_packer* pk, msgpack_object d); - - -/** @} */ - - -#define msgpack_pack_inline_func(name) \ - inline int msgpack_pack ## name - -#define msgpack_pack_inline_func_cint(name) \ - inline int msgpack_pack ## name - -#define msgpack_pack_inline_func_fixint(name) \ - inline int msgpack_pack_fix ## name - -#define msgpack_pack_user msgpack_packer* - -#define msgpack_pack_append_buffer(user, buf, len) \ - return (*(user)->callback)((user)->data, (const char*)buf, len) - -#include "pack_template.h" - -inline void msgpack_packer_init(msgpack_packer* pk, void* data, msgpack_packer_write callback) -{ - pk->data = data; - pk->callback = callback; -} - -inline msgpack_packer* msgpack_packer_new(void* data, msgpack_packer_write callback) -{ - msgpack_packer* pk = (msgpack_packer*)calloc(1, sizeof(msgpack_packer)); - if(!pk) { return NULL; } - msgpack_packer_init(pk, data, callback); - return pk; -} - -inline void msgpack_packer_free(msgpack_packer* pk) -{ - free(pk); -} - - -#ifdef __cplusplus -} -#endif - -#endif /* msgpack/pack.h */ diff --git a/include/msgpack/pack_define.h b/include/msgpack/pack_define.h deleted file mode 100644 index ce98b6755..000000000 --- a/include/msgpack/pack_define.h +++ /dev/null @@ -1,18 +0,0 @@ -/* - * MessagePack unpacking routine template - * - * Copyright (C) 2008-2010 FURUHASHI Sadayuki - * - * 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_PACK_DEFINE_H -#define MSGPACK_PACK_DEFINE_H - -#include "msgpack/sysdep.h" -#include -#include - -#endif /* msgpack/pack_define.h */ - diff --git a/include/msgpack/pack_template.h b/include/msgpack/pack_template.h deleted file mode 100644 index ac112e1d9..000000000 --- a/include/msgpack/pack_template.h +++ /dev/null @@ -1,945 +0,0 @@ -/* - * MessagePack packing routine template - * - * Copyright (C) 2008-2010 FURUHASHI Sadayuki - * - * 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) - */ - -#if MSGPACK_ENDIAN_LITTLE_BYTE -#define TAKE8_8(d) ((uint8_t*)&d)[0] -#define TAKE8_16(d) ((uint8_t*)&d)[0] -#define TAKE8_32(d) ((uint8_t*)&d)[0] -#define TAKE8_64(d) ((uint8_t*)&d)[0] -#elif MSGPACK_ENDIAN_BIG_BYTE -#define TAKE8_8(d) ((uint8_t*)&d)[0] -#define TAKE8_16(d) ((uint8_t*)&d)[1] -#define TAKE8_32(d) ((uint8_t*)&d)[3] -#define TAKE8_64(d) ((uint8_t*)&d)[7] -#else -#error msgpack-c supports only big endian and little endian -#endif - -#ifndef msgpack_pack_inline_func -#error msgpack_pack_inline_func template is not defined -#endif - -#ifndef msgpack_pack_user -#error msgpack_pack_user type is not defined -#endif - -#ifndef msgpack_pack_append_buffer -#error msgpack_pack_append_buffer callback is not defined -#endif - -#if defined(_MSC_VER) -# pragma warning(push) -# pragma warning(disable : 4204) /* nonstandard extension used: non-constant aggregate initializer */ -#endif - -/* - * Integer - */ - -#define msgpack_pack_real_uint8(x, d) \ -do { \ - if(d < (1<<7)) { \ - /* fixnum */ \ - msgpack_pack_append_buffer(x, &TAKE8_8(d), 1); \ - } else { \ - /* unsigned 8 */ \ - unsigned char buf[2] = {0xcc, TAKE8_8(d)}; \ - msgpack_pack_append_buffer(x, buf, 2); \ - } \ -} while(0) - -#define msgpack_pack_real_uint16(x, d) \ -do { \ - if(d < (1<<7)) { \ - /* fixnum */ \ - msgpack_pack_append_buffer(x, &TAKE8_16(d), 1); \ - } else if(d < (1<<8)) { \ - /* unsigned 8 */ \ - unsigned char buf[2] = {0xcc, TAKE8_16(d)}; \ - msgpack_pack_append_buffer(x, buf, 2); \ - } else { \ - /* unsigned 16 */ \ - unsigned char buf[3]; \ - buf[0] = 0xcd; _msgpack_store16(&buf[1], (uint16_t)d); \ - msgpack_pack_append_buffer(x, buf, 3); \ - } \ -} while(0) - -#define msgpack_pack_real_uint32(x, d) \ -do { \ - if(d < (1<<8)) { \ - if(d < (1<<7)) { \ - /* fixnum */ \ - msgpack_pack_append_buffer(x, &TAKE8_32(d), 1); \ - } else { \ - /* unsigned 8 */ \ - unsigned char buf[2] = {0xcc, TAKE8_32(d)}; \ - msgpack_pack_append_buffer(x, buf, 2); \ - } \ - } else { \ - if(d < (1<<16)) { \ - /* unsigned 16 */ \ - unsigned char buf[3]; \ - buf[0] = 0xcd; _msgpack_store16(&buf[1], (uint16_t)d); \ - msgpack_pack_append_buffer(x, buf, 3); \ - } else { \ - /* unsigned 32 */ \ - unsigned char buf[5]; \ - buf[0] = 0xce; _msgpack_store32(&buf[1], (uint32_t)d); \ - msgpack_pack_append_buffer(x, buf, 5); \ - } \ - } \ -} while(0) - -#define msgpack_pack_real_uint64(x, d) \ -do { \ - if(d < (1ULL<<8)) { \ - if(d < (1ULL<<7)) { \ - /* fixnum */ \ - msgpack_pack_append_buffer(x, &TAKE8_64(d), 1); \ - } else { \ - /* unsigned 8 */ \ - unsigned char buf[2] = {0xcc, TAKE8_64(d)}; \ - msgpack_pack_append_buffer(x, buf, 2); \ - } \ - } else { \ - if(d < (1ULL<<16)) { \ - /* unsigned 16 */ \ - unsigned char buf[3]; \ - buf[0] = 0xcd; _msgpack_store16(&buf[1], (uint16_t)d); \ - msgpack_pack_append_buffer(x, buf, 3); \ - } else if(d < (1ULL<<32)) { \ - /* unsigned 32 */ \ - unsigned char buf[5]; \ - buf[0] = 0xce; _msgpack_store32(&buf[1], (uint32_t)d); \ - msgpack_pack_append_buffer(x, buf, 5); \ - } else { \ - /* unsigned 64 */ \ - unsigned char buf[9]; \ - buf[0] = 0xcf; _msgpack_store64(&buf[1], d); \ - msgpack_pack_append_buffer(x, buf, 9); \ - } \ - } \ -} while(0) - -#define msgpack_pack_real_int8(x, d) \ -do { \ - if(d < -(1<<5)) { \ - /* signed 8 */ \ - unsigned char buf[2] = {0xd0, TAKE8_8(d)}; \ - msgpack_pack_append_buffer(x, buf, 2); \ - } else { \ - /* fixnum */ \ - msgpack_pack_append_buffer(x, &TAKE8_8(d), 1); \ - } \ -} while(0) - -#define msgpack_pack_real_int16(x, d) \ -do { \ - if(d < -(1<<5)) { \ - if(d < -(1<<7)) { \ - /* signed 16 */ \ - unsigned char buf[3]; \ - buf[0] = 0xd1; _msgpack_store16(&buf[1], (int16_t)d); \ - msgpack_pack_append_buffer(x, buf, 3); \ - } else { \ - /* signed 8 */ \ - unsigned char buf[2] = {0xd0, TAKE8_16(d)}; \ - msgpack_pack_append_buffer(x, buf, 2); \ - } \ - } else if(d < (1<<7)) { \ - /* fixnum */ \ - msgpack_pack_append_buffer(x, &TAKE8_16(d), 1); \ - } else { \ - if(d < (1<<8)) { \ - /* unsigned 8 */ \ - unsigned char buf[2] = {0xcc, TAKE8_16(d)}; \ - msgpack_pack_append_buffer(x, buf, 2); \ - } else { \ - /* unsigned 16 */ \ - unsigned char buf[3]; \ - buf[0] = 0xcd; _msgpack_store16(&buf[1], (uint16_t)d); \ - msgpack_pack_append_buffer(x, buf, 3); \ - } \ - } \ -} while(0) - -#define msgpack_pack_real_int32(x, d) \ -do { \ - if(d < -(1<<5)) { \ - if(d < -(1<<15)) { \ - /* signed 32 */ \ - unsigned char buf[5]; \ - buf[0] = 0xd2; _msgpack_store32(&buf[1], (int32_t)d); \ - msgpack_pack_append_buffer(x, buf, 5); \ - } else if(d < -(1<<7)) { \ - /* signed 16 */ \ - unsigned char buf[3]; \ - buf[0] = 0xd1; _msgpack_store16(&buf[1], (int16_t)d); \ - msgpack_pack_append_buffer(x, buf, 3); \ - } else { \ - /* signed 8 */ \ - unsigned char buf[2] = {0xd0, TAKE8_32(d)}; \ - msgpack_pack_append_buffer(x, buf, 2); \ - } \ - } else if(d < (1<<7)) { \ - /* fixnum */ \ - msgpack_pack_append_buffer(x, &TAKE8_32(d), 1); \ - } else { \ - if(d < (1<<8)) { \ - /* unsigned 8 */ \ - unsigned char buf[2] = {0xcc, TAKE8_32(d)}; \ - msgpack_pack_append_buffer(x, buf, 2); \ - } else if(d < (1<<16)) { \ - /* unsigned 16 */ \ - unsigned char buf[3]; \ - buf[0] = 0xcd; _msgpack_store16(&buf[1], (uint16_t)d); \ - msgpack_pack_append_buffer(x, buf, 3); \ - } else { \ - /* unsigned 32 */ \ - unsigned char buf[5]; \ - buf[0] = 0xce; _msgpack_store32(&buf[1], (uint32_t)d); \ - msgpack_pack_append_buffer(x, buf, 5); \ - } \ - } \ -} while(0) - -#define msgpack_pack_real_int64(x, d) \ -do { \ - if(d < -(1LL<<5)) { \ - if(d < -(1LL<<15)) { \ - if(d < -(1LL<<31)) { \ - /* signed 64 */ \ - unsigned char buf[9]; \ - buf[0] = 0xd3; _msgpack_store64(&buf[1], d); \ - msgpack_pack_append_buffer(x, buf, 9); \ - } else { \ - /* signed 32 */ \ - unsigned char buf[5]; \ - buf[0] = 0xd2; _msgpack_store32(&buf[1], (int32_t)d); \ - msgpack_pack_append_buffer(x, buf, 5); \ - } \ - } else { \ - if(d < -(1<<7)) { \ - /* signed 16 */ \ - unsigned char buf[3]; \ - buf[0] = 0xd1; _msgpack_store16(&buf[1], (int16_t)d); \ - msgpack_pack_append_buffer(x, buf, 3); \ - } else { \ - /* signed 8 */ \ - unsigned char buf[2] = {0xd0, TAKE8_64(d)}; \ - msgpack_pack_append_buffer(x, buf, 2); \ - } \ - } \ - } else if(d < (1<<7)) { \ - /* fixnum */ \ - msgpack_pack_append_buffer(x, &TAKE8_64(d), 1); \ - } else { \ - if(d < (1LL<<16)) { \ - if(d < (1<<8)) { \ - /* unsigned 8 */ \ - unsigned char buf[2] = {0xcc, TAKE8_64(d)}; \ - msgpack_pack_append_buffer(x, buf, 2); \ - } else { \ - /* unsigned 16 */ \ - unsigned char buf[3]; \ - buf[0] = 0xcd; _msgpack_store16(&buf[1], (uint16_t)d); \ - msgpack_pack_append_buffer(x, buf, 3); \ - } \ - } else { \ - if(d < (1LL<<32)) { \ - /* unsigned 32 */ \ - unsigned char buf[5]; \ - buf[0] = 0xce; _msgpack_store32(&buf[1], (uint32_t)d); \ - msgpack_pack_append_buffer(x, buf, 5); \ - } else { \ - /* unsigned 64 */ \ - unsigned char buf[9]; \ - buf[0] = 0xcf; _msgpack_store64(&buf[1], d); \ - msgpack_pack_append_buffer(x, buf, 9); \ - } \ - } \ - } \ -} while(0) - - -#ifdef msgpack_pack_inline_func_fixint - -msgpack_pack_inline_func_fixint(_uint8)(msgpack_pack_user x, uint8_t d) -{ - unsigned char buf[2] = {0xcc, TAKE8_8(d)}; - msgpack_pack_append_buffer(x, buf, 2); -} - -msgpack_pack_inline_func_fixint(_uint16)(msgpack_pack_user x, uint16_t d) -{ - unsigned char buf[3]; - buf[0] = 0xcd; _msgpack_store16(&buf[1], d); - msgpack_pack_append_buffer(x, buf, 3); -} - -msgpack_pack_inline_func_fixint(_uint32)(msgpack_pack_user x, uint32_t d) -{ - unsigned char buf[5]; - buf[0] = 0xce; _msgpack_store32(&buf[1], d); - msgpack_pack_append_buffer(x, buf, 5); -} - -msgpack_pack_inline_func_fixint(_uint64)(msgpack_pack_user x, uint64_t d) -{ - unsigned char buf[9]; - buf[0] = 0xcf; _msgpack_store64(&buf[1], d); - msgpack_pack_append_buffer(x, buf, 9); -} - -msgpack_pack_inline_func_fixint(_int8)(msgpack_pack_user x, int8_t d) -{ - unsigned char buf[2] = {0xd0, TAKE8_8(d)}; - msgpack_pack_append_buffer(x, buf, 2); -} - -msgpack_pack_inline_func_fixint(_int16)(msgpack_pack_user x, int16_t d) -{ - unsigned char buf[3]; - buf[0] = 0xd1; _msgpack_store16(&buf[1], d); - msgpack_pack_append_buffer(x, buf, 3); -} - -msgpack_pack_inline_func_fixint(_int32)(msgpack_pack_user x, int32_t d) -{ - unsigned char buf[5]; - buf[0] = 0xd2; _msgpack_store32(&buf[1], d); - msgpack_pack_append_buffer(x, buf, 5); -} - -msgpack_pack_inline_func_fixint(_int64)(msgpack_pack_user x, int64_t d) -{ - unsigned char buf[9]; - buf[0] = 0xd3; _msgpack_store64(&buf[1], d); - msgpack_pack_append_buffer(x, buf, 9); -} - -#undef msgpack_pack_inline_func_fixint -#endif - - -msgpack_pack_inline_func(_uint8)(msgpack_pack_user x, uint8_t d) -{ - msgpack_pack_real_uint8(x, d); -} - -msgpack_pack_inline_func(_uint16)(msgpack_pack_user x, uint16_t d) -{ - msgpack_pack_real_uint16(x, d); -} - -msgpack_pack_inline_func(_uint32)(msgpack_pack_user x, uint32_t d) -{ - msgpack_pack_real_uint32(x, d); -} - -msgpack_pack_inline_func(_uint64)(msgpack_pack_user x, uint64_t d) -{ - msgpack_pack_real_uint64(x, d); -} - -msgpack_pack_inline_func(_int8)(msgpack_pack_user x, int8_t d) -{ - msgpack_pack_real_int8(x, d); -} - -msgpack_pack_inline_func(_int16)(msgpack_pack_user x, int16_t d) -{ - msgpack_pack_real_int16(x, d); -} - -msgpack_pack_inline_func(_int32)(msgpack_pack_user x, int32_t d) -{ - msgpack_pack_real_int32(x, d); -} - -msgpack_pack_inline_func(_int64)(msgpack_pack_user x, int64_t d) -{ - msgpack_pack_real_int64(x, d); -} - -msgpack_pack_inline_func(_char)(msgpack_pack_user x, char d) -{ -#if defined(CHAR_MIN) -#if CHAR_MIN < 0 - msgpack_pack_real_int8(x, d); -#else - msgpack_pack_real_uint8(x, d); -#endif -#else -#error CHAR_MIN is not defined -#endif -} - -msgpack_pack_inline_func(_signed_char)(msgpack_pack_user x, signed char d) -{ - msgpack_pack_real_int8(x, d); -} - -msgpack_pack_inline_func(_unsigned_char)(msgpack_pack_user x, unsigned char d) -{ - msgpack_pack_real_uint8(x, d); -} - -#ifdef msgpack_pack_inline_func_cint - -msgpack_pack_inline_func_cint(_short)(msgpack_pack_user x, short d) -{ -#if defined(SIZEOF_SHORT) -#if SIZEOF_SHORT == 2 - msgpack_pack_real_int16(x, d); -#elif SIZEOF_SHORT == 4 - msgpack_pack_real_int32(x, d); -#else - msgpack_pack_real_int64(x, d); -#endif - -#elif defined(SHRT_MAX) -#if SHRT_MAX == 0x7fff - msgpack_pack_real_int16(x, d); -#elif SHRT_MAX == 0x7fffffff - msgpack_pack_real_int32(x, d); -#else - msgpack_pack_real_int64(x, d); -#endif - -#else -if(sizeof(short) == 2) { - msgpack_pack_real_int16(x, d); -} else if(sizeof(short) == 4) { - msgpack_pack_real_int32(x, d); -} else { - msgpack_pack_real_int64(x, d); -} -#endif -} - -msgpack_pack_inline_func_cint(_int)(msgpack_pack_user x, int d) -{ -#if defined(SIZEOF_INT) -#if SIZEOF_INT == 2 - msgpack_pack_real_int16(x, d); -#elif SIZEOF_INT == 4 - msgpack_pack_real_int32(x, d); -#else - msgpack_pack_real_int64(x, d); -#endif - -#elif defined(INT_MAX) -#if INT_MAX == 0x7fff - msgpack_pack_real_int16(x, d); -#elif INT_MAX == 0x7fffffff - msgpack_pack_real_int32(x, d); -#else - msgpack_pack_real_int64(x, d); -#endif - -#else -if(sizeof(int) == 2) { - msgpack_pack_real_int16(x, d); -} else if(sizeof(int) == 4) { - msgpack_pack_real_int32(x, d); -} else { - msgpack_pack_real_int64(x, d); -} -#endif -} - -msgpack_pack_inline_func_cint(_long)(msgpack_pack_user x, long d) -{ -#if defined(SIZEOF_LONG) -#if SIZEOF_LONG == 2 - msgpack_pack_real_int16(x, d); -#elif SIZEOF_LONG == 4 - msgpack_pack_real_int32(x, d); -#else - msgpack_pack_real_int64(x, d); -#endif - -#elif defined(LONG_MAX) -#if LONG_MAX == 0x7fffL - msgpack_pack_real_int16(x, d); -#elif LONG_MAX == 0x7fffffffL - msgpack_pack_real_int32(x, d); -#else - msgpack_pack_real_int64(x, d); -#endif - -#else -if(sizeof(long) == 2) { - msgpack_pack_real_int16(x, d); -} else if(sizeof(long) == 4) { - msgpack_pack_real_int32(x, d); -} else { - msgpack_pack_real_int64(x, d); -} -#endif -} - -msgpack_pack_inline_func_cint(_long_long)(msgpack_pack_user x, long long d) -{ -#if defined(SIZEOF_LONG_LONG) -#if SIZEOF_LONG_LONG == 2 - msgpack_pack_real_int16(x, d); -#elif SIZEOF_LONG_LONG == 4 - msgpack_pack_real_int32(x, d); -#else - msgpack_pack_real_int64(x, d); -#endif - -#elif defined(LLONG_MAX) -#if LLONG_MAX == 0x7fffL - msgpack_pack_real_int16(x, d); -#elif LLONG_MAX == 0x7fffffffL - msgpack_pack_real_int32(x, d); -#else - msgpack_pack_real_int64(x, d); -#endif - -#else -if(sizeof(long long) == 2) { - msgpack_pack_real_int16(x, d); -} else if(sizeof(long long) == 4) { - msgpack_pack_real_int32(x, d); -} else { - msgpack_pack_real_int64(x, d); -} -#endif -} - -msgpack_pack_inline_func_cint(_unsigned_short)(msgpack_pack_user x, unsigned short d) -{ -#if defined(SIZEOF_SHORT) -#if SIZEOF_SHORT == 2 - msgpack_pack_real_uint16(x, d); -#elif SIZEOF_SHORT == 4 - msgpack_pack_real_uint32(x, d); -#else - msgpack_pack_real_uint64(x, d); -#endif - -#elif defined(USHRT_MAX) -#if USHRT_MAX == 0xffffU - msgpack_pack_real_uint16(x, d); -#elif USHRT_MAX == 0xffffffffU - msgpack_pack_real_uint32(x, d); -#else - msgpack_pack_real_uint64(x, d); -#endif - -#else -if(sizeof(unsigned short) == 2) { - msgpack_pack_real_uint16(x, d); -} else if(sizeof(unsigned short) == 4) { - msgpack_pack_real_uint32(x, d); -} else { - msgpack_pack_real_uint64(x, d); -} -#endif -} - -msgpack_pack_inline_func_cint(_unsigned_int)(msgpack_pack_user x, unsigned int d) -{ -#if defined(SIZEOF_INT) -#if SIZEOF_INT == 2 - msgpack_pack_real_uint16(x, d); -#elif SIZEOF_INT == 4 - msgpack_pack_real_uint32(x, d); -#else - msgpack_pack_real_uint64(x, d); -#endif - -#elif defined(UINT_MAX) -#if UINT_MAX == 0xffffU - msgpack_pack_real_uint16(x, d); -#elif UINT_MAX == 0xffffffffU - msgpack_pack_real_uint32(x, d); -#else - msgpack_pack_real_uint64(x, d); -#endif - -#else -if(sizeof(unsigned int) == 2) { - msgpack_pack_real_uint16(x, d); -} else if(sizeof(unsigned int) == 4) { - msgpack_pack_real_uint32(x, d); -} else { - msgpack_pack_real_uint64(x, d); -} -#endif -} - -msgpack_pack_inline_func_cint(_unsigned_long)(msgpack_pack_user x, unsigned long d) -{ -#if defined(SIZEOF_LONG) -#if SIZEOF_LONG == 2 - msgpack_pack_real_uint16(x, d); -#elif SIZEOF_LONG == 4 - msgpack_pack_real_uint32(x, d); -#else - msgpack_pack_real_uint64(x, d); -#endif - -#elif defined(ULONG_MAX) -#if ULONG_MAX == 0xffffUL - msgpack_pack_real_uint16(x, d); -#elif ULONG_MAX == 0xffffffffUL - msgpack_pack_real_uint32(x, d); -#else - msgpack_pack_real_uint64(x, d); -#endif - -#else -if(sizeof(unsigned long) == 2) { - msgpack_pack_real_uint16(x, d); -} else if(sizeof(unsigned long) == 4) { - msgpack_pack_real_uint32(x, d); -} else { - msgpack_pack_real_uint64(x, d); -} -#endif -} - -msgpack_pack_inline_func_cint(_unsigned_long_long)(msgpack_pack_user x, unsigned long long d) -{ -#if defined(SIZEOF_LONG_LONG) -#if SIZEOF_LONG_LONG == 2 - msgpack_pack_real_uint16(x, d); -#elif SIZEOF_LONG_LONG == 4 - msgpack_pack_real_uint32(x, d); -#else - msgpack_pack_real_uint64(x, d); -#endif - -#elif defined(ULLONG_MAX) -#if ULLONG_MAX == 0xffffUL - msgpack_pack_real_uint16(x, d); -#elif ULLONG_MAX == 0xffffffffUL - msgpack_pack_real_uint32(x, d); -#else - msgpack_pack_real_uint64(x, d); -#endif - -#else -if(sizeof(unsigned long long) == 2) { - msgpack_pack_real_uint16(x, d); -} else if(sizeof(unsigned long long) == 4) { - msgpack_pack_real_uint32(x, d); -} else { - msgpack_pack_real_uint64(x, d); -} -#endif -} - -#undef msgpack_pack_inline_func_cint -#endif - - - -/* - * Float - */ - -msgpack_pack_inline_func(_float)(msgpack_pack_user x, float d) -{ - unsigned char buf[5]; - union { float f; uint32_t i; } mem; - mem.f = d; - buf[0] = 0xca; _msgpack_store32(&buf[1], mem.i); - msgpack_pack_append_buffer(x, buf, 5); -} - -msgpack_pack_inline_func(_double)(msgpack_pack_user x, double d) -{ - unsigned char buf[9]; - union { double f; uint64_t i; } mem; - mem.f = d; - buf[0] = 0xcb; -#if defined(TARGET_OS_IPHONE) - // ok -#elif defined(__arm__) && !(__ARM_EABI__) // arm-oabi - // https://github.com/msgpack/msgpack-perl/pull/1 - mem.i = (mem.i & 0xFFFFFFFFUL) << 32UL | (mem.i >> 32UL); -#endif - _msgpack_store64(&buf[1], mem.i); - msgpack_pack_append_buffer(x, buf, 9); -} - - -/* - * Nil - */ - -msgpack_pack_inline_func(_nil)(msgpack_pack_user x) -{ - static const unsigned char d = 0xc0; - msgpack_pack_append_buffer(x, &d, 1); -} - - -/* - * Boolean - */ - -msgpack_pack_inline_func(_true)(msgpack_pack_user x) -{ - static const unsigned char d = 0xc3; - msgpack_pack_append_buffer(x, &d, 1); -} - -msgpack_pack_inline_func(_false)(msgpack_pack_user x) -{ - static const unsigned char d = 0xc2; - msgpack_pack_append_buffer(x, &d, 1); -} - - -/* - * Array - */ - -msgpack_pack_inline_func(_array)(msgpack_pack_user x, size_t n) -{ - if(n < 16) { - unsigned char d = 0x90 | (uint8_t)n; - msgpack_pack_append_buffer(x, &d, 1); - } else if(n < 65536) { - unsigned char buf[3]; - buf[0] = 0xdc; _msgpack_store16(&buf[1], (uint16_t)n); - msgpack_pack_append_buffer(x, buf, 3); - } else { - unsigned char buf[5]; - buf[0] = 0xdd; _msgpack_store32(&buf[1], (uint32_t)n); - msgpack_pack_append_buffer(x, buf, 5); - } -} - - -/* - * Map - */ - -msgpack_pack_inline_func(_map)(msgpack_pack_user x, size_t n) -{ - if(n < 16) { - unsigned char d = 0x80 | (uint8_t)n; - msgpack_pack_append_buffer(x, &TAKE8_8(d), 1); - } else if(n < 65536) { - unsigned char buf[3]; - buf[0] = 0xde; _msgpack_store16(&buf[1], (uint16_t)n); - msgpack_pack_append_buffer(x, buf, 3); - } else { - unsigned char buf[5]; - buf[0] = 0xdf; _msgpack_store32(&buf[1], (uint32_t)n); - msgpack_pack_append_buffer(x, buf, 5); - } -} - - -/* - * Str - */ - -msgpack_pack_inline_func(_str)(msgpack_pack_user x, size_t l) -{ - if(l < 32) { - unsigned char d = 0xa0 | (uint8_t)l; - msgpack_pack_append_buffer(x, &TAKE8_8(d), 1); - } else if(l < 256) { - unsigned char buf[2]; - buf[0] = 0xd9; buf[1] = (uint8_t)l; - msgpack_pack_append_buffer(x, buf, 2); - } else if(l < 65536) { - unsigned char buf[3]; - buf[0] = 0xda; _msgpack_store16(&buf[1], (uint16_t)l); - msgpack_pack_append_buffer(x, buf, 3); - } else { - unsigned char buf[5]; - buf[0] = 0xdb; _msgpack_store32(&buf[1], (uint32_t)l); - msgpack_pack_append_buffer(x, buf, 5); - } -} - -msgpack_pack_inline_func(_str_body)(msgpack_pack_user x, const void* b, size_t l) -{ - msgpack_pack_append_buffer(x, (const unsigned char*)b, l); -} - -/* - * Raw (V4) - */ - -msgpack_pack_inline_func(_v4raw)(msgpack_pack_user x, size_t l) -{ - if(l < 32) { - unsigned char d = 0xa0 | (uint8_t)l; - msgpack_pack_append_buffer(x, &TAKE8_8(d), 1); - } else if(l < 65536) { - unsigned char buf[3]; - buf[0] = 0xda; _msgpack_store16(&buf[1], (uint16_t)l); - msgpack_pack_append_buffer(x, buf, 3); - } else { - unsigned char buf[5]; - buf[0] = 0xdb; _msgpack_store32(&buf[1], (uint32_t)l); - msgpack_pack_append_buffer(x, buf, 5); - } -} - -msgpack_pack_inline_func(_v4raw_body)(msgpack_pack_user x, const void* b, size_t l) -{ - msgpack_pack_append_buffer(x, (const unsigned char*)b, l); -} - -/* - * Bin - */ - -msgpack_pack_inline_func(_bin)(msgpack_pack_user x, size_t l) -{ - if(l < 256) { - unsigned char buf[2]; - buf[0] = 0xc4; buf[1] = (uint8_t)l; - msgpack_pack_append_buffer(x, buf, 2); - } else if(l < 65536) { - unsigned char buf[3]; - buf[0] = 0xc5; _msgpack_store16(&buf[1], (uint16_t)l); - msgpack_pack_append_buffer(x, buf, 3); - } else { - unsigned char buf[5]; - buf[0] = 0xc6; _msgpack_store32(&buf[1], (uint32_t)l); - msgpack_pack_append_buffer(x, buf, 5); - } -} - -msgpack_pack_inline_func(_bin_body)(msgpack_pack_user x, const void* b, size_t l) -{ - msgpack_pack_append_buffer(x, (const unsigned char*)b, l); -} - -/* - * Ext - */ - -msgpack_pack_inline_func(_ext)(msgpack_pack_user x, size_t l, int8_t type) -{ - switch(l) { - case 1: { - unsigned char buf[2]; - buf[0] = 0xd4; - buf[1] = (unsigned char)type; - msgpack_pack_append_buffer(x, buf, 2); - } break; - case 2: { - unsigned char buf[2]; - buf[0] = 0xd5; - buf[1] = (unsigned char)type; - msgpack_pack_append_buffer(x, buf, 2); - } break; - case 4: { - unsigned char buf[2]; - buf[0] = 0xd6; - buf[1] = (unsigned char)type; - msgpack_pack_append_buffer(x, buf, 2); - } break; - case 8: { - unsigned char buf[2]; - buf[0] = 0xd7; - buf[1] = (unsigned char)type; - msgpack_pack_append_buffer(x, buf, 2); - } break; - case 16: { - unsigned char buf[2]; - buf[0] = 0xd8; - buf[1] = (unsigned char)type; - msgpack_pack_append_buffer(x, buf, 2); - } break; - default: - if(l < 256) { - unsigned char buf[3]; - buf[0] = 0xc7; - buf[1] = (unsigned char)l; - buf[2] = (unsigned char)type; - msgpack_pack_append_buffer(x, buf, 3); - } else if(l < 65536) { - unsigned char buf[4]; - buf[0] = 0xc8; - _msgpack_store16(&buf[1], l); - buf[3] = (unsigned char)type; - msgpack_pack_append_buffer(x, buf, 4); - } else { - unsigned char buf[6]; - buf[0] = 0xc9; - _msgpack_store32(&buf[1], l); - buf[5] = (unsigned char)type; - msgpack_pack_append_buffer(x, buf, 6); - } - break; - } -} - -msgpack_pack_inline_func(_ext_body)(msgpack_pack_user x, const void* b, size_t l) -{ - msgpack_pack_append_buffer(x, (const unsigned char*)b, l); -} - -msgpack_pack_inline_func(_timestamp)(msgpack_pack_user x, const msgpack_timestamp* d) -{ - if ((((int64_t)d->tv_sec) >> 34) == 0) { - uint64_t data64 = ((uint64_t) d->tv_nsec << 34) | (uint64_t)d->tv_sec; - if ((data64 & 0xffffffff00000000L) == 0) { - // timestamp 32 - char buf[4]; - uint32_t data32 = (uint32_t)data64; - msgpack_pack_ext(x, 4, -1); - _msgpack_store32(buf, data32); - msgpack_pack_append_buffer(x, buf, 4); - } else { - // timestamp 64 - char buf[8]; - msgpack_pack_ext(x, 8, -1); - _msgpack_store64(buf, data64); - msgpack_pack_append_buffer(x, buf, 8); - } - } else { - // timestamp 96 - char buf[12]; - _msgpack_store32(&buf[0], d->tv_nsec); - _msgpack_store64(&buf[4], d->tv_sec); - msgpack_pack_ext(x, 12, -1); - msgpack_pack_append_buffer(x, buf, 12); - } -} - -#undef msgpack_pack_inline_func -#undef msgpack_pack_user -#undef msgpack_pack_append_buffer - -#undef TAKE8_8 -#undef TAKE8_16 -#undef TAKE8_32 -#undef TAKE8_64 - -#undef msgpack_pack_real_uint8 -#undef msgpack_pack_real_uint16 -#undef msgpack_pack_real_uint32 -#undef msgpack_pack_real_uint64 -#undef msgpack_pack_real_int8 -#undef msgpack_pack_real_int16 -#undef msgpack_pack_real_int32 -#undef msgpack_pack_real_int64 - -#if defined(_MSC_VER) -# pragma warning(pop) -#endif diff --git a/include/msgpack/predef/os/linux.h b/include/msgpack/predef/os/linux.h index 6c517c9d6..62862a757 100644 --- a/include/msgpack/predef/os/linux.h +++ b/include/msgpack/predef/os/linux.h @@ -27,7 +27,7 @@ Distributed under the Boost Software License, Version 1.0. #define MSGPACK_OS_LINUX MSGPACK_VERSION_NUMBER_NOT_AVAILABLE #if !defined(MSGPACK_PREDEF_DETAIL_OS_DETECTED) && ( \ - defined(linux) || defined(__linux) \ + defined(linux) || defined(__linux) || defined(__linux__) \ ) # undef MSGPACK_OS_LINUX # define MSGPACK_OS_LINUX MSGPACK_VERSION_NUMBER_AVAILABLE diff --git a/include/msgpack/preprocessor/config/config.hpp b/include/msgpack/preprocessor/config/config.hpp index 51c43cbed..8a71ce6e4 100644 --- a/include/msgpack/preprocessor/config/config.hpp +++ b/include/msgpack/preprocessor/config/config.hpp @@ -24,16 +24,22 @@ # define MSGPACK_PP_CONFIG_EDG() 0x0020 # define MSGPACK_PP_CONFIG_DMC() 0x0040 # +# if !defined(__clang__) && (!defined(_MSVC_TRADITIONAL) || _MSVC_TRADITIONAL) +# define MSGPACK_TRADITIONAL_MSVC 1 +# else +# define MSGPACK_TRADITIONAL_MSVC 0 +# endif +# # ifndef MSGPACK_PP_CONFIG_FLAGS # if defined(__GCCXML__) || defined(__WAVE__) || defined(__MWERKS__) && __MWERKS__ >= 0x3200 # define MSGPACK_PP_CONFIG_FLAGS() (MSGPACK_PP_CONFIG_STRICT()) # elif defined(__EDG__) || defined(__EDG_VERSION__) -# if defined(_MSC_VER) && !defined(__clang__) && (defined(__INTELLISENSE__) || __EDG_VERSION__ >= 308) +# if defined(_MSC_VER) && MSGPACK_TRADITIONAL_MSVC && (defined(__INTELLISENSE__) || __EDG_VERSION__ >= 308) # define MSGPACK_PP_CONFIG_FLAGS() (MSGPACK_PP_CONFIG_MSVC()) # else # define MSGPACK_PP_CONFIG_FLAGS() (MSGPACK_PP_CONFIG_EDG() | MSGPACK_PP_CONFIG_STRICT()) # endif -# elif defined(_MSC_VER) && defined(__clang__) +# elif defined(_MSC_VER) && !MSGPACK_TRADITIONAL_MSVC # define MSGPACK_PP_CONFIG_FLAGS() (MSGPACK_PP_CONFIG_STRICT()) # elif defined(__MWERKS__) # define MSGPACK_PP_CONFIG_FLAGS() (MSGPACK_PP_CONFIG_MWCC()) @@ -75,7 +81,7 @@ # define MSGPACK_PP_VARIADICS 0 # elif defined(__CUDACC__) # define MSGPACK_PP_VARIADICS 1 -# elif defined(_MSC_VER) && defined(__clang__) +# elif defined(_MSC_VER) && !MSGPACK_TRADITIONAL_MSVC # define MSGPACK_PP_VARIADICS 1 # /* VC++ (C/C++) and Intel C++ Compiler >= 17.0 with MSVC */ # elif defined _MSC_VER && _MSC_VER >= 1400 && (!defined __EDG__ || defined(__INTELLISENSE__) || defined(__INTEL_COMPILER) && __INTEL_COMPILER >= 1700) @@ -94,7 +100,7 @@ # elif !MSGPACK_PP_VARIADICS + 1 < 2 # undef MSGPACK_PP_VARIADICS # define MSGPACK_PP_VARIADICS 1 -# if defined _MSC_VER && _MSC_VER >= 1400 && !defined(__clang__) && (defined(__INTELLISENSE__) || (defined(__INTEL_COMPILER) && __INTEL_COMPILER >= 1700) || !(defined __EDG__ || defined __GCCXML__ || defined __CUDACC__ || defined __PATHSCALE__ || defined __DMC__ || defined __CODEGEARC__ || defined __BORLANDC__ || defined __MWERKS__ || defined __SUNPRO_CC || defined __HP_aCC || defined __MRC__ || defined __SC__ || defined __IBMCPP__ || defined __PGI)) +# if defined _MSC_VER && _MSC_VER >= 1400 && MSGPACK_TRADITIONAL_MSVC && (defined(__INTELLISENSE__) || (defined(__INTEL_COMPILER) && __INTEL_COMPILER >= 1700) || !(defined __EDG__ || defined __GCCXML__ || defined __CUDACC__ || defined __PATHSCALE__ || defined __DMC__ || defined __CODEGEARC__ || defined __BORLANDC__ || defined __MWERKS__ || defined __SUNPRO_CC || defined __HP_aCC || defined __MRC__ || defined __SC__ || defined __IBMCPP__ || defined __PGI)) # undef MSGPACK_PP_VARIADICS_MSVC # define MSGPACK_PP_VARIADICS_MSVC 1 # endif diff --git a/include/msgpack/sbuffer.h b/include/msgpack/sbuffer.h deleted file mode 100644 index c494bae77..000000000 --- a/include/msgpack/sbuffer.h +++ /dev/null @@ -1,110 +0,0 @@ -/* - * MessagePack for C simple buffer implementation - * - * Copyright (C) 2008-2009 FURUHASHI Sadayuki - * - * 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_SBUFFER_H -#define MSGPACK_SBUFFER_H - -#include -#include - -#ifdef __cplusplus -extern "C" { -#endif - - -/** - * @defgroup msgpack_sbuffer Simple buffer - * @ingroup msgpack_buffer - * @{ - */ - -typedef struct msgpack_sbuffer { - size_t size; - char* data; - size_t alloc; -} msgpack_sbuffer; - -static inline void msgpack_sbuffer_init(msgpack_sbuffer* sbuf) -{ - memset(sbuf, 0, sizeof(msgpack_sbuffer)); -} - -static inline void msgpack_sbuffer_destroy(msgpack_sbuffer* sbuf) -{ - free(sbuf->data); -} - -static inline msgpack_sbuffer* msgpack_sbuffer_new(void) -{ - return (msgpack_sbuffer*)calloc(1, sizeof(msgpack_sbuffer)); -} - -static inline void msgpack_sbuffer_free(msgpack_sbuffer* sbuf) -{ - if(sbuf == NULL) { return; } - msgpack_sbuffer_destroy(sbuf); - free(sbuf); -} - -#ifndef MSGPACK_SBUFFER_INIT_SIZE -#define MSGPACK_SBUFFER_INIT_SIZE 8192 -#endif - -static inline int msgpack_sbuffer_write(void* data, const char* buf, size_t len) -{ - msgpack_sbuffer* sbuf = (msgpack_sbuffer*)data; - - if(sbuf->alloc - sbuf->size < len) { - void* tmp; - size_t nsize = (sbuf->alloc) ? - sbuf->alloc * 2 : MSGPACK_SBUFFER_INIT_SIZE; - - while(nsize < sbuf->size + len) { - size_t tmp_nsize = nsize * 2; - if (tmp_nsize <= nsize) { - nsize = sbuf->size + len; - break; - } - nsize = tmp_nsize; - } - - tmp = realloc(sbuf->data, nsize); - if(!tmp) { return -1; } - - sbuf->data = (char*)tmp; - sbuf->alloc = nsize; - } - - memcpy(sbuf->data + sbuf->size, buf, len); - sbuf->size += len; - return 0; -} - -static inline char* msgpack_sbuffer_release(msgpack_sbuffer* sbuf) -{ - char* tmp = sbuf->data; - sbuf->size = 0; - sbuf->data = NULL; - sbuf->alloc = 0; - return tmp; -} - -static inline void msgpack_sbuffer_clear(msgpack_sbuffer* sbuf) -{ - sbuf->size = 0; -} - -/** @} */ - - -#ifdef __cplusplus -} -#endif - -#endif /* msgpack/sbuffer.h */ diff --git a/include/msgpack/sysdep.h b/include/msgpack/sysdep.hpp similarity index 88% rename from include/msgpack/sysdep.h rename to include/msgpack/sysdep.hpp index bf7a887f8..0b857b77c 100644 --- a/include/msgpack/sysdep.h +++ b/include/msgpack/sysdep.hpp @@ -7,15 +7,14 @@ * (See accompanying file LICENSE_1_0.txt or copy at * http://www.boost.org/LICENSE_1_0.txt) */ -#ifndef MSGPACK_SYSDEP_H -#define MSGPACK_SYSDEP_H +#ifndef MSGPACK_SYSDEP_HPP +#define MSGPACK_SYSDEP_HPP #include #include -#include #if defined(_MSC_VER) && _MSC_VER <= 1800 -# define snprintf(buf, len, format,...) _snprintf_s(buf, len, len, format, __VA_ARGS__) +# define snprintf(buf, len, format,...) _snprintf_s(buf, len, _TRUNCATE, format, __VA_ARGS__) #endif #if defined(_MSC_VER) && _MSC_VER < 1600 @@ -27,6 +26,13 @@ typedef unsigned __int32 uint32_t; typedef signed __int64 int64_t; typedef unsigned __int64 uint64_t; +# if defined(_WIN64) + typedef signed __int64 intptr_t; + typedef unsigned __int64 uintptr_t; +# else + typedef signed __int32 intptr_t; + typedef unsigned __int32 uintptr_t; +# endif #elif defined(_MSC_VER) // && _MSC_VER >= 1600 # include #else @@ -61,11 +67,7 @@ #endif #elif defined(__GNUC__) && ((__GNUC__*10 + __GNUC_MINOR__) < 41) -# if defined(__cplusplus) -# define _msgpack_atomic_counter_header "msgpack/gcc_atomic.hpp" -# else -# define _msgpack_atomic_counter_header "msgpack/gcc_atomic.h" -# endif +# define _msgpack_atomic_counter_header "msgpack/gcc_atomic.hpp" #else typedef unsigned int _msgpack_atomic_counter_t; @@ -75,26 +77,35 @@ #ifdef _WIN32 -# ifdef __cplusplus /* numeric_limits::min,max */ -# ifdef max -# undef max -# endif -# ifdef min -# undef min -# endif +# ifdef max +# undef max +# endif +# ifdef min +# undef min # endif #elif defined(unix) || defined(__unix) || defined(__APPLE__) || defined(__OpenBSD__) -# if defined(linux) +#include /* __BYTE_ORDER */ +# if defined(linux) || defined(__linux__) # include # endif #endif #if !defined(MSGPACK_ENDIAN_LITTLE_BYTE) && !defined(MSGPACK_ENDIAN_BIG_BYTE) + +#if defined(MSGPACK_NO_BOOST) #include +#else // defined(MSGPACK_NO_BOOST) +#include + +#define MSGPACK_ENDIAN_LITTLE_BYTE BOOST_ENDIAN_LITTLE_BYTE +#define MSGPACK_ENDIAN_BIG_BYTE BOOST_ENDIAN_BIG_BYTE + +#endif // defined(MSGPACK_NO_BOOST) + #endif // !defined(MSGPACK_ENDIAN_LITTLE_BYTE) && !defined(MSGPACK_ENDIAN_BIG_BYTE) #if MSGPACK_ENDIAN_LITTLE_BYTE @@ -188,27 +199,8 @@ */ -#if !defined(__cplusplus) && defined(_MSC_VER) -# if !defined(_KERNEL_MODE) -# if !defined(FALSE) -# define FALSE (0) -# endif -# if !defined(TRUE) -# define TRUE (!FALSE) -# endif -# endif -# if _MSC_VER >= 1800 -# include -# else -# define bool int -# define true TRUE -# define false FALSE -# endif -# define inline __inline -#endif - #ifdef __APPLE__ # include #endif -#endif /* msgpack/sysdep.h */ +#endif /* msgpack/sysdep.hpp */ diff --git a/include/msgpack/timestamp.h b/include/msgpack/timestamp.h deleted file mode 100644 index 761393125..000000000 --- a/include/msgpack/timestamp.h +++ /dev/null @@ -1,58 +0,0 @@ -/* - * MessagePack for C TimeStamp - * - * Copyright (C) 2018 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_TIMESTAMP_H -#define MSGPACK_TIMESTAMP_H - -#include - -#ifdef __cplusplus -extern "C" { -#endif - - -typedef struct msgpack_timestamp { - int64_t tv_sec; - uint32_t tv_nsec; -} msgpack_timestamp; - -static inline bool msgpack_object_to_timestamp(const msgpack_object* obj, msgpack_timestamp* ts) { - if (obj->type != MSGPACK_OBJECT_EXT) return false; - if (obj->via.ext.type != -1) return false; - switch (obj->via.ext.size) { - case 4: - ts->tv_nsec = 0; - { - uint32_t v; - _msgpack_load32(uint32_t, obj->via.ext.ptr, &v); - ts->tv_sec = v; - } - return true; - case 8: { - uint64_t value; - _msgpack_load64(uint64_t, obj->via.ext.ptr, &value); - ts->tv_nsec = (uint32_t)(value >> 34); - ts->tv_sec = value & 0x00000003ffffffffLL; - return true; - } - case 12: - _msgpack_load32(uint32_t, obj->via.ext.ptr, &ts->tv_nsec); - _msgpack_load64(int64_t, obj->via.ext.ptr + 4, &ts->tv_sec); - return true; - default: - return false; - } -} - - -#ifdef __cplusplus -} -#endif - -#endif /* msgpack/timestamp.h */ diff --git a/include/msgpack/type.hpp b/include/msgpack/type.hpp index 480609a08..9ef3e86d3 100644 --- a/include/msgpack/type.hpp +++ b/include/msgpack/type.hpp @@ -1,13 +1,84 @@ #include "cpp_config.hpp" +#include "adaptor/array_ref.hpp" #include "adaptor/bool.hpp" +#include "adaptor/carray.hpp" +#include "adaptor/char_ptr.hpp" +#include "adaptor/deque.hpp" +#include "adaptor/ext.hpp" +#include "adaptor/fixint.hpp" #include "adaptor/float.hpp" #include "adaptor/int.hpp" +#include "adaptor/complex.hpp" #include "adaptor/list.hpp" #include "adaptor/map.hpp" +#include "adaptor/nil.hpp" #include "adaptor/pair.hpp" +#include "adaptor/raw.hpp" +#include "adaptor/v4raw.hpp" #include "adaptor/set.hpp" #include "adaptor/size_equal_only.hpp" #include "adaptor/string.hpp" #include "adaptor/vector.hpp" +#include "adaptor/vector_bool.hpp" +#include "adaptor/vector_char.hpp" +#include "adaptor/vector_unsigned_char.hpp" +#include "adaptor/wstring.hpp" #include "adaptor/msgpack_tuple.hpp" #include "adaptor/define.hpp" + +#if defined(MSGPACK_USE_CPP03) + +#include "adaptor/tr1/unordered_map.hpp" +#include "adaptor/tr1/unordered_set.hpp" + +#else // defined(MSGPACK_USE_CPP03) + +#include "adaptor/cpp11/array.hpp" +#include "adaptor/cpp11/array_char.hpp" +#include "adaptor/cpp11/array_unsigned_char.hpp" + +#include "adaptor/cpp11/chrono.hpp" + +#include "adaptor/cpp11/forward_list.hpp" +#include "adaptor/cpp11/reference_wrapper.hpp" +#include "adaptor/cpp11/shared_ptr.hpp" +#include "adaptor/cpp11/timespec.hpp" +#include "adaptor/cpp11/tuple.hpp" +#include "adaptor/cpp11/unique_ptr.hpp" +#include "adaptor/cpp11/unordered_map.hpp" +#include "adaptor/cpp11/unordered_set.hpp" + +#if MSGPACK_HAS_INCLUDE() +#include "adaptor/cpp17/optional.hpp" +#endif // MSGPACK_HAS_INCLUDE() + +#if MSGPACK_HAS_INCLUDE() +#include "adaptor/cpp17/string_view.hpp" +#endif // MSGPACK_HAS_INCLUDE() + +#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() +#include "adaptor/cpp17/variant.hpp" +#endif // MSGPACK_HAS_INCLUDE() + +#if MSGPACK_HAS_INCLUDE() +#include "adaptor/cpp20/span.hpp" +#endif // MSGPACK_HAS_INCLUDE() + +#endif // defined(MSGPACK_USE_CPP03) + +#if !defined(MSGPACK_NO_BOOST) +#include "adaptor/boost/fusion.hpp" + +#if !defined(MSGPACK_USE_CPP03) +#include "adaptor/boost/msgpack_variant.hpp" +#endif // !defined(MSGPACK_USE_CPP03) + +#include "adaptor/boost/optional.hpp" +#include "adaptor/boost/string_ref.hpp" +#include "adaptor/boost/string_view.hpp" +#endif // !defined(MSGPACK_NO_BOOST) diff --git a/include/msgpack/unpack.h b/include/msgpack/unpack.h deleted file mode 100644 index 036d575eb..000000000 --- a/include/msgpack/unpack.h +++ /dev/null @@ -1,281 +0,0 @@ -/* - * MessagePack for C unpacking routine - * - * Copyright (C) 2008-2009 FURUHASHI Sadayuki - * - * 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_UNPACKER_H -#define MSGPACK_UNPACKER_H - -#include "zone.h" -#include "object.h" -#include - -#ifdef __cplusplus -extern "C" { -#endif - - -/** - * @defgroup msgpack_unpack Deserializer - * @ingroup msgpack - * @{ - */ - -typedef struct msgpack_unpacked { - msgpack_zone* zone; - msgpack_object data; -} msgpack_unpacked; - -typedef enum { - MSGPACK_UNPACK_SUCCESS = 2, - MSGPACK_UNPACK_EXTRA_BYTES = 1, - MSGPACK_UNPACK_CONTINUE = 0, - MSGPACK_UNPACK_PARSE_ERROR = -1, - MSGPACK_UNPACK_NOMEM_ERROR = -2 -} msgpack_unpack_return; - - -MSGPACK_DLLEXPORT -msgpack_unpack_return -msgpack_unpack_next(msgpack_unpacked* result, - const char* data, size_t len, size_t* off); - -/** @} */ - - -/** - * @defgroup msgpack_unpacker Streaming deserializer - * @ingroup msgpack - * @{ - */ - -typedef struct msgpack_unpacker { - char* buffer; - size_t used; - size_t free; - size_t off; - size_t parsed; - msgpack_zone* z; - size_t initial_buffer_size; - void* ctx; -} msgpack_unpacker; - - -#ifndef MSGPACK_UNPACKER_INIT_BUFFER_SIZE -#define MSGPACK_UNPACKER_INIT_BUFFER_SIZE (64*1024) -#endif - -/** - * Initializes a streaming deserializer. - * The initialized deserializer must be destroyed by msgpack_unpacker_destroy(msgpack_unpacker*). - */ -MSGPACK_DLLEXPORT -bool msgpack_unpacker_init(msgpack_unpacker* mpac, size_t initial_buffer_size); - -/** - * Destroys a streaming deserializer initialized by msgpack_unpacker_init(msgpack_unpacker*, size_t). - */ -MSGPACK_DLLEXPORT -void msgpack_unpacker_destroy(msgpack_unpacker* mpac); - - -/** - * Creates a streaming deserializer. - * The created deserializer must be destroyed by msgpack_unpacker_free(msgpack_unpacker*). - */ -MSGPACK_DLLEXPORT -msgpack_unpacker* msgpack_unpacker_new(size_t initial_buffer_size); - -/** - * Frees a streaming deserializer created by msgpack_unpacker_new(size_t). - */ -MSGPACK_DLLEXPORT -void msgpack_unpacker_free(msgpack_unpacker* mpac); - - -#ifndef MSGPACK_UNPACKER_RESERVE_SIZE -#define MSGPACK_UNPACKER_RESERVE_SIZE (32*1024) -#endif - -/** - * Reserves free space of the internal buffer. - * Use this function to fill the internal buffer with - * msgpack_unpacker_buffer(msgpack_unpacker*), - * msgpack_unpacker_buffer_capacity(const msgpack_unpacker*) and - * msgpack_unpacker_buffer_consumed(msgpack_unpacker*). - */ -static inline bool msgpack_unpacker_reserve_buffer(msgpack_unpacker* mpac, size_t size); - -/** - * Gets pointer to the free space of the internal buffer. - * Use this function to fill the internal buffer with - * msgpack_unpacker_reserve_buffer(msgpack_unpacker*, size_t), - * msgpack_unpacker_buffer_capacity(const msgpack_unpacker*) and - * msgpack_unpacker_buffer_consumed(msgpack_unpacker*). - */ -static inline char* msgpack_unpacker_buffer(msgpack_unpacker* mpac); - -/** - * Gets size of the free space of the internal buffer. - * Use this function to fill the internal buffer with - * msgpack_unpacker_reserve_buffer(msgpack_unpacker*, size_t), - * msgpack_unpacker_buffer(const msgpack_unpacker*) and - * msgpack_unpacker_buffer_consumed(msgpack_unpacker*). - */ -static inline size_t msgpack_unpacker_buffer_capacity(const msgpack_unpacker* mpac); - -/** - * Notifies the deserializer that the internal buffer filled. - * Use this function to fill the internal buffer with - * msgpack_unpacker_reserve_buffer(msgpack_unpacker*, size_t), - * msgpack_unpacker_buffer(msgpack_unpacker*) and - * msgpack_unpacker_buffer_capacity(const msgpack_unpacker*). - */ -static inline void msgpack_unpacker_buffer_consumed(msgpack_unpacker* mpac, size_t size); - - -/** - * Deserializes one object. - * Returns true if it successes. Otherwise false is returned. - * @param pac pointer to an initialized msgpack_unpacked object. - */ -MSGPACK_DLLEXPORT -msgpack_unpack_return msgpack_unpacker_next(msgpack_unpacker* mpac, msgpack_unpacked* pac); - -/** - * Deserializes one object and set the number of parsed bytes involved. - * Returns true if it successes. Otherwise false is returned. - * @param mpac pointer to an initialized msgpack_unpacker object. - * @param result pointer to an initialized msgpack_unpacked object. - * @param p_bytes pointer to variable that will be set with the number of parsed bytes. - */ -MSGPACK_DLLEXPORT -msgpack_unpack_return msgpack_unpacker_next_with_size(msgpack_unpacker* mpac, - msgpack_unpacked* result, - size_t *p_bytes); - -/** - * Initializes a msgpack_unpacked object. - * The initialized object must be destroyed by msgpack_unpacked_destroy(msgpack_unpacker*). - * Use the object with msgpack_unpacker_next(msgpack_unpacker*, msgpack_unpacked*) or - * msgpack_unpack_next(msgpack_unpacked*, const char*, size_t, size_t*). - */ -static inline void msgpack_unpacked_init(msgpack_unpacked* result); - -/** - * Destroys a streaming deserializer initialized by msgpack_unpacked(). - */ -static inline void msgpack_unpacked_destroy(msgpack_unpacked* result); - -/** - * Releases the memory zone from msgpack_unpacked object. - * The released zone must be freed by msgpack_zone_free(msgpack_zone*). - */ -static inline msgpack_zone* msgpack_unpacked_release_zone(msgpack_unpacked* result); - - -MSGPACK_DLLEXPORT -int msgpack_unpacker_execute(msgpack_unpacker* mpac); - -MSGPACK_DLLEXPORT -msgpack_object msgpack_unpacker_data(msgpack_unpacker* mpac); - -MSGPACK_DLLEXPORT -msgpack_zone* msgpack_unpacker_release_zone(msgpack_unpacker* mpac); - -MSGPACK_DLLEXPORT -void msgpack_unpacker_reset_zone(msgpack_unpacker* mpac); - -MSGPACK_DLLEXPORT -void msgpack_unpacker_reset(msgpack_unpacker* mpac); - -static inline size_t msgpack_unpacker_message_size(const msgpack_unpacker* mpac); - - -/** @} */ - - -// obsolete -MSGPACK_DLLEXPORT -msgpack_unpack_return -msgpack_unpack(const char* data, size_t len, size_t* off, - msgpack_zone* result_zone, msgpack_object* result); - - - - -static inline size_t msgpack_unpacker_parsed_size(const msgpack_unpacker* mpac); - -MSGPACK_DLLEXPORT -bool msgpack_unpacker_flush_zone(msgpack_unpacker* mpac); - -MSGPACK_DLLEXPORT -bool msgpack_unpacker_expand_buffer(msgpack_unpacker* mpac, size_t size); - -static inline bool msgpack_unpacker_reserve_buffer(msgpack_unpacker* mpac, size_t size) -{ - if(mpac->free >= size) { return true; } - return msgpack_unpacker_expand_buffer(mpac, size); -} - -static inline char* msgpack_unpacker_buffer(msgpack_unpacker* mpac) -{ - return mpac->buffer + mpac->used; -} - -static inline size_t msgpack_unpacker_buffer_capacity(const msgpack_unpacker* mpac) -{ - return mpac->free; -} - -static inline void msgpack_unpacker_buffer_consumed(msgpack_unpacker* mpac, size_t size) -{ - mpac->used += size; - mpac->free -= size; -} - -static inline size_t msgpack_unpacker_message_size(const msgpack_unpacker* mpac) -{ - return mpac->parsed - mpac->off + mpac->used; -} - -static inline size_t msgpack_unpacker_parsed_size(const msgpack_unpacker* mpac) -{ - return mpac->parsed; -} - - -static inline void msgpack_unpacked_init(msgpack_unpacked* result) -{ - memset(result, 0, sizeof(msgpack_unpacked)); -} - -static inline void msgpack_unpacked_destroy(msgpack_unpacked* result) -{ - if(result->zone != NULL) { - msgpack_zone_free(result->zone); - result->zone = NULL; - memset(&result->data, 0, sizeof(msgpack_object)); - } -} - -static inline msgpack_zone* msgpack_unpacked_release_zone(msgpack_unpacked* result) -{ - if(result->zone != NULL) { - msgpack_zone* z = result->zone; - result->zone = NULL; - return z; - } - return NULL; -} - - -#ifdef __cplusplus -} -#endif - -#endif /* msgpack/unpack.h */ diff --git a/include/msgpack/unpack_define.h b/include/msgpack/unpack_define.hpp similarity index 87% rename from include/msgpack/unpack_define.h rename to include/msgpack/unpack_define.hpp index c7decf659..b3a4db9e6 100644 --- a/include/msgpack/unpack_define.h +++ b/include/msgpack/unpack_define.hpp @@ -7,19 +7,10 @@ * (See accompanying file LICENSE_1_0.txt or copy at * http://www.boost.org/LICENSE_1_0.txt) */ -#ifndef MSGPACK_UNPACK_DEFINE_H -#define MSGPACK_UNPACK_DEFINE_H - -#include "msgpack/sysdep.h" -#include -#include -#include -#include - -#ifdef __cplusplus -extern "C" { -#endif +#ifndef MSGPACK_UNPACK_DEFINE_HPP +#define MSGPACK_UNPACK_DEFINE_HPP +#include "msgpack/sysdep.hpp" #ifndef MSGPACK_EMBED_STACK_SIZE #define MSGPACK_EMBED_STACK_SIZE 32 @@ -81,9 +72,4 @@ typedef enum { } msgpack_container_type; -#ifdef __cplusplus -} -#endif - -#endif /* msgpack/unpack_define.h */ - +#endif /* msgpack/unpack_define.hpp */ diff --git a/include/msgpack/unpack_template.h b/include/msgpack/unpack_template.h deleted file mode 100644 index de30f3cf0..000000000 --- a/include/msgpack/unpack_template.h +++ /dev/null @@ -1,471 +0,0 @@ -/* - * MessagePack unpacking routine template - * - * Copyright (C) 2008-2010 FURUHASHI Sadayuki - * - * 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_unpack_func -#error msgpack_unpack_func template is not defined -#endif - -#ifndef msgpack_unpack_callback -#error msgpack_unpack_callback template is not defined -#endif - -#ifndef msgpack_unpack_struct -#error msgpack_unpack_struct template is not defined -#endif - -#ifndef msgpack_unpack_struct_decl -#define msgpack_unpack_struct_decl(name) msgpack_unpack_struct(name) -#endif - -#ifndef msgpack_unpack_object -#error msgpack_unpack_object type is not defined -#endif - -#ifndef msgpack_unpack_user -#error msgpack_unpack_user type is not defined -#endif - -#ifndef USE_CASE_RANGE -#if !defined(_MSC_VER) -#define USE_CASE_RANGE -#endif -#endif - -#if defined(_KERNEL_MODE) -#undef assert -#define assert NT_ASSERT -#endif - -msgpack_unpack_struct_decl(_stack) { - msgpack_unpack_object obj; - size_t count; - unsigned int ct; - msgpack_unpack_object map_key; -}; - -msgpack_unpack_struct_decl(_context) { - msgpack_unpack_user user; - unsigned int cs; - unsigned int trail; - unsigned int top; - /* - msgpack_unpack_struct(_stack)* stack; - unsigned int stack_size; - msgpack_unpack_struct(_stack) embed_stack[MSGPACK_EMBED_STACK_SIZE]; - */ - msgpack_unpack_struct(_stack) stack[MSGPACK_EMBED_STACK_SIZE]; -}; - - -msgpack_unpack_func(void, _init)(msgpack_unpack_struct(_context)* ctx) -{ - ctx->cs = MSGPACK_CS_HEADER; - ctx->trail = 0; - ctx->top = 0; - /* - ctx->stack = ctx->embed_stack; - ctx->stack_size = MSGPACK_EMBED_STACK_SIZE; - */ - ctx->stack[0].obj = msgpack_unpack_callback(_root)(&ctx->user); -} - -/* -msgpack_unpack_func(void, _destroy)(msgpack_unpack_struct(_context)* ctx) -{ - if(ctx->stack_size != MSGPACK_EMBED_STACK_SIZE) { - free(ctx->stack); - } -} -*/ - -msgpack_unpack_func(msgpack_unpack_object, _data)(msgpack_unpack_struct(_context)* ctx) -{ - return (ctx)->stack[0].obj; -} - - -msgpack_unpack_func(int, _execute)(msgpack_unpack_struct(_context)* ctx, const char* data, size_t len, size_t* off) -{ - assert(len >= *off); - { - const unsigned char* p = (unsigned char*)data + *off; - const unsigned char* const pe = (unsigned char*)data + len; - const void* n = NULL; - - unsigned int trail = ctx->trail; - unsigned int cs = ctx->cs; - unsigned int top = ctx->top; - msgpack_unpack_struct(_stack)* stack = ctx->stack; - /* - unsigned int stack_size = ctx->stack_size; - */ - msgpack_unpack_user* user = &ctx->user; - - msgpack_unpack_object obj; - msgpack_unpack_struct(_stack)* c = NULL; - - int ret; - -#define push_simple_value(func) \ - ret = msgpack_unpack_callback(func)(user, &obj); \ - if(ret < 0) { goto _failed; } \ - goto _push -#define push_fixed_value(func, arg) \ - ret = msgpack_unpack_callback(func)(user, arg, &obj); \ - if(ret < 0) { goto _failed; } \ - goto _push -#define push_variable_value(func, base, pos, len) \ - ret = msgpack_unpack_callback(func)(user, \ - (const char*)base, (const char*)pos, len, &obj); \ - if(ret < 0) { goto _failed; } \ - goto _push - -#define again_fixed_trail(_cs, trail_len) \ - trail = trail_len; \ - cs = _cs; \ - goto _fixed_trail_again -#define again_fixed_trail_if_zero(_cs, trail_len, ifzero) \ - trail = trail_len; \ - if(trail == 0) { goto ifzero; } \ - cs = _cs; \ - goto _fixed_trail_again - -#define start_container(func, count_, ct_) \ - if(top >= MSGPACK_EMBED_STACK_SIZE) { \ - ret = MSGPACK_UNPACK_NOMEM_ERROR; \ - goto _failed; \ - } /* FIXME */ \ - ret = msgpack_unpack_callback(func)(user, count_, &stack[top].obj); \ - if(ret < 0) { goto _failed; } \ - if((count_) == 0) { obj = stack[top].obj; goto _push; } \ - stack[top].ct = ct_; \ - stack[top].count = count_; \ - ++top; \ - goto _header_again - -#define NEXT_CS(p) \ - ((unsigned int)*p & 0x1f) - -#ifdef USE_CASE_RANGE -#define SWITCH_RANGE_BEGIN switch(*p) { -#define SWITCH_RANGE(FROM, TO) case FROM ... TO: -#define SWITCH_RANGE_DEFAULT default: -#define SWITCH_RANGE_END } -#else -#define SWITCH_RANGE_BEGIN { if(0) { -#define SWITCH_RANGE(FROM, TO) } else if(FROM <= *p && *p <= TO) { -#define SWITCH_RANGE_DEFAULT } else { -#define SWITCH_RANGE_END } } -#endif - - if(p == pe) { goto _out; } - do { - switch(cs) { - case MSGPACK_CS_HEADER: - SWITCH_RANGE_BEGIN - SWITCH_RANGE(0x00, 0x7f) // Positive Fixnum - push_fixed_value(_uint8, *(uint8_t*)p); - SWITCH_RANGE(0xe0, 0xff) // Negative Fixnum - push_fixed_value(_int8, *(int8_t*)p); - SWITCH_RANGE(0xc0, 0xdf) // Variable - switch(*p) { - case 0xc0: // nil - push_simple_value(_nil); - //case 0xc1: // string - // again_terminal_trail(NEXT_CS(p), p+1); - case 0xc2: // false - push_simple_value(_false); - case 0xc3: // true - push_simple_value(_true); - case 0xc4: // bin 8 - case 0xc5: // bin 16 - case 0xc6: // bin 32 - again_fixed_trail(NEXT_CS(p), 1 << (((unsigned int)*p) & 0x03)); - case 0xc7: // ext 8 - case 0xc8: // ext 16 - case 0xc9: // ext 32 - again_fixed_trail(NEXT_CS(p), 1 << ((((unsigned int)*p) + 1) & 0x03)); - case 0xca: // float - case 0xcb: // double - case 0xcc: // unsigned int 8 - case 0xcd: // unsigned int 16 - case 0xce: // unsigned int 32 - case 0xcf: // unsigned int 64 - case 0xd0: // signed int 8 - case 0xd1: // signed int 16 - case 0xd2: // signed int 32 - case 0xd3: // signed int 64 - again_fixed_trail(NEXT_CS(p), 1 << (((unsigned int)*p) & 0x03)); - case 0xd4: // fixext 1 - case 0xd5: // fixext 2 - case 0xd6: // fixext 4 - case 0xd7: // fixext 8 - again_fixed_trail_if_zero(MSGPACK_ACS_EXT_VALUE, - (1 << (((unsigned int)*p) & 0x03)) + 1, _ext_zero); - case 0xd8: // fixext 16 - again_fixed_trail_if_zero(MSGPACK_ACS_EXT_VALUE, 16+1, _ext_zero); - - case 0xd9: // str 8 - case 0xda: // str 16 - case 0xdb: // str 32 - again_fixed_trail(NEXT_CS(p), 1 << ((((unsigned int)*p) & 0x03) - 1)); - case 0xdc: // array 16 - case 0xdd: // array 32 - case 0xde: // map 16 - case 0xdf: // map 32 - again_fixed_trail(NEXT_CS(p), 2u << (((unsigned int)*p) & 0x01)); - default: - ret = MSGPACK_UNPACK_PARSE_ERROR; - goto _failed; - } - SWITCH_RANGE(0xa0, 0xbf) // FixStr - again_fixed_trail_if_zero(MSGPACK_ACS_STR_VALUE, ((unsigned int)*p & 0x1f), _str_zero); - SWITCH_RANGE(0x90, 0x9f) // FixArray - start_container(_array, ((unsigned int)*p) & 0x0f, MSGPACK_CT_ARRAY_ITEM); - SWITCH_RANGE(0x80, 0x8f) // FixMap - start_container(_map, ((unsigned int)*p) & 0x0f, MSGPACK_CT_MAP_KEY); - - SWITCH_RANGE_DEFAULT - ret = MSGPACK_UNPACK_PARSE_ERROR; - goto _failed; - SWITCH_RANGE_END - // end MSGPACK_CS_HEADER - - - _fixed_trail_again: - ++p; - // fallthrough - - default: - if((size_t)(pe - p) < trail) { goto _out; } - n = p; p += trail - 1; - switch(cs) { - //case MSGPACK_CS_ - //case MSGPACK_CS_ - case MSGPACK_CS_FLOAT: { - union { uint32_t i; float f; } mem; - _msgpack_load32(uint32_t, n, &mem.i); - push_fixed_value(_float, mem.f); } - case MSGPACK_CS_DOUBLE: { - union { uint64_t i; double f; } mem; - _msgpack_load64(uint64_t, n, &mem.i); -#if defined(TARGET_OS_IPHONE) - // ok -#elif defined(__arm__) && !(__ARM_EABI__) // arm-oabi - // https://github.com/msgpack/msgpack-perl/pull/1 - mem.i = (mem.i & 0xFFFFFFFFUL) << 32UL | (mem.i >> 32UL); -#endif - push_fixed_value(_double, mem.f); } - case MSGPACK_CS_UINT_8: - push_fixed_value(_uint8, *(uint8_t*)n); - case MSGPACK_CS_UINT_16:{ - uint16_t tmp; - _msgpack_load16(uint16_t,n,&tmp); - push_fixed_value(_uint16, tmp); - } - case MSGPACK_CS_UINT_32:{ - uint32_t tmp; - _msgpack_load32(uint32_t,n,&tmp); - push_fixed_value(_uint32, tmp); - } - case MSGPACK_CS_UINT_64:{ - uint64_t tmp; - _msgpack_load64(uint64_t,n,&tmp); - push_fixed_value(_uint64, tmp); - } - case MSGPACK_CS_INT_8: - push_fixed_value(_int8, *(int8_t*)n); - case MSGPACK_CS_INT_16:{ - int16_t tmp; - _msgpack_load16(int16_t,n,&tmp); - push_fixed_value(_int16, tmp); - } - case MSGPACK_CS_INT_32:{ - int32_t tmp; - _msgpack_load32(int32_t,n,&tmp); - push_fixed_value(_int32, tmp); - } - case MSGPACK_CS_INT_64:{ - int64_t tmp; - _msgpack_load64(int64_t,n,&tmp); - push_fixed_value(_int64, tmp); - } - case MSGPACK_CS_FIXEXT_1: - again_fixed_trail_if_zero(MSGPACK_ACS_EXT_VALUE, 1+1, _ext_zero); - case MSGPACK_CS_FIXEXT_2: - again_fixed_trail_if_zero(MSGPACK_ACS_EXT_VALUE, 2+1, _ext_zero); - case MSGPACK_CS_FIXEXT_4: - again_fixed_trail_if_zero(MSGPACK_ACS_EXT_VALUE, 4+1, _ext_zero); - case MSGPACK_CS_FIXEXT_8: - again_fixed_trail_if_zero(MSGPACK_ACS_EXT_VALUE, 8+1, _ext_zero); - case MSGPACK_CS_FIXEXT_16: - again_fixed_trail_if_zero(MSGPACK_ACS_EXT_VALUE, 16+1, _ext_zero); - case MSGPACK_CS_STR_8: - again_fixed_trail_if_zero(MSGPACK_ACS_STR_VALUE, *(uint8_t*)n, _str_zero); - case MSGPACK_CS_BIN_8: - again_fixed_trail_if_zero(MSGPACK_ACS_BIN_VALUE, *(uint8_t*)n, _bin_zero); - case MSGPACK_CS_EXT_8: - again_fixed_trail_if_zero(MSGPACK_ACS_EXT_VALUE, (*(uint8_t*)n) + 1, _ext_zero); - case MSGPACK_CS_STR_16:{ - uint16_t tmp; - _msgpack_load16(uint16_t,n,&tmp); - again_fixed_trail_if_zero(MSGPACK_ACS_STR_VALUE, tmp, _str_zero); - } - case MSGPACK_CS_BIN_16:{ - uint16_t tmp; - _msgpack_load16(uint16_t,n,&tmp); - again_fixed_trail_if_zero(MSGPACK_ACS_BIN_VALUE, tmp, _bin_zero); - } - case MSGPACK_CS_EXT_16:{ - uint16_t tmp; - _msgpack_load16(uint16_t,n,&tmp); - again_fixed_trail_if_zero(MSGPACK_ACS_EXT_VALUE, tmp + 1, _ext_zero); - } - case MSGPACK_CS_STR_32:{ - uint32_t tmp; - _msgpack_load32(uint32_t,n,&tmp); - again_fixed_trail_if_zero(MSGPACK_ACS_STR_VALUE, tmp, _str_zero); - } - case MSGPACK_CS_BIN_32:{ - uint32_t tmp; - _msgpack_load32(uint32_t,n,&tmp); - again_fixed_trail_if_zero(MSGPACK_ACS_BIN_VALUE, tmp, _bin_zero); - } - case MSGPACK_CS_EXT_32:{ - uint32_t tmp; - _msgpack_load32(uint32_t,n,&tmp); - again_fixed_trail_if_zero(MSGPACK_ACS_EXT_VALUE, tmp + 1, _ext_zero); - } - case MSGPACK_ACS_STR_VALUE: - _str_zero: - push_variable_value(_str, data, n, trail); - case MSGPACK_ACS_BIN_VALUE: - _bin_zero: - push_variable_value(_bin, data, n, trail); - case MSGPACK_ACS_EXT_VALUE: - _ext_zero: - push_variable_value(_ext, data, n, trail); - - case MSGPACK_CS_ARRAY_16:{ - uint16_t tmp; - _msgpack_load16(uint16_t,n,&tmp); - start_container(_array, tmp, MSGPACK_CT_ARRAY_ITEM); - } - case MSGPACK_CS_ARRAY_32:{ - /* FIXME security guard */ - uint32_t tmp; - _msgpack_load32(uint32_t,n,&tmp); - start_container(_array, tmp, MSGPACK_CT_ARRAY_ITEM); - } - - case MSGPACK_CS_MAP_16:{ - uint16_t tmp; - _msgpack_load16(uint16_t,n,&tmp); - start_container(_map, tmp, MSGPACK_CT_MAP_KEY); - } - case MSGPACK_CS_MAP_32:{ - /* FIXME security guard */ - uint32_t tmp; - _msgpack_load32(uint32_t,n,&tmp); - start_container(_map, tmp, MSGPACK_CT_MAP_KEY); - } - - default: - ret = MSGPACK_UNPACK_PARSE_ERROR; - goto _failed; - } - } - - _push: - if(top == 0) { goto _finish; } - c = &stack[top-1]; - switch(c->ct) { - case MSGPACK_CT_ARRAY_ITEM: - ret = msgpack_unpack_callback(_array_item)(user, &c->obj, obj); \ - if(ret < 0) { goto _failed; } - if(--c->count == 0) { - obj = c->obj; - --top; - /*printf("stack pop %d\n", top);*/ - goto _push; - } - goto _header_again; - case MSGPACK_CT_MAP_KEY: - c->map_key = obj; - c->ct = MSGPACK_CT_MAP_VALUE; - goto _header_again; - case MSGPACK_CT_MAP_VALUE: - ret = msgpack_unpack_callback(_map_item)(user, &c->obj, c->map_key, obj); \ - if(ret < 0) { goto _failed; } - if(--c->count == 0) { - obj = c->obj; - --top; - /*printf("stack pop %d\n", top);*/ - goto _push; - } - c->ct = MSGPACK_CT_MAP_KEY; - goto _header_again; - - default: - ret = MSGPACK_UNPACK_PARSE_ERROR; - goto _failed; - } - - _header_again: - cs = MSGPACK_CS_HEADER; - ++p; - } while(p != pe); - goto _out; - - - _finish: - stack[0].obj = obj; - ++p; - ret = 1; - /*printf("-- finish --\n"); */ - goto _end; - - _failed: - /*printf("** FAILED **\n"); */ - goto _end; - - _out: - ret = 0; - goto _end; - - _end: - ctx->cs = cs; - ctx->trail = trail; - ctx->top = top; - *off = (size_t)(p - (const unsigned char*)data); - - return ret; - } -} - -#undef msgpack_unpack_func -#undef msgpack_unpack_callback -#undef msgpack_unpack_struct -#undef msgpack_unpack_object -#undef msgpack_unpack_user - -#undef push_simple_value -#undef push_fixed_value -#undef push_variable_value -#undef again_fixed_trail -#undef again_fixed_trail_if_zero -#undef start_container - -#undef NEXT_CS - -#undef SWITCH_RANGE_BEGIN -#undef SWITCH_RANGE -#undef SWITCH_RANGE_DEFAULT -#undef SWITCH_RANGE_END diff --git a/include/msgpack/util.h b/include/msgpack/util.h deleted file mode 100644 index 959b56bec..000000000 --- a/include/msgpack/util.h +++ /dev/null @@ -1,15 +0,0 @@ -/* - * MessagePack for C utilities - * - * Copyright (C) 2014 FURUHASHI Sadayuki - * - * 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_UTIL_H -#define MSGPACK_UTIL_H - -#define MSGPACK_UNUSED(a) (void)(a) - -#endif /* MSGPACK_UTIL_H */ diff --git a/include/msgpack/v1/adaptor/array_ref.hpp b/include/msgpack/v1/adaptor/array_ref.hpp index f90c6ef1f..d44be1645 100644 --- a/include/msgpack/v1/adaptor/array_ref.hpp +++ b/include/msgpack/v1/adaptor/array_ref.hpp @@ -258,14 +258,15 @@ struct object_with_zone > { o.via.array.size = size; typename T::const_iterator it(v.data->begin()); do { -#if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__) +#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wmaybe-uninitialized" -#endif // (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__) +#endif // defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__) + *p = msgpack::object(*it, o.zone); -#if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__) +#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__) #pragma GCC diagnostic pop -#endif // (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__) +#endif // defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__) ++p; ++it; } while(p < pend); diff --git a/include/msgpack/v1/adaptor/array_ref_decl.hpp b/include/msgpack/v1/adaptor/array_ref_decl.hpp index 433e24f66..26a0405da 100644 --- a/include/msgpack/v1/adaptor/array_ref_decl.hpp +++ b/include/msgpack/v1/adaptor/array_ref_decl.hpp @@ -12,6 +12,7 @@ #include "msgpack/versioning.hpp" #include "msgpack/adaptor/adaptor_base.hpp" +#include "msgpack/object.hpp" namespace msgpack { diff --git a/include/msgpack/v1/adaptor/bool.hpp b/include/msgpack/v1/adaptor/bool.hpp index 95cd704f3..420d53988 100644 --- a/include/msgpack/v1/adaptor/bool.hpp +++ b/include/msgpack/v1/adaptor/bool.hpp @@ -12,6 +12,7 @@ #include "msgpack/versioning.hpp" #include "msgpack/adaptor/adaptor_base.hpp" +#include "msgpack/object.hpp" namespace msgpack { diff --git a/include/msgpack/v1/adaptor/boost/fusion.hpp b/include/msgpack/v1/adaptor/boost/fusion.hpp index 69a112406..9d12a368d 100644 --- a/include/msgpack/v1/adaptor/boost/fusion.hpp +++ b/include/msgpack/v1/adaptor/boost/fusion.hpp @@ -12,6 +12,7 @@ #include "msgpack/versioning.hpp" #include "msgpack/adaptor/adaptor_base.hpp" +#include "msgpack/object.hpp" #include "msgpack/adaptor/check_container_size.hpp" #include "msgpack/meta.hpp" @@ -21,11 +22,23 @@ #include "msgpack/adaptor/cpp11/tuple.hpp" #endif // #if !defined (MSGPACK_USE_CPP03) +#if defined(__GNUC__) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif // defined(__GNUC__) + #include #include #include #include #include + + +#if defined(__GNUC__) +#pragma GCC diagnostic pop +#endif // defined(__GNUC__) + + #include namespace msgpack { @@ -111,7 +124,7 @@ struct as< template static std::tuple< typename std::remove_reference< - typename boost::fusion::result_of::at_c::type + typename boost::fusion::result_of::at_c(Is)>::type >::type...> to_tuple(U const& u, seq) { return std::make_tuple(boost::fusion::at_c(u)...); diff --git a/include/msgpack/v1/adaptor/boost/msgpack_variant.hpp b/include/msgpack/v1/adaptor/boost/msgpack_variant.hpp index 26eff00bb..1703f1f4a 100644 --- a/include/msgpack/v1/adaptor/boost/msgpack_variant.hpp +++ b/include/msgpack/v1/adaptor/boost/msgpack_variant.hpp @@ -10,8 +10,6 @@ #ifndef MSGPACK_V1_TYPE_BOOST_MSGPACK_VARIANT_HPP #define MSGPACK_V1_TYPE_BOOST_MSGPACK_VARIANT_HPP -#if defined(MSGPACK_USE_BOOST) - #include "msgpack/v1/adaptor/boost/msgpack_variant_decl.hpp" #include "msgpack/adaptor/check_container_size.hpp" @@ -28,7 +26,18 @@ #include "msgpack/adaptor/vector.hpp" #include "msgpack/adaptor/map.hpp" + +#if defined(__GNUC__) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif // defined(__GNUC__) + #include + +#if defined(__GNUC__) +#pragma GCC diagnostic pop +#endif // defined(__GNUC__) + #include namespace msgpack { @@ -113,6 +122,12 @@ struct basic_variant : int_init(v); } basic_variant(unsigned long long v):base(uint64_t(v)) {} + basic_variant(float v) { + double_init(v); + } + basic_variant(double v) { + double_init(v); + } bool is_nil() const { return boost::get(this) != MSGPACK_NULLPTR; @@ -168,71 +183,50 @@ struct basic_variant : int64_t as_int64_t() const { return boost::get(*this); } - int64_t& as_int64_t() { - return boost::get(*this); - } uint64_t as_uint64_t() const { return boost::get(*this); } - uint64_t& as_uint64_t() { - return boost::get(*this); - } double as_double() const { - return boost::get(*this); - } - double& as_double() { - return boost::get(*this); + if (is_double()) { + return boost::get(*this); + } + if (is_int64_t()) { + return static_cast(boost::get(*this)); + } + if (is_uint64_t()) { + return static_cast(boost::get(*this)); + } + throw msgpack::type_error(); } std::string const& as_string() const { return boost::get(*this); } - std::string& as_string() { - return boost::get(*this); - } #if (BOOST_VERSION / 100000) >= 1 && ((BOOST_VERSION / 100) % 1000) >= 53 boost::string_ref const& as_boost_string_ref() const { return boost::get(*this); } - boost::string_ref& as_boost_string_ref() { - return boost::get(*this); - } #endif // (BOOST_VERSION / 100000) >= 1 && ((BOOST_VERSION / 100) % 1000) >= 53 std::vector const& as_vector_char() const { return boost::get >(*this); } - std::vector& as_vector_char() { - return boost::get >(*this); - } raw_ref const& as_raw_ref() const { return boost::get(*this); } ext const& as_ext() const { return boost::get(*this); } - ext& as_ext() { - return boost::get(*this); - } ext_ref const& as_ext_ref() const { return boost::get(*this); } std::vector > const& as_vector() const { return boost::get > >(*this); } - std::vector >& as_vector() { - return boost::get > >(*this); - } std::map, basic_variant > const& as_map() const { return boost::get, basic_variant > >(*this); } - std::map, basic_variant >& as_map() { - return boost::get, basic_variant > >(*this); - } std::multimap, basic_variant > const& as_multimap() const { return boost::get, basic_variant > >(*this); } - std::multimap, basic_variant >& as_multimap() { - return boost::get, basic_variant > >(*this); - } private: template void int_init(T v) { @@ -243,6 +237,19 @@ struct basic_variant : static_cast(*this) = uint64_t(v); } } + void double_init(double v) { + if (v == v) { // check for nan + if (v >= 0 && v <= double(std::numeric_limits::max()) && v == double(uint64_t(v))) { + static_cast(*this) = uint64_t(v); + return; + } + else if (v < 0 && v >= double(std::numeric_limits::min()) && v == double(int64_t(v))) { + static_cast(*this) = int64_t(v); + return; + } + } + static_cast(*this) = v; + } }; template @@ -439,5 +446,4 @@ struct object_with_zone > { } // namespace msgpack -#endif // MSGPACK_USE_BOOST #endif // MSGPACK_V1_TYPE_BOOST_MSGPACK_VARIANT_HPP diff --git a/include/msgpack/v1/adaptor/boost/msgpack_variant_decl.hpp b/include/msgpack/v1/adaptor/boost/msgpack_variant_decl.hpp index 2bbf91e49..15ad18d47 100644 --- a/include/msgpack/v1/adaptor/boost/msgpack_variant_decl.hpp +++ b/include/msgpack/v1/adaptor/boost/msgpack_variant_decl.hpp @@ -10,10 +10,9 @@ #ifndef MSGPACK_V1_TYPE_BOOST_MSGPACK_VARIANT_DECL_HPP #define MSGPACK_V1_TYPE_BOOST_MSGPACK_VARIANT_DECL_HPP -#if defined(MSGPACK_USE_BOOST) - #include "msgpack/versioning.hpp" #include "msgpack/adaptor/adaptor_base.hpp" +#include "msgpack/object.hpp" #include "msgpack/adaptor/check_container_size.hpp" #include "msgpack/adaptor/boost/string_ref.hpp" #include "msgpack/adaptor/ext.hpp" @@ -58,5 +57,4 @@ typedef basic_variant< } // namespace msgpack -#endif // MSGPACK_USE_BOOST #endif // MSGPACK_V1_TYPE_BOOST_MSGPACK_VARIANT_DECL_HPP diff --git a/include/msgpack/v1/adaptor/boost/optional.hpp b/include/msgpack/v1/adaptor/boost/optional.hpp index 449937a5a..ec8f60b6b 100644 --- a/include/msgpack/v1/adaptor/boost/optional.hpp +++ b/include/msgpack/v1/adaptor/boost/optional.hpp @@ -12,19 +12,29 @@ #include "msgpack/versioning.hpp" #include "msgpack/adaptor/adaptor_base.hpp" +#include "msgpack/object.hpp" #include "msgpack/adaptor/check_container_size.hpp" +#if defined(__GNUC__) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif // defined(__GNUC__) + // To suppress warning on Boost.1.58.0 -#if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) || defined(__clang__) +#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) || defined(__clang__) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wunused-parameter" -#endif // (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) || defined(__clang__) +#endif // defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) || defined(__clang__) #include -#if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) || defined(__clang__) +#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) || defined(__clang__) +#pragma GCC diagnostic pop +#endif // defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) || defined(__clang__) + +#if defined(__GNUC__) #pragma GCC diagnostic pop -#endif // (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) || defined(__clang__) +#endif // defined(__GNUC__) namespace msgpack { diff --git a/include/msgpack/v1/adaptor/boost/string_ref.hpp b/include/msgpack/v1/adaptor/boost/string_ref.hpp index 9af03898b..79b60898b 100644 --- a/include/msgpack/v1/adaptor/boost/string_ref.hpp +++ b/include/msgpack/v1/adaptor/boost/string_ref.hpp @@ -15,6 +15,7 @@ #include "msgpack/versioning.hpp" #include "msgpack/adaptor/adaptor_base.hpp" +#include "msgpack/object.hpp" #include "msgpack/adaptor/check_container_size.hpp" #include diff --git a/include/msgpack/v1/adaptor/boost/string_view.hpp b/include/msgpack/v1/adaptor/boost/string_view.hpp index e3023ca32..e1743900c 100644 --- a/include/msgpack/v1/adaptor/boost/string_view.hpp +++ b/include/msgpack/v1/adaptor/boost/string_view.hpp @@ -15,6 +15,7 @@ #include "msgpack/versioning.hpp" #include "msgpack/adaptor/adaptor_base.hpp" +#include "msgpack/object.hpp" #include "msgpack/adaptor/check_container_size.hpp" #include diff --git a/include/msgpack/v1/adaptor/check_container_size_decl.hpp b/include/msgpack/v1/adaptor/check_container_size_decl.hpp index 7d06c4b82..9a2923208 100644 --- a/include/msgpack/v1/adaptor/check_container_size_decl.hpp +++ b/include/msgpack/v1/adaptor/check_container_size_decl.hpp @@ -12,7 +12,7 @@ #include "msgpack/versioning.hpp" #include -#include "msgpack/sysdep.h" +#include "msgpack/sysdep.hpp" namespace msgpack { diff --git a/include/msgpack/v1/adaptor/complex.hpp b/include/msgpack/v1/adaptor/complex.hpp new file mode 100644 index 000000000..d631b4ac2 --- /dev/null +++ b/include/msgpack/v1/adaptor/complex.hpp @@ -0,0 +1,91 @@ +// +// MessagePack for C++ static resolution routine +// +// Copyright (C) 2020 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_COMPLEX_HPP +#define MSGPACK_V1_TYPE_COMPLEX_HPP + +#include +#include "msgpack/versioning.hpp" +#include "msgpack/adaptor/adaptor_base.hpp" +#include "msgpack/meta.hpp" + +namespace msgpack { + +/// @cond +MSGPACK_API_VERSION_NAMESPACE(v1) { +/// @endcond + +namespace adaptor { + +#if !defined(MSGPACK_USE_CPP03) + +template +struct as, typename std::enable_if::value>::type> { + std::complex operator()(msgpack::object const& o) const { + if (o.type != msgpack::type::ARRAY) + throw msgpack::type_error(); + if (o.via.array.size != 2) + throw msgpack::type_error(); + return std::complex(o.via.array.ptr[0].as(), o.via.array.ptr[1].as()); + } +}; + +#endif // !defined(MSGPACK_USE_CPP03) + +template +struct convert > { + msgpack::object const& operator()(msgpack::object const& o, std::complex& v) const { + if(o.type != msgpack::type::ARRAY) + throw msgpack::type_error(); + if(o.via.array.size != 2) + throw msgpack::type_error(); + T real; + T imag; + o.via.array.ptr[0].convert(real); + o.via.array.ptr[1].convert(imag); + v.real(real); + v.imag(imag); + return o; + } +}; + +template +struct pack > { + template + msgpack::packer& operator()(msgpack::packer& o, std::complex const& v) const { + o.pack_array(2); + o.pack(v.real()); + o.pack(v.imag()); + return o; + } +}; + +template +struct object_with_zone > { + void operator()(msgpack::object::with_zone& o, std::complex const& v) const { + o.type = msgpack::type::ARRAY; + msgpack::object* p = static_cast(o.zone.allocate_align(sizeof(msgpack::object)*2, MSGPACK_ZONE_ALIGNOF(msgpack::object))); + o.via.array.ptr = p; + o.via.array.size = 2; + p[0] = msgpack::object(v.real(), o.zone); + p[1] = msgpack::object(v.imag(), o.zone); + } +}; + +} // namespace adaptor + +/// @cond +} // MSGPACK_API_VERSION_NAMESPACE(v1) +/// @endcond + +} // namespace msgpack + + +#endif // MSGPACK_V1_TYPE_COMPLEX_HPP diff --git a/include/msgpack/v1/adaptor/cpp11/array.hpp b/include/msgpack/v1/adaptor/cpp11/array.hpp index 1a5ba36bb..e816d64a4 100644 --- a/include/msgpack/v1/adaptor/cpp11/array.hpp +++ b/include/msgpack/v1/adaptor/cpp11/array.hpp @@ -13,6 +13,7 @@ #include "msgpack/versioning.hpp" #include "msgpack/adaptor/adaptor_base.hpp" +#include "msgpack/object.hpp" #include "msgpack/adaptor/check_container_size.hpp" #include "msgpack/meta.hpp" diff --git a/include/msgpack/v1/adaptor/cpp11/array_char.hpp b/include/msgpack/v1/adaptor/cpp11/array_char.hpp index 865e77eb5..01888f5a4 100644 --- a/include/msgpack/v1/adaptor/cpp11/array_char.hpp +++ b/include/msgpack/v1/adaptor/cpp11/array_char.hpp @@ -12,6 +12,7 @@ #include "msgpack/versioning.hpp" #include "msgpack/adaptor/adaptor_base.hpp" +#include "msgpack/object.hpp" #include "msgpack/adaptor/check_container_size.hpp" #include diff --git a/include/msgpack/v1/adaptor/cpp11/array_unsigned_char.hpp b/include/msgpack/v1/adaptor/cpp11/array_unsigned_char.hpp index 5b35d15f7..0c698f0c2 100644 --- a/include/msgpack/v1/adaptor/cpp11/array_unsigned_char.hpp +++ b/include/msgpack/v1/adaptor/cpp11/array_unsigned_char.hpp @@ -12,6 +12,7 @@ #include "msgpack/versioning.hpp" #include "msgpack/adaptor/adaptor_base.hpp" +#include "msgpack/object.hpp" #include "msgpack/adaptor/check_container_size.hpp" #include diff --git a/include/msgpack/v1/adaptor/cpp11/chrono.hpp b/include/msgpack/v1/adaptor/cpp11/chrono.hpp index bc5ca0b05..22c3da2bc 100644 --- a/include/msgpack/v1/adaptor/cpp11/chrono.hpp +++ b/include/msgpack/v1/adaptor/cpp11/chrono.hpp @@ -13,8 +13,10 @@ #include "msgpack/versioning.hpp" #include "msgpack/adaptor/adaptor_base.hpp" +#include "msgpack/object.hpp" #include "msgpack/adaptor/check_container_size.hpp" +#include #include namespace msgpack { @@ -25,12 +27,119 @@ MSGPACK_API_VERSION_NAMESPACE(v1) { namespace adaptor { -template <> -struct as { - typename std::chrono::system_clock::time_point operator()(msgpack::object const& o) const { +namespace detail { +template < + typename Target, + typename Source, + bool target_is_signed = std::is_signed::value, + bool source_is_signed = std::is_signed::value, + typename = typename std::enable_if< + std::is_integral::value && + std::is_integral::value + >::type +> +struct would_underflow { + // The default case includes the cases that Source being unsigned, and since Source + // is unsigned, no underflow can happen + would_underflow(Source) : value{false} {} + bool value; +}; + +template +struct would_underflow { + // When Source is signed and Target is unsigned, we only need to compare with 0 to + // detect underflow, this works correctly and also avoids warnings from the compiler + would_underflow(Source source) : value{source < 0} {} + bool value; +}; +template +struct would_underflow { + // When Source and Target are signed, the promotion rules apply sensibly so we do + // not need to do anything + would_underflow(Source source) + : value{source < std::numeric_limits::min()} {} + bool value; +}; + +template < + typename Target, + typename Source, + bool target_is_signed = std::is_signed::value, + bool source_is_signed = std::is_signed::value, + typename = typename std::enable_if< + std::is_integral::value && + std::is_integral::value + >::type +> +struct would_overflow { + // The default case is Source and Target having the same signedness, the promotion + // rule also apply sensibly here so nothing special needs to be done + would_overflow(Source source) + : value{source > std::numeric_limits::max()} {} + bool value; +}; +template +struct would_overflow { + // When Target is unsigned and Source is signed, we cannot rely on the promotion + // rule. + would_overflow(Source source) + : value{ + sizeof(Target) >= sizeof(Source) + // Given Source is signed, Target being unsigned and having at least the + // same size makes impossible to overflow + ? false + // Source being larger than Target makes it safe to cast the maximum value + // of Target to Source + : source > static_cast(std::numeric_limits::max()) + } {} + bool value; +}; +template +struct would_overflow { + // When Target is signed and Source is unsigned, we cannot rely on the promotion + // rule. + would_overflow(Source source) + : value{ + sizeof(Target) > sizeof(Source) + // Target being larger than Source makes it impossible to overflow + ? false + // Source being unsigned and having at least the size of Target makes it + // safe to cast the maximum value of Target to Source + : source > static_cast(std::numeric_limits::max()) + } {} + bool value; +}; + +template < + typename Target, + typename Source, + typename = typename std::enable_if< + std::is_integral::value && + std::is_integral::value + >::type +> +Target integral_cast(Source source) { + if (would_underflow(source).value) { + throw std::underflow_error{ + "casting from Source to Target causes an underflow error" + }; + } + if(would_overflow(source).value) { + throw std::overflow_error{ + "casting from Source to Target causes an overflow error" + }; + } + + return static_cast(source); +} +} // namespace detail + +template +struct as> { + typename std::chrono::time_point operator()(msgpack::object const& o) const { if(o.type != msgpack::type::EXT) { throw msgpack::type_error(); } if(o.via.ext.type() != -1) { throw msgpack::type_error(); } - std::chrono::system_clock::time_point tp; + std::chrono::time_point tp; switch(o.via.ext.size) { case 4: { uint32_t sec; @@ -40,9 +149,9 @@ struct as { case 8: { uint64_t value; _msgpack_load64(uint64_t, o.via.ext.data(), &value); - uint32_t nanosec = static_cast(value >> 34); + uint32_t nanosec = detail::integral_cast(value >> 34); uint64_t sec = value & 0x00000003ffffffffLL; - tp += std::chrono::duration_cast( + tp += std::chrono::duration_cast( std::chrono::nanoseconds(nanosec)); tp += std::chrono::seconds(sec); } break; @@ -51,9 +160,24 @@ struct as { _msgpack_load32(uint32_t, o.via.ext.data(), &nanosec); int64_t sec; _msgpack_load64(int64_t, o.via.ext.data() + 4, &sec); - tp += std::chrono::duration_cast( - std::chrono::nanoseconds(nanosec)); - tp += std::chrono::seconds(sec); + + if (sec > 0) { + tp += std::chrono::seconds(sec); + tp += std::chrono::duration_cast( + std::chrono::nanoseconds(nanosec)); + } + else { + if (nanosec == 0) { + tp += std::chrono::seconds(sec); + } + else { + ++sec; + tp += std::chrono::seconds(sec); + int64_t ns = detail::integral_cast(nanosec) - 1000000000L; + tp += std::chrono::duration_cast( + std::chrono::nanoseconds(ns)); + } + } } break; default: throw msgpack::type_error(); @@ -62,12 +186,12 @@ struct as { } }; -template <> -struct convert { - msgpack::object const& operator()(msgpack::object const& o, std::chrono::system_clock::time_point& v) const { +template +struct convert> { + msgpack::object const& operator()(msgpack::object const& o, std::chrono::time_point& v) const { if(o.type != msgpack::type::EXT) { throw msgpack::type_error(); } if(o.via.ext.type() != -1) { throw msgpack::type_error(); } - std::chrono::system_clock::time_point tp; + std::chrono::time_point tp; switch(o.via.ext.size) { case 4: { uint32_t sec; @@ -78,9 +202,9 @@ struct convert { case 8: { uint64_t value; _msgpack_load64(uint64_t, o.via.ext.data(), &value); - uint32_t nanosec = static_cast(value >> 34); + uint32_t nanosec = detail::integral_cast(value >> 34); uint64_t sec = value & 0x00000003ffffffffLL; - tp += std::chrono::duration_cast( + tp += std::chrono::duration_cast( std::chrono::nanoseconds(nanosec)); tp += std::chrono::seconds(sec); v = tp; @@ -90,9 +214,25 @@ struct convert { _msgpack_load32(uint32_t, o.via.ext.data(), &nanosec); int64_t sec; _msgpack_load64(int64_t, o.via.ext.data() + 4, &sec); - tp += std::chrono::duration_cast( - std::chrono::nanoseconds(nanosec)); - tp += std::chrono::seconds(sec); + + if (sec > 0) { + tp += std::chrono::seconds(sec); + tp += std::chrono::duration_cast( + std::chrono::nanoseconds(nanosec)); + } + else { + if (nanosec == 0) { + tp += std::chrono::seconds(sec); + } + else { + ++sec; + tp += std::chrono::seconds(sec); + int64_t ns = detail::integral_cast(nanosec) - 1000000000L; + tp += std::chrono::duration_cast( + std::chrono::nanoseconds(ns)); + } + } + v = tp; } break; default: @@ -102,31 +242,31 @@ struct convert { } }; -template <> -struct pack { +template +struct pack> { template - msgpack::packer& operator()(msgpack::packer& o, const std::chrono::system_clock::time_point& v) const { - int64_t count = static_cast(v.time_since_epoch().count()); - + msgpack::packer& operator()(msgpack::packer& o, std::chrono::time_point const& v) const { + int64_t count = detail::integral_cast(v.time_since_epoch().count()); int64_t nano_num = - std::chrono::system_clock::duration::period::ratio::num * - (1000000000 / std::chrono::system_clock::duration::period::ratio::den); + Duration::period::ratio::num * + (1000000000L / Duration::period::ratio::den); - int64_t nanosec = count % (1000000000 / nano_num) * nano_num; + int64_t nanosec = count % (1000000000L / nano_num) * nano_num; int64_t sec = 0; if (nanosec < 0) { - nanosec = 1000000000 + nanosec; + nanosec = 1000000000L + nanosec; --sec; } sec += count - * std::chrono::system_clock::duration::period::ratio::num - / std::chrono::system_clock::duration::period::ratio::den; + * Duration::period::ratio::num + / Duration::period::ratio::den; + if ((sec >> 34) == 0) { - uint64_t data64 = (static_cast(nanosec) << 34) | static_cast(sec); + uint64_t data64 = (detail::integral_cast(nanosec) << 34) | detail::integral_cast(sec); if ((data64 & 0xffffffff00000000L) == 0) { // timestamp 32 o.pack_ext(4, -1); - uint32_t data32 = static_cast(data64); + uint32_t data32 = detail::integral_cast(data64); char buf[4]; _msgpack_store32(buf, data32); o.pack_ext_body(buf, 4); @@ -143,7 +283,9 @@ struct pack { // timestamp 96 o.pack_ext(12, -1); char buf[12]; - _msgpack_store32(&buf[0], static_cast(nanosec)); + + + _msgpack_store32(&buf[0], detail::integral_cast(nanosec)); _msgpack_store64(&buf[4], sec); o.pack_ext_body(buf, 12); } @@ -151,33 +293,33 @@ struct pack { } }; -template <> -struct object_with_zone { - void operator()(msgpack::object::with_zone& o, const std::chrono::system_clock::time_point& v) const { - int64_t count = static_cast(v.time_since_epoch().count()); +template +struct object_with_zone> { + void operator()(msgpack::object::with_zone& o, const std::chrono::time_point& v) const { + int64_t count = detail::integral_cast(v.time_since_epoch().count()); int64_t nano_num = - std::chrono::system_clock::duration::period::ratio::num * - (1000000000 / std::chrono::system_clock::duration::period::ratio::den); + Duration::period::ratio::num * + (1000000000L / Duration::period::ratio::den); - int64_t nanosec = count % (1000000000 / nano_num) * nano_num; + int64_t nanosec = count % (1000000000L / nano_num) * nano_num; int64_t sec = 0; if (nanosec < 0) { - nanosec = 1000000000 + nanosec; + nanosec = 1000000000L + nanosec; --sec; } sec += count - * std::chrono::system_clock::duration::period::ratio::num - / std::chrono::system_clock::duration::period::ratio::den; + * Duration::period::ratio::num + / Duration::period::ratio::den; if ((sec >> 34) == 0) { - uint64_t data64 = (static_cast(nanosec) << 34) | static_cast(sec); + uint64_t data64 = (detail::integral_cast(nanosec) << 34) | detail::integral_cast(sec); if ((data64 & 0xffffffff00000000L) == 0) { // timestamp 32 o.type = msgpack::type::EXT; o.via.ext.size = 4; char* p = static_cast(o.zone.allocate_no_align(o.via.ext.size + 1)); p[0] = static_cast(-1); - uint32_t data32 = static_cast(data64); + uint32_t data32 = detail::integral_cast(data64); _msgpack_store32(&p[1], data32); o.via.ext.ptr = p; } @@ -197,7 +339,7 @@ struct object_with_zone { o.via.ext.size = 12; char* p = static_cast(o.zone.allocate_no_align(o.via.ext.size + 1)); p[0] = static_cast(-1); - _msgpack_store32(&p[1], static_cast(nanosec)); + _msgpack_store32(&p[1], detail::integral_cast(nanosec)); _msgpack_store64(&p[1 + 4], sec); o.via.ext.ptr = p; } diff --git a/include/msgpack/v1/adaptor/cpp11/forward_list.hpp b/include/msgpack/v1/adaptor/cpp11/forward_list.hpp index c207c0472..c615411df 100644 --- a/include/msgpack/v1/adaptor/cpp11/forward_list.hpp +++ b/include/msgpack/v1/adaptor/cpp11/forward_list.hpp @@ -13,6 +13,7 @@ #include "msgpack/versioning.hpp" #include "msgpack/adaptor/adaptor_base.hpp" +#include "msgpack/object.hpp" #include "msgpack/adaptor/check_container_size.hpp" #include diff --git a/include/msgpack/v1/adaptor/cpp11/reference_wrapper.hpp b/include/msgpack/v1/adaptor/cpp11/reference_wrapper.hpp index 02abe8376..4e2d387f8 100644 --- a/include/msgpack/v1/adaptor/cpp11/reference_wrapper.hpp +++ b/include/msgpack/v1/adaptor/cpp11/reference_wrapper.hpp @@ -13,6 +13,7 @@ #include "msgpack/versioning.hpp" #include "msgpack/adaptor/adaptor_base.hpp" +#include "msgpack/object.hpp" #include "msgpack/adaptor/check_container_size.hpp" #include diff --git a/include/msgpack/v1/adaptor/cpp11/shared_ptr.hpp b/include/msgpack/v1/adaptor/cpp11/shared_ptr.hpp index f11d63d98..0244074ce 100644 --- a/include/msgpack/v1/adaptor/cpp11/shared_ptr.hpp +++ b/include/msgpack/v1/adaptor/cpp11/shared_ptr.hpp @@ -13,6 +13,7 @@ #include "msgpack/versioning.hpp" #include "msgpack/adaptor/adaptor_base.hpp" +#include "msgpack/object.hpp" #include "msgpack/adaptor/check_container_size.hpp" #include diff --git a/include/msgpack/v1/adaptor/cpp11/timespec.hpp b/include/msgpack/v1/adaptor/cpp11/timespec.hpp index dc047ee00..c68294dec 100644 --- a/include/msgpack/v1/adaptor/cpp11/timespec.hpp +++ b/include/msgpack/v1/adaptor/cpp11/timespec.hpp @@ -13,6 +13,7 @@ #include "msgpack/versioning.hpp" #include "msgpack/adaptor/adaptor_base.hpp" #include "msgpack/object.hpp" +#include "msgpack/object.hpp" #include diff --git a/include/msgpack/v1/adaptor/cpp11/tuple.hpp b/include/msgpack/v1/adaptor/cpp11/tuple.hpp index 08b14f5c4..fd1fc8e91 100644 --- a/include/msgpack/v1/adaptor/cpp11/tuple.hpp +++ b/include/msgpack/v1/adaptor/cpp11/tuple.hpp @@ -12,6 +12,7 @@ #include "msgpack/versioning.hpp" #include "msgpack/adaptor/adaptor_base.hpp" +#include "msgpack/object.hpp" #include "msgpack/adaptor/check_container_size.hpp" #include "msgpack/meta.hpp" diff --git a/include/msgpack/v1/adaptor/cpp11/unique_ptr.hpp b/include/msgpack/v1/adaptor/cpp11/unique_ptr.hpp index a175a84e5..559756870 100644 --- a/include/msgpack/v1/adaptor/cpp11/unique_ptr.hpp +++ b/include/msgpack/v1/adaptor/cpp11/unique_ptr.hpp @@ -13,6 +13,7 @@ #include "msgpack/versioning.hpp" #include "msgpack/adaptor/adaptor_base.hpp" +#include "msgpack/object.hpp" #include "msgpack/adaptor/check_container_size.hpp" #include diff --git a/include/msgpack/v1/adaptor/cpp11/unordered_map.hpp b/include/msgpack/v1/adaptor/cpp11/unordered_map.hpp index bcd8fddc9..551838342 100644 --- a/include/msgpack/v1/adaptor/cpp11/unordered_map.hpp +++ b/include/msgpack/v1/adaptor/cpp11/unordered_map.hpp @@ -12,6 +12,7 @@ #include "msgpack/versioning.hpp" #include "msgpack/adaptor/adaptor_base.hpp" +#include "msgpack/object.hpp" #include "msgpack/adaptor/check_container_size.hpp" #include diff --git a/include/msgpack/v1/adaptor/cpp11/unordered_set.hpp b/include/msgpack/v1/adaptor/cpp11/unordered_set.hpp index 44a3cc3b6..a8e9515a8 100644 --- a/include/msgpack/v1/adaptor/cpp11/unordered_set.hpp +++ b/include/msgpack/v1/adaptor/cpp11/unordered_set.hpp @@ -12,6 +12,7 @@ #include "msgpack/versioning.hpp" #include "msgpack/adaptor/adaptor_base.hpp" +#include "msgpack/object.hpp" #include "msgpack/adaptor/check_container_size.hpp" #include diff --git a/include/msgpack/v1/adaptor/cpp17/array_byte.hpp b/include/msgpack/v1/adaptor/cpp17/array_byte.hpp new file mode 100644 index 000000000..783d37a9d --- /dev/null +++ b/include/msgpack/v1/adaptor/cpp17/array_byte.hpp @@ -0,0 +1,124 @@ +// +// 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/object.hpp" +#include "msgpack/adaptor/check_container_size.hpp" + +#include +#include +#include + +namespace msgpack { + +/// @cond +MSGPACK_API_VERSION_NAMESPACE(v1) { +/// @endcond + +namespace adaptor { + +template +struct convert > { + msgpack::object const& operator()(msgpack::object const& o, std::array& 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 +struct pack > { + template + msgpack::packer& operator()(msgpack::packer& o, const std::array& v) const { + uint32_t size = checked_get_container_size(v.size()); + o.pack_bin(size); + if (size != 0) { + o.pack_bin_body(reinterpret_cast(&v.front()), size); + } + + return o; + } +}; + +template +struct object > { + void operator()(msgpack::object& o, const std::array& 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(&v.front()); + } + o.via.bin.size = size; + } +}; + +template +struct object_with_zone > { + void operator()(msgpack::object::with_zone& o, const std::array& 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(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 diff --git a/include/msgpack/v1/adaptor/cpp17/byte.hpp b/include/msgpack/v1/adaptor/cpp17/byte.hpp index a1d120471..7bf7015b2 100644 --- a/include/msgpack/v1/adaptor/cpp17/byte.hpp +++ b/include/msgpack/v1/adaptor/cpp17/byte.hpp @@ -10,10 +10,13 @@ #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" +#include "msgpack/object.hpp" #include "msgpack/adaptor/adaptor_base.hpp" #include "msgpack/adaptor/int_decl.hpp" #include "msgpack/object.hpp" @@ -69,6 +72,6 @@ struct object_with_zone { } // namespace msgpack -#endif // __cplusplus >= 201703 +#endif // MSGPACK_CPP_VERSION >= 201703 #endif // MSGPACK_V1_TYPE_BYTE_HPP diff --git a/include/msgpack/v1/adaptor/cpp17/carray_byte.hpp b/include/msgpack/v1/adaptor/cpp17/carray_byte.hpp index e2be6bc0e..df4bbdc87 100644 --- a/include/msgpack/v1/adaptor/cpp17/carray_byte.hpp +++ b/include/msgpack/v1/adaptor/cpp17/carray_byte.hpp @@ -10,10 +10,13 @@ #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" +#include "msgpack/object.hpp" #include "msgpack/adaptor/check_container_size.hpp" #include @@ -104,6 +107,6 @@ struct object_with_zone { } // namespace msgpack -#endif // __cplusplus >= 201703 +#endif // MSGPACK_CPP_VERSION >= 201703 #endif // MSGPACK_V1_TYPE_CARRAY_BYTE_HPP diff --git a/include/msgpack/v1/adaptor/cpp17/optional.hpp b/include/msgpack/v1/adaptor/cpp17/optional.hpp index 2179ac081..44407a76a 100644 --- a/include/msgpack/v1/adaptor/cpp17/optional.hpp +++ b/include/msgpack/v1/adaptor/cpp17/optional.hpp @@ -10,10 +10,13 @@ #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" +#include "msgpack/object.hpp" #include "msgpack/adaptor/check_container_size.hpp" #include @@ -85,6 +88,6 @@ struct object_with_zone > { } // namespace msgpack -#endif // __cplusplus >= 201703 +#endif // MSGPACK_CPP_VERSION >= 201703 #endif // MSGPACK_V1_TYPE_OPTIONAL_HPP diff --git a/include/msgpack/v1/adaptor/cpp17/string_view.hpp b/include/msgpack/v1/adaptor/cpp17/string_view.hpp index 8ec56c26c..060c259e3 100644 --- a/include/msgpack/v1/adaptor/cpp17/string_view.hpp +++ b/include/msgpack/v1/adaptor/cpp17/string_view.hpp @@ -10,10 +10,13 @@ #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" +#include "msgpack/object.hpp" #include "msgpack/adaptor/check_container_size.hpp" #include @@ -81,6 +84,6 @@ struct object_with_zone { } // namespace msgpack -#endif // __cplusplus >= 201703 +#endif // MSGPACK_CPP_VERSION >= 201703 #endif // MSGPACK_V1_TYPE_STRING_VIEW_HPP diff --git a/include/msgpack/v1/adaptor/cpp17/variant.hpp b/include/msgpack/v1/adaptor/cpp17/variant.hpp new file mode 100644 index 000000000..d96a15eb0 --- /dev/null +++ b/include/msgpack/v1/adaptor/cpp17/variant.hpp @@ -0,0 +1,151 @@ +// +// MessagePack for C++ static resolution routine +// +// Copyright (C) 2023 Uy Ha +// +// 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_VARIANT_HPP +#define MSGPACK_V1_TYPE_VARIANT_HPP + +#if defined(MSGPACK_USE_STD_VARIANT_ADAPTOR) + +#include "msgpack/cpp_version.hpp" + +#if MSGPACK_CPP_VERSION >= 201703 + +#include "msgpack/adaptor/adaptor_base.hpp" +#include "msgpack/object.hpp" +#include "msgpack/versioning.hpp" + +#include + +namespace msgpack { +MSGPACK_API_VERSION_NAMESPACE(v1) { +namespace adaptor { +namespace detail { +template < + typename Variant, + typename T, + typename... Ts, + std::size_t current_index, + std::size_t... indices +> +Variant construct_variant( + std::size_t index, + msgpack::object& object, + std::index_sequence +) { + if constexpr(sizeof...(Ts) == 0) { + return Variant{std::in_place_index, object.as()}; + } + else { + if (index == current_index) { + return Variant{std::in_place_index, object.as()}; + } + return construct_variant( + index, + object, + std::index_sequence() + ); + } +} + +struct object_variant_overload { + object_variant_overload(msgpack::object& obj, msgpack::zone& zone) + : obj{obj} + , zone{zone} {} + + template + void operator()(T const& value) { + obj = msgpack::object(value, zone); + } + + msgpack::object& obj; + msgpack::zone& zone; +}; +} // namespace detail + +template +struct as, typename std::enable_if<(msgpack::has_as::value && ...)>::type> { + std::variant operator()(msgpack::object const& o) const { + if ( o.type != msgpack::type::ARRAY + || o.via.array.size != 2 + || o.via.array.ptr[0].type != msgpack::type::POSITIVE_INTEGER + || o.via.array.ptr[0].via.u64 >= sizeof...(Ts)) { + throw msgpack::type_error{}; + } + + return detail::construct_variant, Ts...>( + o.via.array.ptr[0].as(), + o.via.array.ptr[1], + std::make_index_sequence() + ); + } +}; + +template +struct convert> { + msgpack::object const& operator()(msgpack::object const& o, std::variant& v) const { + if ( o.type != msgpack::type::ARRAY + || o.via.array.size != 2 + || o.via.array.ptr[0].type != msgpack::type::POSITIVE_INTEGER + || o.via.array.ptr[0].via.u64 >= sizeof...(Ts)) { + throw msgpack::type_error{}; + } + + v = detail::construct_variant, Ts...>( + o.via.array.ptr[0].as(), + o.via.array.ptr[1], + std::make_index_sequence() + ); + return o; + } +}; + +template +struct pack>{ + template + msgpack::packer& operator()( + msgpack::packer& o, + std::variant const& v + ) const { + o.pack_array(2); + o.pack_uint64(v.index()); + std::visit([&o](auto const& value){o.pack(value);}, v); + return o; + } +}; + + +template +struct object_with_zone> { + void operator()( + msgpack::object::with_zone& o, + std::variant const& v + ) const { + msgpack::object *p = + static_cast( + o.zone.allocate_align( + sizeof(msgpack::object) * 2, + MSGPACK_ZONE_ALIGNOF(msgpack::object) + ) + ); + + o.type = msgpack::type::ARRAY; + o.via.array.size = 2; + o.via.array.ptr = p; + o.via.array.ptr[0]= msgpack::object(v.index(), o.zone); + std::visit(detail::object_variant_overload(o.via.array.ptr[1], o.zone), v); + } +}; +} // namespace adaptor +} +} // namespace msgpack + +#endif // MSGPACK_CPP_VERSION >= 201703 +#endif // defined(MSGPACK_USE_STD_VARIANT_ADAPTOR) +#endif // MSGPACK_V1_TYPE_VARIANT_HPP diff --git a/include/msgpack/v1/adaptor/cpp17/vector_byte.hpp b/include/msgpack/v1/adaptor/cpp17/vector_byte.hpp index e291667ed..c486f7dac 100644 --- a/include/msgpack/v1/adaptor/cpp17/vector_byte.hpp +++ b/include/msgpack/v1/adaptor/cpp17/vector_byte.hpp @@ -10,10 +10,13 @@ #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" +#include "msgpack/object.hpp" #include "msgpack/adaptor/check_container_size.hpp" #include @@ -35,27 +38,27 @@ struct convert > { case msgpack::type::BIN: v.resize(o.via.bin.size); if (o.via.bin.size != 0) { -#if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__) +#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wmaybe-uninitialized" -#endif // (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__) +#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 (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__) +#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__) #pragma GCC diagnostic pop -#endif // (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__) +#endif // defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__) } break; case msgpack::type::STR: v.resize(o.via.str.size); if (o.via.str.size != 0) { -#if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__) +#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wmaybe-uninitialized" -#endif // (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__) +#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 (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__) +#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__) #pragma GCC diagnostic pop -#endif // (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__) +#endif // defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__) } break; default: @@ -114,6 +117,6 @@ struct object_with_zone > { } // namespace msgpack -#endif // __cplusplus >= 201703 +#endif // MSGPACK_CPP_VERSION >= 201703 #endif // MSGPACK_V1_TYPE_VECTOR_BYTE_HPP diff --git a/include/msgpack/v1/adaptor/cpp20/span.hpp b/include/msgpack/v1/adaptor/cpp20/span.hpp new file mode 100644 index 000000000..cd1cf1d5f --- /dev/null +++ b/include/msgpack/v1/adaptor/cpp20/span.hpp @@ -0,0 +1,124 @@ +// +// 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/object.hpp" +#include "msgpack/adaptor/check_container_size.hpp" +#include "msgpack/meta.hpp" + +#include +#include +#include + +namespace msgpack { + +/// @cond +MSGPACK_API_VERSION_NAMESPACE(v1) { +/// @endcond + +namespace adaptor { + +#define MSGPACK_ADAPTOR_CONVERT_SPAN_BINARY(byte_t) \ + template <> \ + struct convert > { \ + msgpack::object const& operator()(msgpack::object const& o, std::span& v) const { \ + switch (o.type) { \ + case msgpack::type::BIN: \ + v = std::span(reinterpret_cast(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 > { \ + template \ + msgpack::packer& operator()(msgpack::packer& o, const std::span& v) const { \ + uint32_t size = checked_get_container_size(v.size()); \ + o.pack_bin(size); \ + if (size != 0) { \ + o.pack_bin_body(reinterpret_cast(v.data()), size); \ + } \ + return o; \ + } \ + }; + +#define MSGPACK_ADAPTOR_OBJECT_SPAN_BINARY(byte_t) \ + template <> \ + struct object > { \ + void operator()(msgpack::object& o, const std::span& 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(v.data()); \ + } \ + o.via.bin.size = size; \ + } \ + }; + +#define MSGPACK_ADAPTOR_OBJECT_WITH_ZONE_SPAN_BINARY(byte_t) \ + template <> \ + struct object_with_zone > { \ + void operator()(msgpack::object::with_zone& o, const std::span& 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(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 diff --git a/include/msgpack/v1/adaptor/deque.hpp b/include/msgpack/v1/adaptor/deque.hpp index 41a0bef69..f4fe5e20a 100644 --- a/include/msgpack/v1/adaptor/deque.hpp +++ b/include/msgpack/v1/adaptor/deque.hpp @@ -12,6 +12,7 @@ #include "msgpack/versioning.hpp" #include "msgpack/adaptor/adaptor_base.hpp" +#include "msgpack/object.hpp" #include "msgpack/adaptor/check_container_size.hpp" #include diff --git a/include/msgpack/v1/adaptor/detail/cpp11_convert_helper.hpp b/include/msgpack/v1/adaptor/detail/cpp11_convert_helper.hpp index f9e29ea61..d182e79f6 100644 --- a/include/msgpack/v1/adaptor/detail/cpp11_convert_helper.hpp +++ b/include/msgpack/v1/adaptor/detail/cpp11_convert_helper.hpp @@ -12,7 +12,7 @@ #include -#include +#include "msgpack/object_fwd.hpp" namespace msgpack { /// @cond diff --git a/include/msgpack/v1/adaptor/detail/cpp11_define_array_decl.hpp b/include/msgpack/v1/adaptor/detail/cpp11_define_array_decl.hpp index 6333f660a..15672245c 100644 --- a/include/msgpack/v1/adaptor/detail/cpp11_define_array_decl.hpp +++ b/include/msgpack/v1/adaptor/detail/cpp11_define_array_decl.hpp @@ -12,6 +12,7 @@ #include "msgpack/versioning.hpp" #include "msgpack/adaptor/adaptor_base.hpp" +#include "msgpack/object.hpp" namespace msgpack { /// @cond diff --git a/include/msgpack/v1/adaptor/detail/cpp11_define_map_decl.hpp b/include/msgpack/v1/adaptor/detail/cpp11_define_map_decl.hpp index 403e68c07..0399e52ac 100644 --- a/include/msgpack/v1/adaptor/detail/cpp11_define_map_decl.hpp +++ b/include/msgpack/v1/adaptor/detail/cpp11_define_map_decl.hpp @@ -12,6 +12,7 @@ #include "msgpack/versioning.hpp" #include "msgpack/adaptor/adaptor_base.hpp" +#include "msgpack/object.hpp" namespace msgpack { /// @cond diff --git a/include/msgpack/v1/adaptor/ext.hpp b/include/msgpack/v1/adaptor/ext.hpp index 421b460cb..11fed72f9 100644 --- a/include/msgpack/v1/adaptor/ext.hpp +++ b/include/msgpack/v1/adaptor/ext.hpp @@ -14,7 +14,6 @@ #include "msgpack/adaptor/check_container_size.hpp" #include #include -#include namespace msgpack { @@ -38,7 +37,7 @@ class ext { m_data.resize(static_cast(s) + 1); m_data[0] = static_cast(t); } - ext(ext_ref const&); + explicit ext(ext_ref const&); int8_t type() const { return static_cast(m_data[0]); } @@ -168,6 +167,7 @@ class ext_ref { 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; diff --git a/include/msgpack/v1/adaptor/ext_decl.hpp b/include/msgpack/v1/adaptor/ext_decl.hpp index df5bd1996..fb5ac9c30 100644 --- a/include/msgpack/v1/adaptor/ext_decl.hpp +++ b/include/msgpack/v1/adaptor/ext_decl.hpp @@ -12,9 +12,9 @@ #include "msgpack/versioning.hpp" #include "msgpack/adaptor/adaptor_base.hpp" +#include "msgpack/object.hpp" #include #include -#include namespace msgpack { diff --git a/include/msgpack/v1/adaptor/fixint_decl.hpp b/include/msgpack/v1/adaptor/fixint_decl.hpp index 1c4a439a9..ba24a79f3 100644 --- a/include/msgpack/v1/adaptor/fixint_decl.hpp +++ b/include/msgpack/v1/adaptor/fixint_decl.hpp @@ -12,6 +12,7 @@ #include "msgpack/versioning.hpp" #include "msgpack/adaptor/adaptor_base.hpp" +#include "msgpack/object.hpp" #include "msgpack/adaptor/int.hpp" namespace msgpack { diff --git a/include/msgpack/v1/adaptor/int_decl.hpp b/include/msgpack/v1/adaptor/int_decl.hpp index 75f1c7bf4..b3d43bafc 100644 --- a/include/msgpack/v1/adaptor/int_decl.hpp +++ b/include/msgpack/v1/adaptor/int_decl.hpp @@ -12,6 +12,7 @@ #include "msgpack/versioning.hpp" #include "msgpack/adaptor/adaptor_base.hpp" +#include "msgpack/object.hpp" #include namespace msgpack { diff --git a/include/msgpack/v1/adaptor/list.hpp b/include/msgpack/v1/adaptor/list.hpp index d16c8d219..73051af4b 100644 --- a/include/msgpack/v1/adaptor/list.hpp +++ b/include/msgpack/v1/adaptor/list.hpp @@ -12,6 +12,7 @@ #include "msgpack/versioning.hpp" #include "msgpack/adaptor/adaptor_base.hpp" +#include "msgpack/object.hpp" #include "msgpack/adaptor/check_container_size.hpp" #include diff --git a/include/msgpack/v1/adaptor/map.hpp b/include/msgpack/v1/adaptor/map.hpp index 2c1793e16..3662a486d 100644 --- a/include/msgpack/v1/adaptor/map.hpp +++ b/include/msgpack/v1/adaptor/map.hpp @@ -10,6 +10,8 @@ #ifndef MSGPACK_V1_TYPE_MAP_HPP #define MSGPACK_V1_TYPE_MAP_HPP +#include "msgpack/versioning.hpp" +#include "msgpack/cpp_version.hpp" #include "msgpack/v1/adaptor/map_decl.hpp" #include "msgpack/adaptor/adaptor_base.hpp" @@ -154,13 +156,13 @@ struct convert > { 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); @@ -201,15 +203,15 @@ struct object_with_zone > { o.via.map.size = size; typename std::map::const_iterator it(v.begin()); do { -#if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__) +#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wmaybe-uninitialized" -#endif // (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__) +#endif // defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__) p->key = msgpack::object(it->first, o.zone); p->val = msgpack::object(it->second, o.zone); -#if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__) +#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__) #pragma GCC diagnostic pop -#endif // (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__) +#endif // defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__) ++p; ++it; } while(p < pend); @@ -248,13 +250,13 @@ struct convert > { std::pair 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); diff --git a/include/msgpack/v1/adaptor/nil_decl.hpp b/include/msgpack/v1/adaptor/nil_decl.hpp index 4830ff201..28da87900 100644 --- a/include/msgpack/v1/adaptor/nil_decl.hpp +++ b/include/msgpack/v1/adaptor/nil_decl.hpp @@ -12,6 +12,7 @@ #include "msgpack/versioning.hpp" #include "msgpack/adaptor/adaptor_base.hpp" +#include "msgpack/object.hpp" namespace msgpack { diff --git a/include/msgpack/v1/adaptor/pair.hpp b/include/msgpack/v1/adaptor/pair.hpp index 890abc2b8..422454ac7 100644 --- a/include/msgpack/v1/adaptor/pair.hpp +++ b/include/msgpack/v1/adaptor/pair.hpp @@ -12,6 +12,7 @@ #include "msgpack/versioning.hpp" #include "msgpack/adaptor/adaptor_base.hpp" +#include "msgpack/object.hpp" #include "msgpack/meta.hpp" #include diff --git a/include/msgpack/v1/adaptor/raw.hpp b/include/msgpack/v1/adaptor/raw.hpp index 80efdc78c..e2f4cf42d 100644 --- a/include/msgpack/v1/adaptor/raw.hpp +++ b/include/msgpack/v1/adaptor/raw.hpp @@ -34,7 +34,7 @@ struct raw_ref { bool operator== (const raw_ref& x) const { - return size == x.size && std::memcmp(ptr, x.ptr, size) == 0; + return size == x.size && (size == 0 || std::memcmp(ptr, x.ptr, size) == 0); } bool operator!= (const raw_ref& x) const @@ -44,13 +44,13 @@ struct raw_ref { bool operator< (const raw_ref& x) const { - if(size == x.size) { return std::memcmp(ptr, x.ptr, size) < 0; } + if(size == x.size) { return (size == 0 ? false : std::memcmp(ptr, x.ptr, size) < 0); } else { return size < x.size; } } bool operator> (const raw_ref& x) const { - if(size == x.size) { return std::memcmp(ptr, x.ptr, size) > 0; } + if(size == x.size) { return (size == 0 ? false : std::memcmp(ptr, x.ptr, size) > 0); } else { return size > x.size; } } }; diff --git a/include/msgpack/v1/adaptor/raw_decl.hpp b/include/msgpack/v1/adaptor/raw_decl.hpp index db186d18a..4dcf2ee73 100644 --- a/include/msgpack/v1/adaptor/raw_decl.hpp +++ b/include/msgpack/v1/adaptor/raw_decl.hpp @@ -12,6 +12,7 @@ #include "msgpack/versioning.hpp" #include "msgpack/adaptor/adaptor_base.hpp" +#include "msgpack/object.hpp" #include #include diff --git a/include/msgpack/v1/adaptor/set.hpp b/include/msgpack/v1/adaptor/set.hpp index 96abe25f0..3c280c5cd 100644 --- a/include/msgpack/v1/adaptor/set.hpp +++ b/include/msgpack/v1/adaptor/set.hpp @@ -11,6 +11,7 @@ #define MSGPACK_V1_TYPE_SET_HPP #include "msgpack/versioning.hpp" +#include "msgpack/cpp_version.hpp" #include "msgpack/adaptor/adaptor_base.hpp" #include "msgpack/adaptor/check_container_size.hpp" @@ -54,7 +55,7 @@ struct convert > { --p; tmp.insert(p->as()); } -#if __cplusplus >= 201103L +#if MSGPACK_CPP_VERSION >= 201103L v = std::move(tmp); #else tmp.swap(v); @@ -131,7 +132,7 @@ struct convert > { --p; tmp.insert(p->as()); } -#if __cplusplus >= 201103L +#if MSGPACK_CPP_VERSION >= 201103L v = std::move(tmp); #else tmp.swap(v); diff --git a/include/msgpack/v1/adaptor/size_equal_only_decl.hpp b/include/msgpack/v1/adaptor/size_equal_only_decl.hpp index 6eac047b0..6337ac05b 100644 --- a/include/msgpack/v1/adaptor/size_equal_only_decl.hpp +++ b/include/msgpack/v1/adaptor/size_equal_only_decl.hpp @@ -12,6 +12,7 @@ #include "msgpack/versioning.hpp" #include "msgpack/adaptor/adaptor_base.hpp" +#include "msgpack/object.hpp" #include "msgpack/adaptor/msgpack_tuple.hpp" namespace msgpack { diff --git a/include/msgpack/v1/adaptor/string.hpp b/include/msgpack/v1/adaptor/string.hpp index ca7d3e509..6e5c91d9a 100644 --- a/include/msgpack/v1/adaptor/string.hpp +++ b/include/msgpack/v1/adaptor/string.hpp @@ -12,6 +12,7 @@ #include "msgpack/versioning.hpp" #include "msgpack/adaptor/adaptor_base.hpp" +#include "msgpack/object.hpp" #include "msgpack/adaptor/check_container_size.hpp" #include diff --git a/include/msgpack/v1/adaptor/tr1/unordered_map.hpp b/include/msgpack/v1/adaptor/tr1/unordered_map.hpp index 9c8190e85..b24ac2319 100644 --- a/include/msgpack/v1/adaptor/tr1/unordered_map.hpp +++ b/include/msgpack/v1/adaptor/tr1/unordered_map.hpp @@ -12,6 +12,7 @@ #include "msgpack/versioning.hpp" #include "msgpack/adaptor/adaptor_base.hpp" +#include "msgpack/object.hpp" #include "msgpack/adaptor/check_container_size.hpp" #if defined(_LIBCPP_VERSION) || (_MSC_VER >= 1700) diff --git a/include/msgpack/v1/adaptor/tr1/unordered_set.hpp b/include/msgpack/v1/adaptor/tr1/unordered_set.hpp index dd6c0448f..9c92c2108 100644 --- a/include/msgpack/v1/adaptor/tr1/unordered_set.hpp +++ b/include/msgpack/v1/adaptor/tr1/unordered_set.hpp @@ -12,6 +12,7 @@ #include "msgpack/versioning.hpp" #include "msgpack/adaptor/adaptor_base.hpp" +#include "msgpack/object.hpp" #include "msgpack/adaptor/check_container_size.hpp" #if defined(_LIBCPP_VERSION) || (_MSC_VER >= 1700) diff --git a/include/msgpack/v1/adaptor/v4raw.hpp b/include/msgpack/v1/adaptor/v4raw.hpp index f03f4a068..ae660c61a 100644 --- a/include/msgpack/v1/adaptor/v4raw.hpp +++ b/include/msgpack/v1/adaptor/v4raw.hpp @@ -33,7 +33,7 @@ struct v4raw_ref { bool operator== (const v4raw_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 v4raw_ref& x) const diff --git a/include/msgpack/v1/adaptor/v4raw_decl.hpp b/include/msgpack/v1/adaptor/v4raw_decl.hpp index ae213f7e2..aad031157 100644 --- a/include/msgpack/v1/adaptor/v4raw_decl.hpp +++ b/include/msgpack/v1/adaptor/v4raw_decl.hpp @@ -12,6 +12,7 @@ #include "msgpack/versioning.hpp" #include "msgpack/adaptor/adaptor_base.hpp" +#include "msgpack/object.hpp" namespace msgpack { diff --git a/include/msgpack/v1/adaptor/vector.hpp b/include/msgpack/v1/adaptor/vector.hpp index 2a0345b12..349def4ab 100644 --- a/include/msgpack/v1/adaptor/vector.hpp +++ b/include/msgpack/v1/adaptor/vector.hpp @@ -12,6 +12,7 @@ #include "msgpack/versioning.hpp" #include "msgpack/adaptor/adaptor_base.hpp" +#include "msgpack/object.hpp" #include "msgpack/adaptor/check_container_size.hpp" #include @@ -95,14 +96,14 @@ struct object_with_zone > { o.via.array.size = size; typename std::vector::const_iterator it(v.begin()); do { -#if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__) +#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wmaybe-uninitialized" -#endif // (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__) +#endif // defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__) *p = msgpack::object(*it, o.zone); -#if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__) +#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__) #pragma GCC diagnostic pop -#endif // (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__) +#endif // defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__) ++p; ++it; } while(p < pend); diff --git a/include/msgpack/v1/adaptor/vector_char.hpp b/include/msgpack/v1/adaptor/vector_char.hpp index 315dad678..fa958c873 100644 --- a/include/msgpack/v1/adaptor/vector_char.hpp +++ b/include/msgpack/v1/adaptor/vector_char.hpp @@ -12,6 +12,7 @@ #include "msgpack/versioning.hpp" #include "msgpack/adaptor/adaptor_base.hpp" +#include "msgpack/object.hpp" #include "msgpack/adaptor/check_container_size.hpp" #include @@ -32,27 +33,27 @@ struct convert > { case msgpack::type::BIN: v.resize(o.via.bin.size); if (o.via.bin.size != 0) { -#if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__) +#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wmaybe-uninitialized" -#endif // (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__) +#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 (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__) +#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__) #pragma GCC diagnostic pop -#endif // (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__) +#endif // defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__) } break; case msgpack::type::STR: v.resize(o.via.str.size); if (o.via.str.size != 0) { -#if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__) +#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wmaybe-uninitialized" -#endif // (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__) +#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 (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__) +#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__) #pragma GCC diagnostic pop -#endif // (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__) +#endif // defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__) } break; default: diff --git a/include/msgpack/v1/adaptor/vector_unsigned_char.hpp b/include/msgpack/v1/adaptor/vector_unsigned_char.hpp index 9db72fe7d..f4611a797 100644 --- a/include/msgpack/v1/adaptor/vector_unsigned_char.hpp +++ b/include/msgpack/v1/adaptor/vector_unsigned_char.hpp @@ -12,6 +12,7 @@ #include "msgpack/versioning.hpp" #include "msgpack/adaptor/adaptor_base.hpp" +#include "msgpack/object.hpp" #include "msgpack/adaptor/check_container_size.hpp" #include @@ -32,27 +33,27 @@ struct convert > { case msgpack::type::BIN: v.resize(o.via.bin.size); if (o.via.bin.size != 0) { -#if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__) +#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wmaybe-uninitialized" -#endif // (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__) +#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 (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__) +#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__) #pragma GCC diagnostic pop -#endif // (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__) +#endif // defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__) } break; case msgpack::type::STR: v.resize(o.via.str.size); if (o.via.str.size != 0) { -#if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__) +#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wmaybe-uninitialized" -#endif // (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__) +#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 (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__) +#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__) #pragma GCC diagnostic pop -#endif // (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__) +#endif // defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__) } break; default: diff --git a/include/msgpack/v1/adaptor/wstring.hpp b/include/msgpack/v1/adaptor/wstring.hpp index 66f7929e2..e57f6752c 100644 --- a/include/msgpack/v1/adaptor/wstring.hpp +++ b/include/msgpack/v1/adaptor/wstring.hpp @@ -12,6 +12,7 @@ #include "msgpack/versioning.hpp" #include "msgpack/adaptor/adaptor_base.hpp" +#include "msgpack/object.hpp" #include "msgpack/adaptor/check_container_size.hpp" #include @@ -95,14 +96,14 @@ struct object_with_zone { o.via.array.size = size; std::wstring::const_iterator it(v.begin()); do { -#if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__) +#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wmaybe-uninitialized" -#endif // (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__) +#endif // defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__) *p = msgpack::object(*it, o.zone); -#if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__) +#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__) #pragma GCC diagnostic pop -#endif // (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__) +#endif // defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__) ++p; ++it; } while(p < pend); diff --git a/include/msgpack/v1/cpp_config.hpp b/include/msgpack/v1/cpp_config.hpp index 0eb518d83..18d2a9a6d 100644 --- a/include/msgpack/v1/cpp_config.hpp +++ b/include/msgpack/v1/cpp_config.hpp @@ -11,6 +11,8 @@ #define MSGPACK_V1_CPP_CONFIG_HPP #include "msgpack/cpp_config_decl.hpp" +#include "msgpack/cpp_version.hpp" +#include "msgpack/versioning.hpp" #if defined(MSGPACK_USE_CPP03) @@ -126,14 +128,14 @@ template struct is_pointer : detail::is_pointer_helper= 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 diff --git a/include/msgpack/v1/cpp_config_decl.hpp b/include/msgpack/v1/cpp_config_decl.hpp index c9752f237..383a44511 100644 --- a/include/msgpack/v1/cpp_config_decl.hpp +++ b/include/msgpack/v1/cpp_config_decl.hpp @@ -10,19 +10,9 @@ #ifndef MSGPACK_V1_CPP_CONFIG_DECL_HPP #define MSGPACK_V1_CPP_CONFIG_DECL_HPP +#include "msgpack/cpp_version.hpp" #include "msgpack/versioning.hpp" -#if !defined(MSGPACK_USE_CPP03) -# if defined(_MSC_VER) -# if _MSC_VER < 1900 -# define MSGPACK_USE_CPP03 -# endif -# elif (__cplusplus < 201103L) -# define MSGPACK_USE_CPP03 -# endif -#endif // MSGPACK_USE_CPP03 - - #if defined(MSGPACK_USE_CPP03) #if defined(nullptr) diff --git a/include/msgpack/v1/detail/cpp03_zone.hpp b/include/msgpack/v1/detail/cpp03_zone.hpp index 21b3c5e84..62def9899 100644 --- a/include/msgpack/v1/detail/cpp03_zone.hpp +++ b/include/msgpack/v1/detail/cpp03_zone.hpp @@ -10,7 +10,15 @@ #ifndef MSGPACK_V1_CPP03_ZONE_HPP #define MSGPACK_V1_CPP03_ZONE_HPP +#include "msgpack/versioning.hpp" +#include "msgpack/cpp_config.hpp" #include "msgpack/zone_decl.hpp" +#include "msgpack/assert.hpp" + +#include +#include +#include +#include namespace msgpack { @@ -130,7 +138,7 @@ class zone { finalizer_array m_finalizer_array; public: - zone(size_t chunk_size = MSGPACK_ZONE_CHUNK_SIZE) /* throw() */; + zone(size_t chunk_size = MSGPACK_ZONE_CHUNK_SIZE); public: void* allocate_align(size_t size, size_t align = MSGPACK_ZONE_ALIGN); @@ -231,16 +239,17 @@ class zone { zone& operator=(const zone&); }; -inline zone::zone(size_t chunk_size) /* throw() */ :m_chunk_size(chunk_size), m_chunk_list(m_chunk_size) +inline zone::zone(size_t chunk_size):m_chunk_size(chunk_size), m_chunk_list(m_chunk_size) { } inline char* zone::get_aligned(char* ptr, size_t align) { + MSGPACK_ASSERT(align != 0 && (align & (align - 1)) == 0); // align must be 2^n (n >= 0) return reinterpret_cast( - reinterpret_cast( - (ptr + (align - 1))) / align * align); + reinterpret_cast(ptr + (align - 1)) & ~static_cast(align - 1) + ); } inline void* zone::allocate_align(size_t size, size_t align) diff --git a/include/msgpack/v1/detail/cpp11_zone.hpp b/include/msgpack/v1/detail/cpp11_zone.hpp index c3cf3f6bb..2586f2755 100644 --- a/include/msgpack/v1/detail/cpp11_zone.hpp +++ b/include/msgpack/v1/detail/cpp11_zone.hpp @@ -13,7 +13,9 @@ #include "msgpack/versioning.hpp" #include "msgpack/cpp_config.hpp" #include "msgpack/zone_decl.hpp" +#include "msgpack/assert.hpp" +#include #include #include #include @@ -169,7 +171,7 @@ class zone { finalizer_array m_finalizer_array; public: - zone(size_t chunk_size = MSGPACK_ZONE_CHUNK_SIZE) noexcept; + zone(size_t chunk_size = MSGPACK_ZONE_CHUNK_SIZE); public: void* allocate_align(size_t size, size_t align = MSGPACK_ZONE_ALIGN); @@ -224,16 +226,17 @@ class zone { char* allocate_expand(size_t size); }; -inline zone::zone(size_t chunk_size) noexcept:m_chunk_size(chunk_size), m_chunk_list(m_chunk_size) +inline zone::zone(size_t chunk_size):m_chunk_size(chunk_size), m_chunk_list(m_chunk_size) { } inline char* zone::get_aligned(char* ptr, size_t align) { + MSGPACK_ASSERT(align != 0 && (align & (align - 1)) == 0); // align must be 2^n (n >= 0) return reinterpret_cast( - reinterpret_cast( - (ptr + (align - 1))) / align * align); + reinterpret_cast(ptr + (align - 1)) & ~static_cast(align - 1) + ); } inline void* zone::allocate_align(size_t size, size_t align) diff --git a/include/msgpack/v1/fbuffer.hpp b/include/msgpack/v1/fbuffer.hpp index 265af19ba..fd006baa1 100644 --- a/include/msgpack/v1/fbuffer.hpp +++ b/include/msgpack/v1/fbuffer.hpp @@ -11,6 +11,7 @@ #define MSGPACK_V1_FBUFFER_HPP #include "msgpack/v1/fbuffer_decl.hpp" +#include "msgpack/assert.hpp" #include #include @@ -28,6 +29,8 @@ class fbuffer { public: void write(const char* buf, unsigned int len) { + MSGPACK_ASSERT(buf || len == 0); + if (!buf) return; if (1 != fwrite(buf, len, 1, m_file)) { throw std::runtime_error("fwrite() failed"); } diff --git a/include/msgpack/v1/iterator_decl.hpp b/include/msgpack/v1/iterator_decl.hpp index 1bec2e380..9ae687851 100644 --- a/include/msgpack/v1/iterator_decl.hpp +++ b/include/msgpack/v1/iterator_decl.hpp @@ -12,7 +12,7 @@ #define MSGPACK_V1_ITERATOR_DECL_HPP #if !defined(MSGPACK_USE_CPP03) -#include +#include "msgpack/object_fwd.hpp" namespace msgpack { diff --git a/include/msgpack/v1/object.hpp b/include/msgpack/v1/object.hpp index 05bcaaf3a..fda54be9f 100644 --- a/include/msgpack/v1/object.hpp +++ b/include/msgpack/v1/object.hpp @@ -13,7 +13,12 @@ #include "msgpack/object_decl.hpp" #include "msgpack/adaptor/check_container_size.hpp" -#include +#include +#include +#include +#include +#include +#include #include namespace msgpack { @@ -461,12 +466,17 @@ struct object_stringize_visitor { m_os << '"'; return true; } - bool visit_bin(const char* v, uint32_t size) { - (m_os << '"').write(v, static_cast(size)) << '"'; + bool visit_bin(const char* /*v*/, uint32_t size) { + m_os << "\"BIN(size:" << size << ")\""; return true; } - bool visit_ext(const char* /*v*/, uint32_t /*size*/) { - m_os << "EXT"; + bool visit_ext(const char* v, uint32_t size) { + if (size == 0) { + m_os << "\"EXT(size:0)\""; + } + else { + m_os << "\"EXT(type:" << static_cast(v[0]) << ",size:" << size - 1 << ")\""; + } return true; } bool start_array(uint32_t num_elements) { @@ -1163,27 +1173,6 @@ inline object::object(const T& v, msgpack::zone* z) } -inline object::object(const msgpack_object& o) -{ - // FIXME beter way? - std::memcpy(this, &o, sizeof(o)); -} - -inline void operator<< (msgpack::object& o, const msgpack_object& v) -{ - // FIXME beter way? - std::memcpy(static_cast(&o), &v, sizeof(v)); -} - -inline object::operator msgpack_object() const -{ - // FIXME beter way? - msgpack_object obj; - std::memcpy(&obj, this, sizeof(obj)); - return obj; -} - - // obsolete template inline void convert(T& v, msgpack::object const& o) diff --git a/include/msgpack/v1/object_decl.hpp b/include/msgpack/v1/object_decl.hpp index 6c06fd10e..cc6c7d5a7 100644 --- a/include/msgpack/v1/object_decl.hpp +++ b/include/msgpack/v1/object_decl.hpp @@ -11,8 +11,18 @@ #define MSGPACK_V1_OBJECT_DECL_HPP #include "msgpack/versioning.hpp" +#include "msgpack/pack.hpp" +#include "msgpack/zone.hpp" #include "msgpack/adaptor/adaptor_base.hpp" +#include +#include +#include +#include +#include +#include +#include + namespace msgpack { /// @cond @@ -71,8 +81,6 @@ bool operator!=(const msgpack::object& x, const T& y); template bool operator!=(const T& y, const msgpack::object& x); -void operator<< (msgpack::object& o, const msgpack_object& v); - class object_parser; template diff --git a/include/msgpack/v1/object_fwd.hpp b/include/msgpack/v1/object_fwd.hpp index 66bf4ad19..951dca0e1 100644 --- a/include/msgpack/v1/object_fwd.hpp +++ b/include/msgpack/v1/object_fwd.hpp @@ -53,16 +53,16 @@ template struct has_as { private: template - static auto check(U*) -> + static auto check_(U*) -> // Check v1 specialization typename std::is_same< decltype(adaptor::as()(std::declval())), T >::type; template - static std::false_type check(...); + static std::false_type check_(...); public: - using type = decltype(check(MSGPACK_NULLPTR)); + using type = decltype(check_(MSGPACK_NULLPTR)); static constexpr bool value = type::value; }; @@ -179,9 +179,6 @@ struct object { /// Default constructor. The object is set to nil. object(); - /// Copy constructor. Object is shallow copied. - object(const msgpack_object& o); - /// Construct object from T /** * If `v` is the type that is corresponding to MessegePack format str, bin, ext, array, or map, @@ -222,8 +219,6 @@ struct object { template object& operator=(const T& v); - operator msgpack_object() const; - struct with_zone; protected: diff --git a/include/msgpack/v1/object_fwd_decl.hpp b/include/msgpack/v1/object_fwd_decl.hpp index 5bf303377..2bb4af676 100644 --- a/include/msgpack/v1/object_fwd_decl.hpp +++ b/include/msgpack/v1/object_fwd_decl.hpp @@ -13,8 +13,7 @@ #include "msgpack/versioning.hpp" #include "msgpack/zone.hpp" -#include "msgpack/object.h" - +#include #include namespace msgpack { @@ -26,21 +25,21 @@ MSGPACK_API_VERSION_NAMESPACE(v1) { namespace type { enum object_type { - NIL = MSGPACK_OBJECT_NIL, - BOOLEAN = MSGPACK_OBJECT_BOOLEAN, - POSITIVE_INTEGER = MSGPACK_OBJECT_POSITIVE_INTEGER, - NEGATIVE_INTEGER = MSGPACK_OBJECT_NEGATIVE_INTEGER, - FLOAT32 = MSGPACK_OBJECT_FLOAT32, - FLOAT64 = MSGPACK_OBJECT_FLOAT64, - FLOAT = MSGPACK_OBJECT_FLOAT, + NIL = 0x00, + BOOLEAN = 0x01, + POSITIVE_INTEGER = 0x02, + NEGATIVE_INTEGER = 0x03, + FLOAT32 = 0x0a, + FLOAT64 = 0x04, + FLOAT = 0x04, #if defined(MSGPACK_USE_LEGACY_NAME_AS_FLOAT) - DOUBLE = MSGPACK_DEPRECATED("please use FLOAT64 instead") MSGPACK_OBJECT_DOUBLE, // obsolete + DOUBLE = MSGPACK_DEPRECATED("please use FLOAT64 instead") FLOAT, // obsolete #endif // MSGPACK_USE_LEGACY_NAME_AS_FLOAT - STR = MSGPACK_OBJECT_STR, - BIN = MSGPACK_OBJECT_BIN, - ARRAY = MSGPACK_OBJECT_ARRAY, - MAP = MSGPACK_OBJECT_MAP, - EXT = MSGPACK_OBJECT_EXT + STR = 0x05, + BIN = 0x06, + ARRAY = 0x07, + MAP = 0x08, + EXT = 0x09 }; } diff --git a/include/msgpack/v1/pack.hpp b/include/msgpack/v1/pack.hpp index 5bf4154ba..677c39fa1 100644 --- a/include/msgpack/v1/pack.hpp +++ b/include/msgpack/v1/pack.hpp @@ -11,8 +11,12 @@ #define MSGPACK_V1_PACK_HPP #include "msgpack/v1/pack_decl.hpp" -#include + +#include +#include #include +#include +#include namespace msgpack { diff --git a/include/msgpack/v1/pack_decl.hpp b/include/msgpack/v1/pack_decl.hpp index 519afe982..42e70de40 100644 --- a/include/msgpack/v1/pack_decl.hpp +++ b/include/msgpack/v1/pack_decl.hpp @@ -12,7 +12,7 @@ #include "msgpack/versioning.hpp" #include "msgpack/cpp_config.hpp" -#include "msgpack/sysdep.h" +#include "msgpack/sysdep.hpp" namespace msgpack { diff --git a/include/msgpack/v1/preprocessor.hpp b/include/msgpack/v1/preprocessor.hpp deleted file mode 100644 index d2ba93875..000000000 --- a/include/msgpack/v1/preprocessor.hpp +++ /dev/null @@ -1,19 +0,0 @@ -# /* Copyright (C) 2001 -# * Housemarque Oy -# * http://www.housemarque.com -# * -# * Distributed under the Boost Software License, Version 1.0. (See -# * accompanying file LICENSE_1_0.txt or copy at -# * http://www.boost.org/LICENSE_1_0.txt) -# */ -# -# /* Revised by Paul Mensonides (2002) */ -# -# /* See http://www.boost.org/libs/preprocessor for documentation. */ -# -# ifndef MSGPACK_PREPROCESSOR_HPP -# define MSGPACK_PREPROCESSOR_HPP -# -# include -# -# endif diff --git a/include/msgpack/v1/sbuffer.hpp b/include/msgpack/v1/sbuffer.hpp index 387bdce2f..7ab303106 100644 --- a/include/msgpack/v1/sbuffer.hpp +++ b/include/msgpack/v1/sbuffer.hpp @@ -10,7 +10,9 @@ #ifndef MSGPACK_V1_SBUFFER_HPP #define MSGPACK_V1_SBUFFER_HPP +#include "msgpack/v1/cpp_config_decl.hpp" #include "msgpack/v1/sbuffer_decl.hpp" +#include "msgpack/assert.hpp" #include #include @@ -68,6 +70,10 @@ class sbuffer { void write(const char* buf, size_t len) { + MSGPACK_ASSERT(buf || len == 0); + + if (!buf) return; + if(m_alloc - m_size < len) { expand_buffer(len); } diff --git a/include/msgpack/v1/unpack.hpp b/include/msgpack/v1/unpack.hpp index d4ef4a754..489c285d4 100644 --- a/include/msgpack/v1/unpack.hpp +++ b/include/msgpack/v1/unpack.hpp @@ -15,17 +15,18 @@ #include "msgpack/object.hpp" #include "msgpack/zone.hpp" #include "msgpack/unpack_exception.hpp" -#include "msgpack/unpack_define.h" +#include "msgpack/unpack_define.hpp" #include "msgpack/cpp_config.hpp" -#include "msgpack/sysdep.h" +#include "msgpack/sysdep.hpp" +#include "msgpack/assert.hpp" #include + #if !defined(MSGPACK_USE_CPP03) #include #endif - #if defined(_MSC_VER) // avoiding confliction std::max, std::min, and macro in windows.h #ifndef NOMINMAX @@ -169,12 +170,15 @@ inline void unpack_str(unpack_user& u, const char* p, uint32_t l, msgpack::objec o.via.str.ptr = p; u.set_referenced(true); } - else { + else if (l > 0) { if (l > u.limit().str()) throw msgpack::str_size_overflow("str size overflow"); char* tmp = static_cast(u.zone().allocate_align(l, MSGPACK_ZONE_ALIGNOF(char))); std::memcpy(tmp, p, l); o.via.str.ptr = tmp; } + else { + o.via.str.ptr = MSGPACK_NULLPTR; + } o.via.str.size = l; } @@ -185,12 +189,15 @@ inline void unpack_bin(unpack_user& u, const char* p, uint32_t l, msgpack::objec o.via.bin.ptr = p; u.set_referenced(true); } - else { + else if (l > 0) { if (l > u.limit().bin()) throw msgpack::bin_size_overflow("bin size overflow"); char* tmp = static_cast(u.zone().allocate_align(l, MSGPACK_ZONE_ALIGNOF(char))); std::memcpy(tmp, p, l); o.via.bin.ptr = tmp; } + else { + o.via.bin.ptr = MSGPACK_NULLPTR; + } o.via.bin.size = l; } @@ -458,7 +465,7 @@ inline void context::check_ext_size<4>(std::size_t size) { inline int context::execute(const char* data, std::size_t len, std::size_t& off) { - assert(len >= off); + MSGPACK_ASSERT(len >= off); m_start = data; m_current = data + off; diff --git a/include/msgpack/v1/unpack_decl.hpp b/include/msgpack/v1/unpack_decl.hpp index 99896fa41..0a103fea5 100644 --- a/include/msgpack/v1/unpack_decl.hpp +++ b/include/msgpack/v1/unpack_decl.hpp @@ -11,11 +11,11 @@ #define MSGPACK_V1_UNPACK_DECL_HPP #include "msgpack/versioning.hpp" -#include "msgpack/unpack_define.h" +#include "msgpack/unpack_define.hpp" #include "msgpack/object.hpp" #include "msgpack/zone.hpp" #include "msgpack/cpp_config.hpp" -#include "msgpack/sysdep.h" +#include "msgpack/sysdep.hpp" #include "msgpack/parse_return.hpp" #include diff --git a/include/msgpack/v1/version.hpp b/include/msgpack/v1/version.hpp index 0b447c70f..2ca33efec 100644 --- a/include/msgpack/v1/version.hpp +++ b/include/msgpack/v1/version.hpp @@ -10,7 +10,7 @@ #ifndef MSGPACK_VERSION_HPP #define MSGPACK_VERSION_HPP -#include "version_master.h" +#include "version_master.hpp" #define MSGPACK_STR(v) #v #define MSGPACK_VERSION_I(maj, min, rev) MSGPACK_STR(maj) "." MSGPACK_STR(min) "." MSGPACK_STR(rev) diff --git a/include/msgpack/v1/versioning.hpp b/include/msgpack/v1/versioning.hpp index c1e86c52a..b7428d164 100644 --- a/include/msgpack/v1/versioning.hpp +++ b/include/msgpack/v1/versioning.hpp @@ -10,6 +10,8 @@ #ifndef MSGPACK_VERSIONING_HPP #define MSGPACK_VERSIONING_HPP +#include "msgpack/cpp_version.hpp" + #if !defined(MSGPACK_DEFAULT_API_VERSION) #define MSGPACK_DEFAULT_API_VERSION 1 #endif @@ -54,16 +56,16 @@ #define MSGPACK_DETAIL_PP_IS_NS_ENABLED(ns) MSGPACK_DETAIL_PP_CHECK(MSGPACK_DETAIL_PP_NS_ENABLED_PROBE(ns)) -#if __cplusplus < 201103L +#ifdef MSGPACK_USE_CPP03 #define MSGPACK_API_VERSION_NAMESPACE(ns) MSGPACK_DETAIL_PP_IIF(MSGPACK_DETAIL_PP_IS_NS_ENABLED(ns)) \ (namespace ns{}; using namespace ns; namespace ns, \ namespace ns) -#else // __cplusplus < 201103L +#else // MSGPACK_USE_CPP03 #define MSGPACK_API_VERSION_NAMESPACE(ns) MSGPACK_DETAIL_PP_IIF(MSGPACK_DETAIL_PP_IS_NS_ENABLED(ns)) \ (inline namespace ns, namespace ns) -#endif // __cplusplus < 201103L +#endif // MSGPACK_USE_CPP03 #endif // MSGPACK_VERSIONING_HPP diff --git a/include/msgpack/v1/vrefbuffer.hpp b/include/msgpack/v1/vrefbuffer.hpp index e07c1b057..1887a5c33 100644 --- a/include/msgpack/v1/vrefbuffer.hpp +++ b/include/msgpack/v1/vrefbuffer.hpp @@ -11,6 +11,7 @@ #define MSGPACK_V1_VREFBUFFER_HPP #include "msgpack/v1/vrefbuffer_decl.hpp" +#include "msgpack/assert.hpp" #include #include @@ -24,11 +25,16 @@ #if defined(unix) || defined(__unix) || defined(__APPLE__) || defined(__OpenBSD__) #include +namespace msgpack { +typedef ::iovec iovec; +} // namespace msgpack #else +namespace msgpack { struct iovec { void *iov_base; size_t iov_len; }; +} // namespace msgpack #endif namespace msgpack { @@ -107,6 +113,10 @@ class vrefbuffer { public: void write(const char* buf, size_t len) { + MSGPACK_ASSERT(buf || len == 0); + + if (!buf) return; + if(len < m_ref_size) { append_copy(buf, len); } else { @@ -177,7 +187,7 @@ class vrefbuffer { } } - const struct iovec* vector() const + const iovec* vector() const { return m_array; } diff --git a/include/msgpack/v1/zbuffer.hpp b/include/msgpack/v1/zbuffer.hpp index 94a21238e..96b0af308 100644 --- a/include/msgpack/v1/zbuffer.hpp +++ b/include/msgpack/v1/zbuffer.hpp @@ -11,6 +11,7 @@ #define MSGPACK_V1_ZBUFFER_HPP #include "msgpack/v1/zbuffer_decl.hpp" +#include "msgpack/assert.hpp" #include #include @@ -46,6 +47,9 @@ class zbuffer { public: void write(const char* buf, size_t len) { + MSGPACK_ASSERT(buf || len == 0); + if (!buf) return; + m_stream.next_in = reinterpret_cast(const_cast(buf)); m_stream.avail_in = static_cast(len); diff --git a/include/msgpack/v2/adaptor/boost/msgpack_variant_decl.hpp b/include/msgpack/v2/adaptor/boost/msgpack_variant_decl.hpp index 65ac599a3..6ece08039 100644 --- a/include/msgpack/v2/adaptor/boost/msgpack_variant_decl.hpp +++ b/include/msgpack/v2/adaptor/boost/msgpack_variant_decl.hpp @@ -10,8 +10,6 @@ #ifndef MSGPACK_V2_TYPE_BOOST_MSGPACK_VARIANT_DECL_HPP #define MSGPACK_V2_TYPE_BOOST_MSGPACK_VARIANT_DECL_HPP -#if defined(MSGPACK_USE_BOOST) - #include "msgpack/v1/adaptor/boost/msgpack_variant_decl.hpp" namespace msgpack { @@ -38,5 +36,4 @@ using v1::type::operator==; } // namespace msgpack -#endif // MSGPACK_USE_BOOST #endif // MSGPACK_V2_TYPE_BOOST_MSGPACK_VARIANT_DECL_HPP diff --git a/include/msgpack/v2/adaptor/v4raw_decl.hpp b/include/msgpack/v2/adaptor/v4raw_decl.hpp index b39ef0cfb..6dde1ac6e 100644 --- a/include/msgpack/v2/adaptor/v4raw_decl.hpp +++ b/include/msgpack/v2/adaptor/v4raw_decl.hpp @@ -12,6 +12,7 @@ #include "msgpack/versioning.hpp" #include "msgpack/adaptor/adaptor_base.hpp" +#include "msgpack/object.hpp" namespace msgpack { diff --git a/include/msgpack/v2/cpp_config_decl.hpp b/include/msgpack/v2/cpp_config_decl.hpp index 7e2e98323..ee221a824 100644 --- a/include/msgpack/v2/cpp_config_decl.hpp +++ b/include/msgpack/v2/cpp_config_decl.hpp @@ -11,6 +11,7 @@ #define MSGPACK_V2_CPP_CONFIG_DECL_HPP #include "msgpack/v1/cpp_config_decl.hpp" +#include "msgpack/cpp_version.hpp" #if defined(MSGPACK_USE_CPP03) diff --git a/include/msgpack/v2/create_object_visitor.hpp b/include/msgpack/v2/create_object_visitor.hpp index 3cd8fcea7..d0e234e92 100644 --- a/include/msgpack/v2/create_object_visitor.hpp +++ b/include/msgpack/v2/create_object_visitor.hpp @@ -14,6 +14,7 @@ #include "msgpack/unpack_exception.hpp" #include "msgpack/v2/create_object_visitor_decl.hpp" #include "msgpack/v2/null_visitor.hpp" +#include "msgpack/assert.hpp" namespace msgpack { @@ -106,51 +107,75 @@ class create_object_visitor : public msgpack::v2::null_visitor { return true; } bool visit_str(const char* v, uint32_t size) { + MSGPACK_ASSERT(v || size == 0); if (size > m_limit.str()) throw msgpack::str_size_overflow("str size overflow"); msgpack::object* obj = m_stack.back(); obj->type = msgpack::type::STR; if (m_func && m_func(obj->type, size, m_user_data)) { obj->via.str.ptr = v; + obj->via.str.size = size; set_referenced(true); } else { - char* tmp = static_cast(zone().allocate_align(size, MSGPACK_ZONE_ALIGNOF(char))); - std::memcpy(tmp, v, size); - obj->via.str.ptr = tmp; + if (v) { + char* tmp = static_cast(zone().allocate_align(size, MSGPACK_ZONE_ALIGNOF(char))); + std::memcpy(tmp, v, size); + obj->via.str.ptr = tmp; + obj->via.str.size = size; + } + else { + obj->via.str.ptr = MSGPACK_NULLPTR; + obj->via.str.size = 0; + } } - obj->via.str.size = size; return true; } bool visit_bin(const char* v, uint32_t size) { + MSGPACK_ASSERT(v || size == 0); if (size > m_limit.bin()) throw msgpack::bin_size_overflow("bin size overflow"); msgpack::object* obj = m_stack.back(); obj->type = msgpack::type::BIN; if (m_func && m_func(obj->type, size, m_user_data)) { obj->via.bin.ptr = v; + obj->via.bin.size = size; set_referenced(true); } else { - char* tmp = static_cast(zone().allocate_align(size, MSGPACK_ZONE_ALIGNOF(char))); - std::memcpy(tmp, v, size); - obj->via.bin.ptr = tmp; + if (v) { + char* tmp = static_cast(zone().allocate_align(size, MSGPACK_ZONE_ALIGNOF(char))); + std::memcpy(tmp, v, size); + obj->via.bin.ptr = tmp; + obj->via.bin.size = size; + } + else { + obj->via.bin.ptr = MSGPACK_NULLPTR; + obj->via.bin.size = 0; + } } - obj->via.bin.size = size; return true; } bool visit_ext(const char* v, uint32_t size) { + MSGPACK_ASSERT(v || size == 0); if (size > m_limit.ext()) throw msgpack::ext_size_overflow("ext size overflow"); msgpack::object* obj = m_stack.back(); obj->type = msgpack::type::EXT; if (m_func && m_func(obj->type, size, m_user_data)) { obj->via.ext.ptr = v; + obj->via.ext.size = static_cast(size - 1); set_referenced(true); } else { - char* tmp = static_cast(zone().allocate_align(size, MSGPACK_ZONE_ALIGNOF(char))); - std::memcpy(tmp, v, size); - obj->via.ext.ptr = tmp; + if (v) { + char* tmp = static_cast(zone().allocate_align(size, MSGPACK_ZONE_ALIGNOF(char))); + std::memcpy(tmp, v, size); + obj->via.ext.ptr = tmp; + obj->via.ext.size = static_cast(size - 1); + } + else { + obj->via.ext.ptr = MSGPACK_NULLPTR; + obj->via.ext.size = 0; + } } - obj->via.ext.size = static_cast(size - 1); return true; } bool start_array(uint32_t num_elements) { diff --git a/include/msgpack/v2/iterator_decl.hpp b/include/msgpack/v2/iterator_decl.hpp index c03a3939e..49268f64d 100644 --- a/include/msgpack/v2/iterator_decl.hpp +++ b/include/msgpack/v2/iterator_decl.hpp @@ -12,7 +12,7 @@ #define MSGPACK_V2_ITERATOR_DECL_HPP #if !defined(MSGPACK_USE_CPP03) -#include +#include "msgpack/v1/iterator_decl.hpp" namespace msgpack { diff --git a/include/msgpack/v2/object_fwd.hpp b/include/msgpack/v2/object_fwd.hpp index 9c44aae60..45a631180 100644 --- a/include/msgpack/v2/object_fwd.hpp +++ b/include/msgpack/v2/object_fwd.hpp @@ -79,7 +79,7 @@ template struct has_as { private: template - static auto check(U*) -> + static auto check_(U*) -> typename std::enable_if< // check v2 specialization std::is_same< @@ -92,9 +92,9 @@ struct has_as { std::true_type >::type; template - static std::false_type check(...); + static std::false_type check_(...); public: - using type = decltype(check(MSGPACK_NULLPTR)); + using type = decltype(check_(MSGPACK_NULLPTR)); static constexpr bool value = type::value; }; diff --git a/include/msgpack/v2/parse.hpp b/include/msgpack/v2/parse.hpp index bc1cd9257..bfdd1d007 100644 --- a/include/msgpack/v2/parse.hpp +++ b/include/msgpack/v2/parse.hpp @@ -14,10 +14,11 @@ #include -#include "msgpack/unpack_define.h" +#include "msgpack/unpack_define.hpp" #include "msgpack/parse_return.hpp" #include "msgpack/unpack_exception.hpp" #include "msgpack/unpack_decl.hpp" +#include "msgpack/assert.hpp" namespace msgpack { @@ -165,10 +166,10 @@ class context { case MSGPACK_CT_MAP_KEY: return visitor_holder.visitor().start_map_key() ? PARSE_CONTINUE : PARSE_STOP_VISITOR; case MSGPACK_CT_MAP_VALUE: - assert(0); + MSGPACK_ASSERT(0); return PARSE_STOP_VISITOR; } - assert(0); + MSGPACK_ASSERT(0); return PARSE_STOP_VISITOR; } parse_return consume(VisitorHolder& visitor_holder) { @@ -234,7 +235,7 @@ inline void check_ext_size<4>(std::size_t size) { template inline parse_return context::execute(const char* data, std::size_t len, std::size_t& off) { - assert(len >= off); + MSGPACK_ASSERT(len >= off); m_start = data; m_current = data + off; diff --git a/include/msgpack/v3/adaptor/adaptor_base.hpp b/include/msgpack/v3/adaptor/adaptor_base.hpp index 180cca994..99af27794 100644 --- a/include/msgpack/v3/adaptor/adaptor_base.hpp +++ b/include/msgpack/v3/adaptor/adaptor_base.hpp @@ -32,14 +32,15 @@ struct pack : v2::adaptor::pack { }; template -struct object< - T, - Enabler, - typename msgpack::enable_if< - !msgpack::is_same::value && - !msgpack::is_array::value - >::type> - : v2::adaptor::object { +struct object + : v2::adaptor::object< + T, + typename msgpack::enable_if< + !msgpack::is_same::value && + !msgpack::is_array::value, + Enabler + >::type + > { }; template diff --git a/include/msgpack/v3/adaptor/adaptor_base_decl.hpp b/include/msgpack/v3/adaptor/adaptor_base_decl.hpp index f339f661e..12f096a43 100644 --- a/include/msgpack/v3/adaptor/adaptor_base_decl.hpp +++ b/include/msgpack/v3/adaptor/adaptor_base_decl.hpp @@ -30,7 +30,7 @@ struct convert; template struct pack; -template +template struct object; template diff --git a/include/msgpack/v3/adaptor/boost/msgpack_variant_decl.hpp b/include/msgpack/v3/adaptor/boost/msgpack_variant_decl.hpp index e9cf70010..03fb029d6 100644 --- a/include/msgpack/v3/adaptor/boost/msgpack_variant_decl.hpp +++ b/include/msgpack/v3/adaptor/boost/msgpack_variant_decl.hpp @@ -10,8 +10,6 @@ #ifndef MSGPACK_V3_TYPE_BOOST_MSGPACK_VARIANT_DECL_HPP #define MSGPACK_V3_TYPE_BOOST_MSGPACK_VARIANT_DECL_HPP -#if defined(MSGPACK_USE_BOOST) - #include "msgpack/v2/adaptor/boost/msgpack_variant_decl.hpp" namespace msgpack { @@ -38,5 +36,4 @@ using v2::type::operator==; } // namespace msgpack -#endif // MSGPACK_USE_BOOST #endif // MSGPACK_V3_TYPE_BOOST_MSGPACK_VARIANT_DECL_HPP diff --git a/include/msgpack/v3/adaptor/v4raw_decl.hpp b/include/msgpack/v3/adaptor/v4raw_decl.hpp index cc4f841f7..e9b4f0952 100644 --- a/include/msgpack/v3/adaptor/v4raw_decl.hpp +++ b/include/msgpack/v3/adaptor/v4raw_decl.hpp @@ -12,6 +12,7 @@ #include "msgpack/versioning.hpp" #include "msgpack/adaptor/adaptor_base.hpp" +#include "msgpack/object.hpp" namespace msgpack { diff --git a/include/msgpack/v3/cpp_config_decl.hpp b/include/msgpack/v3/cpp_config_decl.hpp index 2a33dc54e..2944aa02e 100644 --- a/include/msgpack/v3/cpp_config_decl.hpp +++ b/include/msgpack/v3/cpp_config_decl.hpp @@ -11,6 +11,7 @@ #define MSGPACK_V3_CPP_CONFIG_DECL_HPP #include "msgpack/v2/cpp_config_decl.hpp" +#include "msgpack/cpp_version.hpp" #if defined(MSGPACK_USE_CPP03) diff --git a/include/msgpack/v3/iterator_decl.hpp b/include/msgpack/v3/iterator_decl.hpp index 999eb3be9..fb7b103b6 100644 --- a/include/msgpack/v3/iterator_decl.hpp +++ b/include/msgpack/v3/iterator_decl.hpp @@ -12,7 +12,7 @@ #define MSGPACK_V3_ITERATOR_DECL_HPP #if !defined(MSGPACK_USE_CPP03) -#include +#include "msgpack/v2/iterator_decl.hpp" namespace msgpack { diff --git a/include/msgpack/v3/object_fwd.hpp b/include/msgpack/v3/object_fwd.hpp index d282f1b4a..a0ed44aeb 100644 --- a/include/msgpack/v3/object_fwd.hpp +++ b/include/msgpack/v3/object_fwd.hpp @@ -36,7 +36,7 @@ template struct has_as { private: template - static auto check(U*) -> + static auto check_(U*) -> typename std::enable_if< // check v3 specialization std::is_same< @@ -52,9 +52,9 @@ struct has_as { std::true_type >::type; template - static std::false_type check(...); + static std::false_type check_(...); public: - using type = decltype(check(MSGPACK_NULLPTR)); + using type = decltype(check_(MSGPACK_NULLPTR)); static constexpr bool value = type::value; }; diff --git a/include/msgpack/v3/parse.hpp b/include/msgpack/v3/parse.hpp index 6d4628769..8a4b338ae 100644 --- a/include/msgpack/v3/parse.hpp +++ b/include/msgpack/v3/parse.hpp @@ -15,6 +15,7 @@ #include #include "msgpack/parse_return.hpp" +#include "msgpack/assert.hpp" namespace msgpack { @@ -159,10 +160,10 @@ class context { case MSGPACK_CT_MAP_KEY: return visitor_holder.visitor().start_map_key() ? PARSE_CONTINUE : PARSE_STOP_VISITOR; case MSGPACK_CT_MAP_VALUE: - assert(0); + MSGPACK_ASSERT(0); return PARSE_STOP_VISITOR; } - assert(0); + MSGPACK_ASSERT(0); return PARSE_STOP_VISITOR; } parse_return consume(VisitorHolder& visitor_holder, char const*& current) { @@ -243,7 +244,7 @@ inline void check_ext_size<4>(std::size_t size) { template inline parse_return context::execute(const char* data, std::size_t len, std::size_t& off) { - assert(len >= off); + MSGPACK_ASSERT(len >= off); m_start = data; m_current = data + off; diff --git a/include/msgpack/v3/unpack.hpp b/include/msgpack/v3/unpack.hpp index 659411b68..abbf52692 100644 --- a/include/msgpack/v3/unpack.hpp +++ b/include/msgpack/v3/unpack.hpp @@ -33,9 +33,9 @@ inline msgpack::object_handle unpack( data, len, off, *z, obj, referenced, f, user_data, limit); switch(ret) { - case msgpack::PARSE_SUCCESS: + case PARSE_SUCCESS: return msgpack::object_handle(obj, msgpack::move(z)); - case msgpack::PARSE_EXTRA_BYTES: + case PARSE_EXTRA_BYTES: return msgpack::object_handle(obj, msgpack::move(z)); default: break; @@ -84,11 +84,11 @@ inline void unpack( data, len, off, *z, obj, referenced, f, user_data, limit); switch(ret) { - case msgpack::PARSE_SUCCESS: + case PARSE_SUCCESS: result.set(obj); result.zone() = msgpack::move(z); return; - case msgpack::PARSE_EXTRA_BYTES: + case PARSE_EXTRA_BYTES: result.set(obj); result.zone() = msgpack::move(z); return; @@ -141,9 +141,9 @@ inline msgpack::object unpack( data, len, off, z, obj, referenced, f, user_data, limit); switch(ret) { - case msgpack::PARSE_SUCCESS: + case PARSE_SUCCESS: return obj; - case msgpack::PARSE_EXTRA_BYTES: + case PARSE_EXTRA_BYTES: return obj; default: break; diff --git a/include/msgpack/version.h b/include/msgpack/version.h deleted file mode 100644 index bd6605b8c..000000000 --- a/include/msgpack/version.h +++ /dev/null @@ -1,38 +0,0 @@ -/* - * MessagePack for C version information - * - * Copyright (C) 2008-2009 FURUHASHI Sadayuki - * - * 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_VERSION_H -#define MSGPACK_VERSION_H - -#ifdef __cplusplus -extern "C" { -#endif - -MSGPACK_DLLEXPORT -const char* msgpack_version(void); -MSGPACK_DLLEXPORT -int msgpack_version_major(void); -MSGPACK_DLLEXPORT -int msgpack_version_minor(void); -MSGPACK_DLLEXPORT -int msgpack_version_revision(void); - -#include "version_master.h" - -#define MSGPACK_STR(v) #v -#define MSGPACK_VERSION_I(maj, min, rev) MSGPACK_STR(maj) "." MSGPACK_STR(min) "." MSGPACK_STR(rev) - -#define MSGPACK_VERSION MSGPACK_VERSION_I(MSGPACK_VERSION_MAJOR, MSGPACK_VERSION_MINOR, MSGPACK_VERSION_REVISION) - -#ifdef __cplusplus -} -#endif - -#endif /* msgpack/version.h */ - diff --git a/include/msgpack/version.hpp b/include/msgpack/version.hpp index 0b447c70f..2ca33efec 100644 --- a/include/msgpack/version.hpp +++ b/include/msgpack/version.hpp @@ -10,7 +10,7 @@ #ifndef MSGPACK_VERSION_HPP #define MSGPACK_VERSION_HPP -#include "version_master.h" +#include "version_master.hpp" #define MSGPACK_STR(v) #v #define MSGPACK_VERSION_I(maj, min, rev) MSGPACK_STR(maj) "." MSGPACK_STR(min) "." MSGPACK_STR(rev) diff --git a/include/msgpack/version_master.h b/include/msgpack/version_master.h deleted file mode 100644 index afb8ebe51..000000000 --- a/include/msgpack/version_master.h +++ /dev/null @@ -1,3 +0,0 @@ -#define MSGPACK_VERSION_MAJOR 3 -#define MSGPACK_VERSION_MINOR 2 -#define MSGPACK_VERSION_REVISION 0 diff --git a/include/msgpack/version_master.hpp b/include/msgpack/version_master.hpp new file mode 100644 index 000000000..26d2ec3c2 --- /dev/null +++ b/include/msgpack/version_master.hpp @@ -0,0 +1,3 @@ +#define MSGPACK_VERSION_MAJOR 7 +#define MSGPACK_VERSION_MINOR 0 +#define MSGPACK_VERSION_REVISION 0 diff --git a/include/msgpack/versioning.hpp b/include/msgpack/versioning.hpp index 379e715c4..2f36c5bf2 100644 --- a/include/msgpack/versioning.hpp +++ b/include/msgpack/versioning.hpp @@ -10,6 +10,8 @@ #ifndef MSGPACK_VERSIONING_HPP #define MSGPACK_VERSIONING_HPP +#include "msgpack/cpp_version.hpp" + #if !defined(MSGPACK_DEFAULT_API_VERSION) #define MSGPACK_DEFAULT_API_VERSION 3 #endif @@ -56,16 +58,16 @@ #define MSGPACK_DETAIL_PP_IS_NS_ENABLED(ns) MSGPACK_DETAIL_PP_CHECK(MSGPACK_DETAIL_PP_NS_ENABLED_PROBE(ns)) -#if __cplusplus < 201103L +#ifdef MSGPACK_USE_CPP03 #define MSGPACK_API_VERSION_NAMESPACE(ns) MSGPACK_DETAIL_PP_IIF(MSGPACK_DETAIL_PP_IS_NS_ENABLED(ns)) \ (namespace ns{}; using namespace ns; namespace ns, \ namespace ns) -#else // __cplusplus < 201103L +#else // MSGPACK_USE_CPP03 #define MSGPACK_API_VERSION_NAMESPACE(ns) MSGPACK_DETAIL_PP_IIF(MSGPACK_DETAIL_PP_IS_NS_ENABLED(ns)) \ (inline namespace ns, namespace ns) -#endif // __cplusplus < 201103L +#endif // MSGPACK_USE_CPP03 #endif // MSGPACK_VERSIONING_HPP diff --git a/include/msgpack/vrefbuffer.h b/include/msgpack/vrefbuffer.h deleted file mode 100644 index 574c3cb97..000000000 --- a/include/msgpack/vrefbuffer.h +++ /dev/null @@ -1,140 +0,0 @@ -/* - * MessagePack for C zero-copy buffer implementation - * - * Copyright (C) 2008-2009 FURUHASHI Sadayuki - * - * 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_VREFBUFFER_H -#define MSGPACK_VREFBUFFER_H - -#include "zone.h" -#include - -#if defined(unix) || defined(__unix) || defined(__APPLE__) || defined(__OpenBSD__) || defined(__NetBSD__) || defined(__QNX__) || defined(__QNXTO__) || defined(__HAIKU__) -#include -#else -struct iovec { - void *iov_base; - size_t iov_len; -}; -#endif - -#ifdef __cplusplus -extern "C" { -#endif - - -/** - * @defgroup msgpack_vrefbuffer Vectored Referencing buffer - * @ingroup msgpack_buffer - * @{ - */ - -struct msgpack_vrefbuffer_chunk; -typedef struct msgpack_vrefbuffer_chunk msgpack_vrefbuffer_chunk; - -typedef struct msgpack_vrefbuffer_inner_buffer { - size_t free; - char* ptr; - msgpack_vrefbuffer_chunk* head; -} msgpack_vrefbuffer_inner_buffer; - -typedef struct msgpack_vrefbuffer { - struct iovec* tail; - struct iovec* end; - struct iovec* array; - - size_t chunk_size; - size_t ref_size; - - msgpack_vrefbuffer_inner_buffer inner_buffer; -} msgpack_vrefbuffer; - - -#ifndef MSGPACK_VREFBUFFER_REF_SIZE -#define MSGPACK_VREFBUFFER_REF_SIZE 32 -#endif - -#ifndef MSGPACK_VREFBUFFER_CHUNK_SIZE -#define MSGPACK_VREFBUFFER_CHUNK_SIZE 8192 -#endif - -MSGPACK_DLLEXPORT -bool msgpack_vrefbuffer_init(msgpack_vrefbuffer* vbuf, - size_t ref_size, size_t chunk_size); -MSGPACK_DLLEXPORT -void msgpack_vrefbuffer_destroy(msgpack_vrefbuffer* vbuf); - -static inline msgpack_vrefbuffer* msgpack_vrefbuffer_new(size_t ref_size, size_t chunk_size); -static inline void msgpack_vrefbuffer_free(msgpack_vrefbuffer* vbuf); - -static inline int msgpack_vrefbuffer_write(void* data, const char* buf, size_t len); - -static inline const struct iovec* msgpack_vrefbuffer_vec(const msgpack_vrefbuffer* vref); -static inline size_t msgpack_vrefbuffer_veclen(const msgpack_vrefbuffer* vref); - -MSGPACK_DLLEXPORT -int msgpack_vrefbuffer_append_copy(msgpack_vrefbuffer* vbuf, - const char* buf, size_t len); - -MSGPACK_DLLEXPORT -int msgpack_vrefbuffer_append_ref(msgpack_vrefbuffer* vbuf, - const char* buf, size_t len); - -MSGPACK_DLLEXPORT -int msgpack_vrefbuffer_migrate(msgpack_vrefbuffer* vbuf, msgpack_vrefbuffer* to); - -MSGPACK_DLLEXPORT -void msgpack_vrefbuffer_clear(msgpack_vrefbuffer* vref); - -/** @} */ - - -static inline msgpack_vrefbuffer* msgpack_vrefbuffer_new(size_t ref_size, size_t chunk_size) -{ - msgpack_vrefbuffer* vbuf = (msgpack_vrefbuffer*)malloc(sizeof(msgpack_vrefbuffer)); - if (vbuf == NULL) return NULL; - if(!msgpack_vrefbuffer_init(vbuf, ref_size, chunk_size)) { - free(vbuf); - return NULL; - } - return vbuf; -} - -static inline void msgpack_vrefbuffer_free(msgpack_vrefbuffer* vbuf) -{ - if(vbuf == NULL) { return; } - msgpack_vrefbuffer_destroy(vbuf); - free(vbuf); -} - -static inline int msgpack_vrefbuffer_write(void* data, const char* buf, size_t len) -{ - msgpack_vrefbuffer* vbuf = (msgpack_vrefbuffer*)data; - - if(len < vbuf->ref_size) { - return msgpack_vrefbuffer_append_copy(vbuf, buf, len); - } else { - return msgpack_vrefbuffer_append_ref(vbuf, buf, len); - } -} - -static inline const struct iovec* msgpack_vrefbuffer_vec(const msgpack_vrefbuffer* vref) -{ - return vref->array; -} - -static inline size_t msgpack_vrefbuffer_veclen(const msgpack_vrefbuffer* vref) -{ - return (size_t)(vref->tail - vref->array); -} - - -#ifdef __cplusplus -} -#endif - -#endif /* msgpack/vrefbuffer.h */ diff --git a/include/msgpack/zbuffer.h b/include/msgpack/zbuffer.h deleted file mode 100644 index 0357c1cec..000000000 --- a/include/msgpack/zbuffer.h +++ /dev/null @@ -1,201 +0,0 @@ -/* - * MessagePack for C deflate buffer implementation - * - * Copyright (C) 2010 FURUHASHI Sadayuki - * - * 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_ZBUFFER_H -#define MSGPACK_ZBUFFER_H - -#include "sysdep.h" -#include -#include -#include - -#ifdef __cplusplus -extern "C" { -#endif - - -/** - * @defgroup msgpack_zbuffer Compressed buffer - * @ingroup msgpack_buffer - * @{ - */ - -typedef struct msgpack_zbuffer { - z_stream stream; - char* data; - size_t init_size; -} msgpack_zbuffer; - -#ifndef MSGPACK_ZBUFFER_INIT_SIZE -#define MSGPACK_ZBUFFER_INIT_SIZE 8192 -#endif - -static inline bool msgpack_zbuffer_init( - msgpack_zbuffer* zbuf, int level, size_t init_size); -static inline void msgpack_zbuffer_destroy(msgpack_zbuffer* zbuf); - -static inline msgpack_zbuffer* msgpack_zbuffer_new(int level, size_t init_size); -static inline void msgpack_zbuffer_free(msgpack_zbuffer* zbuf); - -static inline char* msgpack_zbuffer_flush(msgpack_zbuffer* zbuf); - -static inline const char* msgpack_zbuffer_data(const msgpack_zbuffer* zbuf); -static inline size_t msgpack_zbuffer_size(const msgpack_zbuffer* zbuf); - -static inline bool msgpack_zbuffer_reset(msgpack_zbuffer* zbuf); -static inline void msgpack_zbuffer_reset_buffer(msgpack_zbuffer* zbuf); -static inline char* msgpack_zbuffer_release_buffer(msgpack_zbuffer* zbuf); - - -#ifndef MSGPACK_ZBUFFER_RESERVE_SIZE -#define MSGPACK_ZBUFFER_RESERVE_SIZE 512 -#endif - -static inline int msgpack_zbuffer_write(void* data, const char* buf, size_t len); - -static inline bool msgpack_zbuffer_expand(msgpack_zbuffer* zbuf); - - -static inline bool msgpack_zbuffer_init(msgpack_zbuffer* zbuf, - int level, size_t init_size) -{ - memset(zbuf, 0, sizeof(msgpack_zbuffer)); - zbuf->init_size = init_size; - if(deflateInit(&zbuf->stream, level) != Z_OK) { - free(zbuf->data); - return false; - } - return true; -} - -static inline void msgpack_zbuffer_destroy(msgpack_zbuffer* zbuf) -{ - deflateEnd(&zbuf->stream); - free(zbuf->data); -} - -static inline msgpack_zbuffer* msgpack_zbuffer_new(int level, size_t init_size) -{ - msgpack_zbuffer* zbuf = (msgpack_zbuffer*)malloc(sizeof(msgpack_zbuffer)); - if (zbuf == NULL) return NULL; - if(!msgpack_zbuffer_init(zbuf, level, init_size)) { - free(zbuf); - return NULL; - } - return zbuf; -} - -static inline void msgpack_zbuffer_free(msgpack_zbuffer* zbuf) -{ - if(zbuf == NULL) { return; } - msgpack_zbuffer_destroy(zbuf); - free(zbuf); -} - -static inline bool msgpack_zbuffer_expand(msgpack_zbuffer* zbuf) -{ - size_t used = static_cast(reinterpret_cast(zbuf->stream.next_out) - zbuf->data); - size_t csize = used + zbuf->stream.avail_out; - - size_t nsize = (csize == 0) ? zbuf->init_size : csize * 2; - - char* tmp = (char*)realloc(zbuf->data, nsize); - if(tmp == NULL) { - return false; - } - - zbuf->data = tmp; - zbuf->stream.next_out = (Bytef*)(tmp + used); - zbuf->stream.avail_out = static_cast(nsize - used); - - return true; -} - -static inline int msgpack_zbuffer_write(void* data, const char* buf, size_t len) -{ - msgpack_zbuffer* zbuf = (msgpack_zbuffer*)data; - - zbuf->stream.next_in = (Bytef*)buf; - zbuf->stream.avail_in = static_cast(len); - - while(zbuf->stream.avail_in > 0) { - if(zbuf->stream.avail_out < MSGPACK_ZBUFFER_RESERVE_SIZE) { - if(!msgpack_zbuffer_expand(zbuf)) { - return -1; - } - } - - if(deflate(&zbuf->stream, Z_NO_FLUSH) != Z_OK) { - return -1; - } - } - - return 0; -} - -static inline char* msgpack_zbuffer_flush(msgpack_zbuffer* zbuf) -{ - while(true) { - switch(deflate(&zbuf->stream, Z_FINISH)) { - case Z_STREAM_END: - return zbuf->data; - case Z_OK: - case Z_BUF_ERROR: - if(!msgpack_zbuffer_expand(zbuf)) { - return NULL; - } - break; - default: - return NULL; - } - } -} - -static inline const char* msgpack_zbuffer_data(const msgpack_zbuffer* zbuf) -{ - return zbuf->data; -} - -static inline size_t msgpack_zbuffer_size(const msgpack_zbuffer* zbuf) -{ - return static_cast(reinterpret_cast(zbuf->stream.next_out) - zbuf->data); -} - -static inline void msgpack_zbuffer_reset_buffer(msgpack_zbuffer* zbuf) -{ - zbuf->stream.avail_out += (uInt)((char*)zbuf->stream.next_out - zbuf->data); - zbuf->stream.next_out = (Bytef*)zbuf->data; -} - -static inline bool msgpack_zbuffer_reset(msgpack_zbuffer* zbuf) -{ - if(deflateReset(&zbuf->stream) != Z_OK) { - return false; - } - msgpack_zbuffer_reset_buffer(zbuf); - return true; -} - -static inline char* msgpack_zbuffer_release_buffer(msgpack_zbuffer* zbuf) -{ - char* tmp = zbuf->data; - zbuf->data = NULL; - zbuf->stream.next_out = NULL; - zbuf->stream.avail_out = 0; - return tmp; -} - -/** @} */ - - -#ifdef __cplusplus -} -#endif - -#endif /* msgpack/zbuffer.h */ diff --git a/include/msgpack/zone.h b/include/msgpack/zone.h deleted file mode 100644 index 9005be793..000000000 --- a/include/msgpack/zone.h +++ /dev/null @@ -1,163 +0,0 @@ -/* - * MessagePack for C memory pool implementation - * - * Copyright (C) 2008-2010 FURUHASHI Sadayuki - * - * 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_ZONE_H -#define MSGPACK_ZONE_H - -#include "sysdep.h" - -#ifdef __cplusplus -extern "C" { -#endif - - -/** - * @defgroup msgpack_zone Memory zone - * @ingroup msgpack - * @{ - */ - -typedef struct msgpack_zone_finalizer { - void (*func)(void* data); - void* data; -} msgpack_zone_finalizer; - -typedef struct msgpack_zone_finalizer_array { - msgpack_zone_finalizer* tail; - msgpack_zone_finalizer* end; - msgpack_zone_finalizer* array; -} msgpack_zone_finalizer_array; - -struct msgpack_zone_chunk; -typedef struct msgpack_zone_chunk msgpack_zone_chunk; - -typedef struct msgpack_zone_chunk_list { - size_t free; - char* ptr; - msgpack_zone_chunk* head; -} msgpack_zone_chunk_list; - -typedef struct msgpack_zone { - msgpack_zone_chunk_list chunk_list; - msgpack_zone_finalizer_array finalizer_array; - size_t chunk_size; -} msgpack_zone; - -#ifndef MSGPACK_ZONE_CHUNK_SIZE -#define MSGPACK_ZONE_CHUNK_SIZE 8192 -#endif - -MSGPACK_DLLEXPORT -bool msgpack_zone_init(msgpack_zone* zone, size_t chunk_size); -MSGPACK_DLLEXPORT -void msgpack_zone_destroy(msgpack_zone* zone); - -MSGPACK_DLLEXPORT -msgpack_zone* msgpack_zone_new(size_t chunk_size); -MSGPACK_DLLEXPORT -void msgpack_zone_free(msgpack_zone* zone); - -static inline void* msgpack_zone_malloc(msgpack_zone* zone, size_t size); -static inline void* msgpack_zone_malloc_no_align(msgpack_zone* zone, size_t size); - -static inline bool msgpack_zone_push_finalizer(msgpack_zone* zone, - void (*func)(void* data), void* data); - -static inline void msgpack_zone_swap(msgpack_zone* a, msgpack_zone* b); - -MSGPACK_DLLEXPORT -bool msgpack_zone_is_empty(msgpack_zone* zone); - -MSGPACK_DLLEXPORT -void msgpack_zone_clear(msgpack_zone* zone); - -/** @} */ - - -#ifndef MSGPACK_ZONE_ALIGN -#define MSGPACK_ZONE_ALIGN sizeof(void*) -#endif - -MSGPACK_DLLEXPORT -void* msgpack_zone_malloc_expand(msgpack_zone* zone, size_t size); - -static inline void* msgpack_zone_malloc_no_align(msgpack_zone* zone, size_t size) -{ - char* ptr; - msgpack_zone_chunk_list* cl = &zone->chunk_list; - - if(zone->chunk_list.free < size) { - return msgpack_zone_malloc_expand(zone, size); - } - - ptr = cl->ptr; - cl->free -= size; - cl->ptr += size; - - return ptr; -} - -static inline void* msgpack_zone_malloc(msgpack_zone* zone, size_t size) -{ - char* aligned = - (char*)( - (size_t)( - zone->chunk_list.ptr + (MSGPACK_ZONE_ALIGN - 1) - ) / MSGPACK_ZONE_ALIGN * MSGPACK_ZONE_ALIGN - ); - size_t adjusted_size = size + (size_t)(aligned - zone->chunk_list.ptr); - if(zone->chunk_list.free >= adjusted_size) { - zone->chunk_list.free -= adjusted_size; - zone->chunk_list.ptr += adjusted_size; - return aligned; - } - { - void* ptr = msgpack_zone_malloc_expand(zone, size + (MSGPACK_ZONE_ALIGN - 1)); - if (ptr) { - return (char*)((size_t)(ptr) / MSGPACK_ZONE_ALIGN * MSGPACK_ZONE_ALIGN); - } - } - return NULL; -} - - -bool msgpack_zone_push_finalizer_expand(msgpack_zone* zone, - void (*func)(void* data), void* data); - -static inline bool msgpack_zone_push_finalizer(msgpack_zone* zone, - void (*func)(void* data), void* data) -{ - msgpack_zone_finalizer_array* const fa = &zone->finalizer_array; - msgpack_zone_finalizer* fin = fa->tail; - - if(fin == fa->end) { - return msgpack_zone_push_finalizer_expand(zone, func, data); - } - - fin->func = func; - fin->data = data; - - ++fa->tail; - - return true; -} - -static inline void msgpack_zone_swap(msgpack_zone* a, msgpack_zone* b) -{ - msgpack_zone tmp = *a; - *a = *b; - *b = tmp; -} - - -#ifdef __cplusplus -} -#endif - -#endif /* msgpack/zone.h */ diff --git a/make_file_list.sh b/make_file_list.sh index 772fe20b2..5156a1614 100755 --- a/make_file_list.sh +++ b/make_file_list.sh @@ -1,21 +1,9 @@ -#!/bin/sh +#!/bin/bash -find src -name "*.c" | sed -e 's/\s\+/\n/g' | sort > srcs.tmp -find include -name "*.h" | sed -e 's/\s\+/\n/g' | sort > c_headers.tmp -find include -name "*.hpp" | sed -e 's/\s\+/\n/g' | sort > cpp_headers.tmp +find include -name "*.hpp" -or -name "*.h" | sed -e 's/\s\+/\n/g' | LC_ALL=C sort > cpp_headers.tmp -echo 'LIST (APPEND msgpackc_SOURCES' > Files.cmake -cat srcs.tmp | sed -e 's/^/ /g' >> Files.cmake +echo 'SET (msgpack-cxx_HEADERS' > Files.cmake +cat cpp_headers.tmp | sed -e 's/^/ /g' >> Files.cmake echo ')' >> Files.cmake -echo 'LIST (APPEND msgpackc_HEADERS' >> Files.cmake -cat c_headers.tmp | sed -e 's/^/ /g' >> Files.cmake -echo ')' >> Files.cmake - -echo 'IF (MSGPACK_ENABLE_CXX)' >> Files.cmake -echo ' LIST (APPEND msgpackc_HEADERS' >> Files.cmake -cat cpp_headers.tmp | sed -e 's/^/ /g' >> Files.cmake -echo ' )' >> Files.cmake -echo 'ENDIF ()' >> Files.cmake - -rm -f srcs.tmp c_headers.tmp cpp_headers.tmp +rm -f cpp_headers.tmp diff --git a/makedist.sh b/makedist.sh index 71ac63e55..9abf598ff 100755 --- a/makedist.sh +++ b/makedist.sh @@ -1,8 +1,8 @@ #!/bin/sh -ver=`cat include/msgpack/version_master.h | tr -d "\n" | sed -e 's/#define MSGPACK_VERSION_MAJOR[[:space:]]*\([[:alnum:]]*\)/\1./g' -e 's/#define MSGPACK_VERSION_MINOR[[:space:]]*\([[:alnum:]]*\)/\1./g' -e 's/#define MSGPACK_VERSION_REVISION[[:space:]]*\([[:alnum:]]*\)/\1/g'` +ver=`cat include/msgpack/version_master.hpp | tr -d "\n" | sed -e 's/#define MSGPACK_VERSION_MAJOR[[:space:]]*\([[:alnum:]]*\)/\1./g' -e 's/#define MSGPACK_VERSION_MINOR[[:space:]]*\([[:alnum:]]*\)/\1./g' -e 's/#define MSGPACK_VERSION_REVISION[[:space:]]*\([[:alnum:]]*\)/\1/g'` -prefix=msgpack-$ver +prefix=msgpack-cxx-$ver filename=$prefix.tar ln -s . $prefix @@ -18,14 +18,13 @@ tar cf $filename $prefix/example tar --append --file=$filename $prefix/test tar --append --file=$filename $prefix/include tar --append --file=$filename $prefix/erb -tar --append --file=$filename $prefix/src tar --append --file=$filename $prefix/fuzz +tar --append --file=$filename $prefix/cmake tar --append --file=$filename $prefix/CMakeLists.txt tar --append --file=$filename $prefix/Files.cmake tar --append --file=$filename $prefix/NOTICE tar --append --file=$filename $prefix/Doxyfile -tar --append --file=$filename $prefix/msgpack.pc.in tar --append --file=$filename $prefix/AUTHORS tar --append --file=$filename $prefix/README.md tar --append --file=$filename $prefix/LICENSE_1_0.txt @@ -33,10 +32,7 @@ tar --append --file=$filename $prefix/ChangeLog tar --append --file=$filename $prefix/NEWS tar --append --file=$filename $prefix/COPYING tar --append --file=$filename $prefix/README -tar --append --file=$filename $prefix/msgpack_vc8.sln -tar --append --file=$filename $prefix/msgpack_vc8.vcproj -tar --append --file=$filename $prefix/msgpack-config.cmake.in - +tar --append --file=$filename $prefix/msgpack-cxx-config.cmake.in rm -f $prefix gzip -f $filename diff --git a/msgpack-config.cmake.in b/msgpack-config.cmake.in deleted file mode 100644 index 9e5b3406f..000000000 --- a/msgpack-config.cmake.in +++ /dev/null @@ -1,24 +0,0 @@ -#.rst: -# msgpack -# ------- -# -# The following import targets are created -# -# :: -# -# Msgpack::msgpackc-static -# Msgpack::msgpackc -# Msgpack::msgpackc-cxx -# - -@PACKAGE_INIT@ - -include(CMakeFindDependencyMacro) - -if(NOT TARGET Msgpack::msgpackc AND NOT TARGET Msgpack::msgpackc-static) - include("${CMAKE_CURRENT_LIST_DIR}/msgpack-targets.cmake") - - if(NOT @MSGPACK_ENABLE_SHARED@) - add_library(Msgpack::msgpackc ALIAS Msgpack::msgpackc-static) - endif() -endif() diff --git a/msgpack-cxx-config.cmake.in b/msgpack-cxx-config.cmake.in new file mode 100644 index 000000000..74738c896 --- /dev/null +++ b/msgpack-cxx-config.cmake.in @@ -0,0 +1,11 @@ +@PACKAGE_INIT@ + +include(CMakeFindDependencyMacro) + +IF (@MSGPACK_USE_BOOST@) + find_dependency(Boost REQUIRED) +ENDIF () + +include("${CMAKE_CURRENT_LIST_DIR}/msgpack-cxx-targets.cmake") + +check_required_components(msgpack-cxx) diff --git a/msgpack.pc.in b/msgpack.pc.in deleted file mode 100644 index 4c75d5729..000000000 --- a/msgpack.pc.in +++ /dev/null @@ -1,10 +0,0 @@ -prefix=@prefix@ -exec_prefix=@exec_prefix@ -libdir=@libdir@ -includedir=@includedir@ - -Name: MessagePack -Description: Binary-based efficient object serialization library -Version: @VERSION@ -Libs: -L${libdir} -lmsgpackc -Cflags: -I${includedir} diff --git a/msgpack_vc8.sln b/msgpack_vc8.sln deleted file mode 100644 index 84718afa5..000000000 --- a/msgpack_vc8.sln +++ /dev/null @@ -1,20 +0,0 @@ - -Microsoft Visual Studio Solution File, Format Version 9.00 -# Visual C++ Express 2008 -Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "MessagePack", "msgpack_vc8.vcproj", "{122A2EA4-B283-4241-9655-786DE78283B2}" -EndProject -Global - GlobalSection(SolutionConfigurationPlatforms) = preSolution - Debug|Win32 = Debug|Win32 - Release|Win32 = Release|Win32 - EndGlobalSection - GlobalSection(ProjectConfigurationPlatforms) = postSolution - {122A2EA4-B283-4241-9655-786DE78283B2}.Debug|Win32.ActiveCfg = Debug|Win32 - {122A2EA4-B283-4241-9655-786DE78283B2}.Debug|Win32.Build.0 = Debug|Win32 - {122A2EA4-B283-4241-9655-786DE78283B2}.Release|Win32.ActiveCfg = Release|Win32 - {122A2EA4-B283-4241-9655-786DE78283B2}.Release|Win32.Build.0 = Release|Win32 - EndGlobalSection - GlobalSection(SolutionProperties) = preSolution - HideSolutionNode = FALSE - EndGlobalSection -EndGlobal diff --git a/msgpack_vc8.vcproj b/msgpack_vc8.vcproj deleted file mode 100644 index abfe51762..000000000 --- a/msgpack_vc8.vcproj +++ /dev/null @@ -1,187 +0,0 @@ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - diff --git a/src/objectc.c b/src/objectc.c deleted file mode 100644 index 04baad1c1..000000000 --- a/src/objectc.c +++ /dev/null @@ -1,482 +0,0 @@ -/* - * MessagePack for C dynamic typing routine - * - * Copyright (C) 2008-2009 FURUHASHI Sadayuki - * - * 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) - */ -#if defined(_KERNEL_MODE) -# undef _NO_CRT_STDIO_INLINE -# define _NO_CRT_STDIO_INLINE -#endif - -#include "msgpack/object.h" -#include "msgpack/pack.h" -#include - -#include -#include - -#if defined(_MSC_VER) -#if _MSC_VER >= 1800 -#include -#else -#define PRIu64 "I64u" -#define PRIi64 "I64i" -#define PRIi8 "i" -#endif -#else -#include -#endif - -#if defined(_KERNEL_MODE) -# undef snprintf -# define snprintf _snprintf -#endif - -int msgpack_pack_object(msgpack_packer* pk, msgpack_object d) -{ - switch(d.type) { - case MSGPACK_OBJECT_NIL: - return msgpack_pack_nil(pk); - - case MSGPACK_OBJECT_BOOLEAN: - if(d.via.boolean) { - return msgpack_pack_true(pk); - } else { - return msgpack_pack_false(pk); - } - - case MSGPACK_OBJECT_POSITIVE_INTEGER: - return msgpack_pack_uint64(pk, d.via.u64); - - case MSGPACK_OBJECT_NEGATIVE_INTEGER: - return msgpack_pack_int64(pk, d.via.i64); - - case MSGPACK_OBJECT_FLOAT32: - return msgpack_pack_float(pk, (float)d.via.f64); - - case MSGPACK_OBJECT_FLOAT64: - return msgpack_pack_double(pk, d.via.f64); - - case MSGPACK_OBJECT_STR: - { - int ret = msgpack_pack_str(pk, d.via.str.size); - if(ret < 0) { return ret; } - return msgpack_pack_str_body(pk, d.via.str.ptr, d.via.str.size); - } - - case MSGPACK_OBJECT_BIN: - { - int ret = msgpack_pack_bin(pk, d.via.bin.size); - if(ret < 0) { return ret; } - return msgpack_pack_bin_body(pk, d.via.bin.ptr, d.via.bin.size); - } - - case MSGPACK_OBJECT_EXT: - { - int ret = msgpack_pack_ext(pk, d.via.ext.size, d.via.ext.type); - if(ret < 0) { return ret; } - return msgpack_pack_ext_body(pk, d.via.ext.ptr, d.via.ext.size); - } - - case MSGPACK_OBJECT_ARRAY: - { - int ret = msgpack_pack_array(pk, d.via.array.size); - if(ret < 0) { - return ret; - } - else { - msgpack_object* o = d.via.array.ptr; - msgpack_object* const oend = d.via.array.ptr + d.via.array.size; - for(; o != oend; ++o) { - ret = msgpack_pack_object(pk, *o); - if(ret < 0) { return ret; } - } - - return 0; - } - } - - case MSGPACK_OBJECT_MAP: - { - int ret = msgpack_pack_map(pk, d.via.map.size); - if(ret < 0) { - return ret; - } - else { - msgpack_object_kv* kv = d.via.map.ptr; - msgpack_object_kv* const kvend = d.via.map.ptr + d.via.map.size; - for(; kv != kvend; ++kv) { - ret = msgpack_pack_object(pk, kv->key); - if(ret < 0) { return ret; } - ret = msgpack_pack_object(pk, kv->val); - if(ret < 0) { return ret; } - } - - return 0; - } - } - - default: - return -1; - } -} - -#if !defined(_KERNEL_MODE) - -static void msgpack_object_bin_print(FILE* out, const char *ptr, size_t size) -{ - size_t i; - for (i = 0; i < size; ++i) { - if (ptr[i] == '"') { - fputs("\\\"", out); - } else if (isprint((unsigned char)ptr[i])) { - fputc(ptr[i], out); - } else { - fprintf(out, "\\x%02x", (unsigned char)ptr[i]); - } - } -} - -void msgpack_object_print(FILE* out, msgpack_object o) -{ - switch(o.type) { - case MSGPACK_OBJECT_NIL: - fprintf(out, "nil"); - break; - - case MSGPACK_OBJECT_BOOLEAN: - fprintf(out, (o.via.boolean ? "true" : "false")); - break; - - case MSGPACK_OBJECT_POSITIVE_INTEGER: -#if defined(PRIu64) - fprintf(out, "%" PRIu64, o.via.u64); -#else - if (o.via.u64 > ULONG_MAX) - fprintf(out, "over 4294967295"); - else - fprintf(out, "%lu", (unsigned long)o.via.u64); -#endif - break; - - case MSGPACK_OBJECT_NEGATIVE_INTEGER: -#if defined(PRIi64) - fprintf(out, "%" PRIi64, o.via.i64); -#else - if (o.via.i64 > LONG_MAX) - fprintf(out, "over +2147483647"); - else if (o.via.i64 < LONG_MIN) - fprintf(out, "under -2147483648"); - else - fprintf(out, "%ld", (signed long)o.via.i64); -#endif - break; - - case MSGPACK_OBJECT_FLOAT32: - case MSGPACK_OBJECT_FLOAT64: - fprintf(out, "%f", o.via.f64); - break; - - case MSGPACK_OBJECT_STR: - fprintf(out, "\""); - fwrite(o.via.str.ptr, o.via.str.size, 1, out); - fprintf(out, "\""); - break; - - case MSGPACK_OBJECT_BIN: - fprintf(out, "\""); - msgpack_object_bin_print(out, o.via.bin.ptr, o.via.bin.size); - fprintf(out, "\""); - break; - - case MSGPACK_OBJECT_EXT: -#if defined(PRIi8) - fprintf(out, "(ext: %" PRIi8 ")", o.via.ext.type); -#else - fprintf(out, "(ext: %d)", (int)o.via.ext.type); -#endif - fprintf(out, "\""); - msgpack_object_bin_print(out, o.via.ext.ptr, o.via.ext.size); - fprintf(out, "\""); - break; - - case MSGPACK_OBJECT_ARRAY: - fprintf(out, "["); - if(o.via.array.size != 0) { - msgpack_object* p = o.via.array.ptr; - msgpack_object* const pend = o.via.array.ptr + o.via.array.size; - msgpack_object_print(out, *p); - ++p; - for(; p < pend; ++p) { - fprintf(out, ", "); - msgpack_object_print(out, *p); - } - } - fprintf(out, "]"); - break; - - case MSGPACK_OBJECT_MAP: - fprintf(out, "{"); - if(o.via.map.size != 0) { - msgpack_object_kv* p = o.via.map.ptr; - msgpack_object_kv* const pend = o.via.map.ptr + o.via.map.size; - msgpack_object_print(out, p->key); - fprintf(out, "=>"); - msgpack_object_print(out, p->val); - ++p; - for(; p < pend; ++p) { - fprintf(out, ", "); - msgpack_object_print(out, p->key); - fprintf(out, "=>"); - msgpack_object_print(out, p->val); - } - } - fprintf(out, "}"); - break; - - default: - // FIXME -#if defined(PRIu64) - fprintf(out, "#", o.type, o.via.u64); -#else - if (o.via.u64 > ULONG_MAX) - fprintf(out, "#", o.type); - else - fprintf(out, "#", o.type, (unsigned long)o.via.u64); -#endif - - } -} - -#endif - -#define MSGPACK_CHECKED_CALL(ret, func, aux_buffer, aux_buffer_size, ...) \ - ret = func(aux_buffer, aux_buffer_size, __VA_ARGS__); \ - if (ret <= 0 || ret > (int)aux_buffer_size) return 0; \ - aux_buffer = aux_buffer + ret; \ - aux_buffer_size = aux_buffer_size - ret \ - -static int msgpack_object_bin_print_buffer(char *buffer, size_t buffer_size, const char *ptr, size_t size) -{ - size_t i; - char *aux_buffer = buffer; - size_t aux_buffer_size = buffer_size; - int ret; - - for (i = 0; i < size; ++i) { - if (ptr[i] == '"') { - MSGPACK_CHECKED_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "\\\""); - } else if (isprint((unsigned char)ptr[i])) { - if (aux_buffer_size > 0) { - memcpy(aux_buffer, ptr + i, 1); - aux_buffer = aux_buffer + 1; - aux_buffer_size = aux_buffer_size - 1; - } - } else { - MSGPACK_CHECKED_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "\\x%02x", (unsigned char)ptr[i]); - } - } - - return (int)(buffer_size - aux_buffer_size); -} - -int msgpack_object_print_buffer(char *buffer, size_t buffer_size, msgpack_object o) -{ - char *aux_buffer = buffer; - size_t aux_buffer_size = buffer_size; - int ret; - switch(o.type) { - case MSGPACK_OBJECT_NIL: - MSGPACK_CHECKED_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "nil"); - break; - - case MSGPACK_OBJECT_BOOLEAN: - MSGPACK_CHECKED_CALL(ret, snprintf, aux_buffer, aux_buffer_size, (o.via.boolean ? "true" : "false")); - break; - - case MSGPACK_OBJECT_POSITIVE_INTEGER: -#if defined(PRIu64) - MSGPACK_CHECKED_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "%" PRIu64, o.via.u64); -#else - if (o.via.u64 > ULONG_MAX) { - MSGPACK_CHECKED_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "over 4294967295"); - } else { - MSGPACK_CHECKED_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "%lu", (unsigned long)o.via.u64); - } -#endif - break; - - case MSGPACK_OBJECT_NEGATIVE_INTEGER: -#if defined(PRIi64) - MSGPACK_CHECKED_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "%" PRIi64, o.via.i64); -#else - if (o.via.i64 > LONG_MAX) { - MSGPACK_CHECKED_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "over +2147483647"); - } else if (o.via.i64 < LONG_MIN) { - MSGPACK_CHECKED_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "under -2147483648"); - } else { - MSGPACK_CHECKED_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "%ld", (signed long)o.via.i64); - } -#endif - break; - - case MSGPACK_OBJECT_FLOAT32: - case MSGPACK_OBJECT_FLOAT64: - MSGPACK_CHECKED_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "%f", o.via.f64); - break; - - case MSGPACK_OBJECT_STR: - MSGPACK_CHECKED_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "\""); - MSGPACK_CHECKED_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "%.*s", (int)o.via.str.size, o.via.str.ptr); - MSGPACK_CHECKED_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "\""); - break; - - case MSGPACK_OBJECT_BIN: - MSGPACK_CHECKED_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "\""); - MSGPACK_CHECKED_CALL(ret, msgpack_object_bin_print_buffer, aux_buffer, aux_buffer_size, o.via.bin.ptr, o.via.bin.size); - MSGPACK_CHECKED_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "\""); - break; - - case MSGPACK_OBJECT_EXT: -#if defined(PRIi8) - MSGPACK_CHECKED_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "(ext: %" PRIi8 ")", o.via.ext.type); -#else - MSGPACK_CHECKED_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "(ext: %d)", (int)o.via.ext.type); -#endif - MSGPACK_CHECKED_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "\""); - MSGPACK_CHECKED_CALL(ret, msgpack_object_bin_print_buffer, aux_buffer, aux_buffer_size, o.via.ext.ptr, o.via.ext.size); - MSGPACK_CHECKED_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "\""); - break; - - case MSGPACK_OBJECT_ARRAY: - MSGPACK_CHECKED_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "["); - if(o.via.array.size != 0) { - msgpack_object* p = o.via.array.ptr; - msgpack_object* const pend = o.via.array.ptr + o.via.array.size; - MSGPACK_CHECKED_CALL(ret, msgpack_object_print_buffer, aux_buffer, aux_buffer_size, *p); - ++p; - for(; p < pend; ++p) { - MSGPACK_CHECKED_CALL(ret, snprintf, aux_buffer, aux_buffer_size, ", "); - MSGPACK_CHECKED_CALL(ret, msgpack_object_print_buffer, aux_buffer, aux_buffer_size, *p); - } - } - MSGPACK_CHECKED_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "]"); - break; - - case MSGPACK_OBJECT_MAP: - MSGPACK_CHECKED_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "{"); - if(o.via.map.size != 0) { - msgpack_object_kv* p = o.via.map.ptr; - msgpack_object_kv* const pend = o.via.map.ptr + o.via.map.size; - MSGPACK_CHECKED_CALL(ret, msgpack_object_print_buffer, aux_buffer, aux_buffer_size, p->key); - MSGPACK_CHECKED_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "=>"); - MSGPACK_CHECKED_CALL(ret, msgpack_object_print_buffer, aux_buffer, aux_buffer_size, p->val); - ++p; - for(; p < pend; ++p) { - MSGPACK_CHECKED_CALL(ret, snprintf, aux_buffer, aux_buffer_size, ", "); - MSGPACK_CHECKED_CALL(ret, msgpack_object_print_buffer, aux_buffer, aux_buffer_size, p->key); - MSGPACK_CHECKED_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "=>"); - MSGPACK_CHECKED_CALL(ret, msgpack_object_print_buffer, aux_buffer, aux_buffer_size, p->val); - } - } - MSGPACK_CHECKED_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "}"); - break; - - default: - // FIXME -#if defined(PRIu64) - MSGPACK_CHECKED_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "#", o.type, o.via.u64); -#else - if (o.via.u64 > ULONG_MAX) { - MSGPACK_CHECKED_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "#", o.type); - } else { - MSGPACK_CHECKED_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "#", o.type, (unsigned long)o.via.u64); - } -#endif - } - - return (int)(buffer_size - aux_buffer_size); -} - -#undef MSGPACK_CHECKED_CALL - -bool msgpack_object_equal(const msgpack_object x, const msgpack_object y) -{ - if(x.type != y.type) { return false; } - - switch(x.type) { - case MSGPACK_OBJECT_NIL: - return true; - - case MSGPACK_OBJECT_BOOLEAN: - return x.via.boolean == y.via.boolean; - - case MSGPACK_OBJECT_POSITIVE_INTEGER: - return x.via.u64 == y.via.u64; - - case MSGPACK_OBJECT_NEGATIVE_INTEGER: - return x.via.i64 == y.via.i64; - - case MSGPACK_OBJECT_FLOAT32: - case MSGPACK_OBJECT_FLOAT64: - return x.via.f64 == y.via.f64; - - case MSGPACK_OBJECT_STR: - return x.via.str.size == y.via.str.size && - memcmp(x.via.str.ptr, y.via.str.ptr, x.via.str.size) == 0; - - case MSGPACK_OBJECT_BIN: - return x.via.bin.size == y.via.bin.size && - memcmp(x.via.bin.ptr, y.via.bin.ptr, x.via.bin.size) == 0; - - case MSGPACK_OBJECT_EXT: - return x.via.ext.size == y.via.ext.size && - x.via.ext.type == y.via.ext.type && - memcmp(x.via.ext.ptr, y.via.ext.ptr, x.via.ext.size) == 0; - - case MSGPACK_OBJECT_ARRAY: - if(x.via.array.size != y.via.array.size) { - return false; - } else if(x.via.array.size == 0) { - return true; - } else { - msgpack_object* px = x.via.array.ptr; - msgpack_object* const pxend = x.via.array.ptr + x.via.array.size; - msgpack_object* py = y.via.array.ptr; - do { - if(!msgpack_object_equal(*px, *py)) { - return false; - } - ++px; - ++py; - } while(px < pxend); - return true; - } - - case MSGPACK_OBJECT_MAP: - if(x.via.map.size != y.via.map.size) { - return false; - } else if(x.via.map.size == 0) { - return true; - } else { - msgpack_object_kv* px = x.via.map.ptr; - msgpack_object_kv* const pxend = x.via.map.ptr + x.via.map.size; - msgpack_object_kv* py = y.via.map.ptr; - do { - if(!msgpack_object_equal(px->key, py->key) || !msgpack_object_equal(px->val, py->val)) { - return false; - } - ++px; - ++py; - } while(px < pxend); - return true; - } - - default: - return false; - } -} diff --git a/src/unpack.c b/src/unpack.c deleted file mode 100644 index 9341cb08a..000000000 --- a/src/unpack.c +++ /dev/null @@ -1,702 +0,0 @@ -/* - * MessagePack for C unpacking routine - * - * Copyright (C) 2008-2009 FURUHASHI Sadayuki - * - * 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/unpack.h" -#include "msgpack/unpack_define.h" -#include "msgpack/util.h" -#include - -#ifdef _msgpack_atomic_counter_header -#include _msgpack_atomic_counter_header -#endif - - -typedef struct { - msgpack_zone** z; - bool referenced; -} unpack_user; - - -#define msgpack_unpack_struct(name) \ - struct template ## name - -#define msgpack_unpack_func(ret, name) \ - ret template ## name - -#define msgpack_unpack_callback(name) \ - template_callback ## name - -#define msgpack_unpack_object msgpack_object - -#define msgpack_unpack_user unpack_user - - -struct template_context; -typedef struct template_context template_context; - -static void template_init(template_context* ctx); - -static msgpack_object template_data(template_context* ctx); - -static int template_execute( - template_context* ctx, const char* data, size_t len, size_t* off); - - -static inline msgpack_object template_callback_root(unpack_user* u) -{ - msgpack_object o; - MSGPACK_UNUSED(u); - o.type = MSGPACK_OBJECT_NIL; - return o; -} - -static inline int template_callback_uint8(unpack_user* u, uint8_t d, msgpack_object* o) -{ - MSGPACK_UNUSED(u); - o->type = MSGPACK_OBJECT_POSITIVE_INTEGER; - o->via.u64 = d; - return 0; -} - -static inline int template_callback_uint16(unpack_user* u, uint16_t d, msgpack_object* o) -{ - MSGPACK_UNUSED(u); - o->type = MSGPACK_OBJECT_POSITIVE_INTEGER; - o->via.u64 = d; - return 0; -} - -static inline int template_callback_uint32(unpack_user* u, uint32_t d, msgpack_object* o) -{ - MSGPACK_UNUSED(u); - o->type = MSGPACK_OBJECT_POSITIVE_INTEGER; - o->via.u64 = d; - return 0; -} - -static inline int template_callback_uint64(unpack_user* u, uint64_t d, msgpack_object* o) -{ - MSGPACK_UNUSED(u); - o->type = MSGPACK_OBJECT_POSITIVE_INTEGER; - o->via.u64 = d; - return 0; -} - -static inline int template_callback_int8(unpack_user* u, int8_t d, msgpack_object* o) -{ - MSGPACK_UNUSED(u); - if(d >= 0) { - o->type = MSGPACK_OBJECT_POSITIVE_INTEGER; - o->via.u64 = (uint64_t)d; - return 0; - } - else { - o->type = MSGPACK_OBJECT_NEGATIVE_INTEGER; - o->via.i64 = d; - return 0; - } -} - -static inline int template_callback_int16(unpack_user* u, int16_t d, msgpack_object* o) -{ - MSGPACK_UNUSED(u); - if(d >= 0) { - o->type = MSGPACK_OBJECT_POSITIVE_INTEGER; - o->via.u64 = (uint64_t)d; - return 0; - } - else { - o->type = MSGPACK_OBJECT_NEGATIVE_INTEGER; - o->via.i64 = d; - return 0; - } -} - -static inline int template_callback_int32(unpack_user* u, int32_t d, msgpack_object* o) -{ - MSGPACK_UNUSED(u); - if(d >= 0) { - o->type = MSGPACK_OBJECT_POSITIVE_INTEGER; - o->via.u64 = (uint64_t)d; - return 0; - } - else { - o->type = MSGPACK_OBJECT_NEGATIVE_INTEGER; - o->via.i64 = d; - return 0; - } -} - -static inline int template_callback_int64(unpack_user* u, int64_t d, msgpack_object* o) -{ - MSGPACK_UNUSED(u); - if(d >= 0) { - o->type = MSGPACK_OBJECT_POSITIVE_INTEGER; - o->via.u64 = (uint64_t)d; - return 0; - } - else { - o->type = MSGPACK_OBJECT_NEGATIVE_INTEGER; - o->via.i64 = d; - return 0; - } -} - -static inline int template_callback_float(unpack_user* u, float d, msgpack_object* o) -{ - MSGPACK_UNUSED(u); - o->type = MSGPACK_OBJECT_FLOAT32; - o->via.f64 = d; - return 0; -} - -static inline int template_callback_double(unpack_user* u, double d, msgpack_object* o) -{ - MSGPACK_UNUSED(u); - o->type = MSGPACK_OBJECT_FLOAT64; - o->via.f64 = d; - return 0; -} - -static inline int template_callback_nil(unpack_user* u, msgpack_object* o) -{ - MSGPACK_UNUSED(u); - o->type = MSGPACK_OBJECT_NIL; - return 0; -} - -static inline int template_callback_true(unpack_user* u, msgpack_object* o) -{ - MSGPACK_UNUSED(u); - o->type = MSGPACK_OBJECT_BOOLEAN; - o->via.boolean = true; - return 0; -} - -static inline int template_callback_false(unpack_user* u, msgpack_object* o) -{ - MSGPACK_UNUSED(u); - o->type = MSGPACK_OBJECT_BOOLEAN; - o->via.boolean = false; - return 0; -} - -static inline int template_callback_array(unpack_user* u, unsigned int n, msgpack_object* o) -{ - size_t size; - // Let's leverage the fact that sizeof(msgpack_object) is a compile time constant - // to check for int overflows. - // Note - while n is constrained to 32-bit, the product of n * sizeof(msgpack_object) - // might not be constrained to 4GB on 64-bit systems -#if SIZE_MAX == UINT_MAX - if (n > SIZE_MAX/sizeof(msgpack_object)) - return MSGPACK_UNPACK_NOMEM_ERROR; -#endif - - o->type = MSGPACK_OBJECT_ARRAY; - o->via.array.size = 0; - - size = n * sizeof(msgpack_object); - - if (*u->z == NULL) { - *u->z = msgpack_zone_new(MSGPACK_ZONE_CHUNK_SIZE); - if(*u->z == NULL) { - return MSGPACK_UNPACK_NOMEM_ERROR; - } - } - - // Unsure whether size = 0 should be an error, and if so, what to return - o->via.array.ptr = (msgpack_object*)msgpack_zone_malloc(*u->z, size); - if(o->via.array.ptr == NULL) { return MSGPACK_UNPACK_NOMEM_ERROR; } - return 0; -} - -static inline int template_callback_array_item(unpack_user* u, msgpack_object* c, msgpack_object o) -{ - MSGPACK_UNUSED(u); -#if defined(__GNUC__) && !defined(__clang__) - memcpy(&c->via.array.ptr[c->via.array.size], &o, sizeof(msgpack_object)); -#else /* __GNUC__ && !__clang__ */ - c->via.array.ptr[c->via.array.size] = o; -#endif /* __GNUC__ && !__clang__ */ - ++c->via.array.size; - return 0; -} - -static inline int template_callback_map(unpack_user* u, unsigned int n, msgpack_object* o) -{ - size_t size; - // Let's leverage the fact that sizeof(msgpack_object_kv) is a compile time constant - // to check for int overflows - // Note - while n is constrained to 32-bit, the product of n * sizeof(msgpack_object) - // might not be constrained to 4GB on 64-bit systems - - // Note - this will always be false on 64-bit systems -#if SIZE_MAX == UINT_MAX - if (n > SIZE_MAX/sizeof(msgpack_object_kv)) - return MSGPACK_UNPACK_NOMEM_ERROR; -#endif - - o->type = MSGPACK_OBJECT_MAP; - o->via.map.size = 0; - - size = n * sizeof(msgpack_object_kv); - - if (*u->z == NULL) { - *u->z = msgpack_zone_new(MSGPACK_ZONE_CHUNK_SIZE); - if(*u->z == NULL) { - return MSGPACK_UNPACK_NOMEM_ERROR; - } - } - - // Should size = 0 be an error? If so, what error to return? - o->via.map.ptr = (msgpack_object_kv*)msgpack_zone_malloc(*u->z, size); - if(o->via.map.ptr == NULL) { return MSGPACK_UNPACK_NOMEM_ERROR; } - return 0; -} - -static inline int template_callback_map_item(unpack_user* u, msgpack_object* c, msgpack_object k, msgpack_object v) -{ - MSGPACK_UNUSED(u); -#if defined(__GNUC__) && !defined(__clang__) - memcpy(&c->via.map.ptr[c->via.map.size].key, &k, sizeof(msgpack_object)); - memcpy(&c->via.map.ptr[c->via.map.size].val, &v, sizeof(msgpack_object)); -#else /* __GNUC__ && !__clang__ */ - c->via.map.ptr[c->via.map.size].key = k; - c->via.map.ptr[c->via.map.size].val = v; -#endif /* __GNUC__ && !__clang__ */ - ++c->via.map.size; - return 0; -} - -static inline int template_callback_str(unpack_user* u, const char* b, const char* p, unsigned int l, msgpack_object* o) -{ - MSGPACK_UNUSED(b); - if (*u->z == NULL) { - *u->z = msgpack_zone_new(MSGPACK_ZONE_CHUNK_SIZE); - if(*u->z == NULL) { - return MSGPACK_UNPACK_NOMEM_ERROR; - } - } - o->type = MSGPACK_OBJECT_STR; - o->via.str.ptr = p; - o->via.str.size = l; - u->referenced = true; - return 0; -} - -static inline int template_callback_bin(unpack_user* u, const char* b, const char* p, unsigned int l, msgpack_object* o) -{ - MSGPACK_UNUSED(b); - if (*u->z == NULL) { - *u->z = msgpack_zone_new(MSGPACK_ZONE_CHUNK_SIZE); - if(*u->z == NULL) { - return MSGPACK_UNPACK_NOMEM_ERROR; - } - } - o->type = MSGPACK_OBJECT_BIN; - o->via.bin.ptr = p; - o->via.bin.size = l; - u->referenced = true; - return 0; -} - -static inline int template_callback_ext(unpack_user* u, const char* b, const char* p, unsigned int l, msgpack_object* o) -{ - MSGPACK_UNUSED(b); - if (l == 0) { - return MSGPACK_UNPACK_PARSE_ERROR; - } - if (*u->z == NULL) { - *u->z = msgpack_zone_new(MSGPACK_ZONE_CHUNK_SIZE); - if(*u->z == NULL) { - return MSGPACK_UNPACK_NOMEM_ERROR; - } - } - o->type = MSGPACK_OBJECT_EXT; - o->via.ext.type = *p; - o->via.ext.ptr = p + 1; - o->via.ext.size = l - 1; - u->referenced = true; - return 0; -} - -#include "msgpack/unpack_template.h" - - -#define CTX_CAST(m) ((template_context*)(m)) -#define CTX_REFERENCED(mpac) CTX_CAST((mpac)->ctx)->user.referenced - -#define COUNTER_SIZE (sizeof(_msgpack_atomic_counter_t)) - - -static inline void init_count(void* buffer) -{ - *(volatile _msgpack_atomic_counter_t*)buffer = 1; -} - -static inline void decr_count(void* buffer) -{ - // atomic if(--*(_msgpack_atomic_counter_t*)buffer == 0) { free(buffer); } - if(_msgpack_sync_decr_and_fetch((volatile _msgpack_atomic_counter_t*)buffer) == 0) { - free(buffer); - } -} - -static inline void incr_count(void* buffer) -{ - // atomic ++*(_msgpack_atomic_counter_t*)buffer; - _msgpack_sync_incr_and_fetch((volatile _msgpack_atomic_counter_t*)buffer); -} - -static inline _msgpack_atomic_counter_t get_count(void* buffer) -{ - return *(volatile _msgpack_atomic_counter_t*)buffer; -} - -bool msgpack_unpacker_init(msgpack_unpacker* mpac, size_t initial_buffer_size) -{ - char* buffer; - void* ctx; - - if(initial_buffer_size < COUNTER_SIZE) { - initial_buffer_size = COUNTER_SIZE; - } - - buffer = (char*)malloc(initial_buffer_size); - if(buffer == NULL) { - return false; - } - - ctx = malloc(sizeof(template_context)); - if(ctx == NULL) { - free(buffer); - return false; - } - - mpac->buffer = buffer; - mpac->used = COUNTER_SIZE; - mpac->free = initial_buffer_size - mpac->used; - mpac->off = COUNTER_SIZE; - mpac->parsed = 0; - mpac->initial_buffer_size = initial_buffer_size; - mpac->z = NULL; - mpac->ctx = ctx; - - init_count(mpac->buffer); - - template_init(CTX_CAST(mpac->ctx)); - CTX_CAST(mpac->ctx)->user.z = &mpac->z; - CTX_CAST(mpac->ctx)->user.referenced = false; - - return true; -} - -void msgpack_unpacker_destroy(msgpack_unpacker* mpac) -{ - msgpack_zone_free(mpac->z); - free(mpac->ctx); - decr_count(mpac->buffer); -} - -msgpack_unpacker* msgpack_unpacker_new(size_t initial_buffer_size) -{ - msgpack_unpacker* mpac = (msgpack_unpacker*)malloc(sizeof(msgpack_unpacker)); - if(mpac == NULL) { - return NULL; - } - - if(!msgpack_unpacker_init(mpac, initial_buffer_size)) { - free(mpac); - return NULL; - } - - return mpac; -} - -void msgpack_unpacker_free(msgpack_unpacker* mpac) -{ - msgpack_unpacker_destroy(mpac); - free(mpac); -} - -bool msgpack_unpacker_expand_buffer(msgpack_unpacker* mpac, size_t size) -{ - if(mpac->used == mpac->off && get_count(mpac->buffer) == 1 - && !CTX_REFERENCED(mpac)) { - // rewind buffer - mpac->free += mpac->used - COUNTER_SIZE; - mpac->used = COUNTER_SIZE; - mpac->off = COUNTER_SIZE; - - if(mpac->free >= size) { - return true; - } - } - - if(mpac->off == COUNTER_SIZE) { - char* tmp; - size_t next_size = (mpac->used + mpac->free) * 2; // include COUNTER_SIZE - while(next_size < size + mpac->used) { - size_t tmp_next_size = next_size * 2; - if (tmp_next_size <= next_size) { - next_size = size + mpac->used; - break; - } - next_size = tmp_next_size; - } - - tmp = (char*)realloc(mpac->buffer, next_size); - if(tmp == NULL) { - return false; - } - - mpac->buffer = tmp; - mpac->free = next_size - mpac->used; - - } else { - char* tmp; - size_t next_size = mpac->initial_buffer_size; // include COUNTER_SIZE - size_t not_parsed = mpac->used - mpac->off; - while(next_size < size + not_parsed + COUNTER_SIZE) { - size_t tmp_next_size = next_size * 2; - if (tmp_next_size <= next_size) { - next_size = size + not_parsed + COUNTER_SIZE; - break; - } - next_size = tmp_next_size; - } - - tmp = (char*)malloc(next_size); - if(tmp == NULL) { - return false; - } - - init_count(tmp); - - memcpy(tmp+COUNTER_SIZE, mpac->buffer+mpac->off, not_parsed); - - if(CTX_REFERENCED(mpac)) { - if(!msgpack_zone_push_finalizer(mpac->z, decr_count, mpac->buffer)) { - free(tmp); - return false; - } - CTX_REFERENCED(mpac) = false; - } else { - decr_count(mpac->buffer); - } - - mpac->buffer = tmp; - mpac->used = not_parsed + COUNTER_SIZE; - mpac->free = next_size - mpac->used; - mpac->off = COUNTER_SIZE; - } - - return true; -} - -int msgpack_unpacker_execute(msgpack_unpacker* mpac) -{ - size_t off = mpac->off; - int ret = template_execute(CTX_CAST(mpac->ctx), - mpac->buffer, mpac->used, &mpac->off); - if(mpac->off > off) { - mpac->parsed += mpac->off - off; - } - return ret; -} - -msgpack_object msgpack_unpacker_data(msgpack_unpacker* mpac) -{ - return template_data(CTX_CAST(mpac->ctx)); -} - -msgpack_zone* msgpack_unpacker_release_zone(msgpack_unpacker* mpac) -{ - msgpack_zone* old = mpac->z; - - if (old == NULL) return NULL; - if(!msgpack_unpacker_flush_zone(mpac)) { - return NULL; - } - - mpac->z = NULL; - CTX_CAST(mpac->ctx)->user.z = &mpac->z; - - return old; -} - -void msgpack_unpacker_reset_zone(msgpack_unpacker* mpac) -{ - msgpack_zone_clear(mpac->z); -} - -bool msgpack_unpacker_flush_zone(msgpack_unpacker* mpac) -{ - if(CTX_REFERENCED(mpac)) { - if(!msgpack_zone_push_finalizer(mpac->z, decr_count, mpac->buffer)) { - return false; - } - CTX_REFERENCED(mpac) = false; - - incr_count(mpac->buffer); - } - - return true; -} - -void msgpack_unpacker_reset(msgpack_unpacker* mpac) -{ - template_init(CTX_CAST(mpac->ctx)); - // don't reset referenced flag - mpac->parsed = 0; -} - -static inline msgpack_unpack_return unpacker_next(msgpack_unpacker* mpac, - msgpack_unpacked* result) -{ - int ret; - - msgpack_unpacked_destroy(result); - - ret = msgpack_unpacker_execute(mpac); - - if(ret < 0) { - result->zone = NULL; - memset(&result->data, 0, sizeof(msgpack_object)); - return (msgpack_unpack_return)ret; - } - - if(ret == 0) { - return MSGPACK_UNPACK_CONTINUE; - } - result->zone = msgpack_unpacker_release_zone(mpac); - result->data = msgpack_unpacker_data(mpac); - - return MSGPACK_UNPACK_SUCCESS; -} - -msgpack_unpack_return msgpack_unpacker_next(msgpack_unpacker* mpac, - msgpack_unpacked* result) -{ - msgpack_unpack_return ret; - - ret = unpacker_next(mpac, result); - if (ret == MSGPACK_UNPACK_SUCCESS) { - msgpack_unpacker_reset(mpac); - } - - return ret; -} - -msgpack_unpack_return -msgpack_unpacker_next_with_size(msgpack_unpacker* mpac, - msgpack_unpacked* result, size_t *p_bytes) -{ - msgpack_unpack_return ret; - - ret = unpacker_next(mpac, result); - if (ret == MSGPACK_UNPACK_SUCCESS || ret == MSGPACK_UNPACK_CONTINUE) { - *p_bytes = mpac->parsed; - } - - if (ret == MSGPACK_UNPACK_SUCCESS) { - msgpack_unpacker_reset(mpac); - } - - return ret; -} - -msgpack_unpack_return -msgpack_unpack(const char* data, size_t len, size_t* off, - msgpack_zone* result_zone, msgpack_object* result) -{ - size_t noff = 0; - if(off != NULL) { noff = *off; } - - if(len <= noff) { - // FIXME - return MSGPACK_UNPACK_CONTINUE; - } - else { - int e; - template_context ctx; - template_init(&ctx); - - ctx.user.z = &result_zone; - ctx.user.referenced = false; - - e = template_execute(&ctx, data, len, &noff); - if(e < 0) { - return (msgpack_unpack_return)e; - } - - if(off != NULL) { *off = noff; } - - if(e == 0) { - return MSGPACK_UNPACK_CONTINUE; - } - - *result = template_data(&ctx); - - if(noff < len) { - return MSGPACK_UNPACK_EXTRA_BYTES; - } - - return MSGPACK_UNPACK_SUCCESS; - } -} - -msgpack_unpack_return -msgpack_unpack_next(msgpack_unpacked* result, - const char* data, size_t len, size_t* off) -{ - size_t noff = 0; - msgpack_unpacked_destroy(result); - - if(off != NULL) { noff = *off; } - - if(len <= noff) { - return MSGPACK_UNPACK_CONTINUE; - } - - { - int e; - template_context ctx; - template_init(&ctx); - - ctx.user.z = &result->zone; - ctx.user.referenced = false; - - e = template_execute(&ctx, data, len, &noff); - - if(off != NULL) { *off = noff; } - - if(e < 0) { - msgpack_zone_free(result->zone); - result->zone = NULL; - return (msgpack_unpack_return)e; - } - - if(e == 0) { - return MSGPACK_UNPACK_CONTINUE; - } - - result->data = template_data(&ctx); - - return MSGPACK_UNPACK_SUCCESS; - } -} - -#if defined(MSGPACK_OLD_COMPILER_BUS_ERROR_WORKAROUND) -// FIXME: Dirty hack to avoid a bus error caused by OS X's old gcc. -static void dummy_function_to_avoid_bus_error() -{ -} -#endif diff --git a/src/version.c b/src/version.c deleted file mode 100644 index 83f75108e..000000000 --- a/src/version.c +++ /dev/null @@ -1,22 +0,0 @@ -#include "msgpack.h" - -const char* msgpack_version(void) -{ - return MSGPACK_VERSION; -} - -int msgpack_version_major(void) -{ - return MSGPACK_VERSION_MAJOR; -} - -int msgpack_version_minor(void) -{ - return MSGPACK_VERSION_MINOR; -} - -int msgpack_version_revision(void) -{ - return MSGPACK_VERSION_REVISION; -} - diff --git a/src/vrefbuffer.c b/src/vrefbuffer.c deleted file mode 100644 index e03d832bf..000000000 --- a/src/vrefbuffer.c +++ /dev/null @@ -1,244 +0,0 @@ -/* - * MessagePack for C zero-copy buffer implementation - * - * Copyright (C) 2008-2009 FURUHASHI Sadayuki - * - * 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/vrefbuffer.h" -#include -#include - -#define MSGPACK_PACKER_MAX_BUFFER_SIZE 9 - -struct msgpack_vrefbuffer_chunk { - struct msgpack_vrefbuffer_chunk* next; - /* data ... */ -}; - -bool msgpack_vrefbuffer_init(msgpack_vrefbuffer* vbuf, - size_t ref_size, size_t chunk_size) -{ - size_t nfirst; - struct iovec* array; - msgpack_vrefbuffer_chunk* chunk; - - vbuf->chunk_size = chunk_size; - vbuf->ref_size = - ref_size > MSGPACK_PACKER_MAX_BUFFER_SIZE + 1 ? - ref_size : MSGPACK_PACKER_MAX_BUFFER_SIZE + 1 ; - - if((sizeof(msgpack_vrefbuffer_chunk) + chunk_size) < chunk_size) { - return false; - } - - nfirst = (sizeof(struct iovec) < 72/2) ? - 72 / sizeof(struct iovec) : 8; - - array = (struct iovec*)malloc( - sizeof(struct iovec) * nfirst); - if(array == NULL) { - return false; - } - - vbuf->tail = array; - vbuf->end = array + nfirst; - vbuf->array = array; - - chunk = (msgpack_vrefbuffer_chunk*)malloc( - sizeof(msgpack_vrefbuffer_chunk) + chunk_size); - if(chunk == NULL) { - free(array); - return false; - } - else { - msgpack_vrefbuffer_inner_buffer* const ib = &vbuf->inner_buffer; - - ib->free = chunk_size; - ib->ptr = ((char*)chunk) + sizeof(msgpack_vrefbuffer_chunk); - ib->head = chunk; - chunk->next = NULL; - - return true; - } -} - -void msgpack_vrefbuffer_destroy(msgpack_vrefbuffer* vbuf) -{ - msgpack_vrefbuffer_chunk* c = vbuf->inner_buffer.head; - while(true) { - msgpack_vrefbuffer_chunk* n = c->next; - free(c); - if(n != NULL) { - c = n; - } else { - break; - } - } - free(vbuf->array); -} - -void msgpack_vrefbuffer_clear(msgpack_vrefbuffer* vbuf) -{ - msgpack_vrefbuffer_chunk* c = vbuf->inner_buffer.head->next; - msgpack_vrefbuffer_chunk* n; - while(c != NULL) { - n = c->next; - free(c); - c = n; - } - - { - msgpack_vrefbuffer_inner_buffer* const ib = &vbuf->inner_buffer; - msgpack_vrefbuffer_chunk* chunk = ib->head; - chunk->next = NULL; - ib->free = vbuf->chunk_size; - ib->ptr = ((char*)chunk) + sizeof(msgpack_vrefbuffer_chunk); - - vbuf->tail = vbuf->array; - } -} - -int msgpack_vrefbuffer_append_ref(msgpack_vrefbuffer* vbuf, - const char* buf, size_t len) -{ - if(vbuf->tail == vbuf->end) { - const size_t nused = (size_t)(vbuf->tail - vbuf->array); - const size_t nnext = nused * 2; - - struct iovec* nvec = (struct iovec*)realloc( - vbuf->array, sizeof(struct iovec)*nnext); - if(nvec == NULL) { - return -1; - } - - vbuf->array = nvec; - vbuf->end = nvec + nnext; - vbuf->tail = nvec + nused; - } - - vbuf->tail->iov_base = (char*)buf; - vbuf->tail->iov_len = len; - ++vbuf->tail; - - return 0; -} - -int msgpack_vrefbuffer_append_copy(msgpack_vrefbuffer* vbuf, - const char* buf, size_t len) -{ - msgpack_vrefbuffer_inner_buffer* const ib = &vbuf->inner_buffer; - char* m; - - if(ib->free < len) { - msgpack_vrefbuffer_chunk* chunk; - size_t sz = vbuf->chunk_size; - if(sz < len) { - sz = len; - } - - if((sizeof(msgpack_vrefbuffer_chunk) + sz) < sz){ - return -1; - } - chunk = (msgpack_vrefbuffer_chunk*)malloc( - sizeof(msgpack_vrefbuffer_chunk) + sz); - if(chunk == NULL) { - return -1; - } - - chunk->next = ib->head; - ib->head = chunk; - ib->free = sz; - ib->ptr = ((char*)chunk) + sizeof(msgpack_vrefbuffer_chunk); - } - - m = ib->ptr; - memcpy(m, buf, len); - ib->free -= len; - ib->ptr += len; - - if(vbuf->tail != vbuf->array && m == - (const char*)((vbuf->tail-1)->iov_base) + (vbuf->tail-1)->iov_len) { - (vbuf->tail-1)->iov_len += len; - return 0; - } else { - return msgpack_vrefbuffer_append_ref(vbuf, m, len); - } -} - -int msgpack_vrefbuffer_migrate(msgpack_vrefbuffer* vbuf, msgpack_vrefbuffer* to) -{ - size_t sz = vbuf->chunk_size; - msgpack_vrefbuffer_chunk* empty; - - if((sizeof(msgpack_vrefbuffer_chunk) + sz) < sz){ - return -1; - } - - empty = (msgpack_vrefbuffer_chunk*)malloc( - sizeof(msgpack_vrefbuffer_chunk) + sz); - if(empty == NULL) { - return -1; - } - - empty->next = NULL; - - { - const size_t nused = (size_t)(vbuf->tail - vbuf->array); - if(to->tail + nused < vbuf->end) { - struct iovec* nvec; - const size_t tosize = (size_t)(to->tail - to->array); - const size_t reqsize = nused + tosize; - size_t nnext = (size_t)(to->end - to->array) * 2; - while(nnext < reqsize) { - size_t tmp_nnext = nnext * 2; - if (tmp_nnext <= nnext) { - nnext = reqsize; - break; - } - nnext = tmp_nnext; - } - - nvec = (struct iovec*)realloc( - to->array, sizeof(struct iovec)*nnext); - if(nvec == NULL) { - free(empty); - return -1; - } - - to->array = nvec; - to->end = nvec + nnext; - to->tail = nvec + tosize; - } - - memcpy(to->tail, vbuf->array, sizeof(struct iovec)*nused); - - to->tail += nused; - vbuf->tail = vbuf->array; - - { - msgpack_vrefbuffer_inner_buffer* const ib = &vbuf->inner_buffer; - msgpack_vrefbuffer_inner_buffer* const toib = &to->inner_buffer; - - msgpack_vrefbuffer_chunk* last = ib->head; - while(last->next != NULL) { - last = last->next; - } - last->next = toib->head; - toib->head = ib->head; - - if(toib->free < ib->free) { - toib->free = ib->free; - toib->ptr = ib->ptr; - } - - ib->head = empty; - ib->free = sz; - ib->ptr = ((char*)empty) + sizeof(msgpack_vrefbuffer_chunk); - } - } - - return 0; -} diff --git a/src/zone.c b/src/zone.c deleted file mode 100644 index 372a1f5b8..000000000 --- a/src/zone.c +++ /dev/null @@ -1,222 +0,0 @@ -/* - * MessagePack for C memory pool implementation - * - * Copyright (C) 2008-2009 FURUHASHI Sadayuki - * - * 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/zone.h" -#include -#include - -struct msgpack_zone_chunk { - struct msgpack_zone_chunk* next; - /* data ... */ -}; - -static inline bool init_chunk_list(msgpack_zone_chunk_list* cl, size_t chunk_size) -{ - msgpack_zone_chunk* chunk = (msgpack_zone_chunk*)malloc( - sizeof(msgpack_zone_chunk) + chunk_size); - if(chunk == NULL) { - return false; - } - - cl->head = chunk; - cl->free = chunk_size; - cl->ptr = ((char*)chunk) + sizeof(msgpack_zone_chunk); - chunk->next = NULL; - - return true; -} - -static inline void destroy_chunk_list(msgpack_zone_chunk_list* cl) -{ - msgpack_zone_chunk* c = cl->head; - while(true) { - msgpack_zone_chunk* n = c->next; - free(c); - if(n != NULL) { - c = n; - } else { - break; - } - } -} - -static inline void clear_chunk_list(msgpack_zone_chunk_list* cl, size_t chunk_size) -{ - msgpack_zone_chunk* c = cl->head; - while(true) { - msgpack_zone_chunk* n = c->next; - if(n != NULL) { - free(c); - c = n; - } else { - cl->head = c; - break; - } - } - cl->head->next = NULL; - cl->free = chunk_size; - cl->ptr = ((char*)cl->head) + sizeof(msgpack_zone_chunk); -} - -void* msgpack_zone_malloc_expand(msgpack_zone* zone, size_t size) -{ - msgpack_zone_chunk_list* const cl = &zone->chunk_list; - msgpack_zone_chunk* chunk; - - size_t sz = zone->chunk_size; - - while(sz < size) { - size_t tmp_sz = sz * 2; - if (tmp_sz <= sz) { - sz = size; - break; - } - sz = tmp_sz; - } - - chunk = (msgpack_zone_chunk*)malloc( - sizeof(msgpack_zone_chunk) + sz); - if (chunk == NULL) { - return NULL; - } - else { - char* ptr = ((char*)chunk) + sizeof(msgpack_zone_chunk); - chunk->next = cl->head; - cl->head = chunk; - cl->free = sz - size; - cl->ptr = ptr + size; - - return ptr; - } -} - - -static inline void init_finalizer_array(msgpack_zone_finalizer_array* fa) -{ - fa->tail = NULL; - fa->end = NULL; - fa->array = NULL; -} - -static inline void call_finalizer_array(msgpack_zone_finalizer_array* fa) -{ - msgpack_zone_finalizer* fin = fa->tail; - for(; fin != fa->array; --fin) { - (*(fin-1)->func)((fin-1)->data); - } -} - -static inline void destroy_finalizer_array(msgpack_zone_finalizer_array* fa) -{ - call_finalizer_array(fa); - free(fa->array); -} - -static inline void clear_finalizer_array(msgpack_zone_finalizer_array* fa) -{ - call_finalizer_array(fa); - fa->tail = fa->array; -} - -bool msgpack_zone_push_finalizer_expand(msgpack_zone* zone, - void (*func)(void* data), void* data) -{ - msgpack_zone_finalizer_array* const fa = &zone->finalizer_array; - msgpack_zone_finalizer* tmp; - - const size_t nused = (size_t)(fa->end - fa->array); - - size_t nnext; - if(nused == 0) { - nnext = (sizeof(msgpack_zone_finalizer) < 72/2) ? - 72 / sizeof(msgpack_zone_finalizer) : 8; - - } else { - nnext = nused * 2; - } - - tmp = (msgpack_zone_finalizer*)realloc(fa->array, - sizeof(msgpack_zone_finalizer) * nnext); - if(tmp == NULL) { - return false; - } - - fa->array = tmp; - fa->end = tmp + nnext; - fa->tail = tmp + nused; - - fa->tail->func = func; - fa->tail->data = data; - - ++fa->tail; - - return true; -} - - -bool msgpack_zone_is_empty(msgpack_zone* zone) -{ - msgpack_zone_chunk_list* const cl = &zone->chunk_list; - msgpack_zone_finalizer_array* const fa = &zone->finalizer_array; - return cl->free == zone->chunk_size && cl->head->next == NULL && - fa->tail == fa->array; -} - - -void msgpack_zone_destroy(msgpack_zone* zone) -{ - destroy_finalizer_array(&zone->finalizer_array); - destroy_chunk_list(&zone->chunk_list); -} - -void msgpack_zone_clear(msgpack_zone* zone) -{ - clear_finalizer_array(&zone->finalizer_array); - clear_chunk_list(&zone->chunk_list, zone->chunk_size); -} - -bool msgpack_zone_init(msgpack_zone* zone, size_t chunk_size) -{ - zone->chunk_size = chunk_size; - - if(!init_chunk_list(&zone->chunk_list, chunk_size)) { - return false; - } - - init_finalizer_array(&zone->finalizer_array); - - return true; -} - -msgpack_zone* msgpack_zone_new(size_t chunk_size) -{ - msgpack_zone* zone = (msgpack_zone*)malloc( - sizeof(msgpack_zone)); - if(zone == NULL) { - return NULL; - } - - zone->chunk_size = chunk_size; - - if(!init_chunk_list(&zone->chunk_list, chunk_size)) { - free(zone); - return NULL; - } - - init_finalizer_array(&zone->finalizer_array); - - return zone; -} - -void msgpack_zone_free(msgpack_zone* zone) -{ - if(zone == NULL) { return; } - msgpack_zone_destroy(zone); - free(zone); -} diff --git a/test-install/CMakeLists.txt b/test-install/CMakeLists.txt new file mode 100644 index 000000000..874198b61 --- /dev/null +++ b/test-install/CMakeLists.txt @@ -0,0 +1,10 @@ +cmake_minimum_required(VERSION 3.1 FATAL_ERROR) + +project(test-install LANGUAGES CXX) + +set(CMAKE_CXX_STANDARD_REQUIRED ON) + +find_package(msgpack-cxx REQUIRED) + +add_executable(test-install simple.cpp) +target_link_libraries(test-install PRIVATE msgpack-cxx) diff --git a/test-install/simple.cpp b/test-install/simple.cpp new file mode 100644 index 000000000..21b570183 --- /dev/null +++ b/test-install/simple.cpp @@ -0,0 +1,44 @@ +// MessagePack for C++ example +// +// Copyright (C) 2008-2015 FURUHASHI Sadayuki and KONDO Takatoshi +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +#include +#include +#include +#include + +int main(void) +{ + msgpack::type::tuple 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 dst; + deserialized.convert(dst); + + return 0; +} diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt index 2cbc2d6e8..b29c07a2c 100644 --- a/test/CMakeLists.txt +++ b/test/CMakeLists.txt @@ -1,25 +1,22 @@ -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) LIST (APPEND check_PROGRAMS array_ref.cpp + boost_fusion.cpp + boost_optional.cpp + boost_string_ref.cpp + boost_string_view.cpp buffer.cpp carray.cpp cases.cpp convert.cpp fixint.cpp - fixint_c.cpp inc_adaptor_define.cpp json.cpp limit.cpp msgpack_basic.cpp - msgpack_c.cpp msgpack_container.cpp msgpack_stream.cpp msgpack_tuple.cpp @@ -27,36 +24,25 @@ LIST (APPEND check_PROGRAMS object.cpp object_with_zone.cpp pack_unpack.cpp - pack_unpack_c.cpp raw.cpp reference.cpp size_equal_only.cpp streaming.cpp - streaming_c.cpp user_class.cpp version.cpp visitor.cpp zone.cpp ) -IF (MSGPACK_BOOST) - LIST (APPEND check_PROGRAMS - boost_fusion.cpp - boost_variant.cpp - boost_optional.cpp - boost_string_ref.cpp - boost_string_view.cpp - ) -ENDIF () - IF (MSGPACK_USE_X3_PARSE) LIST (APPEND check_PROGRAMS msgpack_x3_parse.cpp ) ENDIF () -IF (MSGPACK_CXX11) +IF (MSGPACK_CXX11 OR MSGPACK_CXX14 OR MSGPACK_CXX17 OR MSGPACK_CXX20) LIST (APPEND check_PROGRAMS + boost_variant.cpp iterator_cpp11.cpp msgpack_cpp11.cpp reference_cpp11.cpp @@ -69,37 +55,49 @@ IF (MSGPACK_CXX11) ) 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 ( ${source_file_we} ${source_file} ) + + TARGET_COMPILE_DEFINITIONS (${source_file_we} PRIVATE + $,,BOOST_TEST_DYN_LINK>) + TARGET_LINK_LIBRARIES (${source_file_we} - msgpackc - ${GTEST_BOTH_LIBRARIES} - ${ZLIB_LIBRARIES} - ${CMAKE_THREAD_LIBS_INIT} + msgpack-cxx + Boost::unit_test_framework + Threads::Threads + ZLIB::ZLIB ) - ADD_TEST (${source_file_we} ${source_file_we}) - IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang" OR "${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU") + + 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 () - IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang") + IF ("${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang") SET_PROPERTY (TARGET ${source_file_we} APPEND_STRING PROPERTY COMPILE_FLAGS " -Wno-mismatched-tags") ENDIF () IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC") - IF (CMAKE_CXX_FLAGS MATCHES "/W[0-4] /WX") - STRING(REGEX REPLACE "/W[0-4]" "/W3 /WX" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}") + 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") + SET (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /W3 /WX") ENDIF () ENDIF () ENDFOREACH () @@ -108,8 +106,9 @@ ADD_EXECUTABLE ( multi_file multi_file1.cpp multi_file2.cpp ) -TARGET_INCLUDE_DIRECTORIES (multi_file - PRIVATE - $ + +TARGET_LINK_LIBRARIES (multi_file + msgpack-cxx ) + ADD_TEST (multi_file multi_file) diff --git a/test/array_ref.cpp b/test/array_ref.cpp index b45356ac0..7660e6e33 100644 --- a/test/array_ref.cpp +++ b/test/array_ref.cpp @@ -3,18 +3,14 @@ #include #include -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wconversion" - -#include - -#pragma GCC diagnostic pop +#define BOOST_TEST_MODULE MSGPACK_ARRAY_REF +#include #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 v; v.push_back('a'); @@ -28,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 v2; msgpack::type::array_ref > 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 v; v.push_back('a'); @@ -51,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 v2; msgpack::type::array_ref > 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 v; v.push_back('a'); @@ -72,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 v2; msgpack::type::array_ref > 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 v; v.push_back('a'); @@ -95,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 v2; msgpack::type::array_ref > 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 v; v.push_back('a'); @@ -113,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 v2; msgpack::type::array_ref > 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 v; v.push_back('a'); @@ -133,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 v2; msgpack::type::array_ref > 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 v; v.push_back('a'); @@ -151,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 v2; msgpack::type::array_ref > 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 v; v.push_back('a'); @@ -171,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 v2; msgpack::type::array_ref > 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 v { { 'a', 'b', 'c' } }; @@ -191,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 v2; msgpack::type::array_ref > 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 v { { 'a', 'b', 'c' } }; @@ -211,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 v2; msgpack::type::array_ref > 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 v { { 'a', 'b', 'c' } }; @@ -229,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 v2; msgpack::type::array_ref > 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 v { { 'a', 'b', 'c' } }; @@ -249,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 v2; msgpack::type::array_ref > 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 v { { 'a', 'b', 'c' } }; @@ -264,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 v2; msgpack::type::array_ref > 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 v { { 'a', 'b', 'c' } }; @@ -281,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 v2; msgpack::type::array_ref > 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 v { { 'a', 'b', 'c' } }; @@ -296,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 v2; msgpack::type::array_ref > 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 v { { 'a', 'b', 'c' } }; @@ -313,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 v2; msgpack::type::array_ref > ar2(v2); obj.convert(ar2); - EXPECT_TRUE(ar1 == ar2); + BOOST_CHECK(ar1 == ar2); } #endif // !defined(MSGPACK_USE_CPP03) diff --git a/test/boost_fusion.cpp b/test/boost_fusion.cpp index 3b003515c..280e36dd8 100644 --- a/test/boost_fusion.cpp +++ b/test/boost_fusion.cpp @@ -3,18 +3,19 @@ #include #include -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wconversion" - -#include - -#pragma GCC diagnostic pop +#define BOOST_TEST_MODULE MSGPACK_BOOST +#include #ifdef HAVE_CONFIG_H #include "config.h" #endif -#if defined(MSGPACK_USE_BOOST) +#if defined(MSGPACK_NO_BOOST) + +BOOST_AUTO_TEST_CASE(empty) +{ +} +#else // defined(MSGPACK_NO_BOOST) #include #include @@ -28,7 +29,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; @@ -39,11 +40,11 @@ TEST(MSGPACK_BOOST, fusion_pack_unpack_convert) msgpack::object_handle oh = msgpack::unpack(str.data(), str.size()); mystruct val2 = oh.get().as(); - 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; @@ -51,8 +52,8 @@ TEST(MSGPACK_BOOST, object_with_zone_convert) msgpack::zone z; msgpack::object obj(val1, z); mystruct val2 = obj.as(); - 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) @@ -152,7 +153,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)); @@ -161,7 +162,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(); - EXPECT_TRUE(val1 == val2); + BOOST_CHECK(val1 == val2); } #endif // !defined(_MSC_VER) @@ -204,7 +205,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); @@ -213,7 +214,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(); - EXPECT_TRUE(val1 == val2); + BOOST_CHECK(val1 == val2); } #endif // !defined(_MSC_VER) @@ -222,7 +223,7 @@ TEST(MSGPACK_BOOST, pack_convert_no_def_con_def_con) #include -TEST(MSGPACK_BOOST, fusion_pack_unpack_convert_pair) +BOOST_AUTO_TEST_CASE(fusion_pack_unpack_convert_pair) { std::stringstream ss; std::pair val1(false, 42); @@ -231,15 +232,15 @@ TEST(MSGPACK_BOOST, fusion_pack_unpack_convert_pair) msgpack::object_handle oh = msgpack::unpack(str.data(), str.size()); std::pair val2 = oh.get().as >(); - 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 -TEST(MSGPACK_BOOST, fusion_pack_unpack_convert_tuple) +BOOST_AUTO_TEST_CASE(fusion_pack_unpack_convert_tuple) { std::stringstream ss; std::tuple val1(false, 42); @@ -248,9 +249,9 @@ TEST(MSGPACK_BOOST, fusion_pack_unpack_convert_tuple) msgpack::object_handle oh = msgpack::unpack(str.data(), str.size()); std::tuple val2 = oh.get().as >(); - EXPECT_TRUE(val1 == val2); + BOOST_CHECK(val1 == val2); } #endif // !defined(MSGPACK_USE_CPP03) -#endif // defined(MSGPACK_USE_BOOST) +#endif // defined(MSGPACK_NO_BOOST) diff --git a/test/boost_optional.cpp b/test/boost_optional.cpp index 9d5402523..4cf74a274 100644 --- a/test/boost_optional.cpp +++ b/test/boost_optional.cpp @@ -2,21 +2,21 @@ #include #include -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wconversion" - -#include - -#pragma GCC diagnostic pop - +#define BOOST_TEST_MODULE MSGPACK_BOOST +#include #ifdef HAVE_CONFIG_H #include "config.h" #endif -#if defined(MSGPACK_USE_BOOST) +#if defined(MSGPACK_NO_BOOST) + +BOOST_AUTO_TEST_CASE(empty) +{ +} +#else // defined(MSGPACK_NO_BOOST) -TEST(MSGPACK_BOOST, pack_convert_nil) +BOOST_AUTO_TEST_CASE(pack_convert_nil) { std::stringstream ss; boost::optional val1; @@ -25,10 +25,10 @@ TEST(MSGPACK_BOOST, pack_convert_nil) msgpack::object_handle oh = msgpack::unpack(str.data(), str.size()); boost::optional val2 = oh.get().as >(); - 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 val1 = 1; @@ -37,10 +37,10 @@ TEST(MSGPACK_BOOST, pack_convert_int) msgpack::object_handle oh = msgpack::unpack(str.data(), str.size()); boost::optional val2 = oh.get().as >(); - EXPECT_TRUE(val1 == val2); + BOOST_CHECK(val1 == val2); } -TEST(MSGPACK_BOOST, pack_convert_vector) +BOOST_AUTO_TEST_CASE(pack_convert_vector) { typedef boost::optional > ovi_t; std::stringstream ss; @@ -55,10 +55,10 @@ TEST(MSGPACK_BOOST, pack_convert_vector) msgpack::object_handle oh = msgpack::unpack(str.data(), str.size()); ovi_t val2 = oh.get().as(); - 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 > voi_t; std::stringstream ss; @@ -71,28 +71,28 @@ TEST(MSGPACK_BOOST, pack_convert_vector_optional) msgpack::object_handle oh = msgpack::unpack(str.data(), str.size()); voi_t val2 = oh.get().as(); - EXPECT_TRUE(val1 == val2); + BOOST_CHECK(val1 == val2); } -TEST(MSGPACK_BOOST, object_nil) +BOOST_AUTO_TEST_CASE(object_nil) { boost::optional val1; msgpack::object obj(val1); boost::optional val2 = obj.as >(); - EXPECT_TRUE(val1 == val2); + BOOST_CHECK(val1 == val2); } -TEST(MSGPACK_BOOST, object_int) +BOOST_AUTO_TEST_CASE(object_int) { boost::optional val1 = 1; msgpack::object obj(val1); boost::optional val2 = obj.as >(); - 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 > ovi_t; ovi_t val1; @@ -103,29 +103,29 @@ TEST(MSGPACK_BOOST, object_int) val1 = v; msgpack::object obj(val1); ovi_t val2 = obj.as(); - 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 val1; msgpack::object obj(val1, z); boost::optional val2 = obj.as >(); - 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 val1 = 1; msgpack::object obj(val1, z); boost::optional val2 = obj.as >(); - 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 > voi_t; msgpack::zone z; @@ -135,7 +135,7 @@ TEST(MSGPACK_BOOST, object_with_zone_vector_optional) val1[2] = 3; msgpack::object obj(val1, z); voi_t val2 = obj.as(); - EXPECT_TRUE(val1 == val2); + BOOST_CHECK(val1 == val2); } #if !defined(MSGPACK_USE_CPP03) @@ -170,7 +170,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 val1 = no_def_con(1); @@ -179,9 +179,9 @@ TEST(MSGPACK_BOOST, pack_convert_no_def_con) msgpack::object_handle oh = msgpack::unpack(str.data(), str.size()); boost::optional val2 = oh.get().as>(); - EXPECT_TRUE(val1 == val2); + BOOST_CHECK(val1 == val2); } #endif // !defined(MSGPACK_USE_CPP03 -#endif // defined(MSGPACK_USE_BOOST) +#endif // defined(MSGPACK_NO_BOOST) diff --git a/test/boost_string_ref.cpp b/test/boost_string_ref.cpp index b6968975a..90f6035f1 100644 --- a/test/boost_string_ref.cpp +++ b/test/boost_string_ref.cpp @@ -2,22 +2,23 @@ #include #include -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wconversion" - -#include - -#pragma GCC diagnostic pop - +#define BOOST_TEST_MODULE MSGPACK_BOOST +#include #ifdef HAVE_CONFIG_H #include "config.h" #endif -#if defined(MSGPACK_USE_BOOST) +#if defined(MSGPACK_NO_BOOST) + +BOOST_AUTO_TEST_CASE(empty) +{ +} +#else // defined(MSGPACK_NO_BOOST) + #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"; @@ -29,27 +30,28 @@ 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(); - 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(); - 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(); - EXPECT_TRUE(val1 == val2); + BOOST_CHECK(val1 == val2); } #endif // (BOOST_VERSION / 100000) >= 1 && ((BOOST_VERSION / 100) % 1000) >= 53 -#endif // defined(MSGPACK_USE_BOOST) + +#endif // defined(MSGPACK_NO_BOOST) diff --git a/test/boost_string_view.cpp b/test/boost_string_view.cpp index 97f55f1e1..0f01587da 100644 --- a/test/boost_string_view.cpp +++ b/test/boost_string_view.cpp @@ -2,21 +2,28 @@ #include #include -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wconversion" - -#include - -#pragma GCC diagnostic pop +#define BOOST_TEST_MODULE MSGPACK_BOOST +#include #ifdef HAVE_CONFIG_H #include "config.h" #endif -#if defined(MSGPACK_USE_BOOST) +#if defined(MSGPACK_NO_BOOST) + +BOOST_AUTO_TEST_CASE(empty) +{ +} +#else // defined(MSGPACK_NO_BOOST) + +// 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"; @@ -28,27 +35,28 @@ 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(); - 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(); - 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(); - EXPECT_TRUE(val1 == val2); + BOOST_CHECK(val1 == val2); } #endif // (BOOST_VERSION / 100000) >= 1 && ((BOOST_VERSION / 100) % 1000) >= 61 -#endif // defined(MSGPACK_USE_BOOST) + +#endif // defined(MSGPACK_NO_BOOST) diff --git a/test/boost_variant.cpp b/test/boost_variant.cpp index 3c8d0cf30..647fa4741 100644 --- a/test/boost_variant.cpp +++ b/test/boost_variant.cpp @@ -3,66 +3,67 @@ #include #include -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wconversion" - -#include - -#pragma GCC diagnostic pop +#define BOOST_TEST_MODULE MSGPACK_BOOST +#include #ifdef HAVE_CONFIG_H #include "config.h" #endif -#if defined(MSGPACK_USE_BOOST) +#if defined(MSGPACK_NO_BOOST) + +BOOST_AUTO_TEST_CASE(empty) +{ +} +#else // defined(MSGPACK_NO_BOOST) const double kEPS = 1e-10; // nil -TEST(MSGPACK_BOOST, pack_convert_variant_nil) +BOOST_AUTO_TEST_CASE(pack_convert_variant_nil) { std::stringstream ss; msgpack::type::variant val1 = msgpack::type::nil_t(); - EXPECT_TRUE(val1.is_nil()); + BOOST_CHECK(val1.is_nil()); msgpack::pack(ss, val1); std::string const& str = ss.str(); msgpack::object_handle oh = msgpack::unpack(str.data(), str.size()); msgpack::type::variant val2 = oh.get().as(); - EXPECT_TRUE(val2.is_nil()); - EXPECT_NO_THROW(boost::get(val2)); + BOOST_CHECK(val2.is_nil()); + BOOST_CHECK_NO_THROW(boost::get(val2)); } -TEST(MSGPACK_BOOST, object_variant_nil) +BOOST_AUTO_TEST_CASE(object_variant_nil) { msgpack::type::variant val1 = msgpack::type::nil_t(); - EXPECT_TRUE(val1.is_nil()); + BOOST_CHECK(val1.is_nil()); msgpack::object obj(val1); msgpack::type::variant val2 = obj.as(); - EXPECT_TRUE(val2.is_nil()); - EXPECT_NO_THROW(boost::get(val2)); + BOOST_CHECK(val2.is_nil()); + BOOST_CHECK_NO_THROW(boost::get(val2)); } -TEST(MSGPACK_BOOST, object_with_zone_variant_nil) +BOOST_AUTO_TEST_CASE(object_with_zone_variant_nil) { msgpack::zone z; msgpack::type::variant val1 = msgpack::type::nil_t(); - EXPECT_TRUE(val1.is_nil()); + BOOST_CHECK(val1.is_nil()); msgpack::object obj(val1, z); msgpack::type::variant val2 = obj.as(); - EXPECT_TRUE(val2.is_nil()); - EXPECT_NO_THROW(boost::get(val2)); + BOOST_CHECK(val2.is_nil()); + BOOST_CHECK_NO_THROW(boost::get(val2)); } // nil (default constructor) -TEST(MSGPACK_BOOST, pack_convert_variant_nil_default) +BOOST_AUTO_TEST_CASE(pack_convert_variant_nil_default) { std::stringstream ss; msgpack::type::variant val1; - EXPECT_TRUE(val1.is_nil()); + BOOST_CHECK(val1.is_nil()); msgpack::pack(ss, val1); @@ -70,39 +71,39 @@ TEST(MSGPACK_BOOST, pack_convert_variant_nil_default) msgpack::object_handle oh = msgpack::unpack(str.data(), str.size()); msgpack::type::variant val2 = oh.get().as(); - EXPECT_TRUE(val2.is_nil()); - EXPECT_NO_THROW(boost::get(val2)); + BOOST_CHECK(val2.is_nil()); + BOOST_CHECK_NO_THROW(boost::get(val2)); } -TEST(MSGPACK_BOOST, object_variant_nil_default) +BOOST_AUTO_TEST_CASE(object_variant_nil_default) { msgpack::type::variant val1; - EXPECT_TRUE(val1.is_nil()); + BOOST_CHECK(val1.is_nil()); msgpack::object obj(val1); msgpack::type::variant val2 = obj.as(); - EXPECT_TRUE(val2.is_nil()); - EXPECT_NO_THROW(boost::get(val2)); + BOOST_CHECK(val2.is_nil()); + BOOST_CHECK_NO_THROW(boost::get(val2)); } -TEST(MSGPACK_BOOST, object_with_zone_variant_nil_default) +BOOST_AUTO_TEST_CASE(object_with_zone_variant_nil_default) { msgpack::zone z; msgpack::type::variant val1; - EXPECT_TRUE(val1.is_nil()); + BOOST_CHECK(val1.is_nil()); msgpack::object obj(val1, z); msgpack::type::variant val2 = obj.as(); - EXPECT_TRUE(val2.is_nil()); - EXPECT_NO_THROW(boost::get(val2)); + BOOST_CHECK(val2.is_nil()); + BOOST_CHECK_NO_THROW(boost::get(val2)); } // bool -TEST(MSGPACK_BOOST, pack_convert_variant_bool) +BOOST_AUTO_TEST_CASE(pack_convert_variant_bool) { std::stringstream ss; msgpack::type::variant val1 = true; - EXPECT_TRUE(val1.is_bool()); - EXPECT_TRUE(val1.as_bool()); + BOOST_CHECK(val1.is_bool()); + BOOST_CHECK(val1.as_bool()); msgpack::pack(ss, val1); @@ -110,53 +111,53 @@ TEST(MSGPACK_BOOST, pack_convert_variant_bool) msgpack::object_handle oh = msgpack::unpack(str.data(), str.size()); msgpack::type::variant val2 = oh.get().as(); - EXPECT_TRUE(val2.is_bool()); - EXPECT_TRUE(val2.as_bool()); - EXPECT_NO_THROW(boost::get(val2)); - EXPECT_TRUE(val1 == val2); + BOOST_CHECK(val2.is_bool()); + BOOST_CHECK(val2.as_bool()); + BOOST_CHECK_NO_THROW(boost::get(val2)); + BOOST_CHECK(val1 == val2); // Tests for totally ordered - EXPECT_FALSE(val1 != val2); - EXPECT_FALSE(val1 < val2); - EXPECT_FALSE(val1 > val2); - EXPECT_TRUE(val1 <= val2); - EXPECT_TRUE(val1 >= val2); + BOOST_CHECK(!(val1 != val2)); + BOOST_CHECK(!(val1 < val2)); + BOOST_CHECK(!(val1 > val2)); + BOOST_CHECK(val1 <= val2); + BOOST_CHECK(val1 >= val2); } -TEST(MSGPACK_BOOST, object_variant_bool) +BOOST_AUTO_TEST_CASE(object_variant_bool) { msgpack::type::variant val1 = true; - EXPECT_TRUE(val1.is_bool()); - EXPECT_TRUE(val1.as_bool()); + BOOST_CHECK(val1.is_bool()); + BOOST_CHECK(val1.as_bool()); msgpack::object obj(val1); msgpack::type::variant val2 = obj.as(); - EXPECT_TRUE(val2.is_bool()); - EXPECT_TRUE(val2.as_bool()); - EXPECT_NO_THROW(boost::get(val2)); - EXPECT_TRUE(val1 == val2); + BOOST_CHECK(val2.is_bool()); + BOOST_CHECK(val2.as_bool()); + BOOST_CHECK_NO_THROW(boost::get(val2)); + BOOST_CHECK(val1 == val2); } -TEST(MSGPACK_BOOST, object_with_zone_variant_bool) +BOOST_AUTO_TEST_CASE(object_with_zone_variant_bool) { msgpack::zone z; msgpack::type::variant val1 = true; - EXPECT_TRUE(val1.is_bool()); - EXPECT_TRUE(val1.as_bool()); + BOOST_CHECK(val1.is_bool()); + BOOST_CHECK(val1.as_bool()); msgpack::object obj(val1, z); msgpack::type::variant val2 = obj.as(); - EXPECT_TRUE(val2.is_bool()); - EXPECT_TRUE(val2.as_bool()); - EXPECT_NO_THROW(boost::get(val2)); - EXPECT_TRUE(val1 == val2); + BOOST_CHECK(val2.is_bool()); + BOOST_CHECK(val2.as_bool()); + BOOST_CHECK_NO_THROW(boost::get(val2)); + BOOST_CHECK(val1 == val2); } // positive integer -TEST(MSGPACK_BOOST, pack_convert_variant_positive_integer) +BOOST_AUTO_TEST_CASE(pack_convert_variant_positive_integer) { std::stringstream ss; msgpack::type::variant val1 = 123; - EXPECT_TRUE(val1.is_uint64_t()); - EXPECT_EQ(val1.as_uint64_t(), 123U); + BOOST_CHECK(val1.is_uint64_t()); + BOOST_CHECK_EQUAL(val1.as_uint64_t(), 123U); msgpack::pack(ss, val1); @@ -164,47 +165,47 @@ TEST(MSGPACK_BOOST, pack_convert_variant_positive_integer) msgpack::object_handle oh = msgpack::unpack(str.data(), str.size()); msgpack::type::variant val2 = oh.get().as(); - EXPECT_TRUE(val2.is_uint64_t()); - EXPECT_EQ(val2.as_uint64_t(), 123U); - EXPECT_NO_THROW(boost::get(val2)); - EXPECT_TRUE(val1 == val2); + BOOST_CHECK(val2.is_uint64_t()); + BOOST_CHECK_EQUAL(val2.as_uint64_t(), 123U); + BOOST_CHECK_NO_THROW(boost::get(val2)); + BOOST_CHECK(val1 == val2); } -TEST(MSGPACK_BOOST, object_variant_positive_integer) +BOOST_AUTO_TEST_CASE(object_variant_positive_integer) { msgpack::type::variant val1 = 123; - EXPECT_TRUE(val1.is_uint64_t()); - EXPECT_EQ(val1.as_uint64_t(), 123U); + BOOST_CHECK(val1.is_uint64_t()); + BOOST_CHECK_EQUAL(val1.as_uint64_t(), 123U); msgpack::object obj(val1); msgpack::type::variant val2 = obj.as(); - EXPECT_TRUE(val2.is_uint64_t()); - EXPECT_EQ(val2.as_uint64_t(), 123U); - EXPECT_NO_THROW(boost::get(val2)); - EXPECT_TRUE(val1 == val2); + BOOST_CHECK(val2.is_uint64_t()); + BOOST_CHECK_EQUAL(val2.as_uint64_t(), 123U); + BOOST_CHECK_NO_THROW(boost::get(val2)); + BOOST_CHECK(val1 == val2); } -TEST(MSGPACK_BOOST, object_with_zone_variant_positive_integer) +BOOST_AUTO_TEST_CASE(object_with_zone_variant_positive_integer) { msgpack::zone z; msgpack::type::variant val1 = 123; - EXPECT_TRUE(val1.is_uint64_t()); - EXPECT_EQ(val1.as_uint64_t(), 123U); + BOOST_CHECK(val1.is_uint64_t()); + BOOST_CHECK_EQUAL(val1.as_uint64_t(), 123U); msgpack::object obj(val1, z); msgpack::type::variant val2 = obj.as(); - EXPECT_TRUE(val2.is_uint64_t()); - EXPECT_EQ(val2.as_uint64_t(), 123U); - EXPECT_NO_THROW(boost::get(val2)); - EXPECT_TRUE(val1 == val2); + BOOST_CHECK(val2.is_uint64_t()); + BOOST_CHECK_EQUAL(val2.as_uint64_t(), 123U); + BOOST_CHECK_NO_THROW(boost::get(val2)); + BOOST_CHECK(val1 == val2); } // negative integer -TEST(MSGPACK_BOOST, pack_convert_variant_negative_integer) +BOOST_AUTO_TEST_CASE(pack_convert_variant_negative_integer) { std::stringstream ss; msgpack::type::variant val1 = -123; - EXPECT_TRUE(val1.is_int64_t()); - EXPECT_EQ(val1.as_int64_t(), -123); + BOOST_CHECK(val1.is_int64_t()); + BOOST_CHECK_EQUAL(val1.as_int64_t(), -123); msgpack::pack(ss, val1); @@ -212,47 +213,47 @@ TEST(MSGPACK_BOOST, pack_convert_variant_negative_integer) msgpack::object_handle oh = msgpack::unpack(str.data(), str.size()); msgpack::type::variant val2 = oh.get().as(); - EXPECT_TRUE(val2.is_int64_t()); - EXPECT_EQ(val2.as_int64_t(), -123); - EXPECT_NO_THROW(boost::get(val2)); - EXPECT_TRUE(val1 == val2); + BOOST_CHECK(val2.is_int64_t()); + BOOST_CHECK_EQUAL(val2.as_int64_t(), -123); + BOOST_CHECK_NO_THROW(boost::get(val2)); + BOOST_CHECK(val1 == val2); } -TEST(MSGPACK_BOOST, object_variant_negative_integer) +BOOST_AUTO_TEST_CASE(object_variant_negative_integer) { msgpack::type::variant val1 = -123; - EXPECT_TRUE(val1.is_int64_t()); - EXPECT_EQ(val1.as_int64_t(), -123); + BOOST_CHECK(val1.is_int64_t()); + BOOST_CHECK_EQUAL(val1.as_int64_t(), -123); msgpack::object obj(val1); msgpack::type::variant val2 = obj.as(); - EXPECT_TRUE(val2.is_int64_t()); - EXPECT_EQ(val2.as_int64_t(), -123); - EXPECT_NO_THROW(boost::get(val2)); - EXPECT_TRUE(val1 == val2); + BOOST_CHECK(val2.is_int64_t()); + BOOST_CHECK_EQUAL(val2.as_int64_t(), -123); + BOOST_CHECK_NO_THROW(boost::get(val2)); + BOOST_CHECK(val1 == val2); } -TEST(MSGPACK_BOOST, object_with_zone_variant_negative_integer) +BOOST_AUTO_TEST_CASE(object_with_zone_variant_negative_integer) { msgpack::zone z; msgpack::type::variant val1 = -123; - EXPECT_TRUE(val1.is_int64_t()); - EXPECT_EQ(val1.as_int64_t(), -123); + BOOST_CHECK(val1.is_int64_t()); + BOOST_CHECK_EQUAL(val1.as_int64_t(), -123); msgpack::object obj(val1, z); msgpack::type::variant val2 = obj.as(); - EXPECT_TRUE(val2.is_int64_t()); - EXPECT_EQ(val2.as_int64_t(), -123); - EXPECT_NO_THROW(boost::get(val2)); - EXPECT_TRUE(val1 == val2); + BOOST_CHECK(val2.is_int64_t()); + BOOST_CHECK_EQUAL(val2.as_int64_t(), -123); + BOOST_CHECK_NO_THROW(boost::get(val2)); + BOOST_CHECK(val1 == val2); } // float -TEST(MSGPACK_BOOST, pack_convert_variant_float) +BOOST_AUTO_TEST_CASE(pack_convert_variant_float) { std::stringstream ss; msgpack::type::variant val1 = 12.34; - EXPECT_TRUE(val1.is_double()); - EXPECT_TRUE(fabs(12.34 - val1.as_double()) <= kEPS); + BOOST_CHECK(val1.is_double()); + BOOST_CHECK(fabs(12.34 - val1.as_double()) <= kEPS); msgpack::pack(ss, val1); @@ -260,47 +261,157 @@ TEST(MSGPACK_BOOST, pack_convert_variant_float) msgpack::object_handle oh = msgpack::unpack(str.data(), str.size()); msgpack::type::variant val2 = oh.get().as(); - EXPECT_TRUE(val2.is_double()); - EXPECT_TRUE(fabs(12.34 - val2.as_double()) <= kEPS); - EXPECT_NO_THROW(boost::get(val2)); - EXPECT_TRUE(fabs(val2.as_double() - val2.as_double()) <= kEPS); + BOOST_CHECK(val2.is_double()); + BOOST_CHECK(fabs(12.34 - val2.as_double()) <= kEPS); + BOOST_CHECK_NO_THROW(boost::get(val2)); + BOOST_CHECK(fabs(val1.as_double() - val2.as_double()) <= kEPS); } -TEST(MSGPACK_BOOST, object_variant_float) +BOOST_AUTO_TEST_CASE(object_variant_float) { msgpack::type::variant val1 = 12.34; - EXPECT_TRUE(val1.is_double()); - EXPECT_TRUE(fabs(12.34 - val1.as_double()) <= kEPS); + BOOST_CHECK(val1.is_double()); + BOOST_CHECK(fabs(12.34 - val1.as_double()) <= kEPS); msgpack::object obj(val1); msgpack::type::variant val2 = obj.as(); - EXPECT_TRUE(val2.is_double()); - EXPECT_TRUE(fabs(12.34 - val2.as_double()) <= kEPS); - EXPECT_NO_THROW(boost::get(val2)); - EXPECT_TRUE(fabs(val2.as_double() - val2.as_double()) <= kEPS); + BOOST_CHECK(val2.is_double()); + BOOST_CHECK(fabs(12.34 - val2.as_double()) <= kEPS); + BOOST_CHECK_NO_THROW(boost::get(val2)); + BOOST_CHECK(fabs(val1.as_double() - val2.as_double()) <= kEPS); + BOOST_CHECK(val1 == val2); } -TEST(MSGPACK_BOOST, object_with_zone_variant_float) +BOOST_AUTO_TEST_CASE(object_with_zone_variant_float) { msgpack::zone z; msgpack::type::variant val1 = 12.34; - EXPECT_TRUE(val1.is_double()); - EXPECT_TRUE(fabs(12.34 - val1.as_double()) <= kEPS); + BOOST_CHECK(val1.is_double()); + BOOST_CHECK(fabs(12.34 - val1.as_double()) <= kEPS); + msgpack::object obj(val1, z); + msgpack::type::variant val2 = obj.as(); + BOOST_CHECK(val2.is_double()); + BOOST_CHECK(fabs(12.34 - val2.as_double()) <= kEPS); + BOOST_CHECK_NO_THROW(boost::get(val2)); + BOOST_CHECK(fabs(val1.as_double() - val2.as_double()) <= kEPS); + BOOST_CHECK(val1 == val2); +} + +BOOST_AUTO_TEST_CASE(pack_convert_variant_float_zero_atdp_positive) +{ + std::stringstream ss; + msgpack::type::variant val1 = 12.0; + BOOST_CHECK(val1.is_uint64_t()); + BOOST_CHECK_EQUAL(val1.as_uint64_t(), 12); + BOOST_CHECK(fabs(12.0 - val1.as_double()) <= kEPS); + + msgpack::pack(ss, val1); + + std::string const& str = ss.str(); + msgpack::object_handle oh = + msgpack::unpack(str.data(), str.size()); + msgpack::type::variant val2 = oh.get().as(); + BOOST_CHECK(val2.is_uint64_t()); + BOOST_CHECK_EQUAL(val2.as_uint64_t(), 12); + BOOST_CHECK_NO_THROW(boost::get(val2)); + BOOST_CHECK(fabs(12.0 - val2.as_double()) <= kEPS); + BOOST_CHECK_EQUAL(val1.as_uint64_t(), val2.as_uint64_t()); +} + +BOOST_AUTO_TEST_CASE(object_variant_float_zero_atdp_positive) +{ + msgpack::type::variant val1 = 12.0; + BOOST_CHECK(val1.is_uint64_t()); + BOOST_CHECK_EQUAL(val1.as_uint64_t(), 12); + BOOST_CHECK(fabs(12.0 - val1.as_double()) <= kEPS); + msgpack::object obj(val1); + msgpack::type::variant val2 = obj.as(); + BOOST_CHECK(val2.is_uint64_t()); + BOOST_CHECK_EQUAL(val2.as_uint64_t(), 12); + BOOST_CHECK_NO_THROW(boost::get(val2)); + BOOST_CHECK(fabs(12.0 - val2.as_double()) <= kEPS); + BOOST_CHECK_EQUAL(val1.as_uint64_t(), val2.as_uint64_t()); + BOOST_CHECK(val1 == val2); +} + +BOOST_AUTO_TEST_CASE(object_with_zone_variant_float_zero_atdp_positive) +{ + msgpack::zone z; + msgpack::type::variant val1 = 12.0; + BOOST_CHECK(val1.is_uint64_t()); + BOOST_CHECK_EQUAL(val1.as_uint64_t(), 12); + BOOST_CHECK(fabs(12.0 - val1.as_double()) <= kEPS); + msgpack::object obj(val1, z); + msgpack::type::variant val2 = obj.as(); + BOOST_CHECK(val2.is_uint64_t()); + BOOST_CHECK_EQUAL(val2.as_uint64_t(), 12); + BOOST_CHECK_NO_THROW(boost::get(val2)); + BOOST_CHECK_EQUAL(val1.as_uint64_t(), val2.as_uint64_t()); + BOOST_CHECK(fabs(12.0 - val2.as_double()) <= kEPS); + BOOST_CHECK(val1 == val2); +} + +BOOST_AUTO_TEST_CASE(pack_convert_variant_float_zero_atdp_negative) +{ + std::stringstream ss; + msgpack::type::variant val1 = -12.0; + BOOST_CHECK(val1.is_int64_t()); + BOOST_CHECK_EQUAL(val1.as_int64_t(), -12); + BOOST_CHECK(fabs(-12.0 - val1.as_double()) <= kEPS); + + msgpack::pack(ss, val1); + + std::string const& str = ss.str(); + msgpack::object_handle oh = + msgpack::unpack(str.data(), str.size()); + msgpack::type::variant val2 = oh.get().as(); + BOOST_CHECK(val2.is_int64_t()); + BOOST_CHECK_EQUAL(val2.as_int64_t(), -12); + BOOST_CHECK_NO_THROW(boost::get(val2)); + BOOST_CHECK(fabs(-12.0 - val2.as_double()) <= kEPS); + BOOST_CHECK_EQUAL(val1.as_int64_t(), val2.as_int64_t()); +} + +BOOST_AUTO_TEST_CASE(object_variant_float_zero_atdp_negative) +{ + msgpack::type::variant val1 = -12.0; + BOOST_CHECK(val1.is_int64_t()); + BOOST_CHECK_EQUAL(val1.as_int64_t(), -12); + BOOST_CHECK(fabs(-12.0 - val1.as_double()) <= kEPS); + msgpack::object obj(val1); + msgpack::type::variant val2 = obj.as(); + BOOST_CHECK(val2.is_int64_t()); + BOOST_CHECK_EQUAL(val2.as_int64_t(), -12); + BOOST_CHECK_NO_THROW(boost::get(val2)); + BOOST_CHECK(fabs(-12.0 - val2.as_double()) <= kEPS); + BOOST_CHECK_EQUAL(val1.as_int64_t(), val2.as_int64_t()); + BOOST_CHECK(val1 == val2); +} + +BOOST_AUTO_TEST_CASE(object_with_zone_variant_float_zero_atdp_negative) +{ + msgpack::zone z; + msgpack::type::variant val1 = -12.0; + BOOST_CHECK(val1.is_int64_t()); + BOOST_CHECK_EQUAL(val1.as_int64_t(), -12); + BOOST_CHECK(fabs(-12.0 - val1.as_double()) <= kEPS); msgpack::object obj(val1, z); msgpack::type::variant val2 = obj.as(); - EXPECT_TRUE(val2.is_double()); - EXPECT_TRUE(fabs(12.34 - val2.as_double()) <= kEPS); - EXPECT_NO_THROW(boost::get(val2)); - EXPECT_TRUE(fabs(val2.as_double() - val2.as_double()) <= kEPS); + BOOST_CHECK(val2.is_int64_t()); + BOOST_CHECK_EQUAL(val2.as_int64_t(), -12); + BOOST_CHECK_NO_THROW(boost::get(val2)); + BOOST_CHECK(fabs(-12.0 - val2.as_double()) <= kEPS); + BOOST_CHECK_EQUAL(val1.as_int64_t(), val2.as_int64_t()); + BOOST_CHECK(val1 == val2); } // str -TEST(MSGPACK_BOOST, pack_convert_variant_str) +BOOST_AUTO_TEST_CASE(pack_convert_variant_str) { std::stringstream ss; msgpack::type::variant val1 = "ABC"; - EXPECT_TRUE(val1.is_string()); - EXPECT_EQ(val1.as_string(), "ABC"); + BOOST_CHECK(val1.is_string()); + BOOST_CHECK_EQUAL(val1.as_string(), "ABC"); msgpack::pack(ss, val1); @@ -308,53 +419,53 @@ TEST(MSGPACK_BOOST, pack_convert_variant_str) msgpack::object_handle oh = msgpack::unpack(str.data(), str.size()); msgpack::type::variant val2 = oh.get().as(); - EXPECT_TRUE(val2.is_string()); - EXPECT_EQ(val2.as_string(), "ABC"); - EXPECT_NO_THROW(boost::get(val2)); - EXPECT_TRUE(val1 == val2); + BOOST_CHECK(val2.is_string()); + BOOST_CHECK_EQUAL(val2.as_string(), "ABC"); + BOOST_CHECK_NO_THROW(boost::get(val2)); + BOOST_CHECK(val1 == val2); } -TEST(MSGPACK_BOOST, object_with_zone_variant_str) +BOOST_AUTO_TEST_CASE(object_with_zone_variant_str) { msgpack::zone z; msgpack::type::variant val1 = "ABC"; - EXPECT_TRUE(val1.is_string()); - EXPECT_EQ(val1.as_string(), "ABC"); + BOOST_CHECK(val1.is_string()); + BOOST_CHECK_EQUAL(val1.as_string(), "ABC"); msgpack::object obj(val1, z); msgpack::type::variant val2 = obj.as(); - EXPECT_TRUE(val2.is_string()); - EXPECT_EQ(val2.as_string(), "ABC"); - EXPECT_NO_THROW(boost::get(val2)); - EXPECT_TRUE(val1 == val2); + BOOST_CHECK(val2.is_string()); + BOOST_CHECK_EQUAL(val2.as_string(), "ABC"); + BOOST_CHECK_NO_THROW(boost::get(val2)); + BOOST_CHECK(val1 == val2); } #if (BOOST_VERSION / 100000) >= 1 && ((BOOST_VERSION / 100) % 1000) >= 53 -TEST(MSGPACK_BOOST, object_with_zone_variant_str_ref) +BOOST_AUTO_TEST_CASE(object_with_zone_variant_str_ref) { // You can use boost::string_ref with msgpack::type::variant. msgpack::zone z; std::string s = "ABC"; boost::string_ref sr(s); msgpack::type::variant val1(sr); - EXPECT_TRUE(val1.is_boost_string_ref()); - EXPECT_EQ(val1.as_boost_string_ref(), "ABC"); + BOOST_CHECK(val1.is_boost_string_ref()); + BOOST_CHECK_EQUAL(val1.as_boost_string_ref(), "ABC"); msgpack::object obj(val1, z); msgpack::type::variant val2 = obj.as(); // Converted as std::string. - EXPECT_TRUE(val2.is_string()); - EXPECT_EQ(val2.as_string(), "ABC"); - EXPECT_NO_THROW(boost::get(val2)); + BOOST_CHECK(val2.is_string()); + BOOST_CHECK_EQUAL(val2.as_string(), "ABC"); + BOOST_CHECK_NO_THROW(boost::get(val2)); // boost::string_ref and std::string are different. - EXPECT_FALSE(val1 == val2); + BOOST_CHECK(!(val1 == val2)); } #endif // (BOOST_VERSION / 100000) >= 1 && ((BOOST_VERSION / 100) % 1000) >= 53 // bin -TEST(MSGPACK_BOOST, pack_convert_variant_bin) +BOOST_AUTO_TEST_CASE(pack_convert_variant_bin) { std::stringstream ss; std::vector v; @@ -362,8 +473,8 @@ TEST(MSGPACK_BOOST, pack_convert_variant_bin) v.push_back('b'); v.push_back('c'); msgpack::type::variant val1 = v; - EXPECT_TRUE(val1.is_vector_char()); - EXPECT_EQ(val1.as_vector_char(), v); + BOOST_CHECK(val1.is_vector_char()); + BOOST_CHECK(val1.as_vector_char() == v); msgpack::pack(ss, val1); @@ -371,15 +482,15 @@ TEST(MSGPACK_BOOST, pack_convert_variant_bin) msgpack::object_handle oh = msgpack::unpack(str.data(), str.size()); msgpack::type::variant val2 = oh.get().as(); - EXPECT_TRUE(val2.is_vector_char()); - EXPECT_EQ(val2.as_vector_char(), v); - EXPECT_NO_THROW(boost::get >(val2)); - EXPECT_TRUE(val1 == val2); + BOOST_CHECK(val2.is_vector_char()); + BOOST_CHECK(val2.as_vector_char() == v); + BOOST_CHECK_NO_THROW(boost::get >(val2)); + BOOST_CHECK(val1 == val2); } -TEST(MSGPACK_BOOST, object_with_zone_variant_bin) +BOOST_AUTO_TEST_CASE(object_with_zone_variant_bin) { msgpack::zone z; std::vector v; @@ -387,19 +498,19 @@ TEST(MSGPACK_BOOST, object_with_zone_variant_bin) v.push_back('b'); v.push_back('c'); msgpack::type::variant val1 = v; - EXPECT_TRUE(val1.is_vector_char()); - EXPECT_EQ(val1.as_vector_char(), v); + BOOST_CHECK(val1.is_vector_char()); + BOOST_CHECK(val1.as_vector_char() == v); msgpack::object obj(val1, z); msgpack::type::variant val2 = obj.as(); - EXPECT_TRUE(val2.is_vector_char()); - EXPECT_EQ(val2.as_vector_char(), v); - EXPECT_NO_THROW(boost::get >(val2)); - EXPECT_TRUE(val1 == val2); + BOOST_CHECK(val2.is_vector_char()); + BOOST_CHECK(val2.as_vector_char() == v); + BOOST_CHECK_NO_THROW(boost::get >(val2)); + BOOST_CHECK(val1 == val2); } #if (BOOST_VERSION / 100000) >= 1 && ((BOOST_VERSION / 100) % 1000) >= 53 -TEST(MSGPACK_BOOST, object_with_zone_variant_raw_ref) +BOOST_AUTO_TEST_CASE(object_with_zone_variant_raw_ref) { // You can use boost::string_ref with msgpack::type::variant. msgpack::zone z; @@ -409,23 +520,23 @@ TEST(MSGPACK_BOOST, object_with_zone_variant_raw_ref) v.push_back('c'); msgpack::type::raw_ref rr(&v.front(), static_cast(v.size())); msgpack::type::variant val1 = rr; - EXPECT_TRUE(val1.is_raw_ref()); - EXPECT_EQ(val1.as_raw_ref(), msgpack::type::raw_ref(&v.front(), static_cast(v.size()))); + BOOST_CHECK(val1.is_raw_ref()); + BOOST_CHECK(val1.as_raw_ref() == msgpack::type::raw_ref(&v.front(), static_cast(v.size()))); msgpack::object obj(val1, z); msgpack::type::variant val2 = obj.as(); // Converted as std::vector. - EXPECT_TRUE(val2.is_vector_char()); - EXPECT_EQ(val2.as_vector_char(), v); - EXPECT_NO_THROW(boost::get >(val2)); + BOOST_CHECK(val2.is_vector_char()); + BOOST_CHECK(val2.as_vector_char() == v); + BOOST_CHECK_NO_THROW(boost::get >(val2)); // msgpack::type::raw_ref and std::vector are different. - EXPECT_FALSE(val1 == val2); + BOOST_CHECK(!(val1 == val2)); } #endif // (BOOST_VERSION / 100000) >= 1 && ((BOOST_VERSION / 100) % 1000) >= 53 // ext -TEST(MSGPACK_BOOST, pack_convert_variant_ext) +BOOST_AUTO_TEST_CASE(pack_convert_variant_ext) { std::stringstream ss; std::vector v; @@ -434,8 +545,8 @@ TEST(MSGPACK_BOOST, pack_convert_variant_ext) v.push_back('c'); msgpack::type::ext e(42, v.data(), static_cast(v.size())); msgpack::type::variant val1(e); - EXPECT_TRUE(val1.is_ext()); - EXPECT_EQ(val1.as_ext(), e); + BOOST_CHECK(val1.is_ext()); + BOOST_CHECK(val1.as_ext() == e); msgpack::pack(ss, val1); @@ -443,15 +554,13 @@ TEST(MSGPACK_BOOST, pack_convert_variant_ext) msgpack::object_handle oh = msgpack::unpack(str.data(), str.size()); msgpack::type::variant val2 = oh.get().as(); - EXPECT_TRUE(val2.is_ext()); - EXPECT_EQ(val2.as_ext(), e); - EXPECT_NO_THROW(boost::get(val2)); - EXPECT_TRUE(val1 == val2); + BOOST_CHECK(val2.is_ext()); + BOOST_CHECK(val2.as_ext() == e); + BOOST_CHECK_NO_THROW(boost::get(val2)); + BOOST_CHECK(val1 == val2); } - - -TEST(MSGPACK_BOOST, object_with_zone_variant_ext) +BOOST_AUTO_TEST_CASE(object_with_zone_variant_ext) { msgpack::zone z; std::vector v; @@ -460,17 +569,17 @@ TEST(MSGPACK_BOOST, object_with_zone_variant_ext) v.push_back('c'); msgpack::type::ext e(42, v.data(), static_cast(v.size())); msgpack::type::variant val1(e); - EXPECT_TRUE(val1.is_ext()); - EXPECT_EQ(val1.as_ext(), e); + BOOST_CHECK(val1.is_ext()); + BOOST_CHECK(val1.as_ext() == e); msgpack::object obj(val1, z); msgpack::type::variant val2 = obj.as(); - EXPECT_TRUE(val2.is_ext()); - EXPECT_EQ(val2.as_ext(), e); - EXPECT_NO_THROW(boost::get(val2)); - EXPECT_TRUE(val1 == val2); + BOOST_CHECK(val2.is_ext()); + BOOST_CHECK(val2.as_ext() == e); + BOOST_CHECK_NO_THROW(boost::get(val2)); + BOOST_CHECK(val1 == val2); } -TEST(MSGPACK_BOOST, object_with_zone_variant_ext_ref) +BOOST_AUTO_TEST_CASE(object_with_zone_variant_ext_ref) { // You can use msgpack::type::ext_ref with msgpack::type::variant. msgpack::zone z; @@ -480,21 +589,21 @@ TEST(MSGPACK_BOOST, object_with_zone_variant_ext_ref) v.push_back('c'); msgpack::type::ext_ref e(v.data(), static_cast(v.size())); msgpack::type::variant val1(e); - EXPECT_TRUE(val1.is_ext_ref()); - EXPECT_EQ(val1.as_ext_ref(), e); + BOOST_CHECK(val1.is_ext_ref()); + BOOST_CHECK(val1.as_ext_ref() == e); msgpack::object obj(val1, z); msgpack::type::variant val2 = obj.as(); // Converted as msgpack::type::ext. - EXPECT_TRUE(val2.is_ext()); - EXPECT_EQ(val2.as_ext(), e); - EXPECT_NO_THROW(boost::get(val2)); + BOOST_CHECK(val2.is_ext()); + BOOST_CHECK(val2.as_ext() == msgpack::type::ext(e)); + BOOST_CHECK_NO_THROW(boost::get(val2)); // msgpack::type::ext_ref and msgpack::type::ext are different. - EXPECT_FALSE(val1 == val2); + BOOST_CHECK(!(val1 == val2)); } // array -TEST(MSGPACK_BOOST, pack_convert_variant_array) +BOOST_AUTO_TEST_CASE(pack_convert_variant_array) { std::stringstream ss; std::vector v; @@ -502,8 +611,8 @@ TEST(MSGPACK_BOOST, pack_convert_variant_array) v.push_back(msgpack::type::variant(-1)); v.push_back(msgpack::type::variant("ABC")); msgpack::type::variant val1 = v; - EXPECT_TRUE(val1.is_vector()); - EXPECT_EQ(val1.as_vector(), v); + BOOST_CHECK(val1.is_vector()); + BOOST_CHECK(val1.as_vector() == v); msgpack::pack(ss, val1); @@ -511,13 +620,13 @@ TEST(MSGPACK_BOOST, pack_convert_variant_array) msgpack::object_handle oh = msgpack::unpack(str.data(), str.size()); msgpack::type::variant val2 = oh.get().as(); - EXPECT_TRUE(val2.is_vector()); - EXPECT_EQ(val2.as_vector(), v); - EXPECT_NO_THROW(boost::get >(val2)); - EXPECT_TRUE(val1 == val2); + BOOST_CHECK(val2.is_vector()); + BOOST_CHECK(val2.as_vector() == v); + BOOST_CHECK_NO_THROW(boost::get >(val2)); + BOOST_CHECK(val1 == val2); } -TEST(MSGPACK_BOOST, object_with_zone_variant_array) +BOOST_AUTO_TEST_CASE(object_with_zone_variant_array) { msgpack::zone z; std::vector v; @@ -525,19 +634,19 @@ TEST(MSGPACK_BOOST, object_with_zone_variant_array) v.push_back(msgpack::type::variant(-1)); v.push_back(msgpack::type::variant("ABC")); msgpack::type::variant val1 = v; - EXPECT_TRUE(val1.is_vector()); - EXPECT_EQ(val1.as_vector(), v); + BOOST_CHECK(val1.is_vector()); + BOOST_CHECK(val1.as_vector() == v); msgpack::object obj(val1, z); msgpack::type::variant val2 = obj.as(); - EXPECT_TRUE(val2.is_vector()); - EXPECT_EQ(val2.as_vector(), v); - EXPECT_NO_THROW(boost::get >(val2)); - EXPECT_TRUE(val1 == val2); + BOOST_CHECK(val2.is_vector()); + BOOST_CHECK(val2.as_vector() == v); + BOOST_CHECK_NO_THROW(boost::get >(val2)); + BOOST_CHECK(val1 == val2); } // multimap -TEST(MSGPACK_BOOST, pack_convert_variant_map) +BOOST_AUTO_TEST_CASE(pack_convert_variant_map) { std::stringstream ss; typedef std::multimap multimap_t; @@ -545,8 +654,8 @@ TEST(MSGPACK_BOOST, pack_convert_variant_map) v.insert(multimap_t::value_type(msgpack::type::variant(1), msgpack::type::variant(-1))); v.insert(multimap_t::value_type(msgpack::type::variant("ABC"), msgpack::type::variant("DEF"))); msgpack::type::variant val1 = v; - EXPECT_TRUE(val1.is_multimap()); - EXPECT_EQ(val1.as_multimap(), v); + BOOST_CHECK(val1.is_multimap()); + BOOST_CHECK(val1.as_multimap() == v); msgpack::pack(ss, val1); @@ -554,13 +663,13 @@ TEST(MSGPACK_BOOST, pack_convert_variant_map) msgpack::object_handle oh = msgpack::unpack(str.data(), str.size()); msgpack::type::variant val2 = oh.get().as(); - EXPECT_TRUE(val2.is_multimap()); - EXPECT_EQ(val2.as_multimap(), v); - EXPECT_NO_THROW(boost::get(val2)); - EXPECT_TRUE(val1 == val2); + BOOST_CHECK(val2.is_multimap()); + BOOST_CHECK(val2.as_multimap() == v); + BOOST_CHECK_NO_THROW(boost::get(val2)); + BOOST_CHECK(val1 == val2); } -TEST(MSGPACK_BOOST, object_with_zone_variant_map) +BOOST_AUTO_TEST_CASE(object_with_zone_variant_map) { msgpack::zone z; typedef std::multimap multimap_t; @@ -568,14 +677,14 @@ TEST(MSGPACK_BOOST, object_with_zone_variant_map) v.insert(multimap_t::value_type(msgpack::type::variant(1), msgpack::type::variant(-1))); v.insert(multimap_t::value_type(msgpack::type::variant("ABC"), msgpack::type::variant("DEF"))); msgpack::type::variant val1 = v; - EXPECT_TRUE(val1.is_multimap()); - EXPECT_EQ(val1.as_multimap(), v); + BOOST_CHECK(val1.is_multimap()); + BOOST_CHECK(val1.as_multimap() == v); msgpack::object obj(val1, z); msgpack::type::variant val2 = obj.as(); - EXPECT_TRUE(val2.is_multimap()); - EXPECT_EQ(val2.as_multimap(), v); - EXPECT_NO_THROW(boost::get(val2)); - EXPECT_TRUE(val1 == val2); + BOOST_CHECK(val2.is_multimap()); + BOOST_CHECK(val2.as_multimap() == v); + BOOST_CHECK_NO_THROW(boost::get(val2)); + BOOST_CHECK(val1 == val2); } // variant_ref @@ -584,14 +693,14 @@ TEST(MSGPACK_BOOST, object_with_zone_variant_map) #if (BOOST_VERSION / 100000) >= 1 && ((BOOST_VERSION / 100) % 1000) >= 53 -TEST(MSGPACK_BOOST, pack_convert_variant_ref_str) +BOOST_AUTO_TEST_CASE(pack_convert_variant_ref_str) { std::stringstream ss; std::string s("ABC"); boost::string_ref sr(s); msgpack::type::variant_ref val1 = sr; - EXPECT_TRUE(val1.is_boost_string_ref()); - EXPECT_EQ(val1.as_boost_string_ref(), sr); + BOOST_CHECK(val1.is_boost_string_ref()); + BOOST_CHECK_EQUAL(val1.as_boost_string_ref(), sr); msgpack::pack(ss, val1); @@ -599,35 +708,35 @@ TEST(MSGPACK_BOOST, pack_convert_variant_ref_str) msgpack::object_handle oh = msgpack::unpack(str.data(), str.size()); msgpack::type::variant_ref val2 = oh.get().as(); - EXPECT_TRUE(val2.is_boost_string_ref()); - EXPECT_EQ(val2.as_boost_string_ref(), sr); - EXPECT_NO_THROW(boost::get(val2)); - EXPECT_TRUE(val1 == val2); + BOOST_CHECK(val2.is_boost_string_ref()); + BOOST_CHECK_EQUAL(val2.as_boost_string_ref(), sr); + BOOST_CHECK_NO_THROW(boost::get(val2)); + BOOST_CHECK(val1 == val2); } -TEST(MSGPACK_BOOST, object_with_zone_variant_ref_str) +BOOST_AUTO_TEST_CASE(object_with_zone_variant_ref_str) { msgpack::zone z; std::string s("ABC"); boost::string_ref sr(s); msgpack::type::variant_ref val1 = sr; - EXPECT_TRUE(val1.is_boost_string_ref()); - EXPECT_EQ(val1.as_boost_string_ref(), sr); + BOOST_CHECK(val1.is_boost_string_ref()); + BOOST_CHECK_EQUAL(val1.as_boost_string_ref(), sr); msgpack::object obj(val1, z); msgpack::type::variant_ref val2 = obj.as(); - EXPECT_TRUE(val2.is_boost_string_ref()); - EXPECT_EQ(val2.as_boost_string_ref(), sr); - EXPECT_NO_THROW(boost::get(val2)); - EXPECT_TRUE(val1 == val2); + BOOST_CHECK(val2.is_boost_string_ref()); + BOOST_CHECK_EQUAL(val2.as_boost_string_ref(), sr); + BOOST_CHECK_NO_THROW(boost::get(val2)); + BOOST_CHECK(val1 == val2); } #endif // (BOOST_VERSION / 100000) >= 1 && ((BOOST_VERSION / 100) % 1000) >= 53 // bin -TEST(MSGPACK_BOOST, pack_convert_variant_ref_bin) +BOOST_AUTO_TEST_CASE(pack_convert_variant_ref_bin) { std::stringstream ss; std::vector v; @@ -636,8 +745,8 @@ TEST(MSGPACK_BOOST, pack_convert_variant_ref_bin) v.push_back('c'); msgpack::type::raw_ref rr(v.data(), static_cast(v.size())); msgpack::type::variant_ref val1 = rr; - EXPECT_TRUE(val1.is_raw_ref()); - EXPECT_EQ(val1.as_raw_ref(), rr); + BOOST_CHECK(val1.is_raw_ref()); + BOOST_CHECK(val1.as_raw_ref() == rr); msgpack::pack(ss, val1); @@ -645,15 +754,15 @@ TEST(MSGPACK_BOOST, pack_convert_variant_ref_bin) msgpack::object_handle oh = msgpack::unpack(str.data(), str.size()); msgpack::type::variant_ref val2 = oh.get().as(); - EXPECT_TRUE(val2.is_raw_ref()); - EXPECT_EQ(val2.as_raw_ref(), rr); - EXPECT_NO_THROW(boost::get(val2)); - EXPECT_TRUE(val1 == val2); + BOOST_CHECK(val2.is_raw_ref()); + BOOST_CHECK(val2.as_raw_ref() == rr); + BOOST_CHECK_NO_THROW(boost::get(val2)); + BOOST_CHECK(val1 == val2); } -TEST(MSGPACK_BOOST, object_with_zone_variant_ref_bin) +BOOST_AUTO_TEST_CASE(object_with_zone_variant_ref_bin) { msgpack::zone z; std::vector v; @@ -662,19 +771,19 @@ TEST(MSGPACK_BOOST, object_with_zone_variant_ref_bin) v.push_back('c'); msgpack::type::raw_ref rr(v.data(), static_cast(v.size())); msgpack::type::variant_ref val1 = rr; - EXPECT_TRUE(val1.is_raw_ref()); - EXPECT_EQ(val1.as_raw_ref(), rr); + BOOST_CHECK(val1.is_raw_ref()); + BOOST_CHECK(val1.as_raw_ref() == rr); msgpack::object obj(val1, z); msgpack::type::variant_ref val2 = obj.as(); - EXPECT_TRUE(val2.is_raw_ref()); - EXPECT_EQ(val2.as_raw_ref(), rr); - EXPECT_NO_THROW(boost::get(val2)); - EXPECT_TRUE(val1 == val2); + BOOST_CHECK(val2.is_raw_ref()); + BOOST_CHECK(val2.as_raw_ref() == rr); + BOOST_CHECK_NO_THROW(boost::get(val2)); + BOOST_CHECK(val1 == val2); } // ext -TEST(MSGPACK_BOOST, pack_convert_variant_ref_ext) +BOOST_AUTO_TEST_CASE(pack_convert_variant_ref_ext) { std::stringstream ss; std::vector v; @@ -684,8 +793,8 @@ TEST(MSGPACK_BOOST, pack_convert_variant_ref_ext) v.push_back('c'); msgpack::type::ext_ref er(v.data(), static_cast(v.size())); msgpack::type::variant_ref val1(er); - EXPECT_TRUE(val1.is_ext_ref()); - EXPECT_EQ(val1.as_ext_ref(), er); + BOOST_CHECK(val1.is_ext_ref()); + BOOST_CHECK(val1.as_ext_ref() == er); msgpack::pack(ss, val1); @@ -693,14 +802,14 @@ TEST(MSGPACK_BOOST, pack_convert_variant_ref_ext) msgpack::object_handle oh = msgpack::unpack(str.data(), str.size()); msgpack::type::variant_ref val2 = oh.get().as(); - EXPECT_NO_THROW(boost::get(val2)); - EXPECT_TRUE(val2.is_ext_ref()); - EXPECT_EQ(val2.as_ext_ref(), er); - EXPECT_TRUE(val1 == val2); + BOOST_CHECK_NO_THROW(boost::get(val2)); + BOOST_CHECK(val2.is_ext_ref()); + BOOST_CHECK(val2.as_ext_ref() == er); + BOOST_CHECK(val1 == val2); } -TEST(MSGPACK_BOOST, object_with_zone_variant_ref_ext) +BOOST_AUTO_TEST_CASE(object_with_zone_variant_ref_ext) { msgpack::zone z; std::vector v; @@ -710,19 +819,19 @@ TEST(MSGPACK_BOOST, object_with_zone_variant_ref_ext) v.push_back('c'); msgpack::type::ext_ref er(v.data(), static_cast(v.size())); msgpack::type::variant_ref val1(er); - EXPECT_TRUE(val1.is_ext_ref()); - EXPECT_EQ(val1.as_ext_ref(), er); + BOOST_CHECK(val1.is_ext_ref()); + BOOST_CHECK(val1.as_ext_ref() == er); msgpack::object obj(val1, z); msgpack::type::variant_ref val2 = obj.as(); - EXPECT_TRUE(val2.is_ext_ref()); - EXPECT_EQ(val2.as_ext_ref(), er); - EXPECT_NO_THROW(boost::get(val2)); - EXPECT_TRUE(val1 == val2); + BOOST_CHECK(val2.is_ext_ref()); + BOOST_CHECK(val2.as_ext_ref() == er); + BOOST_CHECK_NO_THROW(boost::get(val2)); + BOOST_CHECK(val1 == val2); } // array -TEST(MSGPACK_BOOST, pack_convert_variant_ref_array) +BOOST_AUTO_TEST_CASE(pack_convert_variant_ref_array) { std::stringstream ss; std::vector v; @@ -735,8 +844,8 @@ TEST(MSGPACK_BOOST, pack_convert_variant_ref_array) v.push_back(msgpack::type::variant_ref(s)); #endif // (BOOST_VERSION / 100000) >= 1 && ((BOOST_VERSION / 100) % 1000) >= 53 msgpack::type::variant_ref val1 = v; - EXPECT_TRUE(val1.is_vector()); - EXPECT_EQ(val1.as_vector(), v); + BOOST_CHECK(val1.is_vector()); + BOOST_CHECK(val1.as_vector() == v); msgpack::pack(ss, val1); @@ -744,13 +853,13 @@ TEST(MSGPACK_BOOST, pack_convert_variant_ref_array) msgpack::object_handle oh = msgpack::unpack(str.data(), str.size()); msgpack::type::variant_ref val2 = oh.get().as(); - EXPECT_TRUE(val2.is_vector()); - EXPECT_EQ(val2.as_vector(), v); - EXPECT_NO_THROW(boost::get >(val2)); - EXPECT_TRUE(val1 == val2); + BOOST_CHECK(val2.is_vector()); + BOOST_CHECK(val2.as_vector() == v); + BOOST_CHECK_NO_THROW(boost::get >(val2)); + BOOST_CHECK(val1 == val2); } -TEST(MSGPACK_BOOST, object_with_zone_variant_ref_array) +BOOST_AUTO_TEST_CASE(object_with_zone_variant_ref_array) { msgpack::zone z; std::vector v; @@ -763,19 +872,19 @@ TEST(MSGPACK_BOOST, object_with_zone_variant_ref_array) v.push_back(msgpack::type::variant_ref(s)); #endif // (BOOST_VERSION / 100000) >= 1 && ((BOOST_VERSION / 100) % 1000) >= 53 msgpack::type::variant_ref val1 = v; - EXPECT_TRUE(val1.is_vector()); - EXPECT_EQ(val1.as_vector(), v); + BOOST_CHECK(val1.is_vector()); + BOOST_CHECK(val1.as_vector() == v); msgpack::object obj(val1, z); msgpack::type::variant_ref val2 = obj.as(); - EXPECT_TRUE(val2.is_vector()); - EXPECT_EQ(val2.as_vector(), v); - EXPECT_NO_THROW(boost::get >(val2)); - EXPECT_TRUE(val1 == val2); + BOOST_CHECK(val2.is_vector()); + BOOST_CHECK(val2.as_vector() == v); + BOOST_CHECK_NO_THROW(boost::get >(val2)); + BOOST_CHECK(val1 == val2); } // multimap -TEST(MSGPACK_BOOST, pack_convert_variant_ref_map) +BOOST_AUTO_TEST_CASE(pack_convert_variant_ref_map) { std::stringstream ss; typedef std::multimap multimap_t; @@ -789,8 +898,8 @@ TEST(MSGPACK_BOOST, pack_convert_variant_ref_map) v.insert(multimap_t::value_type(msgpack::type::variant_ref(s1), msgpack::type::variant_ref(s2))); #endif // (BOOST_VERSION / 100000) >= 1 && ((BOOST_VERSION / 100) % 1000) >= 53 msgpack::type::variant_ref val1 = v; - EXPECT_TRUE(val1.is_multimap()); - EXPECT_EQ(val1.as_multimap(), v); + BOOST_CHECK(val1.is_multimap()); + BOOST_CHECK(val1.as_multimap() == v); msgpack::pack(ss, val1); @@ -798,13 +907,13 @@ TEST(MSGPACK_BOOST, pack_convert_variant_ref_map) msgpack::object_handle oh = msgpack::unpack(str.data(), str.size()); msgpack::type::variant_ref val2 = oh.get().as(); - EXPECT_TRUE(val2.is_multimap()); - EXPECT_EQ(val2.as_multimap(), v); - EXPECT_NO_THROW(boost::get(val2)); - EXPECT_TRUE(val1 == val2); + BOOST_CHECK(val2.is_multimap()); + BOOST_CHECK(val2.as_multimap() == v); + BOOST_CHECK_NO_THROW(boost::get(val2)); + BOOST_CHECK(val1 == val2); } -TEST(MSGPACK_BOOST, object_with_zone_variant_ref_map) +BOOST_AUTO_TEST_CASE(object_with_zone_variant_ref_map) { msgpack::zone z; typedef std::multimap multimap_t; @@ -818,15 +927,14 @@ TEST(MSGPACK_BOOST, object_with_zone_variant_ref_map) v.insert(multimap_t::value_type(msgpack::type::variant_ref(s1), msgpack::type::variant_ref(s2))); #endif // (BOOST_VERSION / 100000) >= 1 && ((BOOST_VERSION / 100) % 1000) >= 53 msgpack::type::variant_ref val1 = v; - EXPECT_TRUE(val1.is_multimap()); - EXPECT_EQ(val1.as_multimap(), v); + BOOST_CHECK(val1.is_multimap()); + BOOST_CHECK(val1.as_multimap() == v); msgpack::object obj(val1, z); msgpack::type::variant_ref val2 = obj.as(); - EXPECT_TRUE(val2.is_multimap()); - EXPECT_EQ(val2.as_multimap(), v); - EXPECT_NO_THROW(boost::get(val2)); - EXPECT_TRUE(val1 == val2); + BOOST_CHECK(val2.is_multimap()); + BOOST_CHECK(val2.as_multimap() == v); + BOOST_CHECK_NO_THROW(boost::get(val2)); + BOOST_CHECK(val1 == val2); } - -#endif // defined(MSGPACK_USE_BOOST) +#endif // defined(MSGPACK_NO_BOOST) diff --git a/test/buffer.cpp b/test/buffer.cpp index 18cc7aaca..90af2dcbe 100644 --- a/test/buffer.cpp +++ b/test/buffer.cpp @@ -1,46 +1,40 @@ #include #include -#include #include -#include -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wconversion" - -#include - -#pragma GCC diagnostic pop +#define BOOST_TEST_MODULE buffer +#include #include -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); vbuf.write("a", 1); vbuf.write("a", 1); - const struct iovec* vec = vbuf.vector(); + const msgpack::iovec* vec = vbuf.vector(); size_t veclen = vbuf.vector_size(); msgpack::sbuffer sbuf; @@ -48,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(); @@ -65,12 +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); @@ -81,23 +74,7 @@ TEST(buffer, zbuffer) zbuf.flush(); } - -TEST(buffer, 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)); - - EXPECT_TRUE(msgpack_zbuffer_flush(&zbuf) != NULL); - - msgpack_zbuffer_destroy(&zbuf); -} - - -TEST(buffer, fbuffer) +BOOST_AUTO_TEST_CASE(fbuffer) { #if defined(_MSC_VER) FILE* file; @@ -105,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); @@ -118,37 +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(ch)); - } - EXPECT_EQ(EOF, fgetc(file)); - fclose(file); -} - - -TEST(buffer, fbuffer_c) -{ -#if defined(_MSC_VER) - FILE* file; - tmpfile_s(&file); -#else // defined(_MSC_VER) - FILE* file = tmpfile(); -#endif // defined(_MSC_VER) - - 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)); - - 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', static_cast(ch)); } - EXPECT_EQ(EOF, fgetc(file)); + BOOST_CHECK_EQUAL(EOF, fgetc(file)); fclose(file); } diff --git a/test/buffer_c.cpp b/test/buffer_c.cpp new file mode 100644 index 000000000..4354608be --- /dev/null +++ b/test/buffer_c.cpp @@ -0,0 +1,140 @@ +#include +#include +#include +#include + +#define BOOST_TEST_MODULE buffer +#include + +#include + +#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 +#else +#define HAVE_SYS_UIO_H 0 +#endif + +BOOST_AUTO_TEST_CASE(zbuffer_c) +{ + msgpack_zbuffer zbuf; + 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)); + + BOOST_CHECK(msgpack_zbuffer_flush(&zbuf) != NULL); + + msgpack_zbuffer_destroy(&zbuf); +} + +BOOST_AUTO_TEST_CASE(fbuffer_c) +{ +#if defined(_MSC_VER) + FILE* file; + tmpfile_s(&file); +#else // defined(_MSC_VER) + FILE* file = tmpfile(); +#endif // defined(_MSC_VER) + + void* fbuf = (void*)file; + + 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); + BOOST_CHECK(ch != EOF); + BOOST_CHECK_EQUAL('a', (char) ch); + } + BOOST_CHECK_EQUAL(EOF, fgetc(file)); + fclose(file); +} + +BOOST_AUTO_TEST_CASE(sbuffer_c) +{ + msgpack_sbuffer *sbuf; + char *data; + + sbuf = msgpack_sbuffer_new(); + 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); + 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); +} + +BOOST_AUTO_TEST_CASE(vrefbuffer_c) +{ + const char *raw = "I was about to sail away in a junk," + "When suddenly I heard" + "The sound of stamping and singing on the bank--" + "It was you and your friends come to bid me farewell." + "The Peach Flower Lake is a thousand fathoms deep," + "But it cannot compare, O Wang Lun," + "With the depth of your love for me."; + const size_t rawlen = strlen(raw); + msgpack_vrefbuffer *vbuf; + const int ref_size = 24, chunk_size = 128; + size_t slices[] = {0, 9, 10, + MSGPACK_VREFBUFFER_REF_SIZE, + MSGPACK_VREFBUFFER_REF_SIZE + 1, + ref_size, chunk_size + 1}; + size_t iovcnt; + const iovec *iov; + size_t len = 0, i; + char *buf; + + vbuf = msgpack_vrefbuffer_new(ref_size, 0); + for (i = 0; i < sizeof(slices) / sizeof(slices[0]); i++) { + msgpack_vrefbuffer_write(vbuf, raw + len, slices[i]); + len += slices[i]; + } + EXPECT_LT(len, rawlen); + iov = msgpack_vrefbuffer_vec(vbuf); + iovcnt = msgpack_vrefbuffer_veclen(vbuf); + + buf = (char *)malloc(rawlen); +#if HAVE_SYS_UIO_H + { + int fd; + char filename[] = "/tmp/mp.XXXXXX"; + + fd = mkstemp(filename); + EXPECT_LT(0, fd); + writev(fd, iov, (int)iovcnt); + len = (size_t)lseek(fd, 0, SEEK_END); + lseek(fd, 0, SEEK_SET); + read(fd, buf, len); + BOOST_CHECK_EQUAL(0, memcmp(buf, raw, len)); + close(fd); + unlink(filename); + } +#else + { + len = 0; + for (i = 0; i < iovcnt; i++) + { + EXPECT_LT(len, rawlen); + memcpy(buf + len, iov[i].iov_base, iov[i].iov_len); + len += iov[i].iov_len; + } + BOOST_CHECK_EQUAL(0, memcmp(buf, raw, len)); + } +#endif + free(buf); + msgpack_vrefbuffer_free(vbuf); +} diff --git a/test/carray.cpp b/test/carray.cpp index 99bb8b040..6e5bfbad1 100644 --- a/test/carray.cpp +++ b/test/carray.cpp @@ -1,15 +1,11 @@ #include -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wconversion" - -#include - -#pragma GCC diagnostic pop +#define BOOST_TEST_MODULE carray +#include #include -TEST(carray, pack_unpack_int) +BOOST_AUTO_TEST_CASE(pack_unpack_int) { std::stringstream ss; int v1[] = { 0, 1 }; @@ -17,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 }; @@ -47,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" }; @@ -77,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 }; @@ -107,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 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' }; @@ -124,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(1)); + BOOST_CHECK_EQUAL(oh.get().type, msgpack::type::STR); + BOOST_CHECK_EQUAL(oh.get().via.str.size, static_cast(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 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(1)); + BOOST_CHECK_EQUAL(o.type, msgpack::type::STR); + BOOST_CHECK_EQUAL(o.via.str.size, static_cast(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 }; @@ -171,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 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 }; @@ -188,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(2)); + BOOST_CHECK_EQUAL(oh.get().type, msgpack::type::BIN); + BOOST_CHECK_EQUAL(oh.get().via.bin.size, static_cast(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 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(2)); + BOOST_CHECK_EQUAL(o.type, msgpack::type::BIN); + BOOST_CHECK_EQUAL(o.via.bin.size, static_cast(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 }; @@ -235,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 diff --git a/test/cases.cpp b/test/cases.cpp index c0ae207e1..2e4db6695 100644 --- a/test/cases.cpp +++ b/test/cases.cpp @@ -1,12 +1,8 @@ #include #include -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wconversion" - -#include - -#pragma GCC diagnostic pop +#define BOOST_TEST_MODULE cases +#include static void feed_file(msgpack::unpacker& pac, const char* path) { @@ -24,12 +20,12 @@ static void feed_file(msgpack::unpacker& pac, const char* path) } } -TEST(cases, format) +BOOST_AUTO_TEST_CASE(format) { -#if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__) +#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wmaybe-uninitialized" -#endif // (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__) +#endif // defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__) msgpack::unpacker pac; msgpack::unpacker pac_compact; @@ -39,12 +35,12 @@ 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) ); -#if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__) + BOOST_CHECK( !pac_compact.next(oh) ); +#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__) #pragma GCC diagnostic pop -#endif // (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__) +#endif // defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__) } diff --git a/test/convert.cpp b/test/convert.cpp index 9e1de4a75..2bc4ae8ab 100644 --- a/test/convert.cpp +++ b/test/convert.cpp @@ -1,11 +1,7 @@ #include -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wconversion" - -#include - -#pragma GCC diagnostic pop +#define BOOST_TEST_MODULE convert +#include class enum_member { public: @@ -33,7 +29,7 @@ class compatibility { MSGPACK_DEFINE(str1, str2); }; -TEST(convert, compatibility_less) +BOOST_AUTO_TEST_CASE(compatibility_less) { std::vector src(1); src[0] = "kumofs"; @@ -42,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 src(3); src[0] = "kumofs"; @@ -59,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; @@ -74,57 +70,57 @@ 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); int i; // obsolete -#if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2)) +#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2)) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wdeprecated-declarations" -#endif // (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2)) - EXPECT_EQ(obj.convert(&i), &i); -#if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2)) +#endif // defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2)) + BOOST_CHECK_EQUAL(obj.convert(&i), &i); +#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2)) #pragma GCC diagnostic pop -#endif // (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2)) - EXPECT_EQ(1, i); +#endif // defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2)) + 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); } diff --git a/test/fixint.cpp b/test/fixint.cpp index 4aa951f7f..24d7ab8da 100644 --- a/test/fixint.cpp +++ b/test/fixint.cpp @@ -1,21 +1,17 @@ #include -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wconversion" - -#include - -#pragma GCC diagnostic pop +#define BOOST_TEST_MODULE fixint +#include template 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(2); check_size(3); @@ -41,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(); check_convert(); diff --git a/test/fixint_c.cpp b/test/fixint_c.cpp deleted file mode 100644 index 2060c90f6..000000000 --- a/test/fixint_c.cpp +++ /dev/null @@ -1,37 +0,0 @@ -#include - -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wconversion" - -#include - -#pragma GCC diagnostic pop - -TEST(fixint, size) -{ - msgpack_sbuffer* sbuf = msgpack_sbuffer_new(); - msgpack_packer* pk = msgpack_packer_new(sbuf, msgpack_sbuffer_write); - - size_t sum = 0; - - EXPECT_EQ(0, msgpack_pack_fix_int8(pk, 0)); - EXPECT_EQ(sum+=2, sbuf->size); - EXPECT_EQ(0, msgpack_pack_fix_int16(pk, 0)); - EXPECT_EQ(sum+=3, sbuf->size); - EXPECT_EQ(0, msgpack_pack_fix_int32(pk, 0)); - EXPECT_EQ(sum+=5, sbuf->size); - EXPECT_EQ(0, msgpack_pack_fix_int64(pk, 0)); - EXPECT_EQ(sum+=9, sbuf->size); - - EXPECT_EQ(0, msgpack_pack_fix_uint8(pk, 0)); - EXPECT_EQ(sum+=2, sbuf->size); - EXPECT_EQ(0, msgpack_pack_fix_uint16(pk, 0)); - EXPECT_EQ(sum+=3, sbuf->size); - EXPECT_EQ(0, msgpack_pack_fix_uint32(pk, 0)); - EXPECT_EQ(sum+=5, sbuf->size); - EXPECT_EQ(0, msgpack_pack_fix_uint64(pk, 0)); - EXPECT_EQ(sum+=9, sbuf->size); - - msgpack_sbuffer_free(sbuf); - msgpack_packer_free(pk); -} diff --git a/test/fuzz_unpack_pack_fuzzer_cpp11.cpp b/test/fuzz_unpack_pack_fuzzer_cpp11.cpp index 956a7f624..69d72fa3b 100644 --- a/test/fuzz_unpack_pack_fuzzer_cpp11.cpp +++ b/test/fuzz_unpack_pack_fuzzer_cpp11.cpp @@ -1,13 +1,9 @@ -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wconversion" - -#include - -#pragma GCC diagnostic pop +#define BOOST_TEST_MODULE FUZZ_UNPACK_PACK_FUZZER +#include #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, LLVMFuzzerTestOneInput(MSGPACK_NULLPTR, 0)); } diff --git a/test/iterator_cpp11.cpp b/test/iterator_cpp11.cpp index df5a52005..ae2b06e35 100644 --- a/test/iterator_cpp11.cpp +++ b/test/iterator_cpp11.cpp @@ -1,18 +1,12 @@ #include -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wconversion" - -#include - -#pragma GCC diagnostic pop +#define BOOST_TEST_MODULE iterator +#include #ifdef HAVE_CONFIG_H #include "config.h" #endif -using namespace std; - #if !defined(MSGPACK_USE_CPP03) #include @@ -21,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; + using vec_type = std::vector; vec_type vec; vec.reserve(VECTOR_SIZE); for (unsigned int i = 0; i < VECTOR_SIZE; i++) { - vec.push_back(static_cast(rand())); + vec.push_back(static_cast(rand())); } msgpack::sbuffer sbuf; msgpack::pack(sbuf, vec); @@ -38,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(dist), vecSize); + BOOST_CHECK_EQUAL(static_cast(dist), vecSize); vec_type::const_iterator correct = std::begin(vec); for (auto const& obj : msgarr) { auto u64 = *correct; - EXPECT_EQ(obj.as(), u64); + BOOST_CHECK_EQUAL(obj.as(), u64); ++correct; } } -TEST(iterator, map) +BOOST_AUTO_TEST_CASE(map) { - using map_type = map; + using map_type = std::map; map_type map; - for (unsigned int i = 0; i < MAP_SIZE; i++) { - map[static_cast(rand())] = static_cast(rand()); + for (unsigned i = 0; i < MAP_SIZE; i++) { + map[static_cast(rand())] = static_cast(rand()); } msgpack::sbuffer sbuf; msgpack::pack(sbuf, map); @@ -64,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(dist), mapSize); + BOOST_CHECK_EQUAL(static_cast(dist), mapSize); for (auto const& kv : msgmap) { - auto key = kv.key.as(); - auto val = kv.val.as(); + auto key = kv.key.as(); + auto val = kv.val.as(); auto correct = map[key]; - EXPECT_EQ(val, correct); + BOOST_CHECK_EQUAL(val, correct); } } diff --git a/test/json.cpp b/test/json.cpp index 33d00cae4..cff3fcca6 100644 --- a/test/json.cpp +++ b/test/json.cpp @@ -2,14 +2,10 @@ #include #include -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wconversion" +#define BOOST_TEST_MODULE json +#include -#include - -#pragma GCC diagnostic pop - -TEST(json, basic_elements) +BOOST_AUTO_TEST_CASE(basic_elements) { typedef std::map map_s_i; map_s_i msi; @@ -23,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"; @@ -34,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) @@ -48,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 \""); } diff --git a/test/limit.cpp b/test/limit.cpp index a5cbad7ef..de4af2f7d 100644 --- a/test/limit.cpp +++ b/test/limit.cpp @@ -1,15 +1,11 @@ #include -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wconversion" - -#include - -#pragma GCC diagnostic pop +#define BOOST_TEST_MODULE limit +#include #include -TEST(limit, unpack_array_no_over) +BOOST_AUTO_TEST_CASE(unpack_array_no_over) { std::stringstream ss; std::vector v; @@ -21,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 v; @@ -43,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 m; @@ -65,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 m; @@ -87,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"); @@ -106,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"); @@ -125,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 v; @@ -147,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 v; @@ -169,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 packer(ss); @@ -190,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 packer(ss); @@ -211,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 [] = { @@ -236,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 [] = { @@ -262,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 inner; @@ -288,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 inner; @@ -310,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); } } @@ -324,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 v; @@ -336,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 v; @@ -359,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 v; @@ -382,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 v; @@ -406,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 v; @@ -430,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 v; @@ -453,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 v; @@ -476,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 v; @@ -500,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 v; @@ -525,28 +521,28 @@ TEST(limit, unpack_array_over_off_ref_pointer) bool ref; std::size_t off = 0; msgpack::object_handle unp; -#if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2)) +#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2)) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wdeprecated-declarations" -#endif // (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2)) +#endif // defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2)) msgpack::unpack(&unp, ss.str().c_str(), ss.str().size(), &off, &ref, MSGPACK_NULLPTR, MSGPACK_NULLPTR, msgpack::unpack_limit(2, 0, 0, 0, 0)); -#if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2)) +#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2)) #pragma GCC diagnostic pop -#endif // (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2)) - EXPECT_TRUE(false); +#endif // defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2)) + 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 v; @@ -562,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()); } diff --git a/test/msgpack_basic.cpp b/test/msgpack_basic.cpp index 48968a1f5..24b2a31fc 100644 --- a/test/msgpack_basic.cpp +++ b/test/msgpack_basic.cpp @@ -9,12 +9,9 @@ #include #include -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wconversion" - -#include - -#pragma GCC diagnostic pop +#define BOOST_TEST_MODULE MSGPACK +#include +#include #if defined(_MSC_VER) || defined(__MINGW32__) #define msgpack_rand() ((double)rand() / RAND_MAX) @@ -48,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()); \ + BOOST_CHECK_EQUAL(val1, oh.get().as()); \ } \ } 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 v; v.push_back(0.0); @@ -184,11 +181,11 @@ TEST(MSGPACK, simple_buffer_float) float val2 = oh.get().as(); 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); } } @@ -202,12 +199,12 @@ struct TypePair { }; } // namespace -template -class IntegerToFloatingPointTest : public testing::Test { -}; -TYPED_TEST_CASE_P(IntegerToFloatingPointTest); +typedef boost::mpl::list, + TypePair, + TypePair, + TypePair > 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; @@ -217,7 +214,7 @@ TYPED_TEST_P(IntegerToFloatingPointTest, simple_buffer) if (numeric_limits::is_signed) v.push_back(static_cast(-1)); else v.push_back(2); for (unsigned int i = 0; i < kLoop; i++) { - v.push_back(rand() % 0x7FFFFF); + v.push_back(static_cast(rand() % 0x7FFFFF)); } for (unsigned int i = 0; i < v.size() ; i++) { msgpack::sbuffer sbuf; @@ -226,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(); - EXPECT_TRUE(fabs(val2 - static_cast(val1)) <= kEPS); + BOOST_CHECK(fabs(val2 - static_cast(val1)) <= kEPS); } } -REGISTER_TYPED_TEST_CASE_P(IntegerToFloatingPointTest, - simple_buffer); - -typedef testing::Types, - TypePair, - TypePair, - TypePair > 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 v; v.push_back(0.0); @@ -281,27 +267,27 @@ TEST(MSGPACK, simple_buffer_double) double val2 = oh.get().as(); 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 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; @@ -309,10 +295,10 @@ TEST(MSGPACK, simple_buffer_true) msgpack::object_handle oh = msgpack::unpack(sbuf.data(), sbuf.size()); bool val2 = oh.get().as(); - 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; @@ -320,10 +306,10 @@ TEST(MSGPACK, simple_buffer_false) msgpack::object_handle oh = msgpack::unpack(sbuf.data(), sbuf.size()); bool val2 = oh.get().as(); - 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 packer(sbuf); @@ -333,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 packer(sbuf); @@ -358,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 packer(sbuf); @@ -385,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 packer(sbuf); @@ -412,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 packer(sbuf); @@ -439,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; @@ -465,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; @@ -481,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; @@ -510,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; @@ -539,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; @@ -568,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; @@ -599,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; @@ -618,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; @@ -638,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; @@ -658,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; @@ -674,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); - string val2 = oh.get().as(); - 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('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); + BOOST_CHECK_EQUAL(oh.get().type, msgpack::type::STR); string val2 = oh.get().as(); - 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('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(); - 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(); - 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); } } diff --git a/test/msgpack_c.cpp b/test/msgpack_c.cpp deleted file mode 100644 index cb70dfc94..000000000 --- a/test/msgpack_c.cpp +++ /dev/null @@ -1,1370 +0,0 @@ -#include "msgpack.h" - -#include -#include -#include - -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wconversion" - -#include - -#pragma GCC diagnostic pop - -#if defined(_MSC_VER) || defined(__MINGW32__) -#define msgpack_rand() ((double)rand() / RAND_MAX) -#else // _MSC_VER || __MINGW32__ -#define msgpack_rand() drand48() -#endif // _MSC_VER || __MINGW32__ - -using namespace std; - -const unsigned int kLoop = 10000; -const double kEPS = 1e-10; - -#define GEN_TEST_SIGNED(test_type, func_type) \ - do { \ - vector v; \ - v.push_back(0); \ - v.push_back(1); \ - v.push_back(-1); \ - v.push_back(numeric_limits::min()); \ - v.push_back(numeric_limits::max()); \ - for (unsigned int i = 0; i < kLoop; i++) \ - v.push_back(static_cast(rand())); \ - for (unsigned int i = 0; i < v.size() ; i++) { \ - test_type val = v[i]; \ - msgpack_sbuffer sbuf; \ - msgpack_sbuffer_init(&sbuf); \ - msgpack_packer pk; \ - msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write); \ - msgpack_pack_##func_type(&pk, val); \ - msgpack_zone z; \ - msgpack_zone_init(&z, 2048); \ - msgpack_object obj; \ - msgpack_unpack_return ret = \ - msgpack_unpack(sbuf.data, sbuf.size, NULL, &z, &obj); \ - EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret); \ - if (val < 0) { \ - EXPECT_EQ(MSGPACK_OBJECT_NEGATIVE_INTEGER, obj.type); \ - EXPECT_EQ(val, obj.via.i64); \ - } else { \ - EXPECT_EQ(MSGPACK_OBJECT_POSITIVE_INTEGER, obj.type); \ - EXPECT_EQ(static_cast(val), obj.via.u64); \ - } \ - msgpack_zone_destroy(&z); \ - msgpack_sbuffer_destroy(&sbuf); \ - } \ - } while(0) - -#define GEN_TEST_UNSIGNED(test_type, func_type) \ - do { \ - vector v; \ - v.push_back(0); \ - v.push_back(1); \ - v.push_back(2); \ - v.push_back(numeric_limits::min()); \ - v.push_back(numeric_limits::max()); \ - for (unsigned int i = 0; i < kLoop; i++) \ - v.push_back(static_cast(rand())); \ - for (unsigned int i = 0; i < v.size() ; i++) { \ - test_type val = v[i]; \ - msgpack_sbuffer sbuf; \ - msgpack_sbuffer_init(&sbuf); \ - msgpack_packer pk; \ - msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write); \ - msgpack_pack_##func_type(&pk, val); \ - msgpack_zone z; \ - msgpack_zone_init(&z, 2048); \ - msgpack_object obj; \ - msgpack_unpack_return ret = \ - msgpack_unpack(sbuf.data, sbuf.size, NULL, &z, &obj); \ - EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret); \ - EXPECT_EQ(MSGPACK_OBJECT_POSITIVE_INTEGER, obj.type); \ - EXPECT_EQ(val, obj.via.u64); \ - msgpack_zone_destroy(&z); \ - msgpack_sbuffer_destroy(&sbuf); \ - } \ - } while(0) - -TEST(MSGPACKC, simple_buffer_char) -{ -#if defined(CHAR_MIN) -#if CHAR_MIN < 0 - GEN_TEST_SIGNED(char, char); -#else - GEN_TEST_UNSIGNED(char, char); -#endif -#else -#error CHAR_MIN is not defined -#endif -} - -TEST(MSGPACKC, simple_buffer_singed_char) -{ - GEN_TEST_SIGNED(signed char, signed_char); -} - -TEST(MSGPACKC, simple_buffer_short) -{ - GEN_TEST_SIGNED(short, short); -} - -TEST(MSGPACKC, simple_buffer_int) -{ - GEN_TEST_SIGNED(int, int); -} - -TEST(MSGPACKC, simple_buffer_long) -{ - GEN_TEST_SIGNED(long, long); -} - -TEST(MSGPACKC, simple_buffer_long_long) -{ - GEN_TEST_SIGNED(long long, long_long); -} - -TEST(MSGPACKC, simple_buffer_unsigned_char) -{ - GEN_TEST_UNSIGNED(unsigned char, unsigned_char); -} - -TEST(MSGPACKC, simple_buffer_unsigned_short) -{ - GEN_TEST_UNSIGNED(unsigned short, unsigned_short); -} - -TEST(MSGPACKC, simple_buffer_unsigned_int) -{ - GEN_TEST_UNSIGNED(unsigned int, unsigned_int); -} - -TEST(MSGPACKC, simple_buffer_unsigned_long) -{ - GEN_TEST_UNSIGNED(unsigned long, unsigned_long); -} - -TEST(MSGPACKC, simple_buffer_unsigned_long_long) -{ - GEN_TEST_UNSIGNED(unsigned long long, unsigned_long_long); -} - -TEST(MSGPACKC, simple_buffer_uint8) -{ - GEN_TEST_UNSIGNED(uint8_t, uint8); -} - -TEST(MSGPACKC, simple_buffer_uint16) -{ - GEN_TEST_UNSIGNED(uint16_t, uint16); -} - -TEST(MSGPACKC, simple_buffer_uint32) -{ - GEN_TEST_UNSIGNED(uint32_t, uint32); -} - -TEST(MSGPACKC, simple_buffer_uint64) -{ - GEN_TEST_UNSIGNED(uint64_t, uint64); -} - -TEST(MSGPACKC, simple_buffer_int8) -{ - GEN_TEST_SIGNED(int8_t, int8); -} - -TEST(MSGPACKC, simple_buffer_int16) -{ - GEN_TEST_SIGNED(int16_t, int16); -} - -TEST(MSGPACKC, simple_buffer_int32) -{ - GEN_TEST_SIGNED(int32_t, int32); -} - -TEST(MSGPACKC, simple_buffer_int64) -{ - GEN_TEST_SIGNED(int64_t, int64); -} - -#if !defined(_MSC_VER) || _MSC_VER >=1800 - -TEST(MSGPACKC, simple_buffer_float) -{ - vector v; - v.push_back(0.0); - v.push_back(1.0); - v.push_back(-1.0); - v.push_back(numeric_limits::min()); - v.push_back(numeric_limits::max()); - v.push_back(nanf("tag")); - if (numeric_limits::has_infinity) { - v.push_back(numeric_limits::infinity()); - v.push_back(-numeric_limits::infinity()); - } - if (numeric_limits::has_quiet_NaN) { - v.push_back(numeric_limits::quiet_NaN()); - } - if (numeric_limits::has_signaling_NaN) { - v.push_back(numeric_limits::signaling_NaN()); - } - - for (unsigned int i = 0; i < kLoop; i++) { - v.push_back(static_cast(msgpack_rand())); - v.push_back(static_cast(-msgpack_rand())); - } - - for (unsigned int i = 0; i < v.size() ; i++) { - float val = v[i]; - msgpack_sbuffer sbuf; - msgpack_sbuffer_init(&sbuf); - msgpack_packer pk; - msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write); - msgpack_pack_float(&pk, val); - msgpack_zone z; - msgpack_zone_init(&z, 2048); - msgpack_object obj; - msgpack_unpack_return ret = - msgpack_unpack(sbuf.data, sbuf.size, NULL, &z, &obj); - EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret); - EXPECT_EQ(MSGPACK_OBJECT_FLOAT32, obj.type); - if (isnan(val)) { - EXPECT_TRUE(isnan(obj.via.f64)); -#if defined(MSGPACK_USE_LEGACY_NAME_AS_FLOAT) - EXPECT_TRUE(isnan(obj.via.dec)); -#endif // MSGPACK_USE_LEGACY_NAME_AS_FLOAT - } - else if (isinf(val)) { - EXPECT_TRUE(isinf(obj.via.f64)); -#if defined(MSGPACK_USE_LEGACY_NAME_AS_FLOAT) - EXPECT_TRUE(isinf(obj.via.dec)); -#endif // MSGPACK_USE_LEGACY_NAME_AS_FLOAT - } - else { - EXPECT_TRUE(fabs(obj.via.f64 - val) <= kEPS); -#if defined(MSGPACK_USE_LEGACY_NAME_AS_FLOAT) - EXPECT_TRUE(fabs(obj.via.dec - val) <= kEPS); -#endif // MSGPACK_USE_LEGACY_NAME_AS_FLOAT - } - msgpack_zone_destroy(&z); - msgpack_sbuffer_destroy(&sbuf); - } -} - -TEST(MSGPACKC, simple_buffer_double) -{ - vector v; - v.push_back(0.0); - v.push_back(-0.0); - v.push_back(1.0); - v.push_back(-1.0); - v.push_back(numeric_limits::min()); - v.push_back(numeric_limits::max()); - v.push_back(nan("tag")); - if (numeric_limits::has_infinity) { - v.push_back(numeric_limits::infinity()); - v.push_back(-numeric_limits::infinity()); - } - if (numeric_limits::has_quiet_NaN) { - v.push_back(numeric_limits::quiet_NaN()); - } - if (numeric_limits::has_signaling_NaN) { - v.push_back(numeric_limits::signaling_NaN()); - } - for (unsigned int i = 0; i < kLoop; i++) { - v.push_back(msgpack_rand()); - v.push_back(-msgpack_rand()); - } - - for (unsigned int i = 0; i < v.size() ; i++) { - double val = v[i]; - msgpack_sbuffer sbuf; - msgpack_sbuffer_init(&sbuf); - msgpack_packer pk; - msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write); - msgpack_pack_double(&pk, val); - msgpack_zone z; - msgpack_zone_init(&z, 2048); - msgpack_object obj; - msgpack_unpack_return ret = - msgpack_unpack(sbuf.data, sbuf.size, NULL, &z, &obj); - EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret); - EXPECT_EQ(MSGPACK_OBJECT_FLOAT64, obj.type); - EXPECT_EQ(MSGPACK_OBJECT_FLOAT, obj.type); -#if defined(MSGPACK_USE_LEGACY_NAME_AS_FLOAT) - EXPECT_EQ(MSGPACK_OBJECT_DOUBLE, obj.type); -#endif // MSGPACK_USE_LEGACY_NAME_AS_FLOAT - if (isnan(val)) { - EXPECT_TRUE(isnan(obj.via.f64)); -#if defined(MSGPACK_USE_LEGACY_NAME_AS_FLOAT) - EXPECT_TRUE(isnan(obj.via.dec)); -#endif // MSGPACK_USE_LEGACY_NAME_AS_FLOAT - } - else if (isinf(val)) { - EXPECT_TRUE(isinf(obj.via.f64)); -#if defined(MSGPACK_USE_LEGACY_NAME_AS_FLOAT) - EXPECT_TRUE(isinf(obj.via.dec)); -#endif // MSGPACK_USE_LEGACY_NAME_AS_FLOAT - } - else { - EXPECT_TRUE(fabs(obj.via.f64 - val) <= kEPS); -#if defined(MSGPACK_USE_LEGACY_NAME_AS_FLOAT) - EXPECT_TRUE(fabs(obj.via.dec - val) <= kEPS); -#endif // MSGPACK_USE_LEGACY_NAME_AS_FLOAT - } - msgpack_zone_destroy(&z); - msgpack_sbuffer_destroy(&sbuf); - } -} - -#endif // !defined(_MSC_VER) || _MSC_VER >=1800 - -TEST(MSGPACKC, simple_buffer_nil) -{ - msgpack_sbuffer sbuf; - msgpack_sbuffer_init(&sbuf); - msgpack_packer pk; - msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write); - msgpack_pack_nil(&pk); - msgpack_zone z; - msgpack_zone_init(&z, 2048); - msgpack_object obj; - msgpack_unpack_return ret = - msgpack_unpack(sbuf.data, sbuf.size, NULL, &z, &obj); - EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret); - EXPECT_EQ(MSGPACK_OBJECT_NIL, obj.type); - msgpack_zone_destroy(&z); - msgpack_sbuffer_destroy(&sbuf); -} - -TEST(MSGPACKC, simple_buffer_true) -{ - msgpack_sbuffer sbuf; - msgpack_sbuffer_init(&sbuf); - msgpack_packer pk; - msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write); - msgpack_pack_true(&pk); - msgpack_zone z; - msgpack_zone_init(&z, 2048); - msgpack_object obj; - msgpack_unpack_return ret = - msgpack_unpack(sbuf.data, sbuf.size, NULL, &z, &obj); - EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret); - EXPECT_EQ(MSGPACK_OBJECT_BOOLEAN, obj.type); - EXPECT_EQ(true, obj.via.boolean); - msgpack_zone_destroy(&z); - msgpack_sbuffer_destroy(&sbuf); -} - -TEST(MSGPACKC, simple_buffer_false) -{ - msgpack_sbuffer sbuf; - msgpack_sbuffer_init(&sbuf); - msgpack_packer pk; - msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write); - msgpack_pack_false(&pk); - msgpack_zone z; - msgpack_zone_init(&z, 2048); - msgpack_object obj; - msgpack_unpack_return ret = - msgpack_unpack(sbuf.data, sbuf.size, NULL, &z, &obj); - EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret); - EXPECT_EQ(MSGPACK_OBJECT_BOOLEAN, obj.type); - EXPECT_FALSE(obj.via.boolean); - msgpack_zone_destroy(&z); - msgpack_sbuffer_destroy(&sbuf); -} - -TEST(MSGPACKC, simple_buffer_fixext1) -{ - msgpack_sbuffer sbuf; - msgpack_sbuffer_init(&sbuf); - msgpack_packer pk; - msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write); - char const buf[] = { 2 }; - - msgpack_pack_ext(&pk, sizeof(buf), 1); - msgpack_pack_ext_body(&pk, buf, sizeof(buf)); - msgpack_zone z; - msgpack_zone_init(&z, 2048); - msgpack_object obj; - msgpack_unpack_return ret = - msgpack_unpack(sbuf.data, sbuf.size, NULL, &z, &obj); - EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret); - EXPECT_EQ(MSGPACK_OBJECT_EXT, obj.type); - EXPECT_EQ(1u, obj.via.ext.size); - EXPECT_EQ(1, obj.via.ext.type); - EXPECT_EQ(2, obj.via.ext.ptr[0]); - msgpack_zone_destroy(&z); - msgpack_sbuffer_destroy(&sbuf); -} - -TEST(MSGPACKC, simple_buffer_fixext2) -{ - msgpack_sbuffer sbuf; - msgpack_sbuffer_init(&sbuf); - msgpack_packer pk; - msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write); - char const buf[] = { 2, 3 }; - - msgpack_pack_ext(&pk, sizeof(buf), 0); - msgpack_pack_ext_body(&pk, buf, sizeof(buf)); - msgpack_zone z; - msgpack_zone_init(&z, 2048); - msgpack_object obj; - msgpack_unpack_return ret = - msgpack_unpack(sbuf.data, sbuf.size, NULL, &z, &obj); - EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret); - EXPECT_EQ(MSGPACK_OBJECT_EXT, obj.type); - EXPECT_EQ(2u, obj.via.ext.size); - EXPECT_EQ(0, obj.via.ext.type); - EXPECT_EQ(0, memcmp(buf, obj.via.ext.ptr, sizeof(buf))); - msgpack_zone_destroy(&z); - msgpack_sbuffer_destroy(&sbuf); -} - -TEST(MSGPACKC, simple_buffer_fixext4) -{ - msgpack_sbuffer sbuf; - msgpack_sbuffer_init(&sbuf); - msgpack_packer pk; - msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write); - char const buf[] = { 2, 3, 4, 5 }; - - msgpack_pack_ext(&pk, sizeof(buf), 1); - msgpack_pack_ext_body(&pk, buf, sizeof(buf)); - msgpack_zone z; - msgpack_zone_init(&z, 2048); - msgpack_object obj; - msgpack_unpack_return ret = - msgpack_unpack(sbuf.data, sbuf.size, NULL, &z, &obj); - EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret); - EXPECT_EQ(MSGPACK_OBJECT_EXT, obj.type); - EXPECT_EQ(4u, obj.via.ext.size); - EXPECT_EQ(1, obj.via.ext.type); - EXPECT_EQ(0, memcmp(buf, obj.via.ext.ptr, sizeof(buf))); - msgpack_zone_destroy(&z); - msgpack_sbuffer_destroy(&sbuf); -} - -TEST(MSGPACKC, simple_buffer_fixext8) -{ - msgpack_sbuffer sbuf; - msgpack_sbuffer_init(&sbuf); - msgpack_packer pk; - msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write); - char const buf [] = { 2, 3, 4, 5, 6, 7, 8, 9 }; - - msgpack_pack_ext(&pk, sizeof(buf), 1); - msgpack_pack_ext_body(&pk, buf, sizeof(buf)); - msgpack_zone z; - msgpack_zone_init(&z, 2048); - msgpack_object obj; - msgpack_unpack_return ret = - msgpack_unpack(sbuf.data, sbuf.size, NULL, &z, &obj); - EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret); - EXPECT_EQ(MSGPACK_OBJECT_EXT, obj.type); - EXPECT_EQ(8u, obj.via.ext.size); - EXPECT_EQ(1, obj.via.ext.type); - EXPECT_EQ(0, memcmp(buf, obj.via.ext.ptr, sizeof(buf))); - msgpack_zone_destroy(&z); - msgpack_sbuffer_destroy(&sbuf); -} - -TEST(MSGPACKC, simple_buffer_fixext16) -{ - msgpack_sbuffer sbuf; - msgpack_sbuffer_init(&sbuf); - msgpack_packer pk; - msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write); - char const buf [] = { 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17 }; - - msgpack_pack_ext(&pk, sizeof(buf), 1); - msgpack_pack_ext_body(&pk, buf, sizeof(buf)); - msgpack_zone z; - msgpack_zone_init(&z, 2048); - msgpack_object obj; - msgpack_unpack_return ret = - msgpack_unpack(sbuf.data, sbuf.size, NULL, &z, &obj); - EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret); - EXPECT_EQ(MSGPACK_OBJECT_EXT, obj.type); - EXPECT_EQ(16u, obj.via.ext.size); - EXPECT_EQ(1, obj.via.ext.type); - EXPECT_EQ(0, memcmp(buf, obj.via.ext.ptr, sizeof(buf))); - msgpack_zone_destroy(&z); - msgpack_sbuffer_destroy(&sbuf); -} - -TEST(MSGPACKC, simple_buffer_fixext_1byte_0) -{ - const size_t size = 0; - msgpack_sbuffer sbuf; - msgpack_sbuffer_init(&sbuf); - msgpack_packer pk; - msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write); - - msgpack_pack_ext(&pk, size, 77); - // fprintf(stderr, "size: %u, data: \"", sbuf.size); - // for (size_t i = 0; i < sbuf.size; i++) - // fprintf(stderr, "%02x ", (uint8_t)sbuf.data[i]); - // fprintf(stderr, "\"\n"); - msgpack_zone z; - msgpack_zone_init(&z, 2048); - msgpack_object obj; - msgpack_unpack_return ret = - msgpack_unpack(sbuf.data, sbuf.size, NULL, &z, &obj); - EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret); - EXPECT_EQ(MSGPACK_OBJECT_EXT, obj.type); - EXPECT_EQ(size, obj.via.ext.size); - EXPECT_EQ(77, obj.via.ext.type); - msgpack_zone_destroy(&z); - msgpack_sbuffer_destroy(&sbuf); -} - -TEST(MSGPACKC, simple_buffer_fixext_1byte_255) -{ - const size_t size = 255; - char buf[size]; - for (size_t i = 0; i != size; ++i) buf[i] = (char)i; - - msgpack_sbuffer sbuf; - msgpack_sbuffer_init(&sbuf); - msgpack_packer pk; - msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write); - - msgpack_pack_ext(&pk, size, 78); - msgpack_pack_ext_body(&pk, buf, sizeof(buf)); - msgpack_zone z; - msgpack_zone_init(&z, 2048); - msgpack_object obj; - msgpack_unpack_return ret = - msgpack_unpack(sbuf.data, sbuf.size, NULL, &z, &obj); - EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret); - EXPECT_EQ(MSGPACK_OBJECT_EXT, obj.type); - EXPECT_EQ(size, obj.via.ext.size); - EXPECT_EQ(78, obj.via.ext.type); - EXPECT_EQ(0, memcmp(buf, obj.via.ext.ptr, sizeof(buf))); - msgpack_zone_destroy(&z); - msgpack_sbuffer_destroy(&sbuf); -} - -TEST(MSGPACKC, simple_buffer_fixext_2byte_256) -{ - const size_t size = 256; - char buf[size]; - for (size_t i = 0; i != size; ++i) buf[i] = (char)i; - - msgpack_sbuffer sbuf; - msgpack_sbuffer_init(&sbuf); - msgpack_packer pk; - msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write); - - msgpack_pack_ext(&pk, size, 79); - msgpack_pack_ext_body(&pk, buf, sizeof(buf)); - msgpack_zone z; - msgpack_zone_init(&z, 2048); - msgpack_object obj; - msgpack_unpack_return ret = - msgpack_unpack(sbuf.data, sbuf.size, NULL, &z, &obj); - EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret); - EXPECT_EQ(MSGPACK_OBJECT_EXT, obj.type); - EXPECT_EQ(size, obj.via.ext.size); - EXPECT_EQ(79, obj.via.ext.type); - EXPECT_EQ(0, memcmp(buf, obj.via.ext.ptr, sizeof(buf))); - msgpack_zone_destroy(&z); - msgpack_sbuffer_destroy(&sbuf); -} - -TEST(MSGPACKC, simple_buffer_fixext_2byte_65535) -{ - const size_t size = 65535; - char buf[size]; - for (size_t i = 0; i != size; ++i) buf[i] = (char)i; - - msgpack_sbuffer sbuf; - msgpack_sbuffer_init(&sbuf); - msgpack_packer pk; - msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write); - - msgpack_pack_ext(&pk, size, 80); - msgpack_pack_ext_body(&pk, buf, sizeof(buf)); - msgpack_zone z; - msgpack_zone_init(&z, 2048); - msgpack_object obj; - msgpack_unpack_return ret = - msgpack_unpack(sbuf.data, sbuf.size, NULL, &z, &obj); - EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret); - EXPECT_EQ(MSGPACK_OBJECT_EXT, obj.type); - EXPECT_EQ(size, obj.via.ext.size); - EXPECT_EQ(80, obj.via.ext.type); - EXPECT_EQ(0, memcmp(buf, obj.via.ext.ptr, sizeof(buf))); - msgpack_zone_destroy(&z); - msgpack_sbuffer_destroy(&sbuf); -} - -TEST(MSGPACKC, simple_buffer_fixext_4byte_65536) -{ - const size_t size = 65536; - char buf[size]; - for (size_t i = 0; i != size; ++i) buf[i] = (char)i; - - msgpack_sbuffer sbuf; - msgpack_sbuffer_init(&sbuf); - msgpack_packer pk; - msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write); - - msgpack_pack_ext(&pk, size, 81); - msgpack_pack_ext_body(&pk, buf, sizeof(buf)); - msgpack_zone z; - msgpack_zone_init(&z, 2048); - msgpack_object obj; - msgpack_unpack_return ret = - msgpack_unpack(sbuf.data, sbuf.size, NULL, &z, &obj); - EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret); - EXPECT_EQ(MSGPACK_OBJECT_EXT, obj.type); - EXPECT_EQ(size, obj.via.ext.size); - EXPECT_EQ(81, obj.via.ext.type); - EXPECT_EQ(0, memcmp(buf, obj.via.ext.ptr, sizeof(buf))); - msgpack_zone_destroy(&z); - msgpack_sbuffer_destroy(&sbuf); -} - -TEST(MSGPACKC, simple_buffer_timestamp_32) -{ - msgpack_timestamp ts = { - 0xffffffff, - 0 - }; - - msgpack_sbuffer sbuf; - msgpack_sbuffer_init(&sbuf); - msgpack_packer pk; - msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write); - - msgpack_pack_timestamp(&pk, &ts); - msgpack_zone z; - msgpack_zone_init(&z, 2048); - msgpack_object obj; - msgpack_unpack_return ret = - msgpack_unpack(sbuf.data, sbuf.size, NULL, &z, &obj); - EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret); - EXPECT_EQ(MSGPACK_OBJECT_EXT, obj.type); - EXPECT_EQ(4u, obj.via.ext.size); - EXPECT_EQ(-1, obj.via.ext.type); - msgpack_timestamp ts2; - bool r = msgpack_object_to_timestamp(&obj, &ts2); - - EXPECT_TRUE(r); - EXPECT_EQ(ts.tv_sec, ts2.tv_sec); - EXPECT_EQ(ts.tv_nsec, ts2.tv_nsec); - - msgpack_zone_destroy(&z); - msgpack_sbuffer_destroy(&sbuf); -} - -TEST(MSGPACKC, simple_buffer_timestamp_64) -{ - msgpack_timestamp ts = { - 0x3ffffffffL, - 999999999 - }; - - msgpack_sbuffer sbuf; - msgpack_sbuffer_init(&sbuf); - msgpack_packer pk; - msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write); - - msgpack_pack_timestamp(&pk, &ts); - msgpack_zone z; - msgpack_zone_init(&z, 2048); - msgpack_object obj; - msgpack_unpack_return ret = - msgpack_unpack(sbuf.data, sbuf.size, NULL, &z, &obj); - EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret); - EXPECT_EQ(MSGPACK_OBJECT_EXT, obj.type); - EXPECT_EQ(8u, obj.via.ext.size); - EXPECT_EQ(-1, obj.via.ext.type); - msgpack_timestamp ts2; - bool r = msgpack_object_to_timestamp(&obj, &ts2); - - EXPECT_TRUE(r); - EXPECT_EQ(ts.tv_sec, ts2.tv_sec); - EXPECT_EQ(ts.tv_nsec, ts2.tv_nsec); - - msgpack_zone_destroy(&z); - msgpack_sbuffer_destroy(&sbuf); -} - -TEST(MSGPACKC, simple_buffer_timestamp_96) -{ - msgpack_timestamp ts = { - 0x7fffffffffffffffLL, - 999999999 - }; - - msgpack_sbuffer sbuf; - msgpack_sbuffer_init(&sbuf); - msgpack_packer pk; - msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write); - - msgpack_pack_timestamp(&pk, &ts); - msgpack_zone z; - msgpack_zone_init(&z, 2048); - msgpack_object obj; - msgpack_unpack_return ret = - msgpack_unpack(sbuf.data, sbuf.size, NULL, &z, &obj); - EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret); - EXPECT_EQ(MSGPACK_OBJECT_EXT, obj.type); - EXPECT_EQ(12u, obj.via.ext.size); - EXPECT_EQ(-1, obj.via.ext.type); - msgpack_timestamp ts2; - bool r = msgpack_object_to_timestamp(&obj, &ts2); - - EXPECT_TRUE(r); - EXPECT_EQ(ts.tv_sec, ts2.tv_sec); - EXPECT_EQ(ts.tv_nsec, ts2.tv_nsec); - - msgpack_zone_destroy(&z); - msgpack_sbuffer_destroy(&sbuf); -} - -TEST(MSGPACKC, simple_buffer_array) -{ - unsigned int array_size = 5; - - msgpack_sbuffer sbuf; - msgpack_sbuffer_init(&sbuf); - msgpack_packer pk; - msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write); - msgpack_pack_array(&pk, array_size); - msgpack_pack_nil(&pk); - msgpack_pack_true(&pk); - msgpack_pack_false(&pk); - msgpack_pack_int(&pk, 10); - msgpack_pack_int(&pk, -10); - - msgpack_zone z; - msgpack_zone_init(&z, 2048); - msgpack_object obj; - msgpack_unpack_return ret; - ret = msgpack_unpack(sbuf.data, sbuf.size, NULL, &z, &obj); - EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret); - EXPECT_EQ(MSGPACK_OBJECT_ARRAY, obj.type); - EXPECT_EQ(array_size, obj.via.array.size); - - for (unsigned int i = 0; i < obj.via.array.size; i++) { - msgpack_object o = obj.via.array.ptr[i]; - switch (i) { - case 0: - EXPECT_EQ(MSGPACK_OBJECT_NIL, o.type); - break; - case 1: - EXPECT_EQ(MSGPACK_OBJECT_BOOLEAN, o.type); - EXPECT_EQ(true, o.via.boolean); - break; - case 2: - EXPECT_EQ(MSGPACK_OBJECT_BOOLEAN, o.type); - EXPECT_FALSE(o.via.boolean); - break; - case 3: - EXPECT_EQ(MSGPACK_OBJECT_POSITIVE_INTEGER, o.type); - EXPECT_EQ(10u, o.via.u64); - break; - case 4: - EXPECT_EQ(MSGPACK_OBJECT_NEGATIVE_INTEGER, o.type); - EXPECT_EQ(-10, o.via.i64); - break; - } - } - - msgpack_zone_destroy(&z); - msgpack_sbuffer_destroy(&sbuf); -} - -TEST(MSGPACKC, simple_buffer_map) -{ - unsigned int map_size = 2; - - msgpack_sbuffer sbuf; - msgpack_sbuffer_init(&sbuf); - msgpack_packer pk; - msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write); - msgpack_pack_map(&pk, map_size); - msgpack_pack_true(&pk); - msgpack_pack_false(&pk); - msgpack_pack_int(&pk, 10); - msgpack_pack_int(&pk, -10); - - msgpack_zone z; - msgpack_zone_init(&z, 2048); - msgpack_object obj; - msgpack_unpack_return ret; - ret = msgpack_unpack(sbuf.data, sbuf.size, NULL, &z, &obj); - EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret); - EXPECT_EQ(MSGPACK_OBJECT_MAP, obj.type); - EXPECT_EQ(map_size, obj.via.map.size); - - for (unsigned int i = 0; i < map_size; i++) { - msgpack_object key = obj.via.map.ptr[i].key; - msgpack_object val = obj.via.map.ptr[i].val; - switch (i) { - case 0: - EXPECT_EQ(MSGPACK_OBJECT_BOOLEAN, key.type); - EXPECT_EQ(true, key.via.boolean); - EXPECT_EQ(MSGPACK_OBJECT_BOOLEAN, val.type); - EXPECT_FALSE(val.via.boolean); - break; - case 1: - EXPECT_EQ(MSGPACK_OBJECT_POSITIVE_INTEGER, key.type); - EXPECT_EQ(10u, key.via.u64); - EXPECT_EQ(MSGPACK_OBJECT_NEGATIVE_INTEGER, val.type); - EXPECT_EQ(-10, val.via.i64); - break; - } - } - - msgpack_zone_destroy(&z); - msgpack_sbuffer_destroy(&sbuf); -} - -TEST(MSGPACKC, simple_buffer_str) -{ - unsigned int str_size = 7; - - msgpack_sbuffer sbuf; - msgpack_sbuffer_init(&sbuf); - msgpack_packer pk; - msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write); - msgpack_pack_str(&pk, str_size); - msgpack_pack_str_body(&pk, "fr", 2); - msgpack_pack_str_body(&pk, "syuki", 5); - // invalid data - msgpack_pack_str_body(&pk, "", 0); - msgpack_pack_str_body(&pk, "kzk", 0); - - msgpack_zone z; - msgpack_zone_init(&z, 2048); - msgpack_object obj; - msgpack_unpack_return ret; - ret = msgpack_unpack(sbuf.data, sbuf.size, NULL, &z, &obj); - EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret); - EXPECT_EQ(MSGPACK_OBJECT_STR, obj.type); - EXPECT_EQ(str_size, obj.via.str.size); - EXPECT_EQ(0, memcmp("frsyuki", obj.via.str.ptr, str_size)); - - msgpack_zone_destroy(&z); - msgpack_sbuffer_destroy(&sbuf); -} - -TEST(MSGPACKC, simple_buffer_str_fix_l) -{ - char const* str = NULL; - unsigned int str_size = 0; - msgpack_sbuffer sbuf; - msgpack_sbuffer_init(&sbuf); - msgpack_packer pk; - msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write); - msgpack_pack_str(&pk, str_size); - msgpack_pack_str_body(&pk, str, str_size); - EXPECT_EQ(sbuf.size, 0x01u); - EXPECT_EQ(sbuf.data[0], static_cast(0xa0u)); - - msgpack_zone z; - msgpack_zone_init(&z, 2048); - msgpack_object obj; - msgpack_unpack_return ret; - ret = msgpack_unpack(sbuf.data, sbuf.size, NULL, &z, &obj); - EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret); - EXPECT_EQ(MSGPACK_OBJECT_STR, obj.type); - EXPECT_EQ(str_size, obj.via.str.size); - - msgpack_zone_destroy(&z); - msgpack_sbuffer_destroy(&sbuf); -} - -TEST(MSGPACKC, simple_buffer_str_fix_h) -{ - char str[0x1f] = {'0'}; - unsigned int str_size = sizeof(str); - msgpack_sbuffer sbuf; - msgpack_sbuffer_init(&sbuf); - msgpack_packer pk; - msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write); - msgpack_pack_str(&pk, str_size); - msgpack_pack_str_body(&pk, str, str_size); - EXPECT_EQ(sbuf.size, 0x1f+1u); - EXPECT_EQ(sbuf.data[0], static_cast(0xbfu)); - - msgpack_zone z; - msgpack_zone_init(&z, 2048); - msgpack_object obj; - msgpack_unpack_return ret; - ret = msgpack_unpack(sbuf.data, sbuf.size, NULL, &z, &obj); - EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret); - EXPECT_EQ(MSGPACK_OBJECT_STR, obj.type); - EXPECT_EQ(str_size, obj.via.str.size); - EXPECT_EQ(0, memcmp(str, obj.via.str.ptr, str_size)); - - msgpack_zone_destroy(&z); - msgpack_sbuffer_destroy(&sbuf); -} - -TEST(MSGPACKC, simple_buffer_str_8_l) -{ - char str[0x1f+1] = {'0'}; - unsigned int str_size = sizeof(str); - msgpack_sbuffer sbuf; - msgpack_sbuffer_init(&sbuf); - msgpack_packer pk; - msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write); - msgpack_pack_str(&pk, str_size); - msgpack_pack_str_body(&pk, str, str_size); - EXPECT_EQ(sbuf.size, 0x1f+1+2u); - EXPECT_EQ(sbuf.data[0], static_cast(0xd9u)); - EXPECT_EQ(sbuf.data[1], static_cast(0x20u)); - - msgpack_zone z; - msgpack_zone_init(&z, 2048); - msgpack_object obj; - msgpack_unpack_return ret; - ret = msgpack_unpack(sbuf.data, sbuf.size, NULL, &z, &obj); - EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret); - EXPECT_EQ(MSGPACK_OBJECT_STR, obj.type); - EXPECT_EQ(str_size, obj.via.str.size); - EXPECT_EQ(0, memcmp(str, obj.via.str.ptr, str_size)); - - msgpack_zone_destroy(&z); - msgpack_sbuffer_destroy(&sbuf); -} - -TEST(MSGPACKC, simple_buffer_str_8_h) -{ - char str[0xff] = {'0'}; - unsigned int str_size = sizeof(str); - msgpack_sbuffer sbuf; - msgpack_sbuffer_init(&sbuf); - msgpack_packer pk; - msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write); - msgpack_pack_str(&pk, str_size); - msgpack_pack_str_body(&pk, str, str_size); - EXPECT_EQ(sbuf.size, 0xff+2u); - EXPECT_EQ(sbuf.data[0], static_cast(0xd9u)); - EXPECT_EQ(sbuf.data[1], static_cast(0xffu)); - - msgpack_zone z; - msgpack_zone_init(&z, 2048); - msgpack_object obj; - msgpack_unpack_return ret; - ret = msgpack_unpack(sbuf.data, sbuf.size, NULL, &z, &obj); - EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret); - EXPECT_EQ(MSGPACK_OBJECT_STR, obj.type); - EXPECT_EQ(str_size, obj.via.str.size); - EXPECT_EQ(0, memcmp(str, obj.via.str.ptr, str_size)); - - msgpack_zone_destroy(&z); - msgpack_sbuffer_destroy(&sbuf); -} - -TEST(MSGPACKC, simple_buffer_str_16_l) -{ - char str[0xff+1] = {'0'}; - unsigned int str_size = sizeof(str); - msgpack_sbuffer sbuf; - msgpack_sbuffer_init(&sbuf); - msgpack_packer pk; - msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write); - msgpack_pack_str(&pk, str_size); - msgpack_pack_str_body(&pk, str, str_size); - EXPECT_EQ(sbuf.size, 0xff+1+3u); - EXPECT_EQ(sbuf.data[0], static_cast(0xdau)); - EXPECT_EQ(sbuf.data[1], static_cast(0x01u)); - EXPECT_EQ(sbuf.data[2], static_cast(0x00u)); - - msgpack_zone z; - msgpack_zone_init(&z, 2048); - msgpack_object obj; - msgpack_unpack_return ret; - ret = msgpack_unpack(sbuf.data, sbuf.size, NULL, &z, &obj); - EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret); - EXPECT_EQ(MSGPACK_OBJECT_STR, obj.type); - EXPECT_EQ(str_size, obj.via.str.size); - EXPECT_EQ(0, memcmp(str, obj.via.str.ptr, str_size)); - - msgpack_zone_destroy(&z); - msgpack_sbuffer_destroy(&sbuf); -} - -TEST(MSGPACKC, simple_buffer_str_16_h) -{ - char str[0xffff] = {'0'}; - unsigned int str_size = sizeof(str); - msgpack_sbuffer sbuf; - msgpack_sbuffer_init(&sbuf); - msgpack_packer pk; - msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write); - msgpack_pack_str(&pk, str_size); - msgpack_pack_str_body(&pk, str, str_size); - EXPECT_EQ(sbuf.size, 0xffff+3u); - EXPECT_EQ(sbuf.data[0], static_cast(0xdau)); - EXPECT_EQ(sbuf.data[1], static_cast(0xffu)); - EXPECT_EQ(sbuf.data[2], static_cast(0xffu)); - - msgpack_zone z; - msgpack_zone_init(&z, 2048); - msgpack_object obj; - msgpack_unpack_return ret; - ret = msgpack_unpack(sbuf.data, sbuf.size, NULL, &z, &obj); - EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret); - EXPECT_EQ(MSGPACK_OBJECT_STR, obj.type); - EXPECT_EQ(str_size, obj.via.str.size); - EXPECT_EQ(0, memcmp(str, obj.via.str.ptr, str_size)); - - msgpack_zone_destroy(&z); - msgpack_sbuffer_destroy(&sbuf); -} - -TEST(MSGPACKC, simple_buffer_str_32_l) -{ - char str[0xffff+1] = {'0'}; - unsigned int str_size = sizeof(str); - msgpack_sbuffer sbuf; - msgpack_sbuffer_init(&sbuf); - msgpack_packer pk; - msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write); - msgpack_pack_str(&pk, str_size); - msgpack_pack_str_body(&pk, str, str_size); - EXPECT_EQ(sbuf.size, 0xffff+1+5u); - EXPECT_EQ(sbuf.data[0], static_cast(0xdbu)); - EXPECT_EQ(sbuf.data[1], static_cast(0x00u)); - EXPECT_EQ(sbuf.data[2], static_cast(0x01u)); - EXPECT_EQ(sbuf.data[3], static_cast(0x00u)); - EXPECT_EQ(sbuf.data[4], static_cast(0x00u)); - - msgpack_zone z; - msgpack_zone_init(&z, 2048); - msgpack_object obj; - msgpack_unpack_return ret; - ret = msgpack_unpack(sbuf.data, sbuf.size, NULL, &z, &obj); - EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret); - EXPECT_EQ(MSGPACK_OBJECT_STR, obj.type); - EXPECT_EQ(str_size, obj.via.str.size); - EXPECT_EQ(0, memcmp(str, obj.via.str.ptr, str_size)); - - msgpack_zone_destroy(&z); - msgpack_sbuffer_destroy(&sbuf); -} - -TEST(MSGPACKC, simple_buffer_v4raw_fix_l) -{ - char const* str = NULL; - unsigned int str_size = 0; - msgpack_sbuffer sbuf; - msgpack_sbuffer_init(&sbuf); - msgpack_packer pk; - msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write); - msgpack_pack_v4raw(&pk, str_size); - msgpack_pack_v4raw_body(&pk, str, str_size); - EXPECT_EQ(sbuf.size, 0x01u); - EXPECT_EQ(sbuf.data[0], static_cast(0xa0u)); - - msgpack_zone z; - msgpack_zone_init(&z, 2048); - msgpack_object obj; - msgpack_unpack_return ret; - ret = msgpack_unpack(sbuf.data, sbuf.size, NULL, &z, &obj); - EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret); - EXPECT_EQ(MSGPACK_OBJECT_STR, obj.type); - EXPECT_EQ(str_size, obj.via.str.size); - - msgpack_zone_destroy(&z); - msgpack_sbuffer_destroy(&sbuf); -} - -TEST(MSGPACKC, simple_buffer_v4raw_fix_h) -{ - char str[0x1f] = {'0'}; - unsigned int str_size = sizeof(str); - msgpack_sbuffer sbuf; - msgpack_sbuffer_init(&sbuf); - msgpack_packer pk; - msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write); - msgpack_pack_v4raw(&pk, str_size); - msgpack_pack_v4raw_body(&pk, str, str_size); - EXPECT_EQ(sbuf.size, 0x1f+1u); - EXPECT_EQ(sbuf.data[0], static_cast(0xbfu)); - - msgpack_zone z; - msgpack_zone_init(&z, 2048); - msgpack_object obj; - msgpack_unpack_return ret; - ret = msgpack_unpack(sbuf.data, sbuf.size, NULL, &z, &obj); - EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret); - EXPECT_EQ(MSGPACK_OBJECT_STR, obj.type); - EXPECT_EQ(str_size, obj.via.str.size); - EXPECT_EQ(0, memcmp(str, obj.via.str.ptr, str_size)); - - msgpack_zone_destroy(&z); - msgpack_sbuffer_destroy(&sbuf); -} - -TEST(MSGPACKC, simple_buffer_v4raw_16_l) -{ - char str[0x1f+1] = {'0'}; - unsigned int str_size = sizeof(str); - msgpack_sbuffer sbuf; - msgpack_sbuffer_init(&sbuf); - msgpack_packer pk; - msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write); - msgpack_pack_v4raw(&pk, str_size); - msgpack_pack_v4raw_body(&pk, str, str_size); - EXPECT_EQ(sbuf.size, 0x1f+1+3u); - EXPECT_EQ(sbuf.data[0], static_cast(0xdau)); - EXPECT_EQ(sbuf.data[1], static_cast(0x00u)); - EXPECT_EQ(sbuf.data[2], static_cast(0x20u)); - - msgpack_zone z; - msgpack_zone_init(&z, 2048); - msgpack_object obj; - msgpack_unpack_return ret; - ret = msgpack_unpack(sbuf.data, sbuf.size, NULL, &z, &obj); - EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret); - EXPECT_EQ(MSGPACK_OBJECT_STR, obj.type); - EXPECT_EQ(str_size, obj.via.str.size); - EXPECT_EQ(0, memcmp(str, obj.via.str.ptr, str_size)); - - msgpack_zone_destroy(&z); - msgpack_sbuffer_destroy(&sbuf); -} - -TEST(MSGPACKC, simple_buffer_v4raw_16_h) -{ - char str[0xffff] = {'0'}; - unsigned int str_size = sizeof(str); - msgpack_sbuffer sbuf; - msgpack_sbuffer_init(&sbuf); - msgpack_packer pk; - msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write); - msgpack_pack_v4raw(&pk, str_size); - msgpack_pack_v4raw_body(&pk, str, str_size); - EXPECT_EQ(sbuf.size, 0xffff+3u); - EXPECT_EQ(sbuf.data[0], static_cast(0xdau)); - EXPECT_EQ(sbuf.data[1], static_cast(0xffu)); - EXPECT_EQ(sbuf.data[2], static_cast(0xffu)); - - msgpack_zone z; - msgpack_zone_init(&z, 2048); - msgpack_object obj; - msgpack_unpack_return ret; - ret = msgpack_unpack(sbuf.data, sbuf.size, NULL, &z, &obj); - EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret); - EXPECT_EQ(MSGPACK_OBJECT_STR, obj.type); - EXPECT_EQ(str_size, obj.via.str.size); - EXPECT_EQ(0, memcmp(str, obj.via.str.ptr, str_size)); - - msgpack_zone_destroy(&z); - msgpack_sbuffer_destroy(&sbuf); -} - -TEST(MSGPACKC, simple_buffer_v4raw_32_l) -{ - char str[0xffff+1] = {'0'}; - unsigned int str_size = sizeof(str); - msgpack_sbuffer sbuf; - msgpack_sbuffer_init(&sbuf); - msgpack_packer pk; - msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write); - msgpack_pack_v4raw(&pk, str_size); - msgpack_pack_v4raw_body(&pk, str, str_size); - EXPECT_EQ(sbuf.size, 0xffff+1+5u); - EXPECT_EQ(sbuf.data[0], static_cast(0xdbu)); - EXPECT_EQ(sbuf.data[1], static_cast(0x00u)); - EXPECT_EQ(sbuf.data[2], static_cast(0x01u)); - EXPECT_EQ(sbuf.data[3], static_cast(0x00u)); - EXPECT_EQ(sbuf.data[4], static_cast(0x00u)); - - msgpack_zone z; - msgpack_zone_init(&z, 2048); - msgpack_object obj; - msgpack_unpack_return ret; - ret = msgpack_unpack(sbuf.data, sbuf.size, NULL, &z, &obj); - EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret); - EXPECT_EQ(MSGPACK_OBJECT_STR, obj.type); - EXPECT_EQ(str_size, obj.via.str.size); - EXPECT_EQ(0, memcmp(str, obj.via.str.ptr, str_size)); - - msgpack_zone_destroy(&z); - msgpack_sbuffer_destroy(&sbuf); -} - - -TEST(MSGPACKC, unpack_fixstr) -{ - size_t str_size = 7; - const char buf[] = { - (char)0xa7, 'f', 'r', 's', 'y', 'u', 'k', 'i' - }; - - msgpack_zone z; - msgpack_zone_init(&z, 2048); - msgpack_object obj; - msgpack_unpack_return ret; - ret = msgpack_unpack(buf, sizeof(buf), NULL, &z, &obj); - EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret); - EXPECT_EQ(MSGPACK_OBJECT_STR, obj.type); - EXPECT_EQ(str_size, obj.via.str.size); - EXPECT_EQ(0, memcmp("frsyuki", obj.via.str.ptr, str_size)); - - msgpack_zone_destroy(&z); -} - -TEST(MSGPACKC, unpack_str8) -{ - size_t str_size = 7; - const char buf[] = { - (char)0xd9, 7, 'f', 'r', 's', 'y', 'u', 'k', 'i' - }; - - msgpack_zone z; - msgpack_zone_init(&z, 2048); - msgpack_object obj; - msgpack_unpack_return ret; - ret = msgpack_unpack(buf, sizeof(buf), NULL, &z, &obj); - EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret); - EXPECT_EQ(MSGPACK_OBJECT_STR, obj.type); - EXPECT_EQ(str_size, obj.via.str.size); - EXPECT_EQ(0, memcmp("frsyuki", obj.via.str.ptr, str_size)); - - msgpack_zone_destroy(&z); -} - -TEST(MSGPACKC, unpack_str16) -{ - size_t str_size = 7; - const char buf[] = { - (char)0xda, 0, 7, 'f', 'r', 's', 'y', 'u', 'k', 'i' - }; - - msgpack_zone z; - msgpack_zone_init(&z, 2048); - msgpack_object obj; - msgpack_unpack_return ret; - ret = msgpack_unpack(buf, sizeof(buf), NULL, &z, &obj); - EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret); - EXPECT_EQ(MSGPACK_OBJECT_STR, obj.type); - EXPECT_EQ(str_size, obj.via.str.size); - EXPECT_EQ(0, memcmp("frsyuki", obj.via.str.ptr, str_size)); - - msgpack_zone_destroy(&z); -} - -TEST(MSGPACKC, unpack_str32) -{ - size_t str_size = 7; - const char buf[] = { - (char)0xdb, 0, 0, 0, 7, 'f', 'r', 's', 'y', 'u', 'k', 'i' - }; - - msgpack_zone z; - msgpack_zone_init(&z, 2048); - msgpack_object obj; - msgpack_unpack_return ret; - ret = msgpack_unpack(buf, sizeof(buf), NULL, &z, &obj); - EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret); - EXPECT_EQ(MSGPACK_OBJECT_STR, obj.type); - EXPECT_EQ(str_size, obj.via.str.size); - EXPECT_EQ(0, memcmp("frsyuki", obj.via.str.ptr, str_size)); - - msgpack_zone_destroy(&z); -} - -TEST(MSGPACKC, unpack_bin8) -{ - size_t bin_size = 7; - const char buf[] = { - (char)0xc4, 7, 'f', 'r', 's', 'y', 'u', 'k', 'i' - }; - - msgpack_zone z; - msgpack_zone_init(&z, 2048); - msgpack_object obj; - msgpack_unpack_return ret; - ret = msgpack_unpack(buf, sizeof(buf), NULL, &z, &obj); - EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret); - EXPECT_EQ(MSGPACK_OBJECT_BIN, obj.type); - EXPECT_EQ(bin_size, obj.via.bin.size); - EXPECT_EQ(0, memcmp("frsyuki", obj.via.bin.ptr, bin_size)); - - msgpack_zone_destroy(&z); -} - -TEST(MSGPACKC, unpack_bin16) -{ - size_t bin_size = 7; - const char buf[] = { - (char)0xc5, 0, 7, 'f', 'r', 's', 'y', 'u', 'k', 'i' - }; - - msgpack_zone z; - msgpack_zone_init(&z, 2048); - msgpack_object obj; - msgpack_unpack_return ret; - ret = msgpack_unpack(buf, sizeof(buf), NULL, &z, &obj); - EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret); - EXPECT_EQ(MSGPACK_OBJECT_BIN, obj.type); - EXPECT_EQ(bin_size, obj.via.bin.size); - EXPECT_EQ(0, memcmp("frsyuki", obj.via.bin.ptr, bin_size)); - - msgpack_zone_destroy(&z); -} - -TEST(MSGPACKC, unpack_bin32) -{ - size_t bin_size = 7; - const char buf[] = { - (char)0xc6, 0, 0, 0, 7, 'f', 'r', 's', 'y', 'u', 'k', 'i' - }; - - msgpack_zone z; - msgpack_zone_init(&z, 2048); - msgpack_object obj; - msgpack_unpack_return ret; - ret = msgpack_unpack(buf, sizeof(buf), NULL, &z, &obj); - EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret); - EXPECT_EQ(MSGPACK_OBJECT_BIN, obj.type); - EXPECT_EQ(bin_size, obj.via.bin.size); - EXPECT_EQ(0, memcmp("frsyuki", obj.via.bin.ptr, bin_size)); - - msgpack_zone_destroy(&z); -} - -TEST(MSGPACKC, unpack_array_uint64) -{ - const char buf[] = { - (char)0x91, (char)0xcf, (char)0xff, (char)0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01 - }; - msgpack_zone z; - msgpack_zone_init(&z, 2048); - msgpack_object obj; - msgpack_unpack_return ret; - ret = msgpack_unpack(buf, sizeof(buf), NULL, &z, &obj); - EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret); - EXPECT_EQ(MSGPACK_OBJECT_ARRAY, obj.type); - EXPECT_EQ(1u, obj.via.array.size); - EXPECT_EQ(MSGPACK_OBJECT_POSITIVE_INTEGER, obj.via.array.ptr[0].type); - EXPECT_EQ(0xFFF0000000000001LL, obj.via.array.ptr[0].via.u64); - msgpack_zone_destroy(&z); -} - - -TEST(MSGPACKC, vref_buffer_overflow) -{ - msgpack_vrefbuffer vbuf; - msgpack_vrefbuffer to; - size_t ref_size = 0; - size_t chunk_size = std::numeric_limits::max(); - EXPECT_FALSE(msgpack_vrefbuffer_init(&vbuf, ref_size, chunk_size)); - EXPECT_EQ(-1, msgpack_vrefbuffer_migrate(&vbuf, &to)); -} diff --git a/test/msgpack_container.cpp b/test/msgpack_container.cpp index e2c596092..cca39b595 100644 --- a/test/msgpack_container.cpp +++ b/test/msgpack_container.cpp @@ -12,12 +12,8 @@ #include "test_allocator.hpp" -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wconversion" - -#include - -#pragma GCC diagnostic pop +#define BOOST_TEST_MODULE MSGPACK_STL +#include #ifdef HAVE_CONFIG_H #include "config.h" @@ -42,7 +38,63 @@ struct less : std::less { } // 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('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(); + 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('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(); + 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(); + BOOST_CHECK(val1 == val2); + wstring val3; + oh.get().convert(val3); + BOOST_CHECK(val1 == val3); + } +} + +BOOST_AUTO_TEST_CASE(simple_buffer_vector) { typedef vector > type; for (unsigned int k = 0; k < kLoop; k++) { @@ -53,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(); - 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 > type; type val1; @@ -68,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(); - 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 > type; for (unsigned int k = 0; k < kLoop; k++) { @@ -85,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(); - 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 > type; type val1; @@ -100,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(); - 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 > type; for (unsigned int k = 0; k < kLoop; k++) { @@ -117,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(); - 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 > type; type val1; @@ -132,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(); - 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::value) return; typedef vector > type; @@ -150,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(); - 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::value) return; typedef vector > type; @@ -166,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(); - 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 > type; type val1; @@ -182,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(); - 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 > type; type val1; @@ -196,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(); - 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, test::allocator > >type; for (unsigned int k = 0; k < kLoop; k++) { @@ -216,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(); - 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, test::allocator > >type; type val1; @@ -230,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(); - 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, test::allocator > > type; for (unsigned int k = 0; k < kLoop; k++) { @@ -246,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(); - 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, test::allocator > > type; type val1; @@ -260,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(); - 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 > type; for (unsigned int k = 0; k < kLoop; k++) { @@ -276,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(); - 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 > type; type val1; @@ -290,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(); - 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 > type; for (unsigned int k = 0; k < kLoop; k++) { @@ -306,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(); - 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 > type; type val1; @@ -320,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(); - 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, test::allocator > type; for (unsigned int k = 0; k < kLoop; k++) { @@ -336,12 +388,12 @@ TEST(MSGPACK_STL, simple_buffer_set) msgpack::object_handle oh = msgpack::unpack(sbuf.data(), sbuf.size()); type val2 = oh.get().as(); - 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, test::allocator > type; type val1; @@ -350,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(); - 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 val1 = make_pair(rand(), rand()); @@ -363,12 +415,42 @@ TEST(MSGPACK_STL, simple_buffer_pair) msgpack::object_handle oh = msgpack::unpack(sbuf.data(), sbuf.size()); pair val2 = oh.get().as >(); - 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_multimap) +BOOST_AUTO_TEST_CASE(simple_buffer_complex_float) +{ + complex val1 = complex(1.23F, 4.56F); + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, val1); + msgpack::object_handle oh = + msgpack::unpack(sbuf.data(), sbuf.size()); + complex val2 = oh.get().as >(); + BOOST_CHECK_EQUAL(val1, val2); + complex val3; + oh.get().convert(val3); + BOOST_CHECK_EQUAL(val1, val3); + +} + +BOOST_AUTO_TEST_CASE(simple_buffer_complex_double) +{ + complex val1 = complex(1.23, 4.56); + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, val1); + msgpack::object_handle oh = + msgpack::unpack(sbuf.data(), sbuf.size()); + complex val2 = oh.get().as >(); + BOOST_CHECK_EQUAL(val1, val2); + complex val3; + oh.get().convert(val3); + BOOST_CHECK_EQUAL(val1, val3); + +} + +BOOST_AUTO_TEST_CASE(simple_buffer_multimap) { typedef multimap, test::allocator > > type; for (unsigned int k = 0; k < kLoop; k++) { @@ -390,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, test::allocator > > type; type val1; @@ -407,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(); - 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, test::allocator > type; for (unsigned int k = 0; k < kLoop; k++) { @@ -429,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, test::allocator > type; type val1; @@ -446,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(); - 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 val1(true, "kzk", 12.3); @@ -458,13 +540,13 @@ TEST(MSGPACK_TUPLE, simple_tuple) msgpack::unpack(sbuf.data(), sbuf.size()); msgpack::type::tuple val2 = oh.get().as >(); - 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; @@ -472,10 +554,10 @@ TEST(MSGPACK_TUPLE, simple_tuple_empty) msgpack::object_handle oh = msgpack::unpack(sbuf.data(), sbuf.size()); oh.get().as >(); - 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 val1(true, "kzk", 42); @@ -484,13 +566,13 @@ TEST(MSGPACK_TUPLE, simple_tuple_grater_than_as) msgpack::unpack(sbuf.data(), sbuf.size()); msgpack::type::tuple val2 = oh.get().as >(); - 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 val1(true, "kzk", 42); @@ -499,13 +581,13 @@ TEST(MSGPACK_TUPLE, simple_tuple_grater_than_convert) msgpack::unpack(sbuf.data(), sbuf.size()); msgpack::type::tuple 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 val1(true, "kzk", 42); @@ -514,12 +596,12 @@ TEST(MSGPACK_TUPLE, simple_tuple_less_than_as) msgpack::unpack(sbuf.data(), sbuf.size()); msgpack::type::tuple val2 = oh.get().as >(); - 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 val1(true, "kzk", 42); @@ -528,12 +610,12 @@ TEST(MSGPACK_TUPLE, simple_tuple_less_than_convert) msgpack::unpack(sbuf.data(), sbuf.size()); msgpack::type::tuple 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 > val1; @@ -542,7 +624,7 @@ TEST(MSGPACK_TUPLE, simple_tuple_nest) msgpack::unpack(sbuf.data(), sbuf.size()); 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 @@ -564,7 +646,7 @@ struct tr1_hash : std::tr1::hash { #ifdef MSGPACK_HAS_STD_TR1_UNORDERED_MAP #include #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, test::equal_to, test::allocator > > type; for (unsigned int k = 0; k < kLoop; k++) { @@ -576,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(); - 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, test::equal_to, test::allocator > > type; type val1; @@ -594,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(); - 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, test::equal_to, test::allocator > > type; for (unsigned int k = 0; k < kLoop; k++) { @@ -619,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, test::equal_to, test::allocator > > type; type val1; @@ -636,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(); - EXPECT_EQ(val1.size(), val2.size()); + BOOST_CHECK_EQUAL(val1.size(), val2.size()); } #endif @@ -644,7 +726,7 @@ TEST(MSGPACK_TR1, simple_buffer_tr1_unordered_multimap_empty) #ifdef MSGPACK_HAS_STD_TR1_UNORDERED_SET #include #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, test::equal_to, test::allocator > type; for (unsigned int k = 0; k < kLoop; k++) { @@ -656,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(); - 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, test::equal_to, test::allocator > type; type val1; @@ -672,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(); - 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, test::equal_to, test::allocator > type; for (unsigned int k = 0; k < kLoop; k++) { @@ -694,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, test::equal_to, test::allocator > type; type val1; @@ -711,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(); - EXPECT_EQ(val1.size(), val2.size()); + BOOST_CHECK_EQUAL(val1.size(), val2.size()); } #endif @@ -733,7 +815,7 @@ struct hash : std::hash { #ifdef MSGPACK_HAS_STD_UNORDERED_MAP #include #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, test::equal_to, test::allocator > > type; for (unsigned int k = 0; k < kLoop; k++) { @@ -745,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(); - 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, test::equal_to, test::allocator > > type; type val1; @@ -763,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(); - 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, test::equal_to, test::allocator > > type; for (unsigned int k = 0; k < kLoop; k++) { @@ -788,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, test::equal_to, test::allocator > > type; type val1; @@ -805,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(); - EXPECT_EQ(val1.size(), val2.size()); + BOOST_CHECK_EQUAL(val1.size(), val2.size()); } #endif @@ -814,7 +896,7 @@ TEST(MSGPACK_TR1, simple_buffer_unordered_multimap_empty) #include #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, test::equal_to, test::allocator > type; for (unsigned int k = 0; k < kLoop; k++) { @@ -826,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(); - 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, test::equal_to, test::allocator > type; type val1; @@ -842,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(); - 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, test::equal_to, test::allocator > type; for (unsigned int k = 0; k < kLoop; k++) { @@ -864,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, test::equal_to, test::allocator > type; type val1; @@ -881,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(); - EXPECT_EQ(val1.size(), val2.size()); + BOOST_CHECK_EQUAL(val1.size(), val2.size()); } #endif diff --git a/test/msgpack_cpp11.cpp b/test/msgpack_cpp11.cpp index 5bf4bdcc3..3375a27bf 100644 --- a/test/msgpack_cpp11.cpp +++ b/test/msgpack_cpp11.cpp @@ -1,11 +1,7 @@ #include -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wconversion" - -#include - -#pragma GCC diagnostic pop +#define BOOST_TEST_MODULE MSGPACK_CPP11 +#include #ifdef HAVE_CONFIG_H #include "config.h" @@ -42,7 +38,7 @@ const unsigned int kElements = 100; // C++11 -TEST(MSGPACK_CPP11, simple_tuple) +BOOST_AUTO_TEST_CASE(simple_tuple) { msgpack::sbuffer sbuf; std::tuple val1(true, "kzk", 12.3); @@ -50,10 +46,10 @@ TEST(MSGPACK_CPP11, simple_tuple) msgpack::object_handle oh = msgpack::unpack(sbuf.data(), sbuf.size()); std::tuple val2 = oh.get().as >(); - EXPECT_EQ(val1, val2); + BOOST_CHECK(val1 == val2); } -TEST(MSGPACK_CPP11, simple_tuple_empty) +BOOST_AUTO_TEST_CASE(simple_tuple_empty) { msgpack::sbuffer sbuf; std::tuple<> val1; @@ -61,10 +57,10 @@ TEST(MSGPACK_CPP11, simple_tuple_empty) msgpack::object_handle oh = msgpack::unpack(sbuf.data(), sbuf.size()); std::tuple<> val2 = oh.get().as >(); - EXPECT_EQ(val1, val2); + BOOST_CHECK(val1 == val2); } -TEST(MSGPACK_CPP11, simple_tuple_size_greater_than_as) +BOOST_AUTO_TEST_CASE(simple_tuple_size_greater_than_as) { msgpack::sbuffer sbuf; std::tuple val1(true, "kzk", 42); @@ -72,12 +68,12 @@ TEST(MSGPACK_CPP11, simple_tuple_size_greater_than_as) msgpack::object_handle oh = msgpack::unpack(sbuf.data(), sbuf.size()); std::tuple val2 = oh.get().as >(); - EXPECT_EQ(std::get<0>(val1), std::get<0>(val2)); - EXPECT_EQ(std::get<1>(val1), std::get<1>(val2)); - EXPECT_EQ(std::get<2>(val1), std::get<2>(val2)); + BOOST_CHECK_EQUAL(std::get<0>(val1), std::get<0>(val2)); + BOOST_CHECK_EQUAL(std::get<1>(val1), std::get<1>(val2)); + BOOST_CHECK_EQUAL(std::get<2>(val1), std::get<2>(val2)); } -TEST(MSGPACK_CPP11, simple_tuple_size_greater_than_convert) +BOOST_AUTO_TEST_CASE(simple_tuple_size_greater_than_convert) { msgpack::sbuffer sbuf; std::tuple val1(true, "kzk", 42); @@ -86,12 +82,12 @@ TEST(MSGPACK_CPP11, simple_tuple_size_greater_than_convert) msgpack::unpack(sbuf.data(), sbuf.size()); std::tuple val2; oh.get().convert(val2); - EXPECT_EQ(std::get<0>(val1), std::get<0>(val2)); - EXPECT_EQ(std::get<1>(val1), std::get<1>(val2)); - EXPECT_EQ(std::get<2>(val1), std::get<2>(val2)); + BOOST_CHECK_EQUAL(std::get<0>(val1), std::get<0>(val2)); + BOOST_CHECK_EQUAL(std::get<1>(val1), std::get<1>(val2)); + BOOST_CHECK_EQUAL(std::get<2>(val1), std::get<2>(val2)); } -TEST(MSGPACK_CPP11, simple_tuple_size_less_than_as) +BOOST_AUTO_TEST_CASE(simple_tuple_size_less_than_as) { msgpack::sbuffer sbuf; std::tuple val1(true, "kzk", 42); @@ -99,11 +95,11 @@ TEST(MSGPACK_CPP11, simple_tuple_size_less_than_as) msgpack::object_handle oh = msgpack::unpack(sbuf.data(), sbuf.size()); std::tuple val2 = oh.get().as >(); - EXPECT_EQ(std::get<0>(val1), std::get<0>(val2)); - EXPECT_EQ(std::get<1>(val1), std::get<1>(val2)); + BOOST_CHECK_EQUAL(std::get<0>(val1), std::get<0>(val2)); + BOOST_CHECK_EQUAL(std::get<1>(val1), std::get<1>(val2)); } -TEST(MSGPACK_CPP11, simple_tuple_size_less_than_convert) +BOOST_AUTO_TEST_CASE(simple_tuple_size_less_than_convert) { msgpack::sbuffer sbuf; std::tuple val1(true, "kzk", 42); @@ -112,11 +108,11 @@ TEST(MSGPACK_CPP11, simple_tuple_size_less_than_convert) msgpack::unpack(sbuf.data(), sbuf.size()); std::tuple val2; oh.get().convert(val2); - EXPECT_EQ(std::get<0>(val1), std::get<0>(val2)); - EXPECT_EQ(std::get<1>(val1), std::get<1>(val2)); + BOOST_CHECK_EQUAL(std::get<0>(val1), std::get<0>(val2)); + BOOST_CHECK_EQUAL(std::get<1>(val1), std::get<1>(val2)); } -TEST(MSGPACK_CPP11, simple_array) +BOOST_AUTO_TEST_CASE(simple_array) { for (unsigned int k = 0; k < kLoop; k++) { array val1; @@ -126,107 +122,107 @@ TEST(MSGPACK_CPP11, simple_array) 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); array val2 = oh.get().as >(); - 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_CPP11, simple_array_empty) +BOOST_AUTO_TEST_CASE(simple_array_empty) { array val1; 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); + BOOST_CHECK_EQUAL(oh.get().type, msgpack::type::ARRAY); array val2 = oh.get().as >(); - 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_CPP11, simple_array_size_less_than) +BOOST_AUTO_TEST_CASE(simple_array_size_less_than) { array val1 { {1 , 2} }; 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); + BOOST_CHECK_EQUAL(oh.get().type, msgpack::type::ARRAY); array val2; try { oh.get().convert(val2); - EXPECT_TRUE(false); + BOOST_CHECK(false); } catch (msgpack::type_error const&) { - EXPECT_TRUE(true); + BOOST_CHECK(true); } } -TEST(MSGPACK_CPP11, simple_array_size_greater_than) +BOOST_AUTO_TEST_CASE(simple_array_size_greater_than) { array val1 { {1 , 2} }; 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); + BOOST_CHECK_EQUAL(oh.get().type, msgpack::type::ARRAY); array val2; oh.get().convert(val2); - EXPECT_EQ(val1[0], val2[0]); - EXPECT_EQ(val1[1], val2[1]); + BOOST_CHECK_EQUAL(val1[0], val2[0]); + BOOST_CHECK_EQUAL(val1[1], val2[1]); } -TEST(MSGPACK_CPP11, simple_buffer_array_char) +BOOST_AUTO_TEST_CASE(simple_buffer_array_char) { for (unsigned int k = 0; k < kLoop; k++) { array val1; for (unsigned int i = 0; i < kElements; i++) - val1[i] = rand(); + val1[i] = static_cast(rand()); msgpack::sbuffer sbuf; 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); array val2 = oh.get().as >(); - 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_CPP11, simple_buffer_array_char_empty) +BOOST_AUTO_TEST_CASE(simple_buffer_array_char_empty) { array val1; msgpack::sbuffer sbuf; 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); array val2 = oh.get().as >(); - 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_CPP11, simple_buffer_array_unsigned_char) +BOOST_AUTO_TEST_CASE(simple_buffer_array_unsigned_char) { if (!msgpack::is_same::value) return; for (unsigned int k = 0; k < kLoop; k++) { array val1; for (unsigned int i = 0; i < kElements; i++) - val1[i] = rand(); + val1[i] = static_cast(rand()); msgpack::sbuffer sbuf; 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); array val2 = oh.get().as >(); - 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_CPP11, simple_buffer_array_unsigned_char_empty) +BOOST_AUTO_TEST_CASE(simple_buffer_array_unsigned_char_empty) { if (!msgpack::is_same::value) return; array val1; @@ -234,10 +230,10 @@ TEST(MSGPACK_CPP11, simple_buffer_array_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); array val2 = oh.get().as >(); - 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())); } // strong typedefs @@ -256,22 +252,38 @@ struct equal_to : std::equal_to { template struct set_allocator : std::allocator { using std::allocator::allocator; + + template + struct rebind { using other = set_allocator; }; }; -template -struct map_allocator : std::allocator> { - using std::allocator>::allocator; +// C++ named requirement Allocator implies that the first template type +// parameter matches the value type of the allocator. There might be additional +// parameters, but the first one must match the type. +// That's why this helper with exactly one template parameter representing +// a whole key-value pair is required +template +struct map_allocator_impl : std::allocator { + using std::allocator::allocator; + + template + struct rebind { using other = map_allocator_impl; }; }; +template +using map_allocator = map_allocator_impl>; + template struct allocator : std::allocator { using std::allocator::allocator; + + template + struct rebind { using other = allocator; }; }; } // namespace test - -TEST(MSGPACK_STL, simple_buffer_forward_list) +BOOST_AUTO_TEST_CASE(simple_buffer_forward_list) { using type = forward_list>; for (unsigned int k = 0; k < kLoop; k++) { @@ -283,11 +295,11 @@ TEST(MSGPACK_STL, simple_buffer_forward_list) msgpack::object_handle oh = msgpack::unpack(sbuf.data(), sbuf.size()); type val2 = oh.get().as(); - EXPECT_EQ(val1, val2); + BOOST_CHECK(val1 == val2); } } -TEST(MSGPACK_STL, simple_buffer_forward_list_empty) +BOOST_AUTO_TEST_CASE(simple_buffer_forward_list_empty) { using type = forward_list>; type val1; @@ -296,10 +308,10 @@ TEST(MSGPACK_STL, simple_buffer_forward_list_empty) msgpack::object_handle oh = msgpack::unpack(sbuf.data(), sbuf.size()); type val2 = oh.get().as(); - EXPECT_EQ(val1, val2); + BOOST_CHECK(val1 == val2); } -TEST(MSGPACK_STL, simple_buffer_unordered_map) +BOOST_AUTO_TEST_CASE(simple_buffer_unordered_map) { using type = unordered_map, test::equal_to, test::map_allocator>; for (unsigned int k = 0; k < kLoop; k++) { @@ -311,11 +323,11 @@ TEST(MSGPACK_STL, simple_buffer_unordered_map) msgpack::object_handle oh = msgpack::unpack(sbuf.data(), sbuf.size()); type val2 = oh.get().as(); - EXPECT_EQ(val1, val2); + BOOST_CHECK(val1 == val2); } } -TEST(MSGPACK_STL, simple_buffer_unordered_map_empty) +BOOST_AUTO_TEST_CASE(simple_buffer_unordered_map_empty) { using type = unordered_map, test::equal_to, test::map_allocator>; type val1; @@ -324,10 +336,10 @@ TEST(MSGPACK_STL, simple_buffer_unordered_map_empty) msgpack::object_handle oh = msgpack::unpack(sbuf.data(), sbuf.size()); type val2 = oh.get().as(); - EXPECT_EQ(val1, val2); + BOOST_CHECK(val1 == val2); } -TEST(MSGPACK_STL, simple_buffer_unordered_multimap) +BOOST_AUTO_TEST_CASE(simple_buffer_unordered_multimap) { using type = unordered_multimap, test::equal_to, test::map_allocator>; for (unsigned int k = 0; k < kLoop; k++) { @@ -343,11 +355,11 @@ TEST(MSGPACK_STL, simple_buffer_unordered_multimap) msgpack::unpack(sbuf.data(), sbuf.size()); type val2 = oh.get().as(); - EXPECT_EQ(val1, val2); + BOOST_CHECK(val1 == val2); } } -TEST(MSGPACK_STL, simple_buffer_unordered_multimap_empty) +BOOST_AUTO_TEST_CASE(simple_buffer_unordered_multimap_empty) { using type = unordered_multimap, test::equal_to, test::map_allocator>; type val1; @@ -357,10 +369,10 @@ TEST(MSGPACK_STL, simple_buffer_unordered_multimap_empty) msgpack::unpack(sbuf.data(), sbuf.size()); type val2 = oh.get().as(); - EXPECT_EQ(val1, val2); + BOOST_CHECK(val1 == val2); } -TEST(MSGPACK_STL, simple_buffer_unordered_set) +BOOST_AUTO_TEST_CASE(simple_buffer_unordered_set) { using type = unordered_set, test::equal_to, test::set_allocator>; for (unsigned int k = 0; k < kLoop; k++) { @@ -372,11 +384,11 @@ TEST(MSGPACK_STL, simple_buffer_unordered_set) msgpack::object_handle oh = msgpack::unpack(sbuf.data(), sbuf.size()); type val2 = oh.get().as(); - EXPECT_EQ(val1, val2); + BOOST_CHECK(val1 == val2); } } -TEST(MSGPACK_STL, simple_buffer_unordered_set_empty) +BOOST_AUTO_TEST_CASE(simple_buffer_unordered_set_empty) { using type = unordered_set, test::equal_to, test::set_allocator>; type val1; @@ -385,10 +397,10 @@ TEST(MSGPACK_STL, simple_buffer_unordered_set_empty) msgpack::object_handle oh = msgpack::unpack(sbuf.data(), sbuf.size()); type val2 = oh.get().as(); - EXPECT_EQ(val1, val2); + BOOST_CHECK(val1 == val2); } -TEST(MSGPACK_STL, simple_buffer_unordered_multiset) +BOOST_AUTO_TEST_CASE(simple_buffer_unordered_multiset) { using type = unordered_multiset, test::equal_to, test::set_allocator>; for (unsigned int k = 0; k < kLoop; k++) { @@ -400,11 +412,11 @@ TEST(MSGPACK_STL, simple_buffer_unordered_multiset) msgpack::object_handle oh = msgpack::unpack(sbuf.data(), sbuf.size()); type val2 = oh.get().as(); - EXPECT_EQ(val1, val2); + BOOST_CHECK(val1 == val2); } } -TEST(MSGPACK_STL, simple_buffer_unordered_multiset_empty) +BOOST_AUTO_TEST_CASE(simple_buffer_unordered_multiset_empty) { using type = unordered_multiset, test::equal_to, test::set_allocator>; type val1; @@ -413,10 +425,10 @@ TEST(MSGPACK_STL, simple_buffer_unordered_multiset_empty) msgpack::object_handle oh = msgpack::unpack(sbuf.data(), sbuf.size()); type val2 = oh.get().as(); - EXPECT_EQ(val1, val2); + BOOST_CHECK(val1 == val2); } -TEST(MSGPACK_USER_DEFINED, simple_buffer_enum_class_member) +BOOST_AUTO_TEST_CASE(simple_buffer_enum_class_member) { TestEnumClassMemberClass val1; msgpack::sbuffer sbuf; @@ -424,9 +436,9 @@ TEST(MSGPACK_USER_DEFINED, simple_buffer_enum_class_member) msgpack::object_handle oh = msgpack::unpack(sbuf.data(), sbuf.size()); TestEnumClassMemberClass val2 = oh.get().as(); - EXPECT_EQ(val1.t1, val2.t1); - EXPECT_EQ(val1.t2, val2.t2); - EXPECT_EQ(val1.t3, val2.t3); + BOOST_CHECK(val1.t1 == val2.t1); + BOOST_CHECK(val1.t2 == val2.t2); + BOOST_CHECK(val1.t3 == val2.t3); } struct no_def_con { @@ -471,7 +483,7 @@ template <> struct hash { }; } // std -TEST(MSGPACK_NO_DEF_CON, simple_buffer) +BOOST_AUTO_TEST_CASE(no_def_con_simple_buffer) { no_def_con val1(42); msgpack::sbuffer sbuf; @@ -480,7 +492,7 @@ TEST(MSGPACK_NO_DEF_CON, simple_buffer) msgpack::unpack(sbuf.data(), sbuf.size()); no_def_con val2 = oh.get().as(); - EXPECT_EQ(val1, val2); + BOOST_CHECK(val1 == val2); } struct no_def_con_composite { @@ -518,7 +530,7 @@ MSGPACK_API_VERSION_NAMESPACE(MSGPACK_DEFAULT_API_NS) { } // MSGPACK_API_VERSION_NAMESPACE(MSGPACK_DEFAULT_API_NS) } // msgpack -TEST(MSGPACK_NO_DEF_CON_COMPOSITE, simple_buffer) +BOOST_AUTO_TEST_CASE(no_def_con_composite_simple_buffer) { no_def_con_composite val1(42); msgpack::sbuffer sbuf; @@ -526,7 +538,7 @@ TEST(MSGPACK_NO_DEF_CON_COMPOSITE, simple_buffer) msgpack::object_handle oh = msgpack::unpack(sbuf.data(), sbuf.size()); no_def_con_composite val2 = oh.get().as(); - EXPECT_EQ(val1, val2); + BOOST_CHECK(val1 == val2); } struct no_def_con_inherit : no_def_con { @@ -550,7 +562,7 @@ MSGPACK_API_VERSION_NAMESPACE(MSGPACK_DEFAULT_API_NS) { } // MSGPACK_API_VERSION_NAMESPACE(MSGPACK_DEFAULT_API_NS) } // msgpack -TEST(MSGPACK_NO_DEF_CON_INHERIT, simple_buffer) +BOOST_AUTO_TEST_CASE(no_def_con_inherit_simple_buffer) { no_def_con_inherit val1(42); msgpack::sbuffer sbuf; @@ -558,10 +570,10 @@ TEST(MSGPACK_NO_DEF_CON_INHERIT, simple_buffer) msgpack::object_handle oh = msgpack::unpack(sbuf.data(), sbuf.size()); no_def_con_inherit val2 = oh.get().as(); - EXPECT_EQ(val1, val2); + BOOST_CHECK(val1 == val2); } -TEST(MSGPACK_NO_DEF_CON_VECTOR, simple_buffer) +BOOST_AUTO_TEST_CASE(no_def_con_vector_simple_buffer) { std::vector val1 { 1, 2, 3 }; msgpack::sbuffer sbuf; @@ -569,10 +581,10 @@ TEST(MSGPACK_NO_DEF_CON_VECTOR, simple_buffer) msgpack::object_handle oh = msgpack::unpack(sbuf.data(), sbuf.size()); std::vector val2 = oh.get().as>(); - EXPECT_EQ(val1, val2); + BOOST_CHECK(val1 == val2); } -TEST(MSGPACK_NO_DEF_CON_LIST, simple_buffer) +BOOST_AUTO_TEST_CASE(no_def_con_list_simple_buffer) { std::list val1 { 1, 2, 3 }; msgpack::sbuffer sbuf; @@ -580,10 +592,10 @@ TEST(MSGPACK_NO_DEF_CON_LIST, simple_buffer) msgpack::object_handle oh = msgpack::unpack(sbuf.data(), sbuf.size()); std::list val2 = oh.get().as>(); - EXPECT_EQ(val1, val2); + BOOST_CHECK(val1 == val2); } -TEST(MSGPACK_NO_DEF_CON_SET, simple_buffer) +BOOST_AUTO_TEST_CASE(no_def_con_set_simple_buffer) { std::set val1 { 1, 2, 3 }; msgpack::sbuffer sbuf; @@ -591,10 +603,10 @@ TEST(MSGPACK_NO_DEF_CON_SET, simple_buffer) msgpack::object_handle oh = msgpack::unpack(sbuf.data(), sbuf.size()); std::set val2 = oh.get().as>(); - EXPECT_EQ(val1, val2); + BOOST_CHECK(val1 == val2); } -TEST(MSGPACK_NO_DEF_CON_MULTISET, simple_buffer) +BOOST_AUTO_TEST_CASE(no_def_con_multiset_simple_buffer) { std::multiset val1 { 1, 2, 3 }; msgpack::sbuffer sbuf; @@ -602,10 +614,10 @@ TEST(MSGPACK_NO_DEF_CON_MULTISET, simple_buffer) msgpack::object_handle oh = msgpack::unpack(sbuf.data(), sbuf.size()); std::multiset val2 = oh.get().as>(); - EXPECT_EQ(val1, val2); + BOOST_CHECK(val1 == val2); } -TEST(MSGPACK_NO_DEF_CON_ASSOC_VECTOR, simple_buffer) +BOOST_AUTO_TEST_CASE(no_def_con_assoc_vector_simple_buffer) { msgpack::type::assoc_vector val1 { {1, 2}, {3, 4}, {5, 6}}; msgpack::sbuffer sbuf; @@ -614,10 +626,10 @@ TEST(MSGPACK_NO_DEF_CON_ASSOC_VECTOR, simple_buffer) msgpack::unpack(sbuf.data(), sbuf.size()); msgpack::type::assoc_vector val2 = oh.get().as>(); - EXPECT_EQ(val1, val2); + BOOST_CHECK(val1 == val2); } -TEST(MSGPACK_NO_DEF_CON_DEF_CON_ASSOC_VECTOR, simple_buffer) +BOOST_AUTO_TEST_CASE(no_def_con_def_con_assoc_vector_simple_buffer) { msgpack::type::assoc_vector val1 { {1, 2}, {3, 4}, {5, 6}}; msgpack::sbuffer sbuf; @@ -626,10 +638,10 @@ TEST(MSGPACK_NO_DEF_CON_DEF_CON_ASSOC_VECTOR, simple_buffer) msgpack::unpack(sbuf.data(), sbuf.size()); msgpack::type::assoc_vector val2 = oh.get().as>(); - EXPECT_EQ(val1, val2); + BOOST_CHECK(val1 == val2); } -TEST(MSGPACK_NO_DEF_CON_MAP, simple_buffer) +BOOST_AUTO_TEST_CASE(no_def_con_map_simple_buffer) { std::map val1 { {1, 2}, {3, 4}, {5, 6}}; msgpack::sbuffer sbuf; @@ -638,10 +650,10 @@ TEST(MSGPACK_NO_DEF_CON_MAP, simple_buffer) msgpack::unpack(sbuf.data(), sbuf.size()); std::map val2 = oh.get().as>(); - EXPECT_EQ(val1, val2); + BOOST_CHECK(val1 == val2); } -TEST(MSGPACK_NO_DEF_CON_DEF_CON_MAP, simple_buffer) +BOOST_AUTO_TEST_CASE(no_def_con_def_con_map_simple_buffer) { std::map val1 { {1, 2}, {3, 4}, {5, 6}}; msgpack::sbuffer sbuf; @@ -650,10 +662,10 @@ TEST(MSGPACK_NO_DEF_CON_DEF_CON_MAP, simple_buffer) msgpack::unpack(sbuf.data(), sbuf.size()); std::map val2 = oh.get().as>(); - EXPECT_EQ(val1, val2); + BOOST_CHECK(val1 == val2); } -TEST(MSGPACK_NO_DEF_CON_MULTIMAP, simple_buffer) +BOOST_AUTO_TEST_CASE(no_def_con_multimap_simple_buffer) { std::multimap val1 { {1, 2}, {3, 4}, {5, 6}}; msgpack::sbuffer sbuf; @@ -662,10 +674,10 @@ TEST(MSGPACK_NO_DEF_CON_MULTIMAP, simple_buffer) msgpack::unpack(sbuf.data(), sbuf.size()); std::multimap val2 = oh.get().as>(); - EXPECT_EQ(val1, val2); + BOOST_CHECK(val1 == val2); } -TEST(MSGPACK_NO_DEF_CON_DEF_CON_MULTIMAP, simple_buffer) +BOOST_AUTO_TEST_CASE(no_def_con_def_con_multimap_simple_buffer) { std::multimap val1 { {1, 2}, {3, 4}, {5, 6}}; msgpack::sbuffer sbuf; @@ -674,10 +686,10 @@ TEST(MSGPACK_NO_DEF_CON_DEF_CON_MULTIMAP, simple_buffer) msgpack::unpack(sbuf.data(), sbuf.size()); std::multimap val2 = oh.get().as>(); - EXPECT_EQ(val1, val2); + BOOST_CHECK(val1 == val2); } -TEST(MSGPACK_NO_DEF_CON_DEQUE, simple_buffer) +BOOST_AUTO_TEST_CASE(no_def_con_deque_simple_buffer) { std::deque val1 { 1, 2, 3 }; msgpack::sbuffer sbuf; @@ -685,10 +697,10 @@ TEST(MSGPACK_NO_DEF_CON_DEQUE, simple_buffer) msgpack::object_handle oh = msgpack::unpack(sbuf.data(), sbuf.size()); std::deque val2 = oh.get().as>(); - EXPECT_EQ(val1, val2); + BOOST_CHECK(val1 == val2); } -TEST(MSGPACK_NO_DEF_CON_PAIR, simple_buffer) +BOOST_AUTO_TEST_CASE(no_def_con_pair_simple_buffer) { std::pair val1 {1, 2}; msgpack::sbuffer sbuf; @@ -697,10 +709,10 @@ TEST(MSGPACK_NO_DEF_CON_PAIR, simple_buffer) msgpack::unpack(sbuf.data(), sbuf.size()); std::pair val2 = oh.get().as>(); - EXPECT_EQ(val1, val2); + BOOST_CHECK(val1 == val2); } -TEST(MSGPACK_NO_DEF_CON_DEF_CON_PAIR, simple_buffer) +BOOST_AUTO_TEST_CASE(no_def_con_def_con_pair_simple_buffer) { std::pair val1 {1, 2}; msgpack::sbuffer sbuf; @@ -709,17 +721,14 @@ TEST(MSGPACK_NO_DEF_CON_DEF_CON_PAIR, simple_buffer) msgpack::unpack(sbuf.data(), sbuf.size()); std::pair val2 = oh.get().as>(); - EXPECT_EQ(val1, val2); + BOOST_CHECK(val1 == val2); } - - // MSVC2015's std::tuple requires default constructor during 'as' process. -// It doesn't support Expression SFINAE yet, then 'as' is fallbacked to 'convert'. -// After MSVC would support Expression SFINAE, remove this guard. -#if !defined(_MSC_VER) +// It doesn't support Expression SFINAE, then 'as' is fallbacked to 'convert'. +#if !defined(_MSC_VER) || (_MSC_VER > 1900) -TEST(MSGPACK_NO_DEF_CON_TUPLE, simple_buffer) +BOOST_AUTO_TEST_CASE(no_def_con_tuple_simple_buffer) { std::tuple val1 {1, 2, 3}; msgpack::sbuffer sbuf; @@ -728,10 +737,10 @@ TEST(MSGPACK_NO_DEF_CON_TUPLE, simple_buffer) msgpack::unpack(sbuf.data(), sbuf.size()); std::tuple val2 = oh.get().as>(); - EXPECT_EQ(val1, val2); + BOOST_CHECK(val1 == val2); } -TEST(MSGPACK_NO_DEF_CON_DEF_CON_TUPLE, simple_buffer) +BOOST_AUTO_TEST_CASE(no_def_con_def_con_tuple_simple_buffer) { std::tuple val1 {1, 2, 3}; msgpack::sbuffer sbuf; @@ -740,10 +749,10 @@ TEST(MSGPACK_NO_DEF_CON_DEF_CON_TUPLE, simple_buffer) msgpack::unpack(sbuf.data(), sbuf.size()); std::tuple val2 = oh.get().as>(); - EXPECT_EQ(val1, val2); + BOOST_CHECK(val1 == val2); } -TEST(MSGPACK_NO_DEF_CON_MSGPACK_TUPLE, simple_buffer) +BOOST_AUTO_TEST_CASE(no_def_con_msgpack_tuple_simple_buffer) { msgpack::type::tuple val1 {1, 2, 3}; msgpack::sbuffer sbuf; @@ -752,10 +761,10 @@ TEST(MSGPACK_NO_DEF_CON_MSGPACK_TUPLE, simple_buffer) msgpack::unpack(sbuf.data(), sbuf.size()); msgpack::type::tuple val2 = oh.get().as>(); - EXPECT_EQ(val1, val2); + BOOST_CHECK(val1 == val2); } -TEST(MSGPACK_NO_DEF_CON_DEF_CON_MSGPACK_TUPLE, simple_buffer) +BOOST_AUTO_TEST_CASE(no_def_con_def_con_msgpack_tuple_simple_buffer) { msgpack::type::tuple val1 {1, 2, 3}; msgpack::sbuffer sbuf; @@ -764,12 +773,12 @@ TEST(MSGPACK_NO_DEF_CON_DEF_CON_MSGPACK_TUPLE, simple_buffer) msgpack::unpack(sbuf.data(), sbuf.size()); msgpack::type::tuple val2 = oh.get().as>(); - EXPECT_EQ(val1, val2); + BOOST_CHECK(val1 == val2); } -#endif // !define(_MSC_VER) +#endif // !defined(_MSC_VER) || (_MSC_VER > 1900) -TEST(MSGPACK_NO_DEF_FORWARD_LIST, simple_buffer) +BOOST_AUTO_TEST_CASE(no_def_forward_list_simple_buffer) { std::forward_list val1 { 1, 2, 3 }; msgpack::sbuffer sbuf; @@ -777,10 +786,10 @@ TEST(MSGPACK_NO_DEF_FORWARD_LIST, simple_buffer) msgpack::object_handle oh = msgpack::unpack(sbuf.data(), sbuf.size()); std::forward_list val2 = oh.get().as>(); - EXPECT_TRUE(val1 == val2); + BOOST_CHECK(val1 == val2); } -TEST(MSGPACK_NO_DEF_CON_UNORDERED_SET, simple_buffer) +BOOST_AUTO_TEST_CASE(no_def_con_unordered_set_simple_buffer) { std::unordered_set val1 { 1, 2, 3 }; msgpack::sbuffer sbuf; @@ -788,10 +797,10 @@ TEST(MSGPACK_NO_DEF_CON_UNORDERED_SET, simple_buffer) msgpack::object_handle oh = msgpack::unpack(sbuf.data(), sbuf.size()); std::unordered_set val2 = oh.get().as>(); - EXPECT_EQ(val1, val2); + BOOST_CHECK(val1 == val2); } -TEST(MSGPACK_NO_DEF_CON_UNORDERED_MULTISET, simple_buffer) +BOOST_AUTO_TEST_CASE(no_def_con_unordered_multiset_simple_buffer) { std::unordered_multiset val1 { 1, 2, 3 }; msgpack::sbuffer sbuf; @@ -799,10 +808,10 @@ TEST(MSGPACK_NO_DEF_CON_UNORDERED_MULTISET, simple_buffer) msgpack::object_handle oh = msgpack::unpack(sbuf.data(), sbuf.size()); std::unordered_multiset val2 = oh.get().as>(); - EXPECT_EQ(val1, val2); + BOOST_CHECK(val1 == val2); } -TEST(MSGPACK_NO_DEF_CON_UNORDERED_MAP, simple_buffer) +BOOST_AUTO_TEST_CASE(no_def_con_unordered_map_simple_buffer) { std::unordered_map val1 { {1, 2}, {3, 4}, {5, 6}}; msgpack::sbuffer sbuf; @@ -811,10 +820,10 @@ TEST(MSGPACK_NO_DEF_CON_UNORDERED_MAP, simple_buffer) msgpack::unpack(sbuf.data(), sbuf.size()); std::unordered_map val2 = oh.get().as>(); - EXPECT_EQ(val1, val2); + BOOST_CHECK(val1 == val2); } -TEST(MSGPACK_NO_DEF_CON_DEF_CON_UNORDERED_MAP, simple_buffer) +BOOST_AUTO_TEST_CASE(no_def_con_def_con_unordered_map_simple_buffer) { std::unordered_map val1 { {1, 2}, {3, 4}, {5, 6}}; msgpack::sbuffer sbuf; @@ -823,10 +832,10 @@ TEST(MSGPACK_NO_DEF_CON_DEF_CON_UNORDERED_MAP, simple_buffer) msgpack::unpack(sbuf.data(), sbuf.size()); std::unordered_map val2 = oh.get().as>(); - EXPECT_EQ(val1, val2); + BOOST_CHECK(val1 == val2); } -TEST(MSGPACK_NO_DEF_CON_UNORDERED_MULTIMAP, simple_buffer) +BOOST_AUTO_TEST_CASE(no_def_con_unordered_multimap_simple_buffer) { std::unordered_multimap val1 { {1, 2}, {3, 4}, {5, 6}}; msgpack::sbuffer sbuf; @@ -835,10 +844,10 @@ TEST(MSGPACK_NO_DEF_CON_UNORDERED_MULTIMAP, simple_buffer) msgpack::unpack(sbuf.data(), sbuf.size()); std::unordered_multimap val2 = oh.get().as>(); - EXPECT_EQ(val1, val2); + BOOST_CHECK(val1 == val2); } -TEST(MSGPACK_NO_DEF_CON_DEF_CON_UNORDERED_MULTIMAP, simple_buffer) +BOOST_AUTO_TEST_CASE(no_def_con_def_con_unordered_multimap_simple_buffer) { std::unordered_multimap val1 { {1, 2}, {3, 4}, {5, 6}}; msgpack::sbuffer sbuf; @@ -847,10 +856,10 @@ TEST(MSGPACK_NO_DEF_CON_DEF_CON_UNORDERED_MULTIMAP, simple_buffer) msgpack::unpack(sbuf.data(), sbuf.size()); std::unordered_multimap val2 = oh.get().as>(); - EXPECT_EQ(val1, val2); + BOOST_CHECK(val1 == val2); } -TEST(MSGPACK_NO_DEF_CON_ARRAY, simple_buffer) +BOOST_AUTO_TEST_CASE(no_def_con_array_simple_buffer) { std::array val1 { { 1, 2, 3 } }; msgpack::sbuffer sbuf; @@ -858,10 +867,10 @@ TEST(MSGPACK_NO_DEF_CON_ARRAY, simple_buffer) msgpack::object_handle oh = msgpack::unpack(sbuf.data(), sbuf.size()); std::array val2 = oh.get().as>(); - EXPECT_EQ(val1, val2); + BOOST_CHECK(val1 == val2); } -TEST(MSGPACK_CHRONO, system_clock) +BOOST_AUTO_TEST_CASE(system_clock) { std::chrono::system_clock::time_point val1; msgpack::sbuffer sbuf; @@ -870,65 +879,65 @@ TEST(MSGPACK_CHRONO, system_clock) msgpack::object_handle oh = msgpack::unpack(sbuf.data(), sbuf.size()); std::chrono::system_clock::time_point val2 = oh.get().as(); - EXPECT_EQ(val1, val2); + BOOST_CHECK(val1 == val2); std::chrono::system_clock::time_point val3; oh.get().convert(val3); - EXPECT_EQ(val1, val3); + BOOST_CHECK(val1 == val3); } -TEST(MSGPACK_CHRONO, system_clock_32) +BOOST_AUTO_TEST_CASE(system_clock_32) { std::chrono::system_clock::time_point val1(std::chrono::seconds(0x12345678L)); msgpack::sbuffer sbuf; msgpack::pack(sbuf, val1); char packed[] = { - static_cast(0xd6), + static_cast(0xd6u), static_cast(-1), static_cast(0x12), static_cast(0x34), static_cast(0x56), static_cast(0x78) }; - EXPECT_EQ(memcmp(sbuf.data(), packed, sizeof(packed)), 0); + BOOST_CHECK_EQUAL(memcmp(sbuf.data(), packed, sizeof(packed)), 0); msgpack::object_handle oh = msgpack::unpack(sbuf.data(), sbuf.size()); std::chrono::system_clock::time_point val2 = oh.get().as(); - EXPECT_EQ(val1, val2); + BOOST_CHECK(val1 == val2); std::chrono::system_clock::time_point val3; oh.get().convert(val3); - EXPECT_EQ(val1, val3); + BOOST_CHECK(val1 == val3); } -TEST(MSGPACK_CHRONO, system_clock_32_max) +BOOST_AUTO_TEST_CASE(system_clock_32_max) { std::chrono::system_clock::time_point val1(std::chrono::seconds(0xffffffffL)); msgpack::sbuffer sbuf; msgpack::pack(sbuf, val1); char packed[] = { - static_cast(0xd6), + static_cast(0xd6u), static_cast(-1), - static_cast(0xff), - static_cast(0xff), - static_cast(0xff), - static_cast(0xff) + static_cast(0xffu), + static_cast(0xffu), + static_cast(0xffu), + static_cast(0xffu) }; - EXPECT_EQ(memcmp(sbuf.data(), packed, sizeof(packed)), 0); + BOOST_CHECK_EQUAL(memcmp(sbuf.data(), packed, sizeof(packed)), 0); msgpack::object_handle oh = msgpack::unpack(sbuf.data(), sbuf.size()); std::chrono::system_clock::time_point val2 = oh.get().as(); - EXPECT_EQ(val1, val2); + BOOST_CHECK(val1 == val2); std::chrono::system_clock::time_point val3; oh.get().convert(val3); - EXPECT_EQ(val1, val3); + BOOST_CHECK(val1 == val3); } -TEST(MSGPACK_CHRONO, system_clock_64) +BOOST_AUTO_TEST_CASE(system_clock_64) { std::chrono::system_clock::time_point val1(std::chrono::seconds(0x31234567L)); val1 += @@ -941,14 +950,14 @@ TEST(MSGPACK_CHRONO, system_clock_64) msgpack::object_handle oh = msgpack::unpack(sbuf.data(), sbuf.size()); std::chrono::system_clock::time_point val2 = oh.get().as(); - EXPECT_EQ(val1, val2); + BOOST_CHECK(val1 == val2); std::chrono::system_clock::time_point val3; oh.get().convert(val3); - EXPECT_EQ(val1, val3); + BOOST_CHECK(val1 == val3); } -TEST(MSGPACK_CHRONO, system_clock_64_max) +BOOST_AUTO_TEST_CASE(system_clock_64_max) { std::chrono::system_clock::time_point val1(std::chrono::seconds(0xffffffffL)); @@ -959,47 +968,47 @@ TEST(MSGPACK_CHRONO, system_clock_64_max) msgpack::sbuffer sbuf; msgpack::pack(sbuf, val1); char packed_nano[] = { - static_cast(0xd7), + static_cast(0xd7u), static_cast(-1), - static_cast(0xee), // 999,999,999 << 2 + static_cast(0xeeu), // 999,999,999 << 2 static_cast(0x6b), static_cast(0x27), - static_cast(0xfc), - static_cast(0xff), // 32 bit sec - static_cast(0xff), - static_cast(0xff), - static_cast(0xff) + static_cast(0xfcu), + static_cast(0xffu), // 32 bit sec + static_cast(0xffu), + static_cast(0xffu), + static_cast(0xffu) }; char packed_micro[] = { - static_cast(0xd7), + static_cast(0xd7u), static_cast(-1), - static_cast(0xee), // 999,999,000 << 2 + static_cast(0xeeu), // 999,999,000 << 2 static_cast(0x6b), static_cast(0x18), static_cast(0x60), - static_cast(0xff), // 32 bit sec - static_cast(0xff), - static_cast(0xff), - static_cast(0xff) + static_cast(0xffu), // 32 bit sec + static_cast(0xffu), + static_cast(0xffu), + static_cast(0xffu) }; if (std::chrono::system_clock::duration::period::ratio::den == 1000000000) { - EXPECT_EQ(memcmp(sbuf.data(), packed_nano, sizeof(packed_nano)), 0); + BOOST_CHECK_EQUAL(memcmp(sbuf.data(), packed_nano, sizeof(packed_nano)), 0); } else if (std::chrono::system_clock::duration::period::ratio::den == 1000000) { - EXPECT_EQ(memcmp(sbuf.data(), packed_micro, sizeof(packed_micro)), 0); + BOOST_CHECK_EQUAL(memcmp(sbuf.data(), packed_micro, sizeof(packed_micro)), 0); } msgpack::object_handle oh = msgpack::unpack(sbuf.data(), sbuf.size()); std::chrono::system_clock::time_point val2 = oh.get().as(); - EXPECT_EQ(val1, val2); + BOOST_CHECK(val1 == val2); std::chrono::system_clock::time_point val3; oh.get().convert(val3); - EXPECT_EQ(val1, val3); + BOOST_CHECK(val1 == val3); } -TEST(MSGPACK_CHRONO, system_clock_impl_min) +BOOST_AUTO_TEST_CASE(system_clock_impl_min) { std::chrono::system_clock::time_point val1(std::chrono::system_clock::time_point::min()); msgpack::sbuffer sbuf; @@ -1008,14 +1017,14 @@ TEST(MSGPACK_CHRONO, system_clock_impl_min) msgpack::object_handle oh = msgpack::unpack(sbuf.data(), sbuf.size()); std::chrono::system_clock::time_point val2 = oh.get().as(); - EXPECT_EQ(val1, val2); + BOOST_CHECK(val1 == val2); std::chrono::system_clock::time_point val3; oh.get().convert(val3); - EXPECT_EQ(val1, val3); + BOOST_CHECK(val1 == val3); } -TEST(MSGPACK_CHRONO, system_clock_impl_max) +BOOST_AUTO_TEST_CASE(system_clock_impl_max) { std::chrono::system_clock::time_point val1(std::chrono::system_clock::time_point::max()); @@ -1025,14 +1034,14 @@ TEST(MSGPACK_CHRONO, system_clock_impl_max) msgpack::object_handle oh = msgpack::unpack(sbuf.data(), sbuf.size()); std::chrono::system_clock::time_point val2 = oh.get().as(); - EXPECT_EQ(val1, val2); + BOOST_CHECK(val1 == val2); std::chrono::system_clock::time_point val3; oh.get().convert(val3); - EXPECT_EQ(val1, val3); + BOOST_CHECK(val1 == val3); } -TEST(MSGPACK_CHRONO, system_clock_impl_now) +BOOST_AUTO_TEST_CASE(system_clock_impl_now) { std::chrono::system_clock::time_point val1(std::chrono::system_clock::now()); @@ -1042,91 +1051,469 @@ TEST(MSGPACK_CHRONO, system_clock_impl_now) msgpack::object_handle oh = msgpack::unpack(sbuf.data(), sbuf.size()); std::chrono::system_clock::time_point val2 = oh.get().as(); - EXPECT_EQ(val1, val2); + BOOST_CHECK(val1 == val2); std::chrono::system_clock::time_point val3; oh.get().convert(val3); - EXPECT_EQ(val1, val3); + BOOST_CHECK(val1 == val3); } -TEST(MSGPACK_TIMESPEC, timespec_pack_convert_zero) +BOOST_AUTO_TEST_CASE(steady_clock) +{ + std::chrono::steady_clock::time_point val1; + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, val1); + + msgpack::object_handle oh = + msgpack::unpack(sbuf.data(), sbuf.size()); + std::chrono::steady_clock::time_point val2 = oh.get().as(); + BOOST_CHECK(val1 == val2); + + std::chrono::steady_clock::time_point val3; + oh.get().convert(val3); + BOOST_CHECK(val1 == val3); +} + +BOOST_AUTO_TEST_CASE(steady_clock_32) +{ + std::chrono::steady_clock::time_point val1(std::chrono::seconds(0x12345678L)); + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, val1); + char packed[] = { + static_cast(0xd6u), + static_cast(-1), + static_cast(0x12), + static_cast(0x34), + static_cast(0x56), + static_cast(0x78) + }; + BOOST_CHECK_EQUAL(memcmp(sbuf.data(), packed, sizeof(packed)), 0); + + msgpack::object_handle oh = + msgpack::unpack(sbuf.data(), sbuf.size()); + std::chrono::steady_clock::time_point val2 = oh.get().as(); + BOOST_CHECK(val1 == val2); + + std::chrono::steady_clock::time_point val3; + oh.get().convert(val3); + BOOST_CHECK(val1 == val3); +} + +BOOST_AUTO_TEST_CASE(steady_clock_32_max) +{ + std::chrono::steady_clock::time_point val1(std::chrono::seconds(0xffffffffL)); + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, val1); + char packed[] = { + static_cast(0xd6u), + static_cast(-1), + static_cast(0xffu), + static_cast(0xffu), + static_cast(0xffu), + static_cast(0xffu) + }; + BOOST_CHECK_EQUAL(memcmp(sbuf.data(), packed, sizeof(packed)), 0); + + msgpack::object_handle oh = + msgpack::unpack(sbuf.data(), sbuf.size()); + std::chrono::steady_clock::time_point val2 = oh.get().as(); + BOOST_CHECK(val1 == val2); + + std::chrono::steady_clock::time_point val3; + oh.get().convert(val3); + BOOST_CHECK(val1 == val3); +} + + +BOOST_AUTO_TEST_CASE(steady_clock_64) +{ + std::chrono::steady_clock::time_point val1(std::chrono::seconds(0x31234567L)); + val1 += + std::chrono::duration_cast( + std::chrono::nanoseconds(0x312345678L) + ); + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, val1); + + msgpack::object_handle oh = + msgpack::unpack(sbuf.data(), sbuf.size()); + std::chrono::steady_clock::time_point val2 = oh.get().as(); + BOOST_CHECK(val1 == val2); + + std::chrono::steady_clock::time_point val3; + oh.get().convert(val3); + BOOST_CHECK(val1 == val3); +} + +BOOST_AUTO_TEST_CASE(steady_clock_64_max) +{ + std::chrono::steady_clock::time_point val1(std::chrono::seconds(0xffffffffL)); + + val1 += + std::chrono::duration_cast( + std::chrono::nanoseconds(0x3b9ac9ffL) // 999,999,999 + ); + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, val1); + char packed_nano[] = { + static_cast(0xd7u), + static_cast(-1), + static_cast(0xeeu), // 999,999,999 << 2 + static_cast(0x6b), + static_cast(0x27), + static_cast(0xfcu), + static_cast(0xffu), // 32 bit sec + static_cast(0xffu), + static_cast(0xffu), + static_cast(0xffu) + }; + char packed_micro[] = { + static_cast(0xd7u), + static_cast(-1), + static_cast(0xeeu), // 999,999,000 << 2 + static_cast(0x6b), + static_cast(0x18), + static_cast(0x60), + static_cast(0xffu), // 32 bit sec + static_cast(0xffu), + static_cast(0xffu), + static_cast(0xffu) + }; + if (std::chrono::steady_clock::duration::period::ratio::den == 1000000000) { + BOOST_CHECK_EQUAL(memcmp(sbuf.data(), packed_nano, sizeof(packed_nano)), 0); + } + else if (std::chrono::steady_clock::duration::period::ratio::den == 1000000) { + BOOST_CHECK_EQUAL(memcmp(sbuf.data(), packed_micro, sizeof(packed_micro)), 0); + } + + msgpack::object_handle oh = + msgpack::unpack(sbuf.data(), sbuf.size()); + std::chrono::steady_clock::time_point val2 = oh.get().as(); + BOOST_CHECK(val1 == val2); + + std::chrono::steady_clock::time_point val3; + oh.get().convert(val3); + BOOST_CHECK(val1 == val3); +} + +BOOST_AUTO_TEST_CASE(steady_clock_impl_min) +{ + std::chrono::steady_clock::time_point val1(std::chrono::steady_clock::time_point::min()); + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, val1); + + msgpack::object_handle oh = + msgpack::unpack(sbuf.data(), sbuf.size()); + std::chrono::steady_clock::time_point val2 = oh.get().as(); + BOOST_CHECK(val1 == val2); + + std::chrono::steady_clock::time_point val3; + oh.get().convert(val3); + BOOST_CHECK(val1 == val3); +} + +BOOST_AUTO_TEST_CASE(steady_clock_impl_max) +{ + std::chrono::steady_clock::time_point val1(std::chrono::steady_clock::time_point::max()); + + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, val1); + + msgpack::object_handle oh = + msgpack::unpack(sbuf.data(), sbuf.size()); + std::chrono::steady_clock::time_point val2 = oh.get().as(); + BOOST_CHECK(val1 == val2); + + std::chrono::steady_clock::time_point val3; + oh.get().convert(val3); + BOOST_CHECK(val1 == val3); +} + +BOOST_AUTO_TEST_CASE(steady_clock_impl_now) +{ + std::chrono::steady_clock::time_point val1(std::chrono::steady_clock::now()); + + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, val1); + + msgpack::object_handle oh = + msgpack::unpack(sbuf.data(), sbuf.size()); + std::chrono::steady_clock::time_point val2 = oh.get().as(); + BOOST_CHECK(val1 == val2); + + std::chrono::steady_clock::time_point val3; + oh.get().convert(val3); + BOOST_CHECK(val1 == val3); +} + + +BOOST_AUTO_TEST_CASE(high_resolution_clock) +{ + std::chrono::high_resolution_clock::time_point val1; + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, val1); + + msgpack::object_handle oh = + msgpack::unpack(sbuf.data(), sbuf.size()); + std::chrono::high_resolution_clock::time_point val2 = oh.get().as(); + BOOST_CHECK(val1 == val2); + + std::chrono::high_resolution_clock::time_point val3; + oh.get().convert(val3); + BOOST_CHECK(val1 == val3); +} + +BOOST_AUTO_TEST_CASE(high_resolution_clock_32) +{ + std::chrono::high_resolution_clock::time_point val1(std::chrono::seconds(0x12345678L)); + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, val1); + char packed[] = { + static_cast(0xd6u), + static_cast(-1), + static_cast(0x12), + static_cast(0x34), + static_cast(0x56), + static_cast(0x78) + }; + BOOST_CHECK_EQUAL(memcmp(sbuf.data(), packed, sizeof(packed)), 0); + + msgpack::object_handle oh = + msgpack::unpack(sbuf.data(), sbuf.size()); + std::chrono::high_resolution_clock::time_point val2 = oh.get().as(); + BOOST_CHECK(val1 == val2); + + std::chrono::high_resolution_clock::time_point val3; + oh.get().convert(val3); + BOOST_CHECK(val1 == val3); +} + +BOOST_AUTO_TEST_CASE(high_resolution_clock_32_max) +{ + std::chrono::high_resolution_clock::time_point val1(std::chrono::seconds(0xffffffffL)); + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, val1); + char packed[] = { + static_cast(0xd6u), + static_cast(-1), + static_cast(0xffu), + static_cast(0xffu), + static_cast(0xffu), + static_cast(0xffu) + }; + BOOST_CHECK_EQUAL(memcmp(sbuf.data(), packed, sizeof(packed)), 0); + + msgpack::object_handle oh = + msgpack::unpack(sbuf.data(), sbuf.size()); + std::chrono::high_resolution_clock::time_point val2 = oh.get().as(); + BOOST_CHECK(val1 == val2); + + std::chrono::high_resolution_clock::time_point val3; + oh.get().convert(val3); + BOOST_CHECK(val1 == val3); +} + + +BOOST_AUTO_TEST_CASE(high_resolution_clock_64) +{ + std::chrono::high_resolution_clock::time_point val1(std::chrono::seconds(0x31234567L)); + val1 += + std::chrono::duration_cast( + std::chrono::nanoseconds(0x312345678L) + ); + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, val1); + + msgpack::object_handle oh = + msgpack::unpack(sbuf.data(), sbuf.size()); + std::chrono::high_resolution_clock::time_point val2 = oh.get().as(); + BOOST_CHECK(val1 == val2); + + std::chrono::high_resolution_clock::time_point val3; + oh.get().convert(val3); + BOOST_CHECK(val1 == val3); +} + +BOOST_AUTO_TEST_CASE(high_resolution_clock_64_max) +{ + std::chrono::high_resolution_clock::time_point val1(std::chrono::seconds(0xffffffffL)); + + val1 += + std::chrono::duration_cast( + std::chrono::nanoseconds(0x3b9ac9ffL) // 999,999,999 + ); + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, val1); + char packed_nano[] = { + static_cast(0xd7u), + static_cast(-1), + static_cast(0xeeu), // 999,999,999 << 2 + static_cast(0x6b), + static_cast(0x27), + static_cast(0xfcu), + static_cast(0xffu), // 32 bit sec + static_cast(0xffu), + static_cast(0xffu), + static_cast(0xffu) + }; + char packed_micro[] = { + static_cast(0xd7u), + static_cast(-1), + static_cast(0xeeu), // 999,999,000 << 2 + static_cast(0x6b), + static_cast(0x18), + static_cast(0x60), + static_cast(0xffu), // 32 bit sec + static_cast(0xffu), + static_cast(0xffu), + static_cast(0xffu) + }; + if (std::chrono::high_resolution_clock::duration::period::ratio::den == 1000000000) { + BOOST_CHECK_EQUAL(memcmp(sbuf.data(), packed_nano, sizeof(packed_nano)), 0); + } + else if (std::chrono::high_resolution_clock::duration::period::ratio::den == 1000000) { + BOOST_CHECK_EQUAL(memcmp(sbuf.data(), packed_micro, sizeof(packed_micro)), 0); + } + + msgpack::object_handle oh = + msgpack::unpack(sbuf.data(), sbuf.size()); + std::chrono::high_resolution_clock::time_point val2 = oh.get().as(); + BOOST_CHECK(val1 == val2); + + std::chrono::high_resolution_clock::time_point val3; + oh.get().convert(val3); + BOOST_CHECK(val1 == val3); +} + +BOOST_AUTO_TEST_CASE(high_resolution_clock_impl_min) +{ + std::chrono::high_resolution_clock::time_point val1(std::chrono::high_resolution_clock::time_point::min()); + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, val1); + + msgpack::object_handle oh = + msgpack::unpack(sbuf.data(), sbuf.size()); + std::chrono::high_resolution_clock::time_point val2 = oh.get().as(); + BOOST_CHECK(val1 == val2); + + std::chrono::high_resolution_clock::time_point val3; + oh.get().convert(val3); + BOOST_CHECK(val1 == val3); +} + +BOOST_AUTO_TEST_CASE(high_resolution_clock_impl_max) +{ + std::chrono::high_resolution_clock::time_point val1(std::chrono::high_resolution_clock::time_point::max()); + + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, val1); + + msgpack::object_handle oh = + msgpack::unpack(sbuf.data(), sbuf.size()); + std::chrono::high_resolution_clock::time_point val2 = oh.get().as(); + BOOST_CHECK(val1 == val2); + + std::chrono::high_resolution_clock::time_point val3; + oh.get().convert(val3); + BOOST_CHECK(val1 == val3); +} + +BOOST_AUTO_TEST_CASE(high_resolution_clock_impl_now) +{ + std::chrono::high_resolution_clock::time_point val1(std::chrono::high_resolution_clock::now()); + + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, val1); + + msgpack::object_handle oh = + msgpack::unpack(sbuf.data(), sbuf.size()); + std::chrono::high_resolution_clock::time_point val2 = oh.get().as(); + BOOST_CHECK(val1 == val2); + + std::chrono::high_resolution_clock::time_point val3; + oh.get().convert(val3); + BOOST_CHECK(val1 == val3); +} + + +BOOST_AUTO_TEST_CASE(timespec_pack_convert_zero) { std::stringstream ss; timespec val1{ 0, 0 }; msgpack::pack(ss, val1); std::string const& str = ss.str(); - EXPECT_EQ(str.data()[0], static_cast(0xd6)); + BOOST_CHECK_EQUAL(str.data()[0], static_cast(0xd6u)); msgpack::object_handle oh; msgpack::unpack(oh, str.data(), str.size()); timespec val2 = oh.get().as(); - EXPECT_EQ(val1.tv_sec, val2.tv_sec); - EXPECT_EQ(val1.tv_nsec, val2.tv_nsec); + BOOST_CHECK_EQUAL(val1.tv_sec, val2.tv_sec); + BOOST_CHECK_EQUAL(val1.tv_nsec, val2.tv_nsec); } -TEST(MSGPACK_TIMESPEC, timespec_object_with_zone_zero) +BOOST_AUTO_TEST_CASE(timespec_object_with_zone_zero) { msgpack::zone z; timespec val1{ 0, 0 }; msgpack::object obj(val1, z); timespec val2 = obj.as(); - EXPECT_EQ(val1.tv_sec, val2.tv_sec); - EXPECT_EQ(val1.tv_nsec, val2.tv_nsec); + BOOST_CHECK_EQUAL(val1.tv_sec, val2.tv_sec); + BOOST_CHECK_EQUAL(val1.tv_nsec, val2.tv_nsec); } -TEST(MSGPACK_TIMESPEC, timespec_pack_convert_32bit_sec) +BOOST_AUTO_TEST_CASE(timespec_pack_convert_32bit_sec) { std::stringstream ss; - timespec val1{ 0xffffffffUL, 0 }; + timespec val1{ std::numeric_limits().tv_sec)>::is_signed ? time_t(INT32_MAX) : time_t(UINT32_MAX), 0 }; msgpack::pack(ss, val1); std::string const& str = ss.str(); - EXPECT_EQ(str.data()[0], static_cast(0xd6)); + BOOST_CHECK_EQUAL(str.data()[0], static_cast(0xd6u)); msgpack::object_handle oh; msgpack::unpack(oh, str.data(), str.size()); timespec val2 = oh.get().as(); - EXPECT_EQ(val1.tv_sec, val2.tv_sec); - EXPECT_EQ(val1.tv_nsec, val2.tv_nsec); + BOOST_CHECK_EQUAL(val1.tv_sec, val2.tv_sec); + BOOST_CHECK_EQUAL(val1.tv_nsec, val2.tv_nsec); } -TEST(MSGPACK_TIMESPEC, timespec_object_with_zone_32bit_sec) +BOOST_AUTO_TEST_CASE(timespec_object_with_zone_32bit_sec) { msgpack::zone z; - timespec val1{ 0xffffffffUL, 0 }; + timespec val1{ std::numeric_limits().tv_sec)>::is_signed ? time_t(INT32_MAX) : time_t(UINT32_MAX), 0 }; msgpack::object obj(val1, z); timespec val2 = obj.as(); - EXPECT_EQ(val1.tv_sec, val2.tv_sec); - EXPECT_EQ(val1.tv_nsec, val2.tv_nsec); + BOOST_CHECK_EQUAL(val1.tv_sec, val2.tv_sec); + BOOST_CHECK_EQUAL(val1.tv_nsec, val2.tv_nsec); } -TEST(MSGPACK_TIMESPEC, timespec_pack_convert_max_nano) +BOOST_AUTO_TEST_CASE(timespec_pack_convert_max_nano) { std::stringstream ss; timespec val1{ 0, 999999999 }; msgpack::pack(ss, val1); std::string const& str = ss.str(); - EXPECT_EQ(str.data()[0], static_cast(0xd7)); + BOOST_CHECK_EQUAL(str.data()[0], static_cast(0xd7u)); msgpack::object_handle oh; msgpack::unpack(oh, str.data(), str.size()); timespec val2 = oh.get().as(); - EXPECT_EQ(val1.tv_sec, val2.tv_sec); - EXPECT_EQ(val1.tv_nsec, val2.tv_nsec); + BOOST_CHECK_EQUAL(val1.tv_sec, val2.tv_sec); + BOOST_CHECK_EQUAL(val1.tv_nsec, val2.tv_nsec); } -TEST(MSGPACK_TIMESPEC, timespec_object_with_zone_max_nano) +BOOST_AUTO_TEST_CASE(timespec_object_with_zone_max_nano) { msgpack::zone z; timespec val1{ 0, 999999999 }; msgpack::object obj(val1, z); timespec val2 = obj.as(); - EXPECT_EQ(val1.tv_sec, val2.tv_sec); - EXPECT_EQ(val1.tv_nsec, val2.tv_nsec); + BOOST_CHECK_EQUAL(val1.tv_sec, val2.tv_sec); + BOOST_CHECK_EQUAL(val1.tv_nsec, val2.tv_nsec); } -TEST(MSGPACK_TIMESPEC, timespec_pack_convert_34bit_sec_max_nano) +BOOST_AUTO_TEST_CASE(timespec_pack_convert_34bit_sec_max_nano) { if (sizeof(decltype(std::declval().tv_sec)) <= 4) return; std::stringstream ss; @@ -1134,27 +1521,27 @@ TEST(MSGPACK_TIMESPEC, timespec_pack_convert_34bit_sec_max_nano) msgpack::pack(ss, val1); std::string const& str = ss.str(); - EXPECT_EQ(str.data()[0], static_cast(0xd7)); + BOOST_CHECK_EQUAL(str.data()[0], static_cast(0xd7u)); msgpack::object_handle oh; msgpack::unpack(oh, str.data(), str.size()); timespec val2 = oh.get().as(); - EXPECT_EQ(val1.tv_sec, val2.tv_sec); - EXPECT_EQ(val1.tv_nsec, val2.tv_nsec); + BOOST_CHECK_EQUAL(val1.tv_sec, val2.tv_sec); + BOOST_CHECK_EQUAL(val1.tv_nsec, val2.tv_nsec); } -TEST(MSGPACK_TIMESPEC, timespec_object_with_zone_34bit_sec_max_nano) +BOOST_AUTO_TEST_CASE(timespec_object_with_zone_34bit_sec_max_nano) { if (sizeof(decltype(std::declval().tv_sec)) <= 4) return; msgpack::zone z; timespec val1{ static_cast().tv_sec)>(0x3ffffffffULL), 999999999 }; msgpack::object obj(val1, z); timespec val2 = obj.as(); - EXPECT_EQ(val1.tv_sec, val2.tv_sec); - EXPECT_EQ(val1.tv_nsec, val2.tv_nsec); + BOOST_CHECK_EQUAL(val1.tv_sec, val2.tv_sec); + BOOST_CHECK_EQUAL(val1.tv_nsec, val2.tv_nsec); } -TEST(MSGPACK_TIMESPEC, timespec_pack_convert_35bit_sec_max_nano) +BOOST_AUTO_TEST_CASE(timespec_pack_convert_35bit_sec_max_nano) { if (sizeof(decltype(std::declval().tv_sec)) <= 4) return; std::stringstream ss; @@ -1162,50 +1549,51 @@ TEST(MSGPACK_TIMESPEC, timespec_pack_convert_35bit_sec_max_nano) msgpack::pack(ss, val1); std::string const& str = ss.str(); - EXPECT_EQ(str.data()[0], static_cast(0xc7)); + BOOST_CHECK_EQUAL(str.data()[0], static_cast(0xc7u)); msgpack::object_handle oh; msgpack::unpack(oh, str.data(), str.size()); timespec val2 = oh.get().as(); - EXPECT_EQ(val1.tv_sec, val2.tv_sec); - EXPECT_EQ(val1.tv_nsec, val2.tv_nsec); + BOOST_CHECK_EQUAL(val1.tv_sec, val2.tv_sec); + BOOST_CHECK_EQUAL(val1.tv_nsec, val2.tv_nsec); } -TEST(MSGPACK_TIMESPEC, timespec_object_with_zone_35bit_sec_max_nano) +BOOST_AUTO_TEST_CASE(timespec_object_with_zone_35bit_sec_max_nano) { if (sizeof(decltype(std::declval().tv_sec)) <= 4) return; msgpack::zone z; timespec val1{ static_cast().tv_sec)>(0x7ffffffffULL), 999999999 }; msgpack::object obj(val1, z); timespec val2 = obj.as(); - EXPECT_EQ(val1.tv_sec, val2.tv_sec); - EXPECT_EQ(val1.tv_nsec, val2.tv_nsec); + BOOST_CHECK_EQUAL(val1.tv_sec, val2.tv_sec); + BOOST_CHECK_EQUAL(val1.tv_nsec, val2.tv_nsec); } -TEST(MSGPACK_TIMESPEC, timespec_pack_convert_64bit_sec_max_nano) +BOOST_AUTO_TEST_CASE(timespec_pack_convert_64bit_sec_max_nano) { + if (sizeof(decltype(std::declval().tv_sec)) <= 4) return; std::stringstream ss; timespec val1{ std::numeric_limits().tv_sec)>::max(), 999999999 }; msgpack::pack(ss, val1); std::string const& str = ss.str(); - EXPECT_EQ(str.data()[0], static_cast(0xc7)); + BOOST_CHECK_EQUAL(str.data()[0], static_cast(0xc7u)); msgpack::object_handle oh; msgpack::unpack(oh, str.data(), str.size()); timespec val2 = oh.get().as(); - EXPECT_EQ(val1.tv_sec, val2.tv_sec); - EXPECT_EQ(val1.tv_nsec, val2.tv_nsec); + BOOST_CHECK_EQUAL(val1.tv_sec, val2.tv_sec); + BOOST_CHECK_EQUAL(val1.tv_nsec, val2.tv_nsec); } -TEST(MSGPACK_TIMESPEC, timespec_object_with_zone_64bit_sec_max_nano) +BOOST_AUTO_TEST_CASE(timespec_object_with_zone_64bit_sec_max_nano) { msgpack::zone z; timespec val1{ std::numeric_limits().tv_sec)>::max(), 999999999 }; msgpack::object obj(val1, z); timespec val2 = obj.as(); - EXPECT_EQ(val1.tv_sec, val2.tv_sec); - EXPECT_EQ(val1.tv_nsec, val2.tv_nsec); + BOOST_CHECK_EQUAL(val1.tv_sec, val2.tv_sec); + BOOST_CHECK_EQUAL(val1.tv_nsec, val2.tv_nsec); } diff --git a/test/msgpack_cpp17.cpp b/test/msgpack_cpp17.cpp index 932341726..be3d9d410 100644 --- a/test/msgpack_cpp17.cpp +++ b/test/msgpack_cpp17.cpp @@ -1,28 +1,24 @@ #include -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wconversion" - -#include - -#pragma GCC diagnostic pop +#define BOOST_TEST_MODULE MSGPACK_CPP17 +#include #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() -TEST(MSGPACK_CPP17, optional_pack_convert_nil) +BOOST_AUTO_TEST_CASE(optional_pack_convert_nil) { std::stringstream ss; std::optional val1; @@ -31,10 +27,10 @@ TEST(MSGPACK_CPP17, optional_pack_convert_nil) msgpack::object_handle oh = msgpack::unpack(str.data(), str.size()); std::optional val2 = oh.get().as >(); - 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 val1 = 1; @@ -43,10 +39,10 @@ TEST(MSGPACK_CPP17, optional_pack_convert_int) msgpack::object_handle oh = msgpack::unpack(str.data(), str.size()); std::optional val2 = oh.get().as >(); - 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 > ovi_t; std::stringstream ss; @@ -61,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(); - 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 > voi_t; std::stringstream ss; @@ -77,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(); - EXPECT_TRUE(val1 == val2); + BOOST_CHECK(val1 == val2); } -TEST(MSGPACK_CPP17, optional_object_nil) +BOOST_AUTO_TEST_CASE(optional_object_nil) { std::optional val1; msgpack::object obj(val1); std::optional val2 = obj.as >(); - EXPECT_TRUE(val1 == val2); + BOOST_CHECK(val1 == val2); } -TEST(MSGPACK_CPP17, optional_object_int) +BOOST_AUTO_TEST_CASE(optional_object_int) { std::optional val1 = 1; msgpack::object obj(val1); std::optional val2 = obj.as >(); - 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 > ovi_t; ovi_t val1; @@ -109,29 +105,29 @@ TEST(MSGPACK_CPP17, optional_object_int) val1 = v; msgpack::object obj(val1); ovi_t val2 = obj.as(); - 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 val1; msgpack::object obj(val1, z); std::optional val2 = obj.as >(); - 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 val1 = 1; msgpack::object obj(val1, z); std::optional val2 = obj.as >(); - 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 > voi_t; msgpack::zone z; @@ -141,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(); - EXPECT_TRUE(val1 == val2); + BOOST_CHECK(val1 == val2); } struct no_def_con { @@ -176,7 +172,7 @@ struct as { } // 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 val1 = no_def_con(1); @@ -185,14 +181,14 @@ TEST(MSGPACK_CPP17, optional_pack_convert_no_def_con) msgpack::object_handle oh = msgpack::unpack(str.data(), str.size()); std::optional val2 = oh.get().as>(); - EXPECT_TRUE(val1 == val2); + BOOST_CHECK(val1 == val2); } #endif // MSGPACK_HAS_INCLUDE() #if MSGPACK_HAS_INCLUDE() -TEST(MSGPACK_CPP17, string_view_pack_convert) +BOOST_AUTO_TEST_CASE(string_view_pack_convert) { std::stringstream ss; std::string s = "ABC"; @@ -204,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(); - 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(); - 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(); - EXPECT_TRUE(val1 == val2); + BOOST_CHECK(val1 == val2); } #endif // MSGPACK_HAS_INCLUDE() -TEST(MSGPACK_CPP17, byte_pack_convert) +BOOST_AUTO_TEST_CASE(byte_pack_convert) { std::stringstream ss; std::byte val1{0xff}; @@ -239,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(); - 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(); - 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(); - 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 val1{ @@ -267,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 val2 = oh.get().as>(); - EXPECT_EQ(val1, val2); + BOOST_CHECK(val1 == val2); } -TEST(MSGPACK_CPP17, vector_byte_object) +BOOST_AUTO_TEST_CASE(vector_byte_object) { std::vector val1{ std::byte{0x01}, std::byte{0x02}, std::byte{0x7f}, std::byte{0x80}, std::byte{0xff} @@ -291,10 +287,10 @@ TEST(MSGPACK_CPP17, vector_byte_object) msgpack::object obj(val1); std::vector val2 = obj.as>(); - 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 val1{ @@ -303,10 +299,129 @@ TEST(MSGPACK_CPP17, vector_byte_object_with_zone) msgpack::object obj(val1, z); std::vector val2 = obj.as>(); - 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 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>(); + BOOST_CHECK(val1 == val2); + } + { + msgpack::object_handle oh; + msgpack::unpack(oh, str.data(), str.size()); + BOOST_CHECK_THROW((oh.get().as>()), msgpack::type_error); + BOOST_CHECK_THROW((oh.get().as>()), msgpack::type_error); + BOOST_CHECK_THROW((oh.get().as>()), msgpack::type_error); + } +} + +BOOST_AUTO_TEST_CASE(array_byte_object) +{ + std::array 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>(); + BOOST_CHECK(val1 == val2); + + BOOST_CHECK_THROW((obj.as>()), msgpack::type_error); + BOOST_CHECK_THROW((obj.as>()), msgpack::type_error); + BOOST_CHECK_THROW((obj.as>()), msgpack::type_error); +} + +BOOST_AUTO_TEST_CASE(array_byte_object_with_zone) +{ + msgpack::zone z; + std::array 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>(); + BOOST_CHECK(val1 == val2); + + BOOST_CHECK_THROW((obj.as>()), msgpack::type_error); + BOOST_CHECK_THROW((obj.as>()), msgpack::type_error); + BOOST_CHECK_THROW((obj.as>()), msgpack::type_error); +} + +BOOST_AUTO_TEST_CASE(array_byte_empty_pack_convert) +{ + std::stringstream ss; + std::array 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>(); + BOOST_CHECK(val1 == val2); + } + { + msgpack::object_handle oh; + msgpack::unpack(oh, str.data(), str.size()); + BOOST_CHECK_THROW((oh.get().as>()), msgpack::type_error); + BOOST_CHECK_THROW((oh.get().as>()), msgpack::type_error); + } +} + +BOOST_AUTO_TEST_CASE(array_byte_empty_object) +{ + std::array val1{}; + + // Caller need to manage val1's lifetime. The Data is not copied. + msgpack::object obj(val1); + + auto val2 = obj.as>(); + BOOST_CHECK(val1 == val2); + + BOOST_CHECK_THROW((obj.as>()), msgpack::type_error); + BOOST_CHECK_THROW((obj.as>()), msgpack::type_error); +} + +BOOST_AUTO_TEST_CASE(array_byte_empty_object_with_zone) +{ + msgpack::zone z; + std::array val1{}; + msgpack::object obj(val1, z); + + auto val2 = obj.as>(); + BOOST_CHECK(val1 == val2); + + BOOST_CHECK_THROW((obj.as>()), msgpack::type_error); + BOOST_CHECK_THROW((obj.as>()), msgpack::type_error); +} + +BOOST_AUTO_TEST_CASE(carray_byte_pack_convert) { std::stringstream ss; std::byte val1[] = { @@ -314,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[] = { @@ -342,8 +457,56 @@ 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 +#if defined(MSGPACK_USE_STD_VARIANT_ADAPTOR) + +BOOST_AUTO_TEST_CASE(variant_pack_unpack_as) { + std::stringstream ss; + std::variant val1{1.0}; + msgpack::pack(ss, val1); + std::string const& str = ss.str(); + msgpack::object_handle oh = + msgpack::unpack(str.data(), str.size()); + std::variant val2 = + oh.get().as >(); + BOOST_CHECK(val1 == val2); + BOOST_CHECK_THROW((oh.get().as>()), msgpack::type_error); + + { + std::stringstream same_ss; + std::variant same_expected{std::in_place_index<2>, 2}; + msgpack::pack(same_ss, same_expected); + std::string const& same_str = same_ss.str(); + msgpack::object_handle same_oh = + msgpack::unpack(same_str.data(), same_str.size()); + std::variant same_actual = same_oh->as>(); + BOOST_CHECK(same_expected == same_actual); + } + + { + std::stringstream same_ss; + std::variant same_expected{std::in_place_index<1>, 2}; + msgpack::pack(same_ss, same_expected); + std::string const& same_str = same_ss.str(); + msgpack::object_handle same_oh = + msgpack::unpack(same_str.data(), same_str.size()); + std::variant same_actual = same_oh->as>(); + BOOST_CHECK(same_expected == same_actual); + } +} + +BOOST_AUTO_TEST_CASE(variant_with_zone) { + msgpack::zone z; + std::variant val1{1.0}; + msgpack::object obj(val1, z); + std::variant val2 = obj.as>(); + BOOST_CHECK(val1 == val2); + BOOST_CHECK_THROW((obj.as>()), msgpack::type_error); +} + +#endif // defined(MSGPACK_USE_STD_VARIANT_ADAPTOR) + +#endif // MSGPACK_CPP_VERSION >= 201703 diff --git a/test/msgpack_cpp20.cpp b/test/msgpack_cpp20.cpp new file mode 100644 index 000000000..29400aa8b --- /dev/null +++ b/test/msgpack_cpp20.cpp @@ -0,0 +1,131 @@ +#include + +#define BOOST_TEST_MODULE MSGPACK_CPP20 +#include + +#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() + +template +bool operator==(const std::span& lhs, const std::span& 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 +bool operator==(const std::span& lhs, const std::vector& rhs) +{ + return lhs == std::span{rhs.data(), rhs.size()}; +} + +template +bool operator==(const std::vector& lhs, const std::span& rhs) +{ + return std::span{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 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>(); \ + BOOST_CHECK(val1 == val2); \ + } \ + { \ + auto val2 = oh.get().as>(); \ + 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 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>(); \ + BOOST_CHECK(val1 == val2); \ + } \ + { \ + auto val2 = obj.as>(); \ + 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 val1(raw_data, sizeof(raw_data)); \ + \ + msgpack::object obj(val1, z); \ + \ + { \ + auto val2 = obj.as>(); \ + BOOST_CHECK(val1 == val2); \ + } \ + { \ + auto val2 = obj.as>(); \ + 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() + +#endif // MSGPACK_CPP_VERSION > 201703 diff --git a/test/msgpack_stream.cpp b/test/msgpack_stream.cpp index 4369b50c9..7b2806815 100644 --- a/test/msgpack_stream.cpp +++ b/test/msgpack_stream.cpp @@ -9,12 +9,8 @@ #include #include -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wconversion" - -#include - -#pragma GCC diagnostic pop +#define BOOST_TEST_MODULE MSGPACK +#include #ifdef HAVE_CONFIG_H #include "config.h" @@ -51,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; \ @@ -60,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); } diff --git a/test/msgpack_tuple.cpp b/test/msgpack_tuple.cpp index e71136487..3afe5d1bd 100644 --- a/test/msgpack_tuple.cpp +++ b/test/msgpack_tuple.cpp @@ -1,109 +1,106 @@ #include -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wconversion" +#define BOOST_TEST_MODULE msgpack_tuple +#include -#include - -#pragma GCC diagnostic pop - - -TEST(msgpack_tuple, member_get) +BOOST_AUTO_TEST_CASE(member_get) { msgpack::type::tuple 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 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 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 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 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 t1 = msgpack::type::make_tuple(42); msgpack::type::tuple t2 = msgpack::type::make_tuple(true, "ABC"); msgpack::type::tuple 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 t1 = msgpack::type::make_tuple(42, true, "ABC"); msgpack::type::tuple 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 diff --git a/test/msgpack_vref.cpp b/test/msgpack_vref.cpp index 20fb0622c..afab2103e 100644 --- a/test/msgpack_vref.cpp +++ b/test/msgpack_vref.cpp @@ -9,12 +9,8 @@ #include #include -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wconversion" - -#include - -#pragma GCC diagnostic pop +#define BOOST_TEST_MODULE MSGPACK +#include #ifdef HAVE_CONFIG_H #include "config.h" @@ -30,253 +26,253 @@ using namespace std; test_type val1 = v[i]; \ msgpack::pack(vbuf, val1); \ msgpack::sbuffer sbuf; \ - const struct iovec* cur = vbuf.vector(); \ - const struct iovec* end = cur + vbuf.vector_size(); \ + const msgpack::iovec* cur = vbuf.vector(); \ + const msgpack::iovec* end = cur + vbuf.vector_size(); \ for(; cur != end; ++cur) \ sbuf.write((const char*)cur->iov_base, cur->iov_len); \ msgpack::object_handle oh; \ msgpack::unpack(oh, sbuf.data(), sbuf.size()); \ test_type val2 = oh.get().as(); \ - 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::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); } diff --git a/test/msgpack_x3_parse.cpp b/test/msgpack_x3_parse.cpp index 3dbd900ee..216b098f1 100644 --- a/test/msgpack_x3_parse.cpp +++ b/test/msgpack_x3_parse.cpp @@ -4,15 +4,11 @@ #include #include -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wconversion" - -#include - -#pragma GCC diagnostic pop +#define BOOST_TEST_MODULE MSGPACK_X3_PARSE +#include // To avoid link error -TEST(MSGPACK_X3_PARSE, dummy) +BOOST_AUTO_TEST_CASE(dummy) { } @@ -22,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()); + BOOST_CHECK_EQUAL(v, oh.get().as()); } -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()); + BOOST_CHECK_EQUAL(v, oh.get().as()); } -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()); + BOOST_CHECK_EQUAL(v, oh.get().as()); } -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()); + BOOST_CHECK_EQUAL(v, oh.get().as()); } -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()); + BOOST_CHECK_EQUAL(v, oh.get().as()); } -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()); + BOOST_CHECK_EQUAL(v, oh.get().as()); } -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()); + BOOST_CHECK_EQUAL(v, oh.get().as()); } -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()); + BOOST_CHECK_EQUAL(v, oh.get().as()); } -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()); + BOOST_CHECK_EQUAL(v, oh.get().as()); } -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()); + BOOST_CHECK_EQUAL(v, oh.get().as()); } -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()); + BOOST_CHECK_EQUAL(v, oh.get().as()); } -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()); + BOOST_CHECK_EQUAL(v, oh.get().as()); } -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()); + BOOST_CHECK_EQUAL(v, oh.get().as()); } -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()); + BOOST_CHECK_EQUAL(v, oh.get().as()); } -TEST(MSGPACK_X3_PARSE, int8_1) +BOOST_AUTO_TEST_CASE(int8_1) { int8_t v = static_cast(0b11011111); std::stringstream ss; msgpack::pack(ss, v); auto oh = msgpack::unpack(ss.str().begin(), ss.str().end()); - EXPECT_EQ(v, oh.get().as()); + BOOST_CHECK_EQUAL(v, oh.get().as()); } -TEST(MSGPACK_X3_PARSE, int8_2) +BOOST_AUTO_TEST_CASE(int8_2) { int8_t v = static_cast(0b10000000); std::stringstream ss; msgpack::pack(ss, v); auto oh = msgpack::unpack(ss.str().begin(), ss.str().end()); - EXPECT_EQ(v, oh.get().as()); + BOOST_CHECK_EQUAL(v, oh.get().as()); } -TEST(MSGPACK_X3_PARSE, int16_1) +BOOST_AUTO_TEST_CASE(int16_1) { int16_t v = static_cast(0xff00); std::stringstream ss; msgpack::pack(ss, v); auto oh = msgpack::unpack(ss.str().begin(), ss.str().end()); - EXPECT_EQ(v, oh.get().as()); + BOOST_CHECK_EQUAL(v, oh.get().as()); } -TEST(MSGPACK_X3_PARSE, int16_2) +BOOST_AUTO_TEST_CASE(int16_2) { int16_t v = static_cast(0x8000); std::stringstream ss; msgpack::pack(ss, v); auto oh = msgpack::unpack(ss.str().begin(), ss.str().end()); - EXPECT_EQ(v, oh.get().as()); + BOOST_CHECK_EQUAL(v, oh.get().as()); } -TEST(MSGPACK_X3_PARSE, int32_1) +BOOST_AUTO_TEST_CASE(int32_1) { int32_t v = static_cast(0xff000000L); std::stringstream ss; msgpack::pack(ss, v); auto oh = msgpack::unpack(ss.str().begin(), ss.str().end()); - EXPECT_EQ(v, oh.get().as()); + BOOST_CHECK_EQUAL(v, oh.get().as()); } -TEST(MSGPACK_X3_PARSE, int32_2) +BOOST_AUTO_TEST_CASE(int32_2) { int32_t v = static_cast(0x80000000L); std::stringstream ss; msgpack::pack(ss, v); auto oh = msgpack::unpack(ss.str().begin(), ss.str().end()); - EXPECT_EQ(v, oh.get().as()); + BOOST_CHECK_EQUAL(v, oh.get().as()); } -TEST(MSGPACK_X3_PARSE, int64_1) +BOOST_AUTO_TEST_CASE(int64_1) { int64_t v = static_cast(0xff00000000000000LL); std::stringstream ss; msgpack::pack(ss, v); auto oh = msgpack::unpack(ss.str().begin(), ss.str().end()); - EXPECT_EQ(v, oh.get().as()); + BOOST_CHECK_EQUAL(v, oh.get().as()); } -TEST(MSGPACK_X3_PARSE, int64_2) +BOOST_AUTO_TEST_CASE(int64_2) { int64_t v = static_cast(0x8000000000000000LL); std::stringstream ss; msgpack::pack(ss, v); auto oh = msgpack::unpack(ss.str().begin(), ss.str().end()); - EXPECT_EQ(v, oh.get().as()); + BOOST_CHECK_EQUAL(v, oh.get().as()); } -TEST(MSGPACK_X3_PARSE, array_1) +BOOST_AUTO_TEST_CASE(array_1) { std::vector v; std::stringstream ss; msgpack::pack(ss, v); auto oh = msgpack::unpack(ss.str().begin(), ss.str().end()); - EXPECT_EQ(v, oh.get().as >()); + BOOST_CHECK(v == oh.get().as >()); } -TEST(MSGPACK_X3_PARSE, array_2) +BOOST_AUTO_TEST_CASE(array_2) { std::vector v; std::stringstream ss; @@ -270,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 >()); + BOOST_CHECK(v == oh.get().as >()); } -TEST(MSGPACK_X3_PARSE, array_3) +BOOST_AUTO_TEST_CASE(array_3) { std::vector v; std::stringstream ss; @@ -281,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 >()); + BOOST_CHECK(v == oh.get().as >()); } -TEST(MSGPACK_X3_PARSE, array_4) +BOOST_AUTO_TEST_CASE(array_4) { std::vector v; std::stringstream ss; @@ -292,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 >()); + BOOST_CHECK(v == oh.get().as >()); } -TEST(MSGPACK_X3_PARSE, array_5) +BOOST_AUTO_TEST_CASE(array_5) { std::vector v; std::stringstream ss; @@ -303,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 >()); + BOOST_CHECK(v == oh.get().as >()); } -TEST(MSGPACK_X3_PARSE, map_1) +BOOST_AUTO_TEST_CASE(map_1) { std::map v; std::stringstream ss; msgpack::pack(ss, v); auto oh = msgpack::unpack(ss.str().begin(), ss.str().end()); - EXPECT_EQ(v, (oh.get().as >())); + BOOST_CHECK(v == (oh.get().as >())); } -TEST(MSGPACK_X3_PARSE, map_2) +BOOST_AUTO_TEST_CASE(map_2) { std::map v; std::stringstream ss; @@ -324,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 >())); + BOOST_CHECK(v == (oh.get().as >())); } -TEST(MSGPACK_X3_PARSE, map_3) +BOOST_AUTO_TEST_CASE(map_3) { std::map v; std::stringstream ss; @@ -335,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 >())); + BOOST_CHECK(v == (oh.get().as >())); } -TEST(MSGPACK_X3_PARSE, map_4) +BOOST_AUTO_TEST_CASE(map_4) { std::map v; std::stringstream ss; @@ -346,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 >())); + BOOST_CHECK(v == (oh.get().as >())); } -TEST(MSGPACK_X3_PARSE, map_5) +BOOST_AUTO_TEST_CASE(map_5) { std::map v; std::stringstream ss; @@ -357,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 >())); + BOOST_CHECK(v == (oh.get().as >())); } -TEST(MSGPACK_X3_PARSE, float_1) +BOOST_AUTO_TEST_CASE(float_1) { std::vector v; v.push_back(0.0); @@ -390,15 +386,15 @@ TEST(MSGPACK_X3_PARSE, float_1) float val2 = oh.get().as(); 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 v; v.push_back(0.0); @@ -428,25 +424,25 @@ TEST(MSGPACK_X3_PARSE, double_1) double val2 = oh.get().as(); 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()); + BOOST_CHECK_EQUAL(v, oh.get().as()); } -TEST(MSGPACK_X3_PARSE, string_2) +BOOST_AUTO_TEST_CASE(string_2) { std::string v; @@ -456,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()); + BOOST_CHECK_EQUAL(v, oh.get().as()); } -TEST(MSGPACK_X3_PARSE, string_3) +BOOST_AUTO_TEST_CASE(string_3) { std::string v; @@ -469,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()); + BOOST_CHECK_EQUAL(v, oh.get().as()); } -TEST(MSGPACK_X3_PARSE, string_4) +BOOST_AUTO_TEST_CASE(string_4) { std::string v; @@ -482,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()); + BOOST_CHECK_EQUAL(v, oh.get().as()); } -TEST(MSGPACK_X3_PARSE, string_5) +BOOST_AUTO_TEST_CASE(string_5) { std::string v; @@ -495,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()); + BOOST_CHECK_EQUAL(v, oh.get().as()); } -TEST(MSGPACK_X3_PARSE, string_6) +BOOST_AUTO_TEST_CASE(string_6) { std::string v; @@ -508,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()); + BOOST_CHECK_EQUAL(v, oh.get().as()); } -TEST(MSGPACK_X3_PARSE, bin_1) +BOOST_AUTO_TEST_CASE(bin_1) { std::vector v; std::stringstream ss; msgpack::pack(ss, v); auto oh = msgpack::unpack(ss.str().begin(), ss.str().end()); - EXPECT_EQ(v, oh.get().as>()); + BOOST_CHECK(v == oh.get().as>()); } -TEST(MSGPACK_X3_PARSE, bin_2) +BOOST_AUTO_TEST_CASE(bin_2) { std::vector v; @@ -531,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>()); + BOOST_CHECK(v == oh.get().as>()); } -TEST(MSGPACK_X3_PARSE, bin_3) +BOOST_AUTO_TEST_CASE(bin_3) { std::vector v; @@ -544,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>()); + BOOST_CHECK(v == oh.get().as>()); } -TEST(MSGPACK_X3_PARSE, bin_4) +BOOST_AUTO_TEST_CASE(bin_4) { std::vector v; @@ -557,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>()); + BOOST_CHECK(v == oh.get().as>()); } -TEST(MSGPACK_X3_PARSE, bin_5) +BOOST_AUTO_TEST_CASE(bin_5) { std::vector v; @@ -570,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>()); + BOOST_CHECK(v == oh.get().as>()); } -TEST(MSGPACK_X3_PARSE, bin_6) +BOOST_AUTO_TEST_CASE(bin_6) { std::vector v; @@ -583,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>()); + BOOST_CHECK(v == oh.get().as>()); } -TEST(MSGPACK_X3_PARSE, fixext1) +BOOST_AUTO_TEST_CASE(fixext1) { std::stringstream ss; msgpack::packer packer(ss); @@ -596,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 packer(ss); @@ -611,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 packer(ss); @@ -627,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 packer(ss); @@ -643,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 packer(ss); @@ -659,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; @@ -674,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; @@ -690,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; @@ -708,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; @@ -726,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; @@ -744,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; @@ -759,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()); + BOOST_CHECK(!r); + BOOST_CHECK_EQUAL(v, oh.get().as()); } -TEST(MSGPACK_X3_PARSE, unpack_referenced_2) +BOOST_AUTO_TEST_CASE(unpack_referenced_2) { std::string v = "ABC"; std::stringstream ss; @@ -781,11 +777,11 @@ TEST(MSGPACK_X3_PARSE, unpack_referenced_2) return true; } ); - EXPECT_TRUE(r); - EXPECT_EQ(v, oh.get().as()); + BOOST_CHECK(r); + BOOST_CHECK_EQUAL(v, oh.get().as()); } -TEST(MSGPACK_X3_PARSE, unpack_zone_1) +BOOST_AUTO_TEST_CASE(unpack_zone_1) { std::string v = "ABC"; std::stringstream ss; @@ -794,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()); + BOOST_CHECK_EQUAL(v, obj.as()); } -TEST(MSGPACK_X3_PARSE, unpack_zone_2) +BOOST_AUTO_TEST_CASE(unpack_zone_2) { std::string v = "ABC"; std::stringstream ss; @@ -807,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()); + BOOST_CHECK_EQUAL(v, obj.as()); - EXPECT_FALSE(r); - EXPECT_EQ(v, obj.as()); + BOOST_CHECK(!r); + BOOST_CHECK_EQUAL(v, obj.as()); } -TEST(MSGPACK_X3_PARSE, unpack_zone_3) +BOOST_AUTO_TEST_CASE(unpack_zone_3) { std::string v = "ABC"; std::stringstream ss; @@ -833,8 +829,8 @@ TEST(MSGPACK_X3_PARSE, unpack_zone_3) return true; } ); - EXPECT_TRUE(r); - EXPECT_EQ(v, obj.as()); + BOOST_CHECK(r); + BOOST_CHECK_EQUAL(v, obj.as()); } #endif // defined(MSGPACK_USE_X3_PARSE) && MSGPACK_DEFAULT_API_VERSION >= 2 diff --git a/test/object.cpp b/test/object.cpp index 9095dab8a..1f6d7bbd8 100644 --- a/test/object.cpp +++ b/test/object.cpp @@ -1,12 +1,7 @@ #include -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wconversion" - -#include - -#pragma GCC diagnostic pop - +#define BOOST_TEST_MODULE object +#include enum enum_test { elem @@ -67,7 +62,7 @@ std::ostream& operator<<(std::ostream& o, const myclass& m) } -TEST(object, convert) +BOOST_AUTO_TEST_CASE(convert) { myclass m1(1, "custom"); @@ -80,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"); @@ -94,10 +89,10 @@ TEST(object, as) msgpack::object_handle oh = msgpack::unpack(sbuf.data(), sbuf.size()); - EXPECT_EQ(m1, oh.get().as()); + BOOST_CHECK_EQUAL(m1, oh.get().as()); } -TEST(object, cross_zone_copy) +BOOST_AUTO_TEST_CASE(cross_zone_copy) { myclass m1(1, "custom"); m1.vec.push_back(1.0); @@ -118,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()); + BOOST_CHECK_EQUAL(m1, obj1.as()); } -TEST(object, cross_zone_copy_construct) +BOOST_AUTO_TEST_CASE(cross_zone_copy_construct) { myclass m1(1, "custom"); m1.vec.push_back(1.0); @@ -159,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()); + BOOST_CHECK_EQUAL(m1, obj1.as()); } -TEST(object, cross_zone_copy_ext) +BOOST_AUTO_TEST_CASE(cross_zone_copy_ext) { msgpack::zone z1; msgpack::zone z2; @@ -195,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; @@ -217,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(), msgpack::type_error); - EXPECT_THROW(obj.as >(), msgpack::type_error); - EXPECT_EQ(1, obj.as()); - EXPECT_EQ(1, obj.as()); - EXPECT_EQ(1u, obj.as()); - EXPECT_EQ(1u, obj.as()); + BOOST_CHECK_THROW(obj.as(), msgpack::type_error); + BOOST_CHECK_THROW(obj.as >(), msgpack::type_error); + BOOST_CHECK_EQUAL(1, obj.as()); + BOOST_CHECK_EQUAL(1, obj.as()); + BOOST_CHECK_EQUAL(1u, obj.as()); + BOOST_CHECK_EQUAL(1u, obj.as()); } - -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(elem), obj.via.u64); + BOOST_CHECK_EQUAL(msgpack::type::POSITIVE_INTEGER, obj.type); + BOOST_CHECK_EQUAL(static_cast(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(elem), obj.via.u64); + BOOST_CHECK_EQUAL(msgpack::type::POSITIVE_INTEGER, obj.type); + BOOST_CHECK_EQUAL(static_cast(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"; @@ -374,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()); + BOOST_CHECK_EQUAL(v, oh.get().as()); } -TEST(object, clone_bin) +BOOST_AUTO_TEST_CASE(clone_bin) { msgpack::object_handle oh; std::vector v; @@ -396,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 v2 = oh.get().as >(); - 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 v; @@ -420,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 v2 = oh.get().as >(); - 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 v; @@ -444,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 v2 = oh.get().as >(); - 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(5), ss1.str().size()); - EXPECT_EQ(ss1.str(), ss2.str()); + BOOST_CHECK_EQUAL(static_cast(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(9), ss1.str().size()); - EXPECT_EQ(ss1.str(), ss2.str()); + BOOST_CHECK_EQUAL(static_cast(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(), oh.get().as()); + BOOST_CHECK_EQUAL(oh.get(), *oh); + BOOST_CHECK_EQUAL(oh->as(), oh.get().as()); +} + +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 v1; + v1.push_back(1); + for (unsigned int i = 1; i < kElements; i++) + v1.push_back(static_cast(i)); + msgpack::object obj(v1); + BOOST_CHECK(obj.as >() == v1); + v1.front() = 42; + // obj refer to v1 + BOOST_CHECK_EQUAL(obj.as >().front(), 42); + } +} + +BOOST_AUTO_TEST_CASE(vector_unsigned_char) +{ + if (!msgpack::is_same::value) return; + for (unsigned int k = 0; k < kLoop; k++) { + std::vector v1; + v1.push_back(1); + for (unsigned int i = 1; i < kElements; i++) + v1.push_back(static_cast(i)); + msgpack::object obj(v1); + BOOST_CHECK(obj.as >() == v1); + v1.front() = 42; + // obj refer to v1 + BOOST_CHECK_EQUAL(obj.as >().front(), 42); + } } + +BOOST_AUTO_TEST_CASE(raw_ref) +{ + std::string s = "abc"; + msgpack::type::raw_ref v(s.data(), static_cast(s.size())); + msgpack::zone z; + msgpack::object obj(v); + BOOST_CHECK(obj.as() == v); + s[0] = 'd'; + BOOST_CHECK(obj.as() == v); +} + +#if MSGPACK_CPP_VERSION >= 201703 + +BOOST_AUTO_TEST_CASE(array_char) +{ + typedef std::array 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(rand()); + msgpack::object obj(v1); + BOOST_CHECK(obj.as() == v1); + v1.front() = 42; + // obj refer to v1 + BOOST_CHECK_EQUAL(obj.as().front(), 42); + } +} + + +BOOST_AUTO_TEST_CASE(array_unsigned_char) +{ + if (!msgpack::is_same::value) return; + typedef std::array 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(rand()); + msgpack::object obj(v1); + BOOST_CHECK(obj.as() == v1); + v1.front() = 42; + // obj refer to v1 + BOOST_CHECK_EQUAL(obj.as().front(), 42); + } +} + +#endif // MSGPACK_CPP_VERSION >= 201703 diff --git a/test/object_with_zone.cpp b/test/object_with_zone.cpp index df71418f1..fbd2c7659 100644 --- a/test/object_with_zone.cpp +++ b/test/object_with_zone.cpp @@ -1,11 +1,7 @@ #include -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wconversion" - -#include - -#pragma GCC diagnostic pop +#define BOOST_TEST_MODULE object_with_zone +#include #include @@ -46,448 +42,432 @@ MSGPACK_ADD_ENUM(outer_enum_class::enum_class_test); #endif // !defined(MSGPACK_USE_CPP03) - -using namespace std; - const unsigned int kLoop = 1000; const unsigned int kElements = 100; const double kEPS = 1e-10; // bool -TEST(object_with_zone, bool) +BOOST_AUTO_TEST_CASE(bool_) { bool v = true; msgpack::zone z; msgpack::object obj(v, z); - EXPECT_EQ(obj.as(), v); + BOOST_CHECK_EQUAL(obj.as(), v); v = false; - EXPECT_TRUE(obj.as()); + BOOST_CHECK(obj.as()); } // char -TEST(object_with_zone, char) +BOOST_AUTO_TEST_CASE(char_) { char v = 1; msgpack::zone z; msgpack::object obj(v, z); - EXPECT_EQ(obj.as(), v); + BOOST_CHECK_EQUAL(obj.as(), v); v = 2; - EXPECT_EQ(obj.as(), 1); + BOOST_CHECK_EQUAL(obj.as(), 1); } // signed integer family -TEST(object_with_zone, signed_char) +BOOST_AUTO_TEST_CASE(signed_char) { signed char v = -1; msgpack::zone z; msgpack::object obj(v, z); - EXPECT_EQ(obj.as(), v); + BOOST_CHECK_EQUAL(obj.as(), v); v = -2; - EXPECT_EQ(obj.as(), -1); + BOOST_CHECK_EQUAL(obj.as(), -1); } -TEST(object_with_zone, signed_short) +BOOST_AUTO_TEST_CASE(signed_short) { signed short v = -1; msgpack::zone z; msgpack::object obj(v, z); - EXPECT_EQ(obj.as(), v); + BOOST_CHECK_EQUAL(obj.as(), v); v = -2; - EXPECT_EQ(obj.as(), -1); + BOOST_CHECK_EQUAL(obj.as(), -1); } -TEST(object_with_zone, signed_int) +BOOST_AUTO_TEST_CASE(signed_int) { signed int v = -1; msgpack::zone z; msgpack::object obj(v, z); - EXPECT_EQ(obj.as(), v); + BOOST_CHECK_EQUAL(obj.as(), v); v = -2; - EXPECT_EQ(obj.as(), -1); + BOOST_CHECK_EQUAL(obj.as(), -1); } -TEST(object_with_zone, signed_long) +BOOST_AUTO_TEST_CASE(signed_long) { signed long v = -1; msgpack::zone z; msgpack::object obj(v, z); - EXPECT_EQ(obj.as(), v); + BOOST_CHECK_EQUAL(obj.as(), v); v = -2; - EXPECT_EQ(obj.as(), -1); + BOOST_CHECK_EQUAL(obj.as(), -1); } -TEST(object_with_zone, signed_long_long) +BOOST_AUTO_TEST_CASE(signed_long_long) { signed long long v = -1; msgpack::zone z; msgpack::object obj(v, z); - EXPECT_EQ(obj.as(), v); + BOOST_CHECK_EQUAL(obj.as(), v); v = -2; - EXPECT_EQ(obj.as(), -1); + BOOST_CHECK_EQUAL(obj.as(), -1); } // unsigned integer family -TEST(object_with_zone, unsigned_char) +BOOST_AUTO_TEST_CASE(unsigned_char) { unsigned char v = 1; msgpack::zone z; msgpack::object obj(v, z); - EXPECT_EQ(obj.as(), v); + BOOST_CHECK_EQUAL(obj.as(), v); v = 2; - EXPECT_EQ(obj.as(), 1); + BOOST_CHECK_EQUAL(obj.as(), 1); } -TEST(object_with_zone, unsigned_short) +BOOST_AUTO_TEST_CASE(unsigned_short) { unsigned short v = 1; msgpack::zone z; msgpack::object obj(v, z); - EXPECT_EQ(obj.as(), v); + BOOST_CHECK_EQUAL(obj.as(), v); v = 2; - EXPECT_EQ(obj.as(), 1); + BOOST_CHECK_EQUAL(obj.as(), 1); } -TEST(object_with_zone, unsigned_int) +BOOST_AUTO_TEST_CASE(unsigned_int) { unsigned int v = 1; msgpack::zone z; msgpack::object obj(v, z); - EXPECT_EQ(obj.as(), v); + BOOST_CHECK_EQUAL(obj.as(), v); v = 2; - EXPECT_EQ(obj.as(), 1u); + BOOST_CHECK_EQUAL(obj.as(), 1u); } -TEST(object_with_zone, unsigned_long) +BOOST_AUTO_TEST_CASE(unsigned_long) { unsigned long v = 1; msgpack::zone z; msgpack::object obj(v, z); - EXPECT_EQ(obj.as(), v); + BOOST_CHECK_EQUAL(obj.as(), v); v = 2; - EXPECT_EQ(obj.as(), 1u); + BOOST_CHECK_EQUAL(obj.as(), 1u); } -TEST(object_with_zone, unsigned_long_long) +BOOST_AUTO_TEST_CASE(unsigned_long_long) { unsigned long long v = 1; msgpack::zone z; msgpack::object obj(v, z); - EXPECT_EQ(obj.as(), v); + BOOST_CHECK_EQUAL(obj.as(), v); v = 2; - EXPECT_EQ(obj.as(), 1u); + BOOST_CHECK_EQUAL(obj.as(), 1u); } // float -TEST(object_with_zone, float) +BOOST_AUTO_TEST_CASE(float_) { float v = 1.23f; msgpack::zone z; msgpack::object obj(v, z); - EXPECT_EQ(obj.type, msgpack::type::FLOAT32); - EXPECT_TRUE(fabs(obj.as() - v) <= kEPS); + BOOST_CHECK_EQUAL(obj.type, msgpack::type::FLOAT32); + BOOST_CHECK(fabs(obj.as() - v) <= kEPS); v = 4.56f; - EXPECT_TRUE(fabs(obj.as() - static_cast(1.23)) <= kEPS); + BOOST_CHECK(fabs(obj.as() - static_cast(1.23)) <= kEPS); } // double -TEST(object_with_zone, double) +BOOST_AUTO_TEST_CASE(double_) { double v = 1.23; msgpack::zone z; msgpack::object obj(v, z); - EXPECT_EQ(obj.type, msgpack::type::FLOAT64); - EXPECT_TRUE(fabs(obj.as() - v) <= kEPS); + BOOST_CHECK_EQUAL(obj.type, msgpack::type::FLOAT64); + BOOST_CHECK(fabs(obj.as() - v) <= kEPS); v = 4.56; - EXPECT_TRUE(fabs(obj.as() - 1.23) <= kEPS); + BOOST_CHECK(fabs(obj.as() - 1.23) <= kEPS); } // vector -TEST(object_with_zone, vector) +BOOST_AUTO_TEST_CASE(vector) { for (unsigned int k = 0; k < kLoop; k++) { - vector v1; + std::vector v1; v1.push_back(1); for (unsigned int i = 1; i < kElements; i++) v1.push_back(static_cast(i)); msgpack::zone z; msgpack::object obj(v1, z); - EXPECT_TRUE(obj.as >() == v1); + BOOST_CHECK(obj.as >() == v1); v1.front() = 42; - EXPECT_EQ(obj.as >().front(), 1); + BOOST_CHECK_EQUAL(obj.as >().front(), 1); } } // vector_char -TEST(object_with_zone, vector_char) +BOOST_AUTO_TEST_CASE(vector_char) { for (unsigned int k = 0; k < kLoop; k++) { - vector v1; + std::vector v1; v1.push_back(1); for (unsigned int i = 1; i < kElements; i++) v1.push_back(static_cast(i)); msgpack::zone z; msgpack::object obj(v1, z); - EXPECT_TRUE(obj.as >() == v1); + BOOST_CHECK(obj.as >() == v1); v1.front() = 42; - EXPECT_EQ(obj.as >().front(), 1); + BOOST_CHECK_EQUAL(obj.as >().front(), 1); } } -TEST(object_without_zone, vector_char) -{ - for (unsigned int k = 0; k < kLoop; k++) { - vector v1; - v1.push_back(1); - for (unsigned int i = 1; i < kElements; i++) - v1.push_back(static_cast(i)); - msgpack::object obj(v1); - EXPECT_TRUE(obj.as >() == v1); - v1.front() = 42; - // obj refer to v1 - EXPECT_EQ(obj.as >().front(), 42); - } -} + // vector_unsgined_char -TEST(object_with_zone, vector_unsigned_char) +BOOST_AUTO_TEST_CASE(vector_unsigned_char) { if (!msgpack::is_same::value) return; for (unsigned int k = 0; k < kLoop; k++) { - vector v1; + std::vector v1; v1.push_back(1); for (unsigned int i = 1; i < kElements; i++) v1.push_back(static_cast(i)); msgpack::zone z; msgpack::object obj(v1, z); - EXPECT_TRUE(obj.as >() == v1); - v1.front() = 42; - EXPECT_EQ(obj.as >().front(), 1); - } -} - -TEST(object_without_zone, vector_unsigned_char) -{ - if (!msgpack::is_same::value) return; - for (unsigned int k = 0; k < kLoop; k++) { - vector v1; - v1.push_back(1); - for (unsigned int i = 1; i < kElements; i++) - v1.push_back(static_cast(i)); - msgpack::object obj(v1); - EXPECT_TRUE(obj.as >() == v1); + BOOST_CHECK(obj.as >() == v1); v1.front() = 42; - // obj refer to v1 - EXPECT_EQ(obj.as >().front(), 42); + BOOST_CHECK_EQUAL(obj.as >().front(), 1); } } // list -TEST(object_with_zone, list) +BOOST_AUTO_TEST_CASE(list) { for (unsigned int k = 0; k < kLoop; k++) { - list v1; + std::list v1; v1.push_back(1); for (unsigned int i = 1; i < kElements; i++) v1.push_back(static_cast(i)); msgpack::zone z; msgpack::object obj(v1, z); - EXPECT_TRUE(obj.as >() == v1); + BOOST_CHECK(obj.as >() == v1); v1.front() = 42; - EXPECT_EQ(obj.as >().front(), 1); + BOOST_CHECK_EQUAL(obj.as >().front(), 1); } } // deque -TEST(object_with_zone, deque) +BOOST_AUTO_TEST_CASE(deque) { for (unsigned int k = 0; k < kLoop; k++) { - deque v1; + std::deque v1; v1.push_back(1); for (unsigned int i = 1; i < kElements; i++) v1.push_back(static_cast(i)); msgpack::zone z; msgpack::object obj(v1, z); - EXPECT_TRUE(obj.as >() == v1); + BOOST_CHECK(obj.as >() == v1); v1.front() = 42; - EXPECT_EQ(obj.as >().front(), 1); + BOOST_CHECK_EQUAL(obj.as >().front(), 1); } } // string -TEST(object_with_zone, string) +BOOST_AUTO_TEST_CASE(string) { - string v = "abc"; + std::string v = "abc"; msgpack::zone z; msgpack::object obj(v, z); - EXPECT_EQ(obj.as(), v); + BOOST_CHECK_EQUAL(obj.as(), v); v[0] = 'd'; - EXPECT_EQ(obj.as()[0], 'a'); + BOOST_CHECK_EQUAL(obj.as()[0], 'a'); } #if MSGPACK_DEFAULT_API_VERSION == 1 -TEST(object_without_zone, string) +BOOST_AUTO_TEST_CASE(without_zone_string) { - string v = "abc"; + std::string v = "abc"; msgpack::zone z; msgpack::object obj(v); - EXPECT_EQ(obj.as(), v); + BOOST_CHECK_EQUAL(obj.as(), v); v[0] = 'd'; - EXPECT_EQ(obj.as()[0], 'd'); + BOOST_CHECK_EQUAL(obj.as()[0], 'd'); } #endif // MSGPACK_DEFAULT_API_VERSION == 1 // wstring -TEST(object_with_zone, wstring) +BOOST_AUTO_TEST_CASE(wstring) { - wstring v = L"abc"; + std::wstring v = L"abc"; msgpack::zone z; msgpack::object obj(v, z); - EXPECT_EQ(obj.as(), v); + BOOST_CHECK(obj.as() == v); v[0] = 'd'; - EXPECT_EQ(obj.as()[0], L'a'); + BOOST_CHECK(obj.as()[0] == L'a'); } // char* -TEST(object_with_zone, char_ptr) +BOOST_AUTO_TEST_CASE(char_ptr) { char v[] = "abc"; msgpack::zone z; msgpack::object obj(v, z); - EXPECT_EQ(obj.as(), std::string(v)); + BOOST_CHECK_EQUAL(obj.as(), std::string(v)); v[0] = 'd'; - EXPECT_EQ(obj.as()[0], 'a'); + BOOST_CHECK_EQUAL(obj.as()[0], 'a'); +} + +// complex +BOOST_AUTO_TEST_CASE(complex_float) +{ + typedef std::complex test_t; + test_t v(1.23F, 4.56F); + msgpack::zone z; + msgpack::object obj(v, z); + float r = v.real(); + BOOST_CHECK(fabs(obj.as().real() - v.real()) <= kEPS); + BOOST_CHECK(fabs(obj.as().imag() - v.imag()) <= kEPS); + v.real(7.89F); + BOOST_CHECK(fabs(obj.as().real() - r) <= kEPS); +} + +BOOST_AUTO_TEST_CASE(complex_double) +{ + typedef std::complex test_t; + test_t v(1.23, 4.56); + msgpack::zone z; + msgpack::object obj(v, z); + double r = v.real(); + BOOST_CHECK(fabs(obj.as().real() - v.real()) <= kEPS); + BOOST_CHECK(fabs(obj.as().imag() - v.imag()) <= kEPS); + v.real(7.89); + BOOST_CHECK(fabs(obj.as().real() - r) <= kEPS); } #if MSGPACK_DEFAULT_API_VERSION == 1 -TEST(object_without_zone, char_ptr) +BOOST_AUTO_TEST_CASE(without_zone_char_ptr) { char v[] = "abc"; msgpack::zone z; msgpack::object obj(v); - EXPECT_EQ(obj.as(), std::string(v)); + BOOST_CHECK_EQUAL(obj.as(), std::string(v)); v[0] = 'd'; - EXPECT_EQ(obj.as()[0], 'd'); + BOOST_CHECK_EQUAL(obj.as()[0], 'd'); } #endif // MSGPACK_DEFAULT_API_VERSION == 1 // raw_ref -TEST(object_with_zone, raw_ref) +BOOST_AUTO_TEST_CASE(raw_ref) { - string s = "abc"; + std::string s = "abc"; msgpack::type::raw_ref v(s.data(), static_cast(s.size())); msgpack::zone z; msgpack::object obj(v, z); - EXPECT_TRUE(obj.as() == v); + BOOST_CHECK(obj.as() == v); s[0] = 'd'; // even if with_zone, not copied due to raw_ref // Basically, the combination raw_ref and object::wit_zone // is meaningless. - EXPECT_TRUE(obj.as() == v); -} - -TEST(object_without_zone, raw_ref) -{ - string s = "abc"; - msgpack::type::raw_ref v(s.data(), static_cast(s.size())); - msgpack::zone z; - msgpack::object obj(v); - EXPECT_TRUE(obj.as() == v); - s[0] = 'd'; - EXPECT_TRUE(obj.as() == v); + BOOST_CHECK(obj.as() == v); } // pair -TEST(object_with_zone, pair) +BOOST_AUTO_TEST_CASE(pair) { - typedef pair test_t; + typedef std::pair test_t; test_t v(1, "abc"); msgpack::zone z; msgpack::object obj(v, z); - EXPECT_TRUE(obj.as() == v); + BOOST_CHECK(obj.as() == v); v.first = 42; - EXPECT_EQ(obj.as().first, 1); + BOOST_CHECK_EQUAL(obj.as().first, 1); } // set -TEST(object_with_zone, set) +BOOST_AUTO_TEST_CASE(set) { for (unsigned int k = 0; k < kLoop; k++) { - set v1; + std::set v1; for (unsigned int i = 0; i < kElements; i++) v1.insert(static_cast(i)); msgpack::zone z; msgpack::object obj(v1, z); - EXPECT_TRUE(obj.as >() == v1); + BOOST_CHECK(obj.as >() == v1); } } // multiset -TEST(object_with_zone, multiset) +BOOST_AUTO_TEST_CASE(multiset) { for (unsigned int k = 0; k < kLoop; k++) { - multiset v1; + std::multiset v1; for (unsigned int i = 0; i < kElements; i++) v1.insert(i % (kElements / 2)); msgpack::zone z; msgpack::object obj(v1, z); - EXPECT_TRUE(obj.as >() == v1); + BOOST_CHECK(obj.as >() == v1); } } // map -TEST(object_with_zone, map) +BOOST_AUTO_TEST_CASE(map) { - typedef map test_t; + typedef std::map test_t; for (unsigned int k = 0; k < kLoop; k++) { test_t v1; for (unsigned int i = 0; i < kElements; i++) v1.insert(std::make_pair(i, i*2)); msgpack::zone z; msgpack::object obj(v1, z); - EXPECT_TRUE(obj.as() == v1); + BOOST_CHECK(obj.as() == v1); } } // multimap -TEST(object_with_zone, multimap) +BOOST_AUTO_TEST_CASE(multimap) { - typedef multimap test_t; + typedef std::multimap test_t; for (unsigned int k = 0; k < kLoop; k++) { test_t v1; for (unsigned int i = 0; i < kElements; i++) v1.insert(std::make_pair(i % (kElements / 2), i*2)); msgpack::zone z; msgpack::object obj(v1, z); - EXPECT_TRUE(obj.as() == v1); + BOOST_CHECK(obj.as() == v1); } } // msgpack_tuple -TEST(object_with_zone, msgpack_tuple) +BOOST_AUTO_TEST_CASE(msgpack_tuple) { - typedef msgpack::type::tuple test_t; + typedef msgpack::type::tuple test_t; test_t v(1, "abc", true); msgpack::zone z; msgpack::object obj(v, z); - EXPECT_EQ(msgpack::type::get<0>(obj.as()), 1); - EXPECT_EQ(msgpack::type::get<1>(obj.as()), "abc"); - EXPECT_EQ(msgpack::type::get<2>(obj.as()), true); + BOOST_CHECK_EQUAL(msgpack::type::get<0>(obj.as()), 1); + BOOST_CHECK_EQUAL(msgpack::type::get<1>(obj.as()), "abc"); + BOOST_CHECK_EQUAL(msgpack::type::get<2>(obj.as()), true); msgpack::type::get<0>(v) = 42; - EXPECT_EQ(msgpack::type::get<0>(obj.as()), 1); + BOOST_CHECK_EQUAL(msgpack::type::get<0>(obj.as()), 1); } -TEST(object_with_zone, msgpack_tuple_empty) +BOOST_AUTO_TEST_CASE(msgpack_tuple_empty) { typedef msgpack::type::tuple<> test_t; test_t v; msgpack::zone z; msgpack::object obj(v, z); - EXPECT_EQ(obj.via.array.size, 0u); + BOOST_CHECK_EQUAL(obj.via.array.size, 0u); } // TR1 @@ -495,9 +475,9 @@ TEST(object_with_zone, msgpack_tuple_empty) #ifdef MSGPACK_HAS_STD_TR1_UNORDERED_MAP #include #include "msgpack/adaptor/tr1/unordered_map.hpp" -TEST(object_with_zone, tr1_unordered_map) +BOOST_AUTO_TEST_CASE(tr1_unordered_map) { - typedef tr1::unordered_map test_t; + typedef std::tr1::unordered_map test_t; for (unsigned int k = 0; k < kLoop; k++) { test_t v1; for (unsigned int i = 0; i < kElements; i++) @@ -505,40 +485,40 @@ TEST(object_with_zone, tr1_unordered_map) msgpack::zone z; msgpack::object obj(v1, z); test_t v2 = obj.as(); - EXPECT_EQ(v1.size(), v2.size()); + BOOST_CHECK_EQUAL(v1.size(), v2.size()); test_t::const_iterator it; for (it = v1.begin(); it != v1.end(); ++it) { - EXPECT_TRUE(v2.find(it->first) != v2.end()); - EXPECT_EQ(it->second, v2.find(it->first)->second); + BOOST_CHECK(v2.find(it->first) != v2.end()); + BOOST_CHECK_EQUAL(it->second, v2.find(it->first)->second); } } } -TEST(object_with_zone, tr1_unordered_multimap) +BOOST_AUTO_TEST_CASE(tr1_unordered_multimap) { - typedef tr1::unordered_multimap test_t; + typedef std::tr1::unordered_multimap test_t; for (unsigned int k = 0; k < kLoop; k++) { test_t v1; for (unsigned int i = 0; i < kElements; i++) { int i1 = rand(); - v1.insert(make_pair(i1, rand())); - v1.insert(make_pair(i1, rand())); + v1.insert(std::make_pair(i1, rand())); + v1.insert(std::make_pair(i1, rand())); } msgpack::zone z; msgpack::object obj(v1, z); test_t v2 = obj.as(); - vector > vec1, vec2; - tr1::unordered_multimap::const_iterator it; + std::vector > vec1, vec2; + std::tr1::unordered_multimap::const_iterator it; for (it = v1.begin(); it != v1.end(); ++it) - vec1.push_back(make_pair(it->first, it->second)); + vec1.push_back(std::make_pair(it->first, it->second)); for (it = v2.begin(); it != v2.end(); ++it) - vec2.push_back(make_pair(it->first, it->second)); - EXPECT_EQ(v1.size(), v2.size()); - EXPECT_EQ(vec1.size(), vec2.size()); - sort(vec1.begin(), vec1.end()); - sort(vec2.begin(), vec2.end()); - EXPECT_TRUE(vec1 == vec2); + vec2.push_back(std::make_pair(it->first, it->second)); + BOOST_CHECK_EQUAL(v1.size(), v2.size()); + BOOST_CHECK_EQUAL(vec1.size(), vec2.size()); + std::sort(vec1.begin(), vec1.end()); + std::sort(vec2.begin(), vec2.end()); + BOOST_CHECK(vec1 == vec2); } } #endif @@ -546,9 +526,9 @@ TEST(object_with_zone, tr1_unordered_multimap) #ifdef MSGPACK_HAS_STD_TR1_UNORDERED_SET #include #include "msgpack/adaptor/tr1/unordered_set.hpp" -TEST(object_with_zone, tr1_unordered_set) +BOOST_AUTO_TEST_CASE(tr1_unordered_set) { - typedef tr1::unordered_set test_t; + typedef std::tr1::unordered_set test_t; for (unsigned int k = 0; k < kLoop; k++) { test_t v1; for (unsigned int i = 0; i < kElements; i++) @@ -556,16 +536,16 @@ TEST(object_with_zone, tr1_unordered_set) msgpack::zone z; msgpack::object obj(v1, z); test_t v2 = obj.as(); - EXPECT_EQ(v1.size(), v2.size()); - tr1::unordered_set::const_iterator it; + BOOST_CHECK_EQUAL(v1.size(), v2.size()); + std::tr1::unordered_set::const_iterator it; for (it = v1.begin(); it != v1.end(); ++it) - EXPECT_TRUE(v2.find(*it) != v2.end()); + BOOST_CHECK(v2.find(*it) != v2.end()); } } -TEST(object_with_zone, tr1_unordered_multiset) +BOOST_AUTO_TEST_CASE(tr1_unordered_multiset) { - typedef tr1::unordered_set test_t; + typedef std::tr1::unordered_set test_t; for (unsigned int k = 0; k < kLoop; k++) { test_t v1; for (unsigned int i = 0; i < kElements; i++) { @@ -576,17 +556,17 @@ TEST(object_with_zone, tr1_unordered_multiset) msgpack::zone z; msgpack::object obj(v1, z); test_t v2 = obj.as(); - vector vec1, vec2; - tr1::unordered_multiset::const_iterator it; + std::vector vec1, vec2; + std::tr1::unordered_multiset::const_iterator it; for (it = v1.begin(); it != v1.end(); ++it) vec1.push_back(*it); for (it = v2.begin(); it != v2.end(); ++it) vec2.push_back(*it); - EXPECT_EQ(v1.size(), v2.size()); - EXPECT_EQ(vec1.size(), vec2.size()); - sort(vec1.begin(), vec1.end()); - sort(vec2.begin(), vec2.end()); - EXPECT_TRUE(vec1 == vec2); + BOOST_CHECK_EQUAL(v1.size(), v2.size()); + BOOST_CHECK_EQUAL(vec1.size(), vec2.size()); + std::sort(vec1.begin(), vec1.end()); + std::sort(vec2.begin(), vec2.end()); + BOOST_CHECK(vec1 == vec2); } } #endif @@ -594,9 +574,9 @@ TEST(object_with_zone, tr1_unordered_multiset) #ifdef MSGPACK_HAS_STD_UNORDERED_MAP #include #include "msgpack/adaptor/tr1/unordered_map.hpp" -TEST(object_with_zone, unordered_map) +BOOST_AUTO_TEST_CASE(unordered_map) { - typedef unordered_map test_t; + typedef std::unordered_map test_t; for (unsigned int k = 0; k < kLoop; k++) { test_t v1; for (unsigned int i = 0; i < kElements; i++) @@ -604,39 +584,39 @@ TEST(object_with_zone, unordered_map) msgpack::zone z; msgpack::object obj(v1, z); test_t v2 = obj.as(); - EXPECT_EQ(v1.size(), v2.size()); + BOOST_CHECK_EQUAL(v1.size(), v2.size()); test_t::const_iterator it; for (it = v1.begin(); it != v1.end(); ++it) { - EXPECT_TRUE(v2.find(it->first) != v2.end()); - EXPECT_EQ(it->second, v2.find(it->first)->second); + BOOST_CHECK(v2.find(it->first) != v2.end()); + BOOST_CHECK_EQUAL(it->second, v2.find(it->first)->second); } } } -TEST(object_with_zone, unordered_multimap) +BOOST_AUTO_TEST_CASE(unordered_multimap) { - typedef unordered_multimap test_t; + typedef std::unordered_multimap test_t; for (unsigned int k = 0; k < kLoop; k++) { test_t v1; for (unsigned int i = 0; i < kElements; i++) { int i1 = rand(); - v1.insert(make_pair(i1, rand())); - v1.insert(make_pair(i1, rand())); + v1.insert(std::make_pair(i1, rand())); + v1.insert(std::make_pair(i1, rand())); } msgpack::zone z; msgpack::object obj(v1, z); test_t v2 = obj.as(); - vector > vec1, vec2; - unordered_multimap::const_iterator it; + std::vector > vec1, vec2; + std::unordered_multimap::const_iterator it; for (it = v1.begin(); it != v1.end(); ++it) - vec1.push_back(make_pair(it->first, it->second)); + vec1.push_back(std::make_pair(it->first, it->second)); for (it = v2.begin(); it != v2.end(); ++it) - vec2.push_back(make_pair(it->first, it->second)); - EXPECT_EQ(v1.size(), v2.size()); - EXPECT_EQ(vec1.size(), vec2.size()); + vec2.push_back(std::make_pair(it->first, it->second)); + BOOST_CHECK_EQUAL(v1.size(), v2.size()); + BOOST_CHECK_EQUAL(vec1.size(), vec2.size()); sort(vec1.begin(), vec1.end()); sort(vec2.begin(), vec2.end()); - EXPECT_TRUE(vec1 == vec2); + BOOST_CHECK(vec1 == vec2); } } #endif @@ -644,9 +624,9 @@ TEST(object_with_zone, unordered_multimap) #ifdef MSGPACK_HAS_STD_UNORDERED_SET #include #include "msgpack/adaptor/tr1/unordered_set.hpp" -TEST(object_with_zone, unordered_set) +BOOST_AUTO_TEST_CASE(unordered_set) { - typedef unordered_set test_t; + typedef std::unordered_set test_t; for (unsigned int k = 0; k < kLoop; k++) { test_t v1; for (unsigned int i = 0; i < kElements; i++) @@ -654,16 +634,16 @@ TEST(object_with_zone, unordered_set) msgpack::zone z; msgpack::object obj(v1, z); test_t v2 = obj.as(); - EXPECT_EQ(v1.size(), v2.size()); - unordered_set::const_iterator it; + BOOST_CHECK_EQUAL(v1.size(), v2.size()); + std::unordered_set::const_iterator it; for (it = v1.begin(); it != v1.end(); ++it) - EXPECT_TRUE(v2.find(*it) != v2.end()); + BOOST_CHECK(v2.find(*it) != v2.end()); } } -TEST(object_with_zone, unordered_multiset) +BOOST_AUTO_TEST_CASE(unordered_multiset) { - typedef unordered_set test_t; + typedef std::unordered_set test_t; for (unsigned int k = 0; k < kLoop; k++) { test_t v1; for (unsigned int i = 0; i < kElements; i++) { @@ -674,17 +654,17 @@ TEST(object_with_zone, unordered_multiset) msgpack::zone z; msgpack::object obj(v1, z); test_t v2 = obj.as(); - vector vec1, vec2; - unordered_multiset::const_iterator it; + std::vector vec1, vec2; + std::unordered_multiset::const_iterator it; for (it = v1.begin(); it != v1.end(); ++it) vec1.push_back(*it); for (it = v2.begin(); it != v2.end(); ++it) vec2.push_back(*it); - EXPECT_EQ(v1.size(), v2.size()); - EXPECT_EQ(vec1.size(), vec2.size()); - sort(vec1.begin(), vec1.end()); - sort(vec2.begin(), vec2.end()); - EXPECT_TRUE(vec1 == vec2); + BOOST_CHECK_EQUAL(v1.size(), v2.size()); + BOOST_CHECK_EQUAL(vec1.size(), vec2.size()); + std::sort(vec1.begin(), vec1.end()); + std::sort(vec2.begin(), vec2.end()); + BOOST_CHECK(vec1 == vec2); } } #endif @@ -695,46 +675,46 @@ class TestClass public: TestClass() : i(0), s("kzk") {} int i; - string s; + std::string s; MSGPACK_DEFINE(i, s); }; -TEST(object_with_zone, user_defined) +BOOST_AUTO_TEST_CASE(user_defined) { TestClass v1; msgpack::zone z; msgpack::object obj(v1, z); TestClass v2 = obj.as(); - EXPECT_EQ(v1.i, v2.i); - EXPECT_EQ(v1.s, v2.s); + BOOST_CHECK_EQUAL(v1.i, v2.i); + BOOST_CHECK_EQUAL(v1.s, v2.s); } -TEST(object_with_zone, construct_enum) +BOOST_AUTO_TEST_CASE(construct_enum) { msgpack::zone z; msgpack::object obj(elem, z); - EXPECT_EQ(msgpack::type::POSITIVE_INTEGER, obj.type); - EXPECT_EQ(static_cast(elem), obj.via.u64); + BOOST_CHECK_EQUAL(msgpack::type::POSITIVE_INTEGER, obj.type); + BOOST_CHECK_EQUAL(static_cast(elem), obj.via.u64); } #if !defined(MSGPACK_USE_CPP03) -TEST(object_with_zone, construct_enum_newstyle) +BOOST_AUTO_TEST_CASE(construct_enum_newstyle) { msgpack::zone z; msgpack::object obj(enum_test::elem, z); - 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_with_zone, construct_enum_outer) +BOOST_AUTO_TEST_CASE(construct_enum_outer) { msgpack::zone z; msgpack::object obj(outer_enum::elem, z); - EXPECT_EQ(msgpack::type::POSITIVE_INTEGER, obj.type); - EXPECT_EQ(static_cast(elem), obj.via.u64); + BOOST_CHECK_EQUAL(msgpack::type::POSITIVE_INTEGER, obj.type); + BOOST_CHECK_EQUAL(static_cast(elem), obj.via.u64); } // User defined inheriting classes @@ -758,7 +738,7 @@ struct bottom : mid1, mid2 { MSGPACK_DEFINE(MSGPACK_BASE(mid1), MSGPACK_BASE(mid2), b); }; -TEST(object_with_zone, user_defined_non_virtual) +BOOST_AUTO_TEST_CASE(user_defined_non_virtual) { bottom b; b.b = 1; @@ -769,19 +749,19 @@ TEST(object_with_zone, user_defined_non_virtual) msgpack::zone z; msgpack::object obj(b, z); -#if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__) +#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wmaybe-uninitialized" -#endif // (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__) +#endif // defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__) bottom br = obj.as(); -#if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__) +#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__) #pragma GCC diagnostic pop -#endif // (__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.mid1::t, br.mid1::t); - EXPECT_EQ(b.mid2::t, br.mid2::t); +#endif // defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__) + 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.mid1::t, br.mid1::t); + BOOST_CHECK_EQUAL(b.mid2::t, br.mid2::t); } struct v_top { @@ -804,7 +784,7 @@ struct v_bottom : v_mid1, v_mid2 { MSGPACK_DEFINE(MSGPACK_BASE(v_mid1), MSGPACK_BASE(v_mid2), MSGPACK_BASE(v_top), b); }; -TEST(object_with_zone, user_defined_virtual) +BOOST_AUTO_TEST_CASE(user_defined_virtual) { v_bottom b; b.b = 1; @@ -814,51 +794,51 @@ TEST(object_with_zone, user_defined_virtual) msgpack::zone z; msgpack::object obj(b, z); -#if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__) +#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wmaybe-uninitialized" -#endif // (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__) +#endif // defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__) v_bottom br = obj.as(); -#if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__) +#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__) #pragma GCC diagnostic pop -#endif // (__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.t, br.t); +#endif // defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__) + 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); } #if !defined(MSGPACK_USE_CPP03) -TEST(object_with_zone, construct_enum_outer_newstyle) +BOOST_AUTO_TEST_CASE(construct_enum_outer_newstyle) { msgpack::zone z; msgpack::object obj(outer_enum::enum_test::elem, z); - 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_with_zone, construct_class_enum) +BOOST_AUTO_TEST_CASE(construct_class_enum) { msgpack::zone z; msgpack::object obj(enum_class_test::elem, z); - 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_with_zone, construct_class_enum_outer) +BOOST_AUTO_TEST_CASE(construct_class_enum_outer) { msgpack::zone z; msgpack::object obj(outer_enum_class::enum_class_test::elem, z); - 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_with_zone, array) +BOOST_AUTO_TEST_CASE(array) { - typedef array test_t; + typedef std::array test_t; for (unsigned int k = 0; k < kLoop; k++) { test_t v1; v1[0] = 1; @@ -866,15 +846,15 @@ TEST(object_with_zone, array) v1[i] = rand(); msgpack::zone z; msgpack::object obj(v1, z); - EXPECT_TRUE(obj.as() == v1); + BOOST_CHECK(obj.as() == v1); v1.front() = 42; - EXPECT_EQ(obj.as().front(), 1); + BOOST_CHECK_EQUAL(obj.as().front(), 1); } } -TEST(object_with_zone, array_char) +BOOST_AUTO_TEST_CASE(array_char) { - typedef array test_t; + typedef std::array test_t; for (unsigned int k = 0; k < kLoop; k++) { test_t v1; v1[0] = 1; @@ -882,32 +862,16 @@ TEST(object_with_zone, array_char) v1[i] = static_cast(rand()); msgpack::zone z; msgpack::object obj(v1, z); - EXPECT_TRUE(obj.as() == v1); - v1.front() = 42; - EXPECT_EQ(obj.as().front(), 1); - } -} - -TEST(object_without_zone, array_char) -{ - typedef array 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(rand()); - msgpack::object obj(v1); - EXPECT_TRUE(obj.as() == v1); + BOOST_CHECK(obj.as() == v1); v1.front() = 42; - // obj refer to v1 - EXPECT_EQ(obj.as().front(), 42); + BOOST_CHECK_EQUAL(obj.as().front(), 1); } } -TEST(object_with_zone, array_unsigned_char) +BOOST_AUTO_TEST_CASE(array_unsigned_char) { if (!msgpack::is_same::value) return; - typedef array test_t; + typedef std::array test_t; for (unsigned int k = 0; k < kLoop; k++) { test_t v1; v1[0] = 1; @@ -915,87 +879,71 @@ TEST(object_with_zone, array_unsigned_char) v1[i] = static_cast(rand()); msgpack::zone z; msgpack::object obj(v1, z); - EXPECT_TRUE(obj.as() == v1); - v1.front() = 42; - EXPECT_EQ(obj.as().front(), 1); - } -} - -TEST(object_without_zone, array_unsigned_char) -{ - if (!msgpack::is_same::value) return; - typedef array 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(rand()); - msgpack::object obj(v1); - EXPECT_TRUE(obj.as() == v1); + BOOST_CHECK(obj.as() == v1); v1.front() = 42; - // obj refer to v1 - EXPECT_EQ(obj.as().front(), 42); + BOOST_CHECK_EQUAL(obj.as().front(), 1); } } - -TEST(object_with_zone, forward_list) +BOOST_AUTO_TEST_CASE(forward_list) { for (unsigned int k = 0; k < kLoop; k++) { - forward_list v1; + std::forward_list v1; for (unsigned int i = 0; i < kElements; i++) v1.push_front(static_cast(i)); msgpack::zone z; msgpack::object obj(v1, z); - EXPECT_TRUE(obj.as >() == v1); + BOOST_CHECK(obj.as >() == v1); v1.front() = 42; - EXPECT_EQ(obj.as >().front(), static_cast(kElements - 1)); + BOOST_CHECK_EQUAL(obj.as >().front(), static_cast(kElements - 1)); } } -TEST(object_with_zone, tuple) +BOOST_AUTO_TEST_CASE(tuple) { - typedef tuple test_t; + typedef std::tuple test_t; test_t v(1, "abc", true); msgpack::zone z; msgpack::object obj(v, z); - EXPECT_TRUE(obj.as() == v); + BOOST_CHECK(obj.as() == v); } -TEST(object_with_zone, tuple_empty) +BOOST_AUTO_TEST_CASE(tuple_empty) { - typedef tuple<> test_t; + typedef std::tuple<> test_t; test_t v; msgpack::zone z; msgpack::object obj(v, z); - EXPECT_TRUE(obj.as() == v); + BOOST_CHECK(obj.as() == v); } -TEST(object_with_zone, system_clock) +#if !defined(MSGPACK_NO_BOOST) + +BOOST_AUTO_TEST_CASE(system_clock) { std::chrono::system_clock::time_point v; msgpack::zone z; msgpack::object obj(v, z); - EXPECT_TRUE(obj.as() == v); + BOOST_CHECK(obj.as() == v); } -TEST(object_with_zone, system_clock_32) +BOOST_AUTO_TEST_CASE(system_clock_32) { std::chrono::system_clock::time_point v(std::chrono::seconds(0x12345678L)); msgpack::zone z; msgpack::object obj(v, z); - EXPECT_TRUE(obj.as() == v); + BOOST_CHECK(obj.as() == v); } -TEST(object_with_zone, system_clock_32_max) +BOOST_AUTO_TEST_CASE(system_clock_32_max) { std::chrono::system_clock::time_point v(std::chrono::seconds(0xffffffffL)); msgpack::zone z; msgpack::object obj(v, z); - EXPECT_TRUE(obj.as() == v); + BOOST_CHECK(obj.as() == v); } -TEST(object_with_zone, system_clock_64) +BOOST_AUTO_TEST_CASE(system_clock_64) { std::chrono::system_clock::time_point v(std::chrono::seconds(0x31234567L)); v += @@ -1004,10 +952,10 @@ TEST(object_with_zone, system_clock_64) ); msgpack::zone z; msgpack::object obj(v, z); - EXPECT_TRUE(obj.as() == v); + BOOST_CHECK(obj.as() == v); } -TEST(object_with_zone, system_clock_64_max) +BOOST_AUTO_TEST_CASE(system_clock_64_max) { std::chrono::system_clock::time_point v(std::chrono::seconds(0xffffffffL)); v += @@ -1016,71 +964,73 @@ TEST(object_with_zone, system_clock_64_max) ); msgpack::zone z; msgpack::object obj(v, z); - EXPECT_TRUE(obj.as() == v); + BOOST_CHECK(obj.as() == v); } -TEST(object_with_zone, system_clock_impl_min) +BOOST_AUTO_TEST_CASE(system_clock_impl_min) { std::chrono::system_clock::time_point v(std::chrono::system_clock::time_point::min()); msgpack::zone z; msgpack::object obj(v, z); - EXPECT_TRUE(obj.as() == v); + BOOST_CHECK(obj.as() == v); } -TEST(object_with_zone, system_clock_impl_max) +BOOST_AUTO_TEST_CASE(system_clock_impl_max) { std::chrono::system_clock::time_point v(std::chrono::system_clock::time_point::max()); msgpack::zone z; msgpack::object obj(v, z); - EXPECT_TRUE(obj.as() == v); + BOOST_CHECK(obj.as() == v); } +#endif // !defined(MSGPACK_NO_BOOST) + #endif // !defined(MSGPACK_USE_CPP03) -TEST(object_with_zone, ext_empty) +BOOST_AUTO_TEST_CASE(ext_empty) { msgpack::type::ext v; msgpack::zone z; msgpack::object obj(v, z); - EXPECT_TRUE(obj.as() == v); - EXPECT_TRUE(obj.as() == v); + BOOST_CHECK(obj.as() == v); + BOOST_CHECK(obj.as() == v); } -TEST(object_with_zone, ext) +BOOST_AUTO_TEST_CASE(ext) { msgpack::type::ext v(42, 10); for (int i = 0; i < 10; ++i) v.data()[i] = static_cast(i); msgpack::zone z; msgpack::object obj(v, z); - EXPECT_TRUE(obj.as() == v); - EXPECT_TRUE(obj.as() == v); + BOOST_CHECK(obj.as() == v); + BOOST_CHECK(obj.as() == v); } -TEST(object_with_zone, ext_from_buf) +BOOST_AUTO_TEST_CASE(ext_from_buf) { char const buf[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9}; msgpack::type::ext v(42, buf, sizeof(buf)); msgpack::zone z; msgpack::object obj(v, z); - EXPECT_TRUE(obj.as() == v); - EXPECT_TRUE(obj.as() == v); + BOOST_CHECK(obj.as() == v); + BOOST_CHECK(obj.as() == v); } -TEST(object_with_zone, ext_ref_empty) +BOOST_AUTO_TEST_CASE(ext_ref_empty) { msgpack::type::ext_ref v; msgpack::zone z; msgpack::object obj(v, z); - EXPECT_TRUE(obj.as() == v); - EXPECT_TRUE(obj.as() == v); + BOOST_CHECK(obj.as() == msgpack::type::ext(v)); + BOOST_CHECK(obj.as() == v); } -TEST(object_with_zone, ext_ref_from_buf) +BOOST_AUTO_TEST_CASE(ext_ref_from_buf) { char const buf[] = { 77, 1, 2, 3, 4, 5, 6, 7, 8, 9}; msgpack::type::ext_ref v(buf, sizeof(buf)); msgpack::zone z; msgpack::object obj(v, z); - EXPECT_TRUE(obj.as() == v); - EXPECT_TRUE(obj.as() == v); + BOOST_CHECK(obj.as() == msgpack::type::ext(v)); + BOOST_CHECK(obj.as() == v); } diff --git a/test/pack_unpack.cpp b/test/pack_unpack.cpp index f29e20018..af3e2c4c5 100644 --- a/test/pack_unpack.cpp +++ b/test/pack_unpack.cpp @@ -1,22 +1,18 @@ #include -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wconversion" - -#include - -#pragma GCC diagnostic pop +#define BOOST_TEST_MODULE pack_unpack +#include #include -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 vec; @@ -27,7 +23,7 @@ TEST(pack, vector) } -TEST(pack, to_ostream) +BOOST_AUTO_TEST_CASE(pack_to_ostream) { std::ostringstream stream; msgpack::pack(stream, 1); @@ -49,7 +45,7 @@ struct myclass { }; -TEST(pack, myclass) +BOOST_AUTO_TEST_CASE(pack_myclass) { msgpack::sbuffer sbuf; myclass m(1, "msgpack"); @@ -57,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()); + BOOST_CHECK_EQUAL(1, oh.get().as()); } -TEST(unpack, int_ret_offset_no_ref) +BOOST_AUTO_TEST_CASE(unpack_int_ret_offset_no_ref) { msgpack::sbuffer sbuf; msgpack::pack(sbuf, 1); @@ -74,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()); - EXPECT_EQ(off, sbuf.size()); + BOOST_CHECK_EQUAL(1, oh.get().as()); + 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()); - EXPECT_FALSE(referenced); + BOOST_CHECK_EQUAL(1, oh.get().as()); + 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); @@ -97,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()); - EXPECT_FALSE(referenced); - EXPECT_EQ(off, sbuf.size()); + BOOST_CHECK_EQUAL(1, oh.get().as()); + 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()); + BOOST_CHECK_EQUAL(1, oh.get().as()); } -TEST(unpack, int_offset_no_ref) +BOOST_AUTO_TEST_CASE(unpack_int_offset_no_ref) { msgpack::sbuffer sbuf; msgpack::pack(sbuf, 1); @@ -122,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()); - EXPECT_EQ(off, sbuf.size()); + BOOST_CHECK_EQUAL(1, oh.get().as()); + 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); @@ -134,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()); - EXPECT_FALSE(referenced); + BOOST_CHECK_EQUAL(1, oh.get().as()); + BOOST_CHECK(!referenced); } -TEST(unpack, int_offset_ref) +BOOST_AUTO_TEST_CASE(unpack_int_offset_ref) { msgpack::sbuffer sbuf; msgpack::pack(sbuf, 1); @@ -147,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()); - EXPECT_FALSE(referenced); - EXPECT_EQ(off, sbuf.size()); + BOOST_CHECK_EQUAL(1, oh.get().as()); + 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); @@ -163,19 +159,19 @@ TEST(unpack, int_pointer_off_no_ref) std::size_t off = 0; // obsolete -#if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2)) +#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2)) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wdeprecated-declarations" -#endif // (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2)) +#endif // defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2)) msgpack::unpack(&oh, sbuf.data(), sbuf.size(), &off); -#if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2)) +#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2)) #pragma GCC diagnostic pop -#endif // (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2)) - EXPECT_EQ(1, oh.get().as()); - EXPECT_EQ(off, sbuf.size()); +#endif // defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2)) + BOOST_CHECK_EQUAL(1, oh.get().as()); + 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); @@ -184,19 +180,19 @@ TEST(unpack, int_pointer_off_no_ref_explicit) std::size_t off = 0; // obsolete -#if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2)) +#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2)) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wdeprecated-declarations" -#endif // (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2)) +#endif // defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2)) msgpack::unpack(&oh, sbuf.data(), sbuf.size(), &off, MSGPACK_NULLPTR); -#if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2)) +#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2)) #pragma GCC diagnostic pop -#endif // (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2)) - EXPECT_EQ(1, oh.get().as()); - EXPECT_EQ(off, sbuf.size()); +#endif // defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2)) + BOOST_CHECK_EQUAL(1, oh.get().as()); + 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); @@ -204,19 +200,19 @@ TEST(unpack, int_pointer_no_off_ref) bool referenced; // obsolete -#if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2)) +#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2)) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wdeprecated-declarations" -#endif // (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2)) +#endif // defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2)) msgpack::unpack(&oh, sbuf.data(), sbuf.size(), MSGPACK_NULLPTR, &referenced); -#if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2)) +#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2)) #pragma GCC diagnostic pop -#endif // (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2)) - EXPECT_EQ(1, oh.get().as()); - EXPECT_FALSE(referenced); +#endif // defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2)) + BOOST_CHECK_EQUAL(1, oh.get().as()); + 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); @@ -225,51 +221,51 @@ TEST(unpack, int_pointer_off_ref) std::size_t off = 0; // obsolete -#if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2)) +#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2)) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wdeprecated-declarations" -#endif // (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2)) +#endif // defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2)) msgpack::unpack(&oh, sbuf.data(), sbuf.size(), &off, &referenced); -#if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2)) +#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2)) #pragma GCC diagnostic pop -#endif // (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2)) - EXPECT_EQ(1, oh.get().as()); - EXPECT_EQ(off, sbuf.size()); - EXPECT_FALSE(referenced); +#endif // defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2)) + BOOST_CHECK_EQUAL(1, oh.get().as()); + 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); msgpack::object_handle oh; // obsolete -#if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2)) +#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2)) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wdeprecated-declarations" -#endif // (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2)) +#endif // defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2)) msgpack::unpack(&oh, sbuf.data(), sbuf.size()); -#if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2)) +#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2)) #pragma GCC diagnostic pop -#endif // (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2)) - EXPECT_EQ(1, oh.get().as()); +#endif // defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2)) + BOOST_CHECK_EQUAL(1, oh.get().as()); } #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()); + BOOST_CHECK_EQUAL(1, obj.as()); } -TEST(unpack, int_zone_offset_no_ref) +BOOST_AUTO_TEST_CASE(unpack_int_zone_offset_no_ref) { msgpack::sbuffer sbuf; msgpack::pack(sbuf, 1); @@ -278,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()); - EXPECT_EQ(off, sbuf.size()); + BOOST_CHECK_EQUAL(1, obj.as()); + 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); @@ -290,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()); - EXPECT_FALSE(referenced); + BOOST_CHECK_EQUAL(1, obj.as()); + 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); @@ -303,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()); - EXPECT_FALSE(referenced); - EXPECT_EQ(off, sbuf.size()); + BOOST_CHECK_EQUAL(1, obj.as()); + 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); @@ -321,19 +317,19 @@ TEST(unpack, sequence) msgpack::object_handle oh; msgpack::unpack(oh, sbuf.data(), sbuf.size(), off); - EXPECT_EQ(1, oh.get().as()); + BOOST_CHECK_EQUAL(1, oh.get().as()); msgpack::unpack(oh, sbuf.data(), sbuf.size(), off); - EXPECT_EQ(2, oh.get().as()); + BOOST_CHECK_EQUAL(2, oh.get().as()); msgpack::unpack(oh, sbuf.data(), sbuf.size(), off); - EXPECT_EQ(3, oh.get().as()); + BOOST_CHECK_EQUAL(3, oh.get().as()); - 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); @@ -341,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()); + BOOST_CHECK_EQUAL(1, oh.get().as()); } -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()); + BOOST_CHECK_EQUAL(1, oh.get().as()); } -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()); + BOOST_CHECK_EQUAL(1, oh.get().as()); } -TEST(unpack, insufficient_bytes_ref) +BOOST_AUTO_TEST_CASE(unpack_insufficient_bytes_ref) { msgpack::sbuffer sbuf; msgpack::pack(sbuf, 255); // uint8 (2bytes) @@ -373,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) @@ -394,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) @@ -416,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; @@ -439,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; @@ -457,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; @@ -476,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()); + BOOST_CHECK_EQUAL(1, oh.get().as()); } -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()); + BOOST_CHECK_EQUAL(1, obj.as()); } -TEST(unpack, int_off_larger_than_length) +BOOST_AUTO_TEST_CASE(unpack_int_off_larger_than_length) { msgpack::sbuffer sbuf; msgpack::pack(sbuf, 1); @@ -517,40 +513,40 @@ 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(0x90)); + buf.push_back(static_cast(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(0xdc)); + buf.push_back(static_cast(0xdcu)); buf.push_back(static_cast(0x00)); buf.push_back(static_cast(0x00)); 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(0xdd)); + buf.push_back(static_cast(0xddu)); buf.push_back(static_cast(0x00)); buf.push_back(static_cast(0x00)); buf.push_back(static_cast(0x00)); @@ -558,41 +554,41 @@ 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(0x80)); + buf.push_back(static_cast(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(0xde)); + buf.push_back(static_cast(0xdeu)); buf.push_back(static_cast(0x00)); buf.push_back(static_cast(0x00)); 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(0xdf)); + buf.push_back(static_cast(0xdfu)); buf.push_back(static_cast(0x00)); buf.push_back(static_cast(0x00)); buf.push_back(static_cast(0x00)); @@ -600,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); } diff --git a/test/pack_unpack_c.cpp b/test/pack_unpack_c.cpp deleted file mode 100644 index 8c35f9910..000000000 --- a/test/pack_unpack_c.cpp +++ /dev/null @@ -1,99 +0,0 @@ -#include - -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wconversion" - -#include - -#pragma GCC diagnostic pop - -#include - -TEST(pack, num) -{ - msgpack_sbuffer* sbuf = msgpack_sbuffer_new(); - msgpack_packer* pk = msgpack_packer_new(sbuf, msgpack_sbuffer_write); - - EXPECT_EQ(0, msgpack_pack_int(pk, 1)); - - msgpack_sbuffer_free(sbuf); - msgpack_packer_free(pk); -} - - -TEST(pack, array) -{ - msgpack_sbuffer* sbuf = msgpack_sbuffer_new(); - msgpack_packer* pk = msgpack_packer_new(sbuf, msgpack_sbuffer_write); - - EXPECT_EQ(0, msgpack_pack_array(pk, 3)); - EXPECT_EQ(0, msgpack_pack_int(pk, 1)); - EXPECT_EQ(0, msgpack_pack_int(pk, 2)); - EXPECT_EQ(0, msgpack_pack_int(pk, 3)); - - msgpack_sbuffer_free(sbuf); - msgpack_packer_free(pk); -} - - -TEST(unpack, sequence) -{ - msgpack_sbuffer* sbuf = msgpack_sbuffer_new(); - msgpack_packer* pk = msgpack_packer_new(sbuf, msgpack_sbuffer_write); - - EXPECT_EQ(0, msgpack_pack_int(pk, 1)); - EXPECT_EQ(0, msgpack_pack_int(pk, 2)); - EXPECT_EQ(0, msgpack_pack_int(pk, 3)); - - msgpack_packer_free(pk); - - msgpack_unpack_return success; - size_t offset = 0; - - msgpack_unpacked msg; - msgpack_unpacked_init(&msg); - - success = msgpack_unpack_next(&msg, sbuf->data, sbuf->size, &offset); - EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, success); - EXPECT_EQ(MSGPACK_OBJECT_POSITIVE_INTEGER, msg.data.type); - EXPECT_EQ(1u, msg.data.via.u64); - - success = msgpack_unpack_next(&msg, sbuf->data, sbuf->size, &offset); - EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, success); - EXPECT_EQ(MSGPACK_OBJECT_POSITIVE_INTEGER, msg.data.type); - EXPECT_EQ(2u, msg.data.via.u64); - - success = msgpack_unpack_next(&msg, sbuf->data, sbuf->size, &offset); - EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, success); - EXPECT_EQ(MSGPACK_OBJECT_POSITIVE_INTEGER, msg.data.type); - EXPECT_EQ(3u, msg.data.via.u64); - - success = msgpack_unpack_next(&msg, sbuf->data, sbuf->size, &offset); - EXPECT_EQ(MSGPACK_UNPACK_CONTINUE, success); - - msgpack_sbuffer_free(sbuf); - msgpack_unpacked_destroy(&msg); -} - -TEST(pack, insufficient) -{ - msgpack_sbuffer* sbuf = msgpack_sbuffer_new(); - msgpack_packer* pk = msgpack_packer_new(sbuf, msgpack_sbuffer_write); - - EXPECT_EQ(0, msgpack_pack_int(pk, 255)); // uint8 (2bytes) - - msgpack_unpack_return success; - size_t offset = 0; - - msgpack_unpacked msg; - msgpack_unpacked_init(&msg); - - success = msgpack_unpack_next(&msg, sbuf->data, 1, &offset); - EXPECT_EQ(MSGPACK_UNPACK_CONTINUE, success); - EXPECT_EQ(1u, offset); - - msgpack_unpacked_destroy(&msg); - - msgpack_sbuffer_free(sbuf); - msgpack_packer_free(pk); -} diff --git a/test/raw.cpp b/test/raw.cpp index a3cfc313f..bc7487310 100644 --- a/test/raw.cpp +++ b/test/raw.cpp @@ -3,18 +3,14 @@ #include #include -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wconversion" - -#include - -#pragma GCC diagnostic pop +#define BOOST_TEST_MODULE MSGPACK_RAW_REF +#include #ifdef HAVE_CONFIG_H #include "config.h" #endif -TEST(MSGPACK_RAW_REF, pack_unpack) +BOOST_AUTO_TEST_CASE(pack_unpack) { std::string s = "ABC"; @@ -22,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(0xc4u)); - EXPECT_EQ(packed_str[1], static_cast(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(0xc4u)); + BOOST_CHECK_EQUAL(packed_str[1], static_cast(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(); - 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; @@ -42,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(0xc4u)); - EXPECT_EQ(packed_str[1], static_cast(0x00u)); + BOOST_CHECK_EQUAL(packed_str[0], static_cast(0xc4u)); + BOOST_CHECK_EQUAL(packed_str[1], static_cast(0x00u)); msgpack::object_handle oh = msgpack::unpack(packed_str.data(), packed_str.size()); msgpack::type::raw_ref rr2 = oh.get().as(); - 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'); @@ -59,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(0xc4u)); - EXPECT_EQ(packed_str[1], static_cast(0xffu)); - EXPECT_EQ(packed_str[2], 'A'); + BOOST_CHECK_EQUAL(packed_str[0], static_cast(0xc4u)); + BOOST_CHECK_EQUAL(packed_str[1], static_cast(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(); - 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'); @@ -77,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(0xc5u)); - EXPECT_EQ(packed_str[1], static_cast(0x01)); - EXPECT_EQ(packed_str[2], static_cast(0x00)); - EXPECT_EQ(packed_str[3], 'A'); + BOOST_CHECK_EQUAL(packed_str[0], static_cast(0xc5u)); + BOOST_CHECK_EQUAL(packed_str[1], static_cast(0x01)); + BOOST_CHECK_EQUAL(packed_str[2], static_cast(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(); - 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'); @@ -96,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(0xc5u)); - EXPECT_EQ(packed_str[1], static_cast(0xffu)); - EXPECT_EQ(packed_str[2], static_cast(0xffu)); - EXPECT_EQ(packed_str[3], 'A'); + BOOST_CHECK_EQUAL(packed_str[0], static_cast(0xc5u)); + BOOST_CHECK_EQUAL(packed_str[1], static_cast(0xffu)); + BOOST_CHECK_EQUAL(packed_str[2], static_cast(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(); - 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'); @@ -115,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(0xc6u)); - EXPECT_EQ(packed_str[1], static_cast(0x00)); - EXPECT_EQ(packed_str[2], static_cast(0x01)); - EXPECT_EQ(packed_str[3], static_cast(0x00)); - EXPECT_EQ(packed_str[4], static_cast(0x00)); - EXPECT_EQ(packed_str[5], 'A'); + BOOST_CHECK_EQUAL(packed_str[0], static_cast(0xc6u)); + BOOST_CHECK_EQUAL(packed_str[1], static_cast(0x00)); + BOOST_CHECK_EQUAL(packed_str[2], static_cast(0x01)); + BOOST_CHECK_EQUAL(packed_str[3], static_cast(0x00)); + BOOST_CHECK_EQUAL(packed_str[4], static_cast(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(); - 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"; @@ -136,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(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(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(); - 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; @@ -155,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(0xa0u)); + BOOST_CHECK_EQUAL(packed_str[0], static_cast(0xa0u)); msgpack::object_handle oh = msgpack::unpack(packed_str.data(), packed_str.size()); msgpack::type::v4raw_ref rr2 = oh.get().as(); - 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'); @@ -171,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(0xbfu)); - EXPECT_EQ(packed_str[1], 'A'); + BOOST_CHECK_EQUAL(packed_str[0], static_cast(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(); - 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'); @@ -188,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(0xdau)); - EXPECT_EQ(packed_str[1], static_cast(0x00u)); - EXPECT_EQ(packed_str[2], static_cast(0x20u)); - EXPECT_EQ(packed_str[3], 'A'); + BOOST_CHECK_EQUAL(packed_str[0], static_cast(0xdau)); + BOOST_CHECK_EQUAL(packed_str[1], static_cast(0x00u)); + BOOST_CHECK_EQUAL(packed_str[2], static_cast(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(); - 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'); @@ -207,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(0xdau)); - EXPECT_EQ(packed_str[1], static_cast(0xffu)); - EXPECT_EQ(packed_str[2], static_cast(0xffu)); - EXPECT_EQ(packed_str[3], 'A'); + BOOST_CHECK_EQUAL(packed_str[0], static_cast(0xdau)); + BOOST_CHECK_EQUAL(packed_str[1], static_cast(0xffu)); + BOOST_CHECK_EQUAL(packed_str[2], static_cast(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(); - 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'); @@ -226,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(0xdbu)); - EXPECT_EQ(packed_str[1], static_cast(0x00)); - EXPECT_EQ(packed_str[2], static_cast(0x01)); - EXPECT_EQ(packed_str[3], static_cast(0x00)); - EXPECT_EQ(packed_str[4], static_cast(0x00)); - EXPECT_EQ(packed_str[5], 'A'); + BOOST_CHECK_EQUAL(packed_str[0], static_cast(0xdbu)); + BOOST_CHECK_EQUAL(packed_str[1], static_cast(0x00)); + BOOST_CHECK_EQUAL(packed_str[2], static_cast(0x01)); + BOOST_CHECK_EQUAL(packed_str[3], static_cast(0x00)); + BOOST_CHECK_EQUAL(packed_str[4], static_cast(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(); - EXPECT_TRUE(rr1 == rr2); + BOOST_CHECK(rr1 == rr2); } diff --git a/test/reference.cpp b/test/reference.cpp index 77f67aa82..e3240c3dd 100644 --- a/test/reference.cpp +++ b/test/reference.cpp @@ -1,13 +1,9 @@ #include -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wconversion" +#define BOOST_TEST_MODULE reference +#include -#include - -#pragma GCC diagnostic pop - -TEST(reference, unpack_int) +BOOST_AUTO_TEST_CASE(unpack_int) { msgpack::sbuffer sbuf; msgpack::pack(sbuf, 1); @@ -15,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")); @@ -26,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 packer(sbuf); @@ -40,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 packer(sbuf); @@ -54,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; } @@ -68,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); @@ -76,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")); @@ -87,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 packer(sbuf); @@ -101,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 packer(sbuf); @@ -116,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; @@ -135,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); @@ -150,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")); @@ -165,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")); @@ -180,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 packer(sbuf); @@ -198,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 packer(sbuf); @@ -214,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 packer(sbuf); @@ -231,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 packer(sbuf); @@ -248,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); @@ -267,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")); @@ -283,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 packer(sbuf); @@ -302,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 packer(sbuf); @@ -322,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); @@ -341,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")); @@ -359,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")); @@ -377,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 packer(sbuf); @@ -399,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 packer(sbuf); @@ -420,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 packer(sbuf); @@ -442,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 packer(sbuf); @@ -464,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); } diff --git a/test/reference_cpp11.cpp b/test/reference_cpp11.cpp index 995065dec..fe7bb4043 100644 --- a/test/reference_cpp11.cpp +++ b/test/reference_cpp11.cpp @@ -1,35 +1,31 @@ #include -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wconversion" - -#include - -#pragma GCC diagnostic pop +#define BOOST_TEST_MODULE reference +#include #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 packer(sbuf); @@ -39,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 packer(sbuf); @@ -52,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; } @@ -66,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 packer(sbuf); @@ -96,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 packer(sbuf); @@ -109,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; @@ -128,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); @@ -141,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")); @@ -155,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")); @@ -168,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 packer(sbuf); @@ -184,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 packer(sbuf); @@ -199,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 packer(sbuf); @@ -215,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 packer(sbuf); @@ -231,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) diff --git a/test/reference_wrapper_cpp11.cpp b/test/reference_wrapper_cpp11.cpp index b94ca88d3..406ab8bc3 100644 --- a/test/reference_wrapper_cpp11.cpp +++ b/test/reference_wrapper_cpp11.cpp @@ -1,12 +1,8 @@ #include #include -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wconversion" - -#include - -#pragma GCC diagnostic pop +#define BOOST_TEST_MODULE MSGPACK_REFERENCE_WRAPPER +#include #ifdef HAVE_CONFIG_H #include "config.h" @@ -14,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 val1(i1); @@ -25,10 +21,10 @@ TEST(MSGPACK_REFERENCE_WRAPPER, pack_convert) int i2 = 0; std::reference_wrapper 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 val1(i1); @@ -39,10 +35,10 @@ TEST(MSGPACK_REFERENCE_WRAPPER, pack_convert_const) int i2 = 0; std::reference_wrapper 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> val1{i1}; @@ -51,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 val2 = oh.get().as>(); - EXPECT_EQ(val2.size(), static_cast(1)); - EXPECT_EQ(val1[0], val2[0]); + BOOST_CHECK_EQUAL(val2.size(), static_cast(1)); + BOOST_CHECK_EQUAL(val1[0], val2[0]); } -TEST(MSGPACK_REFERENCE_WRAPPER, object) +BOOST_AUTO_TEST_CASE(object) { int i1 = 42; std::reference_wrapper val1(i1); @@ -63,10 +59,10 @@ TEST(MSGPACK_REFERENCE_WRAPPER, object) int i2 = 0; std::reference_wrapper 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 val1(i1); @@ -74,10 +70,10 @@ TEST(MSGPACK_REFERENCE_WRAPPER, object_const) int i2 = 0; std::reference_wrapper 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 val1(s1); @@ -86,10 +82,10 @@ TEST(MSGPACK_REFERENCE_WRAPPER, object_with_zone) std::string s2 = "DE"; std::reference_wrapper 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 val1(s1); @@ -98,7 +94,7 @@ TEST(MSGPACK_REFERENCE_WRAPPER, object_with_zone_const) std::string s2 = "DE"; std::reference_wrapper val2(s2); o.convert(val2); - EXPECT_EQ(s1, s2); + BOOST_CHECK_EQUAL(s1, s2); } #endif // !defined(MSGPACK_USE_CPP03) diff --git a/test/shared_ptr_cpp11.cpp b/test/shared_ptr_cpp11.cpp index 18f345749..e8feb8343 100644 --- a/test/shared_ptr_cpp11.cpp +++ b/test/shared_ptr_cpp11.cpp @@ -2,20 +2,15 @@ #include #include -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wconversion" - -#include - -#pragma GCC diagnostic pop - +#define BOOST_TEST_MODULE SHARED_PTR +#include #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 val1; @@ -24,10 +19,10 @@ TEST(SHARED_PTR, pack_convert_nil) msgpack::object_handle oh = msgpack::unpack(str.data(), str.size()); std::shared_ptr val2 = oh.get().as>(); - 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 val1(new int(1)); @@ -36,54 +31,54 @@ TEST(SHARED_PTR, pack_convert_int) msgpack::object_handle oh = msgpack::unpack(str.data(), str.size()); std::shared_ptr val2 = oh.get().as>(); - EXPECT_TRUE(*val1 == *val2); + BOOST_CHECK(*val1 == *val2); } -TEST(SHARED_PTR, object_nil) +BOOST_AUTO_TEST_CASE(object_nil) { std::shared_ptr val1; msgpack::object obj(val1); std::shared_ptr val2 = obj.as>(); - EXPECT_TRUE(val1 == val2); + BOOST_CHECK(val1 == val2); } -TEST(SHARED_PTR, object_int) +BOOST_AUTO_TEST_CASE(object_int) { std::shared_ptr val1(new int(1)); msgpack::object obj(val1); std::shared_ptr val2 = obj.as>(); - 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> ovi_t; ovi_t val1(new std::vector()); msgpack::object obj(val1); ovi_t val2 = obj.as(); - 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 val1; msgpack::object obj(val1, z); std::shared_ptr val2 = obj.as>(); - 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 val1(new int(1)); msgpack::object obj(val1, z); std::shared_ptr val2 = obj.as>(); - EXPECT_TRUE(*val1 == *val2); + BOOST_CHECK(*val1 == *val2); } struct no_def_con { @@ -116,7 +111,7 @@ struct as { } // 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 val1(new no_def_con(1)); @@ -125,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 val2 = oh.get().as>(); - EXPECT_TRUE(*val1 == *val2); + BOOST_CHECK(*val1 == *val2); } diff --git a/test/size_equal_only.cpp b/test/size_equal_only.cpp index 0fe53ef97..743fb49d4 100644 --- a/test/size_equal_only.cpp +++ b/test/size_equal_only.cpp @@ -1,14 +1,10 @@ #include #include -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wconversion" +#define BOOST_TEST_MODULE size_equal_only +#include -#include - -#pragma GCC diagnostic pop - -TEST(size_equal_only, array) +BOOST_AUTO_TEST_CASE(array) { std::stringstream ss; int buf[3] = { 1, 2, 3 }; @@ -20,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 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 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 buf; @@ -64,28 +60,28 @@ TEST(size_equal_only, vector) std::vector ret_buf1; oh.get().convert(ret_buf1); - EXPECT_EQ(buf, ret_buf1); + BOOST_CHECK(buf == ret_buf1); std::vector ret_buf2; ret_buf2.resize(3); msgpack::type::size_equal_only > ret_seo2(ret_buf2); oh.get().convert(ret_seo2); - EXPECT_EQ(buf, ret_buf2); + BOOST_CHECK(buf == ret_buf2); std::vector ret_buf3; ret_buf2.resize(4); msgpack::type::size_equal_only > 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 buf(1, false, "ABC"); @@ -98,52 +94,52 @@ TEST(size_equal_only, msgpack_tuple) msgpack::type::tuple 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 ret_buf2; msgpack::type::size_equal_only > 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 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 ret_buf4; msgpack::type::size_equal_only > 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 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 ret_buf6; msgpack::type::size_equal_only > 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 buf(1, false, "ABC"); @@ -156,42 +152,42 @@ TEST(size_equal_only, tuple) std::tuple ret_buf1; oh.get().convert(ret_buf1); - EXPECT_EQ(buf, ret_buf1); + BOOST_CHECK(buf == ret_buf1); std::tuple 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 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 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 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 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); } } @@ -209,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); @@ -220,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); } } diff --git a/test/streaming.cpp b/test/streaming.cpp index def6a7e95..78309cee2 100644 --- a/test/streaming.cpp +++ b/test/streaming.cpp @@ -1,15 +1,11 @@ #include -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wconversion" - -#include - -#pragma GCC diagnostic pop +#define BOOST_TEST_MODULE streaming +#include #include -TEST(streaming, basic) +BOOST_AUTO_TEST_CASE(basic) { msgpack::sbuffer buffer; @@ -40,25 +36,25 @@ TEST(streaming, basic) msgpack::object obj = oh.get(); switch(count++) { case 0: - EXPECT_EQ(1, obj.as()); + BOOST_CHECK_EQUAL(1, obj.as()); break; case 1: - EXPECT_EQ(2, obj.as()); + BOOST_CHECK_EQUAL(2, obj.as()); break; case 2: - EXPECT_EQ(3, obj.as()); + BOOST_CHECK_EQUAL(3, obj.as()); 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; @@ -85,29 +81,29 @@ TEST(streaming, basic_pointer) pac.buffer_consumed(len); -#if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2)) +#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2)) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wdeprecated-declarations" -#endif // (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2)) +#endif // defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2)) while(pac.next(&oh)) { -#if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2)) +#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2)) #pragma GCC diagnostic pop -#endif // (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2)) +#endif // defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2)) msgpack::object obj = oh.get(); switch(count++) { case 0: - EXPECT_EQ(1, obj.as()); + BOOST_CHECK_EQUAL(1, obj.as()); break; case 1: - EXPECT_EQ(2, obj.as()); + BOOST_CHECK_EQUAL(2, obj.as()); break; case 2: - EXPECT_EQ(3, obj.as()); + BOOST_CHECK_EQUAL(3, obj.as()); return; } } - EXPECT_TRUE(input < eof); + BOOST_CHECK(input < eof); } } @@ -115,7 +111,7 @@ TEST(streaming, basic_pointer) #if !defined(MSGPACK_USE_CPP03) -TEST(streaming, move) +BOOST_AUTO_TEST_CASE(move) { msgpack::sbuffer buffer; @@ -147,18 +143,18 @@ TEST(streaming, move) msgpack::object obj = oh.get(); switch(count++) { case 0: - EXPECT_EQ(1, obj.as()); + BOOST_CHECK_EQUAL(1, obj.as()); break; case 1: - EXPECT_EQ(2, obj.as()); + BOOST_CHECK_EQUAL(2, obj.as()); break; case 2: - EXPECT_EQ(3, obj.as()); + BOOST_CHECK_EQUAL(3, obj.as()); return; } } - EXPECT_TRUE(input < eof); + BOOST_CHECK(input < eof); pac = std::move(pac_in); } } @@ -196,7 +192,7 @@ class event_handler { void on_message(msgpack::object obj, msgpack::unique_ptr) { - EXPECT_EQ(expect, obj.as()); + BOOST_CHECK_EQUAL(expect, obj.as()); } int expect; @@ -206,7 +202,7 @@ class event_handler { msgpack::unpacker pac; }; -TEST(streaming, event) +BOOST_AUTO_TEST_CASE(event) { std::stringstream stream; msgpack::packer pk(&stream); @@ -230,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 pk(&stream); @@ -257,13 +253,13 @@ TEST(streaming, basic_compat) switch(count++) { case 0: - EXPECT_EQ(1, obj.as()); + BOOST_CHECK_EQUAL(1, obj.as()); break; case 1: - EXPECT_EQ(2, obj.as()); + BOOST_CHECK_EQUAL(2, obj.as()); break; case 2: - EXPECT_EQ(3, obj.as()); + BOOST_CHECK_EQUAL(3, obj.as()); return; } @@ -306,7 +302,7 @@ class event_handler_compat { void on_message(msgpack::object obj, msgpack::unique_ptr) { - EXPECT_EQ(expect, obj.as()); + BOOST_CHECK_EQUAL(expect, obj.as()); } int expect; @@ -316,7 +312,7 @@ class event_handler_compat { msgpack::unpacker pac; }; -TEST(streaming, event_compat) +BOOST_AUTO_TEST_CASE(event_compat) { std::stringstream stream; msgpack::packer pk(&stream); diff --git a/test/streaming_c.cpp b/test/streaming_c.cpp deleted file mode 100644 index f59f15c68..000000000 --- a/test/streaming_c.cpp +++ /dev/null @@ -1,190 +0,0 @@ -#include - -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wconversion" - -#include - -#pragma GCC diagnostic pop - -#include - -TEST(streaming, basic) -{ - msgpack_sbuffer* buffer = msgpack_sbuffer_new(); - - msgpack_packer* pk = msgpack_packer_new(buffer, msgpack_sbuffer_write); - - // 1, 2, 3, "str", ["str_data"], "bin", ["bin_data"], {0.3: 0.4} - EXPECT_EQ(0, msgpack_pack_int(pk, 1)); - EXPECT_EQ(0, msgpack_pack_int(pk, 2)); - EXPECT_EQ(0, msgpack_pack_int(pk, 3)); - EXPECT_EQ(0, msgpack_pack_str(pk, 3)); - EXPECT_EQ(0, msgpack_pack_str_body(pk, "str", 3)); - EXPECT_EQ(0, msgpack_pack_array(pk, 1)); - EXPECT_EQ(0, msgpack_pack_str(pk, 8)); - EXPECT_EQ(0, msgpack_pack_str_body(pk, "str_data", 8)); - EXPECT_EQ(0, msgpack_pack_bin(pk, 3)); - EXPECT_EQ(0, msgpack_pack_bin_body(pk, "bin", 3)); - EXPECT_EQ(0, msgpack_pack_array(pk, 1)); - EXPECT_EQ(0, msgpack_pack_bin(pk, 8)); - EXPECT_EQ(0, msgpack_pack_bin_body(pk, "bin_data", 8)); - EXPECT_EQ(0, msgpack_pack_map(pk, 1)); - EXPECT_EQ(0, msgpack_pack_float(pk, 0.4f)); - EXPECT_EQ(0, msgpack_pack_double(pk, 0.8)); - int max_count = 6; - - msgpack_packer_free(pk); - - const char* input = buffer->data; - const char* const eof = input + buffer->size; - - msgpack_unpacker pac; - msgpack_unpacker_init(&pac, MSGPACK_UNPACKER_INIT_BUFFER_SIZE); - - msgpack_unpacked result; - msgpack_unpacked_init(&result); - - int count = 0; - while(count < max_count) { - bool unpacked = false; - - msgpack_unpacker_reserve_buffer(&pac, 32*1024); - - while(!unpacked) { - /* read buffer into msgpack_unapcker_buffer(&pac) upto - * msgpack_unpacker_buffer_capacity(&pac) bytes. */ - memcpy(msgpack_unpacker_buffer(&pac), input, 1); - input += 1; - - EXPECT_TRUE(input <= eof); - - msgpack_unpacker_buffer_consumed(&pac, 1); - - while(msgpack_unpacker_next(&pac, &result) == MSGPACK_UNPACK_SUCCESS) { - unpacked = 1; - msgpack_object obj = result.data; - msgpack_object e; - switch(count++) { - case 0: - EXPECT_EQ(MSGPACK_OBJECT_POSITIVE_INTEGER, obj.type); - EXPECT_EQ(1u, obj.via.u64); - break; - case 1: - EXPECT_EQ(MSGPACK_OBJECT_POSITIVE_INTEGER, obj.type); - EXPECT_EQ(2u, obj.via.u64); - break; - case 2: - EXPECT_EQ(MSGPACK_OBJECT_POSITIVE_INTEGER, obj.type); - EXPECT_EQ(3u, obj.via.u64); - break; - case 3: - EXPECT_EQ(MSGPACK_OBJECT_STR, obj.type); - EXPECT_EQ(std::string("str",3), std::string(obj.via.str.ptr, obj.via.str.size)); - break; - case 4: - EXPECT_EQ(MSGPACK_OBJECT_ARRAY, obj.type); - EXPECT_EQ(1u, obj.via.array.size); - e = obj.via.array.ptr[0]; - EXPECT_EQ(MSGPACK_OBJECT_STR, e.type); - EXPECT_EQ(std::string("str_data",8), std::string(e.via.str.ptr, e.via.str.size)); - break; - case 5: - EXPECT_EQ(MSGPACK_OBJECT_BIN, obj.type); - EXPECT_EQ(std::string("bin",3), std::string(obj.via.bin.ptr, obj.via.bin.size)); - break; - case 6: - EXPECT_EQ(MSGPACK_OBJECT_ARRAY, obj.type); - EXPECT_EQ(1u, obj.via.array.size); - e = obj.via.array.ptr[0]; - EXPECT_EQ(MSGPACK_OBJECT_BIN, e.type); - EXPECT_EQ(std::string("bin_data",8), std::string(e.via.bin.ptr, e.via.bin.size)); - break; - case 7: - EXPECT_EQ(MSGPACK_OBJECT_MAP, obj.type); - EXPECT_EQ(1u, obj.via.map.size); - e = obj.via.map.ptr[0].key; - EXPECT_EQ(MSGPACK_OBJECT_FLOAT, e.type); - ASSERT_FLOAT_EQ(0.4f, static_cast(e.via.f64)); -#if defined(MSGPACK_USE_LEGACY_NAME_AS_FLOAT) - EXPECT_EQ(MSGPACK_OBJECT_DOUBLE, e.type); - ASSERT_FLOAT_EQ(0.4f, static_cast(e.via.dec)); -#endif // MSGPACK_USE_LEGACY_NAME_AS_FLOAT - e = obj.via.map.ptr[0].val; - EXPECT_EQ(MSGPACK_OBJECT_FLOAT, e.type); - ASSERT_DOUBLE_EQ(0.8, e.via.f64); -#if defined(MSGPACK_USE_LEGACY_NAME_AS_FLOAT) - EXPECT_EQ(MSGPACK_OBJECT_DOUBLE, e.type); - ASSERT_DOUBLE_EQ(0.8, e.via.dec); -#endif // MSGPACK_USE_LEGACY_NAME_AS_FLOAT - break; - } - } - } - } - - msgpack_unpacker_destroy(&pac); - msgpack_unpacked_destroy(&result); - msgpack_sbuffer_free(buffer); -} - -TEST(streaming, basic_with_size) -{ - int ret; - size_t bytes; - size_t parsed = 0; - msgpack_sbuffer* buffer = msgpack_sbuffer_new(); - msgpack_packer* pk = msgpack_packer_new(buffer, msgpack_sbuffer_write); - msgpack_unpacked result; - msgpack_unpacker *unp; - - // 1, 2, 3, "str", ["str_data"], "bin", ["bin_data"], {0.3: 0.4} - msgpack_pack_int(pk, 1); - msgpack_pack_int(pk, 2); - msgpack_pack_int(pk, 3); - msgpack_pack_str(pk, 3); - msgpack_pack_str_body(pk, "str", 3); - msgpack_pack_array(pk, 1); - msgpack_pack_str(pk, 8); - msgpack_pack_str_body(pk, "str_data", 8); - msgpack_pack_bin(pk, 3); - msgpack_pack_bin_body(pk, "bin", 3); - msgpack_pack_array(pk, 1); - msgpack_pack_bin(pk, 8); - msgpack_pack_bin_body(pk, "bin_data", 8); - msgpack_pack_map(pk, 1); - msgpack_pack_float(pk, 0.4f); - msgpack_pack_double(pk, 0.8); - msgpack_packer_free(pk); - - unp = msgpack_unpacker_new(32 * 1024); - msgpack_unpacked_init(&result); - - const char* input = buffer->data; - - while (parsed < buffer->size) { - memcpy(msgpack_unpacker_buffer(unp), input, 1); - msgpack_unpacker_buffer_consumed(unp, 1); - input += 1; - - bytes = 0; - ret = msgpack_unpacker_next_with_size(unp, &result, &bytes); - if (ret == MSGPACK_UNPACK_CONTINUE) { - EXPECT_GT(bytes, static_cast(0)); - continue; - } - - while (ret == MSGPACK_UNPACK_SUCCESS) { - EXPECT_GT(bytes, static_cast(0)); - parsed += bytes; - ret = msgpack_unpacker_next_with_size(unp, &result, &bytes); - } - - } - - EXPECT_EQ(parsed, buffer->size); - - msgpack_unpacked_destroy(&result); - msgpack_unpacker_free(unp); - msgpack_sbuffer_free(buffer); -} diff --git a/test/test_allocator.hpp b/test/test_allocator.hpp index 482710323..2ac566f8c 100644 --- a/test/test_allocator.hpp +++ b/test/test_allocator.hpp @@ -11,6 +11,8 @@ #ifndef TEST_ALLOCATOR_HPP #define TEST_ALLOCATOR_HPP +#include + #include namespace test { @@ -18,13 +20,20 @@ namespace test { template struct allocator { typedef typename std::allocator::value_type value_type; + typedef typename std::allocator::size_type size_type; + typedef typename std::allocator::difference_type difference_type; + template struct rebind { typedef allocator other; }; +#if MSGPACK_CPP_VERSION <= 201703 typedef typename std::allocator::pointer pointer; typedef typename std::allocator::reference reference; typedef typename std::allocator::const_pointer const_pointer; typedef typename std::allocator::const_reference const_reference; - typedef typename std::allocator::size_type size_type; - typedef typename std::allocator::difference_type difference_type; - template struct rebind { typedef allocator 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 allocator (const allocator& alloc) noexcept :alloc_(alloc.alloc_) {} +#if MSGPACK_CPP_VERSION <= 201703 template void construct (U* p, Args&&... args) { return alloc_.construct(p, std::forward(args)...); } size_type max_size() const noexcept { return alloc_.max_size(); } +#else // MSGPACK_CPP_VERSION <= 201703 + template + void construct (U* p, Args&&... args) { + return std::allocator_traits::construct(alloc_, p, std::forward(args)...); + } + size_type max_size() const noexcept { + return std::allocator_traits::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::destroy(alloc_, p); + } +#endif // MSGPACK_CPP_VERSION <= 201703 std::allocator alloc_; }; diff --git a/test/unique_ptr_cpp11.cpp b/test/unique_ptr_cpp11.cpp index d28e94e2b..4cf12750c 100644 --- a/test/unique_ptr_cpp11.cpp +++ b/test/unique_ptr_cpp11.cpp @@ -2,12 +2,8 @@ #include #include -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wconversion" - -#include - -#pragma GCC diagnostic pop +#define BOOST_TEST_MODULE UNIQUE_PTR +#include #ifdef HAVE_CONFIG_H #include "config.h" @@ -15,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 val1; @@ -24,10 +20,10 @@ TEST(UNIQUE_PTR, pack_convert_nil) msgpack::object_handle oh = msgpack::unpack(str.data(), str.size()); std::unique_ptr val2 = oh.get().as>(); - 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 val1(new int(1)); @@ -36,54 +32,54 @@ TEST(UNIQUE_PTR, pack_convert_int) msgpack::object_handle oh = msgpack::unpack(str.data(), str.size()); std::unique_ptr val2 = oh.get().as>(); - EXPECT_TRUE(*val1 == *val2); + BOOST_CHECK(*val1 == *val2); } -TEST(UNIQUE_PTR, object_nil) +BOOST_AUTO_TEST_CASE(object_nil) { std::unique_ptr val1; msgpack::object obj(val1); std::unique_ptr val2 = obj.as>(); - EXPECT_TRUE(val1 == val2); + BOOST_CHECK(val1 == val2); } -TEST(UNIQUE_PTR, object_int) +BOOST_AUTO_TEST_CASE(object_int) { std::unique_ptr val1(new int(1)); msgpack::object obj(val1); std::unique_ptr val2 = obj.as>(); - 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> ovi_t; ovi_t val1(new std::vector()); msgpack::object obj(val1); ovi_t val2 = obj.as(); - 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 val1; msgpack::object obj(val1, z); std::unique_ptr val2 = obj.as>(); - 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 val1(new int(1)); msgpack::object obj(val1, z); std::unique_ptr val2 = obj.as>(); - EXPECT_TRUE(*val1 == *val2); + BOOST_CHECK(*val1 == *val2); } struct no_def_con { @@ -116,7 +112,7 @@ struct as { } // 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 val1(new no_def_con(1)); @@ -125,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 val2 = oh.get().as>(); - EXPECT_TRUE(*val1 == *val2); + BOOST_CHECK(*val1 == *val2); } diff --git a/test/user_class.cpp b/test/user_class.cpp index 77b2c0898..4fcb5b9d3 100644 --- a/test/user_class.cpp +++ b/test/user_class.cpp @@ -2,19 +2,13 @@ #include #include -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wconversion" - -#include - -#pragma GCC diagnostic pop +#define BOOST_TEST_MODULE MSGPACK_USER_DEFINED +#include #ifdef HAVE_CONFIG_H #include "config.h" #endif - - using namespace std; const unsigned int kLoop = 1000; @@ -53,7 +47,7 @@ class TestClass 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; @@ -62,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(); - 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); } } @@ -80,7 +74,7 @@ class TestClass2 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; @@ -89,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(); - 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; @@ -104,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(); - 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; @@ -118,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(); - 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 @@ -153,30 +147,30 @@ class TestUnionMemberClass void msgpack_unpack(msgpack::object o) { -#if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__) +#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wmaybe-uninitialized" -#endif // (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__) - msgpack::type::tuple tuple(false, msgpack::object()); +#endif // defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__) + msgpack::type::tuple tuple; o.convert(tuple); is_double = tuple.get<0>(); if (is_double) - tuple.get<1>().convert(value.f); + tuple.get<1>().convert(value.f); else - tuple.get<1>().convert(value.i); -#if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__) + tuple.get<1>().convert(value.i); +#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__) #pragma GCC diagnostic pop -#endif // (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__) +#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 (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__) +#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wmaybe-uninitialized" -#endif // (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__) +#endif // defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__) { // double TestUnionMemberClass val1(1.0); @@ -185,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(); - 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 @@ -196,13 +190,13 @@ TEST(MSGPACK_USER_DEFINED, simple_buffer_union_member) msgpack::object_handle oh = msgpack::unpack(sbuf.data(), sbuf.size()); TestUnionMemberClass val2 = oh.get().as(); - 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 (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__) +#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__) #pragma GCC diagnostic pop -#endif // (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__) +#endif // defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__) } // inheritance @@ -229,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; @@ -242,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(); - 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 { @@ -269,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; @@ -281,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(); - 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 @@ -309,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; @@ -322,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(); - 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 { @@ -349,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; @@ -361,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(); - 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 @@ -389,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; @@ -401,19 +395,19 @@ TEST(MSGPACK_INHERIT, define_map_non_virtual) msgpack::pack(sbuf, b); msgpack::object_handle oh = msgpack::unpack(sbuf.data(), sbuf.size()); -#if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__) +#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wmaybe-uninitialized" -#endif // (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__) +#endif // defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__) dm_bottom br = oh.get().as(); -#if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__) +#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__) #pragma GCC diagnostic pop -#endif // (__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); +#endif // defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__) + 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 { @@ -436,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; @@ -448,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(); - 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 @@ -471,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; @@ -481,9 +475,9 @@ TEST(MSGPACK_MIGRATION, order_number_changed) msgpack::unpack(sbuf.data(), sbuf.size()); s_v2 v2 = oh.get().as(); - 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 << @@ -537,7 +531,7 @@ struct object_with_zone } // 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; @@ -547,7 +541,7 @@ TEST(MSGPACK_USER_DEFINED, test_non_intrusive) msgpack::unpack(sbuf.data(), sbuf.size()); test_non_intrusive t2 = oh.get().as(); - EXPECT_EQ(t1.name(), t2.name()); + BOOST_CHECK_EQUAL(t1.name(), t2.name()); } struct nvp_base { @@ -562,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; @@ -575,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(3)); + BOOST_CHECK_EQUAL(obj.via.map.size, static_cast(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(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(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(); - 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 { @@ -612,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 pk(sbuf); @@ -622,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(); - EXPECT_TRUE(false); + BOOST_CHECK(false); } catch (msgpack::type_error const&) { - EXPECT_TRUE(true); + BOOST_CHECK(true); } catch (...) { - EXPECT_TRUE(false); + BOOST_CHECK(false); } } diff --git a/test/version.cpp b/test/version.cpp index 78c3bfaa0..e91bf72d8 100644 --- a/test/version.cpp +++ b/test/version.cpp @@ -1,20 +1,18 @@ #include -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wconversion" +#define BOOST_TEST_MODULE version +#include -#include +#include -#pragma GCC diagnostic pop - -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()); } diff --git a/test/visitor.cpp b/test/visitor.cpp index c3faa69c3..d16a3c920 100644 --- a/test/visitor.cpp +++ b/test/visitor.cpp @@ -1,16 +1,11 @@ #include -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wconversion" - -#include - -#pragma GCC diagnostic pop +#define BOOST_TEST_MODULE visitor +#include #include -// To avoid link error -TEST(visitor, dummy) +BOOST_AUTO_TEST_CASE(dummy) { } @@ -76,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 p(ss); @@ -100,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(1), parsed_offset); - EXPECT_EQ(static_cast(2), error_offset); + BOOST_CHECK_EQUAL(static_cast(1), parsed_offset); + BOOST_CHECK_EQUAL(static_cast(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(0x93u), 0x01u, static_cast(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(2), parsed_offset); - EXPECT_EQ(static_cast(3), error_offset); + BOOST_CHECK_EQUAL(static_cast(2), parsed_offset); + BOOST_CHECK_EQUAL(static_cast(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(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 { @@ -163,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(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 } @@ -188,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(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 } @@ -213,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(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 } @@ -235,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(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 { @@ -251,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(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 { @@ -267,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(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 } @@ -287,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(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 { @@ -306,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(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 } @@ -331,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(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 } @@ -356,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(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 } @@ -381,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(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 } @@ -406,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(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 } @@ -428,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(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 { @@ -444,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(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 { @@ -460,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(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 } @@ -480,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(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 diff --git a/test/zone.cpp b/test/zone.cpp index e0acb5fd9..438f69b2f 100644 --- a/test/zone.cpp +++ b/test/zone.cpp @@ -1,34 +1,30 @@ #include -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wconversion" +#define BOOST_TEST_MODULE zone +#include -#include - -#pragma GCC diagnostic pop - -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(start) % sizeof(int)); - for (std::size_t s = 1; s < sizeof(int); ++s) { + BOOST_CHECK_EQUAL(0ul, reinterpret_cast(start) % sizeof(int)); + for (std::size_t s = 1; s < sizeof(int); s <<= 1) { z.allocate_no_align(s); char* buf_a = (char*)z.allocate_align(1); - EXPECT_EQ(0ul, reinterpret_cast(buf_a) % sizeof(int)); + BOOST_CHECK_EQUAL(0ul, reinterpret_cast(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) { + for (std::size_t align = 1; align < 64; align <<= 1) { char* start = (char*)z.allocate_align(1, align); - EXPECT_EQ(0ul, reinterpret_cast(start) % align); - for (std::size_t s = 1; s < align; ++s) { + BOOST_CHECK_EQUAL(0ul, reinterpret_cast(start) % align); + for (std::size_t s = 1; s < align; s <<= 1) { z.allocate_no_align(s); char* buf_a = (char*)z.allocate_align(1, align); - EXPECT_EQ(0ul, reinterpret_cast(buf_a) % align); + BOOST_CHECK_EQUAL(0ul, reinterpret_cast(buf_a) % align); } } } @@ -50,21 +46,21 @@ class myclass { }; -TEST(zone, allocate) +BOOST_AUTO_TEST_CASE(allocate) { msgpack::zone z; myclass* m = z.allocate(); - 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(7, "msgpack"); - EXPECT_EQ(m->num, 7); - EXPECT_EQ(m->str, "msgpack"); + BOOST_CHECK_EQUAL(m->num, 7); + BOOST_CHECK_EQUAL(m->str, "msgpack"); } @@ -74,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(); @@ -82,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 am(new myclass()); @@ -90,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(z.allocate_no_align(4)); + char* buf2 = reinterpret_cast(z.allocate_no_align(4)); + BOOST_CHECK_EQUAL(reinterpret_cast(buf1+4), reinterpret_cast(buf2)); } diff --git a/update_version.sh b/update_version.sh index a07b45732..c7fe2c4de 100755 --- a/update_version.sh +++ b/update_version.sh @@ -9,9 +9,9 @@ major=`echo $1 | sed -e "s/^\([0-9]*\)\.[0-9]*\.[0-9]*/\1/"` minor=`echo $1 | sed -e "s/^[0-9]*\.\([0-9]*\)\.[0-9]*/\1/"` revision=`echo $1 | sed -e "s/^[0-9]*\.[0-9]*\.\([0-9]*\)/\1/"` -sed -i -e "s/^\(#define MSGPACK_VERSION_MAJOR[[:space:]]*\)[0-9]*/\1$major/" include/msgpack/version_master.h -sed -i -e "s/^\(#define MSGPACK_VERSION_MINOR[[:space:]]*\)[0-9]*/\1$minor/" include/msgpack/version_master.h -sed -i -e "s/^\(#define MSGPACK_VERSION_REVISION[[:space:]]*\)[0-9]*/\1$revision/" include/msgpack/version_master.h +sed -i -e "s/^\(#define MSGPACK_VERSION_MAJOR[[:space:]]*\)[0-9]*/\1$major/" include/msgpack/version_master.hpp +sed -i -e "s/^\(#define MSGPACK_VERSION_MINOR[[:space:]]*\)[0-9]*/\1$minor/" include/msgpack/version_master.hpp +sed -i -e "s/^\(#define MSGPACK_VERSION_REVISION[[:space:]]*\)[0-9]*/\1$revision/" include/msgpack/version_master.hpp sed -i -e "s/\(^Version \)[0-9]*\.[0-9]*\.[0-9]*/\1$1/" README.md sed -i -e "s/\(^version: \)[0-9]*\.[0-9]*\.[0-9]*/\1$1/" appveyor.yml