From 005d628652a71bbd0caa6cf5ee5e5dcfa59bed0a Mon Sep 17 00:00:00 2001 From: ilerik Date: Sat, 18 Apr 2015 17:50:59 +0300 Subject: [PATCH 1/7] Added support for std::valarray. 1) Implemented std::valarray serialization (based on vector.hpp) in file valarray.hpp 2) Implemented unit tests in file valarray.cpp (based on vector.cpp tests, except for bool case) 3) vs2013/unittests project configuration updated accordingly 4) unittests/common.hpp updated. 5) No documentation so far --- include/cereal/types/valarray.hpp | 103 ++++++++++++++++++ unittests/common.hpp | 1 + unittests/valarray.cpp | 120 +++++++++++++++++++++ vs2013/unittests/unittests.vcxproj | 7 +- vs2013/unittests/unittests.vcxproj.filters | 5 +- 5 files changed, 232 insertions(+), 4 deletions(-) create mode 100644 include/cereal/types/valarray.hpp create mode 100644 unittests/valarray.cpp diff --git a/include/cereal/types/valarray.hpp b/include/cereal/types/valarray.hpp new file mode 100644 index 000000000..ca743bb0b --- /dev/null +++ b/include/cereal/types/valarray.hpp @@ -0,0 +1,103 @@ +/*! \file valarray.hpp +\brief Support for types found in \ +\ingroup STLSupport */ + +/* +Copyright (c) 2014, Randolph Voorhies, Shane Grant +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: +* Redistributions of source code must retain the above copyright +notice, this list of conditions and the following disclaimer. +* Redistributions in binary form must reproduce the above copyright +notice, this list of conditions and the following disclaimer in the +documentation and/or other materials provided with the distribution. +* Neither the name of cereal nor the +names of its contributors may be used to endorse or promote products +derived from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND +ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES OR SHANE GRANT BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +#ifndef CEREAL_TYPES_VALARRAY_HPP_ +#define CEREAL_TYPES_VALARRAY_HPP_ + +#include +#include + +namespace cereal +{ + /* Implementation note + Since valarray can only contain arithmetic types, pointer or other valarrays we need to define serialization for all the cases mentioned + Following implementation in valarray.hpp we get serialization for std::valarray arithmetic values directly and all other cases implemented as calls + for underlying serialization of every valarray element. */ + + //! Saving for std::valarray arithmetic types + //! using binary serialization, if supported + template inline + typename std::enable_if, Archive>::value + && std::is_arithmetic::value, void>::type + CEREAL_SAVE_FUNCTION_NAME(Archive & ar, std::valarray const & valarray) + { + size_type valarraySize = static_cast(valarray.size()); //get valarray size + ar(make_size_tag(valarraySize)); // save number of elements + if (valarraySize > 0) { // save data if it's not empty + ar(binary_data(&valarray[0], static_cast(valarraySize) * sizeof(T))); // &valarray[0] applicable since std::valarray guaranteed to be stored contignously + } + } + + //! Loading for std::valarray arithmetic types + //! using binary serialization, if supported + template inline + typename std::enable_if, Archive>::value + && std::is_arithmetic::value, void>::type + CEREAL_LOAD_FUNCTION_NAME(Archive & ar, std::valarray & valarray) + { + size_type valarraySize; + ar(make_size_tag(valarraySize)); + + valarray.resize(static_cast(valarraySize)); + if (valarraySize > 0) { // load data if it's not empty + ar( binary_data(&valarray[0], static_cast(valarraySize) * sizeof(T)) ); + } + } + + //! Saving for std::valarray all other types + template inline + typename std::enable_if, Archive>::value + || !std::is_arithmetic::value, void>::type + CEREAL_SAVE_FUNCTION_NAME(Archive & ar, std::valarray const & valarray) + { + ar(make_size_tag(static_cast(valarray.size()))); // number of elements + for (auto const & i : valarray) + ar(i); + } + + //! Loading for std::valarray all other types + template inline + typename std::enable_if, Archive>::value + || !std::is_arithmetic::value, void>::type + CEREAL_LOAD_FUNCTION_NAME(Archive & ar, std::valarray & valarray) + { + size_type valarraySize; + ar(make_size_tag(valarraySize)); + + valarray.resize(static_cast(valarraySize)); + if (valarraySize > 0) { // load data if it's not empty + for (auto & i : valarray) + ar(i); + } + } +} // namespace cereal + +#endif // CEREAL_TYPES_VALARRAY_HPP_ diff --git a/unittests/common.hpp b/unittests/common.hpp index 258fc3658..d3e58c961 100644 --- a/unittests/common.hpp +++ b/unittests/common.hpp @@ -29,6 +29,7 @@ #include #include +#include #include #include #include diff --git a/unittests/valarray.cpp b/unittests/valarray.cpp new file mode 100644 index 000000000..b1bc3c74d --- /dev/null +++ b/unittests/valarray.cpp @@ -0,0 +1,120 @@ +/* +Copyright (c) 2014, Randolph Voorhies, Shane Grant +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: +* Redistributions of source code must retain the above copyright +notice, this list of conditions and the following disclaimer. +* Redistributions in binary form must reproduce the above copyright +notice, this list of conditions and the following disclaimer in the +documentation and/or other materials provided with the distribution. +* Neither the name of cereal nor the +names of its contributors may be used to endorse or promote products +derived from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND +ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES AND SHANE GRANT BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ +#include "common.hpp" +#include + +template +void test_valarray() +{ + std::random_device rd; + std::mt19937 gen(rd()); + + for (int ii = 0; ii<100; ++ii) + { + std::valarray o_podvalarray(100); + for (auto & elem : o_podvalarray) + elem = random_value(gen); + + std::valarray o_iservalarray(100); + for (auto & elem : o_iservalarray) + elem = StructInternalSerialize(random_value(gen), random_value(gen)); + + std::valarray o_isplvalarray(100); + for (auto & elem : o_isplvalarray) + elem = StructInternalSplit(random_value(gen), random_value(gen)); + + std::valarray o_eservalarray(100); + for (auto & elem : o_eservalarray) + elem = StructExternalSerialize(random_value(gen), random_value(gen)); + + std::valarray o_esplvalarray(100); + for (auto & elem : o_esplvalarray) + elem = StructExternalSplit(random_value(gen), random_value(gen)); + + std::ostringstream os; + { + OArchive oar(os); + + oar(o_podvalarray); + oar(o_iservalarray); + oar(o_isplvalarray); + oar(o_eservalarray); + oar(o_esplvalarray); + } + + std::valarray i_podvalarray; + std::valarray i_iservalarray; + std::valarray i_isplvalarray; + std::valarray i_eservalarray; + std::valarray i_esplvalarray; + + std::istringstream is(os.str()); + { + IArchive iar(is); + + iar(i_podvalarray); + iar(i_iservalarray); + iar(i_isplvalarray); + iar(i_eservalarray); + iar(i_esplvalarray); + } + + BOOST_CHECK_EQUAL(i_podvalarray.size(), o_podvalarray.size()); + BOOST_CHECK_EQUAL(i_iservalarray.size(), o_iservalarray.size()); + BOOST_CHECK_EQUAL(i_isplvalarray.size(), o_isplvalarray.size()); + BOOST_CHECK_EQUAL(i_eservalarray.size(), o_eservalarray.size()); + BOOST_CHECK_EQUAL(i_esplvalarray.size(), o_esplvalarray.size()); + + BOOST_CHECK_EQUAL_COLLECTIONS(std::begin(i_podvalarray), std::end(i_podvalarray), std::begin(o_podvalarray), std::end(o_podvalarray)); + BOOST_CHECK_EQUAL_COLLECTIONS(std::begin(i_iservalarray), std::end(i_iservalarray), std::begin(o_iservalarray), std::end(o_iservalarray)); + BOOST_CHECK_EQUAL_COLLECTIONS(std::begin(i_isplvalarray), std::end(i_isplvalarray), std::begin(o_isplvalarray), std::end(o_isplvalarray)); + BOOST_CHECK_EQUAL_COLLECTIONS(std::begin(i_eservalarray), std::end(i_eservalarray), std::begin(o_eservalarray), std::end(o_eservalarray)); + BOOST_CHECK_EQUAL_COLLECTIONS(std::begin(i_esplvalarray), std::end(i_esplvalarray), std::begin(o_esplvalarray), std::end(o_esplvalarray)); + } +} + +BOOST_AUTO_TEST_CASE(binary_valarray) +{ + test_valarray(); +} + +BOOST_AUTO_TEST_CASE(portable_binary_valarray) +{ + test_valarray(); +} + +BOOST_AUTO_TEST_CASE(xml_valarray) +{ + test_valarray(); +} + +BOOST_AUTO_TEST_CASE(json_valarray) +{ + test_valarray(); +} + + diff --git a/vs2013/unittests/unittests.vcxproj b/vs2013/unittests/unittests.vcxproj index 8e615f5a0..951f45bab 100644 --- a/vs2013/unittests/unittests.vcxproj +++ b/vs2013/unittests/unittests.vcxproj @@ -1,4 +1,4 @@ - + @@ -52,6 +52,7 @@ + @@ -103,7 +104,7 @@ - $(SolutionDir)\..\include;$(SolutionDir)\..\unittests;E:\Boost\include\boost-1_55;$(IncludePath) + $(SolutionDir)\..\include;$(SolutionDir)\..\unittests;D:\Libs\boost_1_58_0;$(IncludePath) E:\Boost\lib;$(LibraryPath) @@ -111,7 +112,7 @@ E:\Boost\lib\x64;$(LibraryPath) - $(SolutionDir)\..\include;$(SolutionDir)\..\unittests;E:\Boost\include\boost-1_55;$(IncludePath) + $(SolutionDir)\..\include;$(SolutionDir)\..\unittests;D:\Libs\boost_1_58_0;$(IncludePath) E:\Boost\lib;$(LibraryPath) diff --git a/vs2013/unittests/unittests.vcxproj.filters b/vs2013/unittests/unittests.vcxproj.filters index f4d3d90ab..902b5351c 100644 --- a/vs2013/unittests/unittests.vcxproj.filters +++ b/vs2013/unittests/unittests.vcxproj.filters @@ -1,4 +1,4 @@ - + @@ -110,6 +110,9 @@ Source Files + + + Source Files Source Files From 5d541d33cd432a7d22463c4cb1ff56c0af1351db Mon Sep 17 00:00:00 2001 From: Shane Grant Date: Sat, 2 May 2015 21:17:44 -0700 Subject: [PATCH 2/7] JSON now matches string length for out of order NVPs Fixes #183, relates #168, #169 fix originally proposed by @felixzng --- include/cereal/archives/json.hpp | 6 +++++- unittests/unordered_loads.cpp | 12 ++++++++---- 2 files changed, 13 insertions(+), 5 deletions(-) diff --git a/include/cereal/archives/json.hpp b/include/cereal/archives/json.hpp index 8cc96a0be..49556cc88 100644 --- a/include/cereal/archives/json.hpp +++ b/include/cereal/archives/json.hpp @@ -491,11 +491,15 @@ namespace cereal const auto len = std::strlen( searchName ); size_t index = 0; for( auto it = itsMemberItBegin; it != itsMemberItEnd; ++it, ++index ) - if( std::strncmp( searchName, it->name.GetString(), len ) == 0 ) + { + const auto currentName = it->name.GetString(); + if( ( std::strncmp( searchName, currentName, len ) == 0 ) && + ( std::strlen( currentName ) == len ) ) { itsIndex = index; return; } + } throw Exception("JSON Parsing failed - provided NVP not found"); } diff --git a/unittests/unordered_loads.cpp b/unittests/unordered_loads.cpp index cd11d7531..4357b67c3 100644 --- a/unittests/unordered_loads.cpp +++ b/unittests/unordered_loads.cpp @@ -30,6 +30,7 @@ struct unordered_naming { int x; + int xx; int y; int z; @@ -38,7 +39,8 @@ struct unordered_naming { ar( CEREAL_NVP(x), CEREAL_NVP(z), - CEREAL_NVP(y) ); + CEREAL_NVP(y), + CEREAL_NVP(xx) ); } template @@ -46,18 +48,19 @@ struct unordered_naming { ar( x, CEREAL_NVP(y), - CEREAL_NVP(z) ); + CEREAL_NVP(z), + CEREAL_NVP(xx) ); } bool operator==( unordered_naming const & other ) const { - return x == other.x && y == other.y && z == other.z; + return x == other.x && xx == other.xx && y == other.y && z == other.z; } }; std::ostream& operator<<(std::ostream& os, unordered_naming const & s) { - os << "[x: " << s.x << " y: " << s.y << " z: " << s.z << "]"; + os << "[x: " << s.x << " xx: " << s.xx << " y: " << s.y << " z: " << s.z << "]"; return os; } @@ -92,6 +95,7 @@ void test_unordered_loads() std::pair o_un7; o_un7.first = rngF(); o_un7.second.x = rngI(); + o_un7.second.xx = rngI(); o_un7.second.y = rngI(); o_un7.second.z = rngI(); From 839ae30cc0237ef9cccddc0e02a6c821dc72759f Mon Sep 17 00:00:00 2001 From: Shane Grant Date: Sat, 2 May 2015 21:41:43 -0700 Subject: [PATCH 3/7] style changes --- include/cereal/types/valarray.hpp | 80 +++++++++++++------------------ 1 file changed, 33 insertions(+), 47 deletions(-) diff --git a/include/cereal/types/valarray.hpp b/include/cereal/types/valarray.hpp index ca743bb0b..3cd8690a6 100644 --- a/include/cereal/types/valarray.hpp +++ b/include/cereal/types/valarray.hpp @@ -37,67 +37,53 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. namespace cereal { - /* Implementation note - Since valarray can only contain arithmetic types, pointer or other valarrays we need to define serialization for all the cases mentioned - Following implementation in valarray.hpp we get serialization for std::valarray arithmetic values directly and all other cases implemented as calls - for underlying serialization of every valarray element. */ - - //! Saving for std::valarray arithmetic types - //! using binary serialization, if supported + //! Saving for std::valarray arithmetic types, using binary serialization, if supported template inline - typename std::enable_if, Archive>::value - && std::is_arithmetic::value, void>::type - CEREAL_SAVE_FUNCTION_NAME(Archive & ar, std::valarray const & valarray) + typename std::enable_if, Archive>::value + && std::is_arithmetic::value, void>::type + CEREAL_SAVE_FUNCTION_NAME( Archive & ar, std::valarray const & valarray ) { - size_type valarraySize = static_cast(valarray.size()); //get valarray size - ar(make_size_tag(valarraySize)); // save number of elements - if (valarraySize > 0) { // save data if it's not empty - ar(binary_data(&valarray[0], static_cast(valarraySize) * sizeof(T))); // &valarray[0] applicable since std::valarray guaranteed to be stored contignously - } - } + ar( make_size_tag( static_cast(valarray.size()) ) ); // number of elements + ar( binary_data( &valarray[0], valarray.size() * sizeof(T) ) ); // &valarray[0] ok since guaranteed contiguous + } - //! Loading for std::valarray arithmetic types - //! using binary serialization, if supported + //! Loading for std::valarray arithmetic types, using binary serialization, if supported template inline - typename std::enable_if, Archive>::value - && std::is_arithmetic::value, void>::type - CEREAL_LOAD_FUNCTION_NAME(Archive & ar, std::valarray & valarray) - { - size_type valarraySize; - ar(make_size_tag(valarraySize)); + typename std::enable_if, Archive>::value + && std::is_arithmetic::value, void>::type + CEREAL_LOAD_FUNCTION_NAME( Archive & ar, std::valarray & valarray ) + { + size_type valarraySize; + ar( make_size_tag( valarraySize ) ); - valarray.resize(static_cast(valarraySize)); - if (valarraySize > 0) { // load data if it's not empty - ar( binary_data(&valarray[0], static_cast(valarraySize) * sizeof(T)) ); - } - } + valarray.resize( static_cast( valarraySize ) ); + ar( binary_data( &valarray[0], static_cast( valarraySize ) * sizeof(T) ) ); + } //! Saving for std::valarray all other types template inline - typename std::enable_if, Archive>::value - || !std::is_arithmetic::value, void>::type - CEREAL_SAVE_FUNCTION_NAME(Archive & ar, std::valarray const & valarray) + typename std::enable_if, Archive>::value + || !std::is_arithmetic::value, void>::type + CEREAL_SAVE_FUNCTION_NAME( Archive & ar, std::valarray const & valarray ) { - ar(make_size_tag(static_cast(valarray.size()))); // number of elements - for (auto const & i : valarray) - ar(i); - } + ar( make_size_tag( static_cast(valarray.size()) ) ); // number of elements + for(auto && v : valarray) + ar(v); + } //! Loading for std::valarray all other types template inline - typename std::enable_if, Archive>::value - || !std::is_arithmetic::value, void>::type - CEREAL_LOAD_FUNCTION_NAME(Archive & ar, std::valarray & valarray) + typename std::enable_if, Archive>::value + || !std::is_arithmetic::value, void>::type + CEREAL_LOAD_FUNCTION_NAME( Archive & ar, std::valarray & valarray ) { - size_type valarraySize; - ar(make_size_tag(valarraySize)); + size_type valarraySize; + ar( make_size_tag( valarraySize ) ); - valarray.resize(static_cast(valarraySize)); - if (valarraySize > 0) { // load data if it's not empty - for (auto & i : valarray) - ar(i); - } - } + valarray.resize( static_cast( valarraySize ) ); + for(auto && v : valarray) + ar(v); + } } // namespace cereal #endif // CEREAL_TYPES_VALARRAY_HPP_ From 15d4e9f10ea0f18ec0f2d07be9f8842b1b37b0c5 Mon Sep 17 00:00:00 2001 From: Shane Grant Date: Sat, 2 May 2015 21:49:39 -0700 Subject: [PATCH 4/7] style changes --- unittests/valarray.cpp | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/unittests/valarray.cpp b/unittests/valarray.cpp index b1bc3c74d..a74bb5899 100644 --- a/unittests/valarray.cpp +++ b/unittests/valarray.cpp @@ -24,6 +24,7 @@ ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ + #include "common.hpp" #include @@ -116,5 +117,3 @@ BOOST_AUTO_TEST_CASE(json_valarray) { test_valarray(); } - - From 4b1b70b30257ec01679b73655098c5367d1496b9 Mon Sep 17 00:00:00 2001 From: Shane Grant Date: Sat, 2 May 2015 21:52:44 -0700 Subject: [PATCH 5/7] tab spacing style fix --- include/cereal/types/valarray.hpp | 22 +++++++++++----------- 1 file changed, 11 insertions(+), 11 deletions(-) diff --git a/include/cereal/types/valarray.hpp b/include/cereal/types/valarray.hpp index 3cd8690a6..eade2fe3b 100644 --- a/include/cereal/types/valarray.hpp +++ b/include/cereal/types/valarray.hpp @@ -37,18 +37,18 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. namespace cereal { - //! Saving for std::valarray arithmetic types, using binary serialization, if supported - template inline + //! Saving for std::valarray arithmetic types, using binary serialization, if supported + template inline typename std::enable_if, Archive>::value && std::is_arithmetic::value, void>::type CEREAL_SAVE_FUNCTION_NAME( Archive & ar, std::valarray const & valarray ) - { + { ar( make_size_tag( static_cast(valarray.size()) ) ); // number of elements ar( binary_data( &valarray[0], valarray.size() * sizeof(T) ) ); // &valarray[0] ok since guaranteed contiguous } - //! Loading for std::valarray arithmetic types, using binary serialization, if supported - template inline + //! Loading for std::valarray arithmetic types, using binary serialization, if supported + template inline typename std::enable_if, Archive>::value && std::is_arithmetic::value, void>::type CEREAL_LOAD_FUNCTION_NAME( Archive & ar, std::valarray & valarray ) @@ -60,23 +60,23 @@ namespace cereal ar( binary_data( &valarray[0], static_cast( valarraySize ) * sizeof(T) ) ); } - //! Saving for std::valarray all other types - template inline + //! Saving for std::valarray all other types + template inline typename std::enable_if, Archive>::value || !std::is_arithmetic::value, void>::type CEREAL_SAVE_FUNCTION_NAME( Archive & ar, std::valarray const & valarray ) - { + { ar( make_size_tag( static_cast(valarray.size()) ) ); // number of elements for(auto && v : valarray) ar(v); } - //! Loading for std::valarray all other types - template inline + //! Loading for std::valarray all other types + template inline typename std::enable_if, Archive>::value || !std::is_arithmetic::value, void>::type CEREAL_LOAD_FUNCTION_NAME( Archive & ar, std::valarray & valarray ) - { + { size_type valarraySize; ar( make_size_tag( valarraySize ) ); From 676ebf76fa7e9f604d0f7718cef4b8f53525c977 Mon Sep 17 00:00:00 2001 From: Shane Grant Date: Sat, 2 May 2015 21:53:30 -0700 Subject: [PATCH 6/7] more tab spacing fixes --- unittests/valarray.cpp | 138 ++++++++++++++++++++--------------------- 1 file changed, 69 insertions(+), 69 deletions(-) diff --git a/unittests/valarray.cpp b/unittests/valarray.cpp index a74bb5899..7a1fbd1f5 100644 --- a/unittests/valarray.cpp +++ b/unittests/valarray.cpp @@ -31,89 +31,89 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. template void test_valarray() { - std::random_device rd; - std::mt19937 gen(rd()); - - for (int ii = 0; ii<100; ++ii) - { - std::valarray o_podvalarray(100); - for (auto & elem : o_podvalarray) - elem = random_value(gen); - - std::valarray o_iservalarray(100); - for (auto & elem : o_iservalarray) - elem = StructInternalSerialize(random_value(gen), random_value(gen)); - - std::valarray o_isplvalarray(100); - for (auto & elem : o_isplvalarray) - elem = StructInternalSplit(random_value(gen), random_value(gen)); - - std::valarray o_eservalarray(100); - for (auto & elem : o_eservalarray) - elem = StructExternalSerialize(random_value(gen), random_value(gen)); - - std::valarray o_esplvalarray(100); - for (auto & elem : o_esplvalarray) - elem = StructExternalSplit(random_value(gen), random_value(gen)); - - std::ostringstream os; - { - OArchive oar(os); - - oar(o_podvalarray); - oar(o_iservalarray); - oar(o_isplvalarray); - oar(o_eservalarray); - oar(o_esplvalarray); - } - - std::valarray i_podvalarray; - std::valarray i_iservalarray; - std::valarray i_isplvalarray; - std::valarray i_eservalarray; - std::valarray i_esplvalarray; - - std::istringstream is(os.str()); - { - IArchive iar(is); - - iar(i_podvalarray); - iar(i_iservalarray); - iar(i_isplvalarray); - iar(i_eservalarray); - iar(i_esplvalarray); - } - - BOOST_CHECK_EQUAL(i_podvalarray.size(), o_podvalarray.size()); - BOOST_CHECK_EQUAL(i_iservalarray.size(), o_iservalarray.size()); - BOOST_CHECK_EQUAL(i_isplvalarray.size(), o_isplvalarray.size()); - BOOST_CHECK_EQUAL(i_eservalarray.size(), o_eservalarray.size()); - BOOST_CHECK_EQUAL(i_esplvalarray.size(), o_esplvalarray.size()); - - BOOST_CHECK_EQUAL_COLLECTIONS(std::begin(i_podvalarray), std::end(i_podvalarray), std::begin(o_podvalarray), std::end(o_podvalarray)); - BOOST_CHECK_EQUAL_COLLECTIONS(std::begin(i_iservalarray), std::end(i_iservalarray), std::begin(o_iservalarray), std::end(o_iservalarray)); - BOOST_CHECK_EQUAL_COLLECTIONS(std::begin(i_isplvalarray), std::end(i_isplvalarray), std::begin(o_isplvalarray), std::end(o_isplvalarray)); - BOOST_CHECK_EQUAL_COLLECTIONS(std::begin(i_eservalarray), std::end(i_eservalarray), std::begin(o_eservalarray), std::end(o_eservalarray)); - BOOST_CHECK_EQUAL_COLLECTIONS(std::begin(i_esplvalarray), std::end(i_esplvalarray), std::begin(o_esplvalarray), std::end(o_esplvalarray)); - } + std::random_device rd; + std::mt19937 gen(rd()); + + for (int ii = 0; ii<100; ++ii) + { + std::valarray o_podvalarray(100); + for (auto & elem : o_podvalarray) + elem = random_value(gen); + + std::valarray o_iservalarray(100); + for (auto & elem : o_iservalarray) + elem = StructInternalSerialize(random_value(gen), random_value(gen)); + + std::valarray o_isplvalarray(100); + for (auto & elem : o_isplvalarray) + elem = StructInternalSplit(random_value(gen), random_value(gen)); + + std::valarray o_eservalarray(100); + for (auto & elem : o_eservalarray) + elem = StructExternalSerialize(random_value(gen), random_value(gen)); + + std::valarray o_esplvalarray(100); + for (auto & elem : o_esplvalarray) + elem = StructExternalSplit(random_value(gen), random_value(gen)); + + std::ostringstream os; + { + OArchive oar(os); + + oar(o_podvalarray); + oar(o_iservalarray); + oar(o_isplvalarray); + oar(o_eservalarray); + oar(o_esplvalarray); + } + + std::valarray i_podvalarray; + std::valarray i_iservalarray; + std::valarray i_isplvalarray; + std::valarray i_eservalarray; + std::valarray i_esplvalarray; + + std::istringstream is(os.str()); + { + IArchive iar(is); + + iar(i_podvalarray); + iar(i_iservalarray); + iar(i_isplvalarray); + iar(i_eservalarray); + iar(i_esplvalarray); + } + + BOOST_CHECK_EQUAL(i_podvalarray.size(), o_podvalarray.size()); + BOOST_CHECK_EQUAL(i_iservalarray.size(), o_iservalarray.size()); + BOOST_CHECK_EQUAL(i_isplvalarray.size(), o_isplvalarray.size()); + BOOST_CHECK_EQUAL(i_eservalarray.size(), o_eservalarray.size()); + BOOST_CHECK_EQUAL(i_esplvalarray.size(), o_esplvalarray.size()); + + BOOST_CHECK_EQUAL_COLLECTIONS(std::begin(i_podvalarray), std::end(i_podvalarray), std::begin(o_podvalarray), std::end(o_podvalarray)); + BOOST_CHECK_EQUAL_COLLECTIONS(std::begin(i_iservalarray), std::end(i_iservalarray), std::begin(o_iservalarray), std::end(o_iservalarray)); + BOOST_CHECK_EQUAL_COLLECTIONS(std::begin(i_isplvalarray), std::end(i_isplvalarray), std::begin(o_isplvalarray), std::end(o_isplvalarray)); + BOOST_CHECK_EQUAL_COLLECTIONS(std::begin(i_eservalarray), std::end(i_eservalarray), std::begin(o_eservalarray), std::end(o_eservalarray)); + BOOST_CHECK_EQUAL_COLLECTIONS(std::begin(i_esplvalarray), std::end(i_esplvalarray), std::begin(o_esplvalarray), std::end(o_esplvalarray)); + } } BOOST_AUTO_TEST_CASE(binary_valarray) { - test_valarray(); + test_valarray(); } BOOST_AUTO_TEST_CASE(portable_binary_valarray) { - test_valarray(); + test_valarray(); } BOOST_AUTO_TEST_CASE(xml_valarray) { - test_valarray(); + test_valarray(); } BOOST_AUTO_TEST_CASE(json_valarray) { - test_valarray(); + test_valarray(); } From 774fe618cb597e567c013487f9be9d11092c514e Mon Sep 17 00:00:00 2001 From: Shane Grant Date: Sat, 2 May 2015 23:19:39 -0700 Subject: [PATCH 7/7] tested working on vs --- vs2013/unittests/unittests.vcxproj | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/vs2013/unittests/unittests.vcxproj b/vs2013/unittests/unittests.vcxproj index 951f45bab..2a8419298 100644 --- a/vs2013/unittests/unittests.vcxproj +++ b/vs2013/unittests/unittests.vcxproj @@ -1,4 +1,4 @@ - + @@ -104,7 +104,7 @@ - $(SolutionDir)\..\include;$(SolutionDir)\..\unittests;D:\Libs\boost_1_58_0;$(IncludePath) + $(SolutionDir)\..\include;$(SolutionDir)\..\unittests;E:\Boost\include\boost-1_55;$(IncludePath) E:\Boost\lib;$(LibraryPath) @@ -112,7 +112,7 @@ E:\Boost\lib\x64;$(LibraryPath) - $(SolutionDir)\..\include;$(SolutionDir)\..\unittests;D:\Libs\boost_1_58_0;$(IncludePath) + $(SolutionDir)\..\include;$(SolutionDir)\..\unittests;E:\Boost\include\boost-1_55;$(IncludePath) E:\Boost\lib;$(LibraryPath)