From 0a262ece48a8f38e2d3d29d7f6d2943ddeaf4c28 Mon Sep 17 00:00:00 2001 From: Shane Grant Date: Tue, 1 Nov 2016 11:36:22 -0700 Subject: [PATCH] More tests split, switch to CHECk_EQ over CHECK see #139 --- unittests/boost_variant.cpp | 51 +++--------------- unittests/boost_variant.hpp | 70 ++++++++++++++++++++++++ unittests/chrono.cpp | 87 +++--------------------------- unittests/chrono.hpp | 105 ++++++++++++++++++++++++++++++++++++ unittests/common.hpp | 1 - unittests/complex.cpp | 60 +++------------------ unittests/complex.hpp | 77 ++++++++++++++++++++++++++ 7 files changed, 272 insertions(+), 179 deletions(-) create mode 100644 unittests/boost_variant.hpp create mode 100644 unittests/chrono.hpp create mode 100644 unittests/complex.hpp diff --git a/unittests/boost_variant.cpp b/unittests/boost_variant.cpp index 3bb9d75f2..7e073b8f4 100644 --- a/unittests/boost_variant.cpp +++ b/unittests/boost_variant.cpp @@ -24,64 +24,29 @@ (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 +#define DOCTEST_CONFIG_IMPLEMENT_WITH_MAIN +#include "boost_variant.hpp" -template -void test_boost_variant() -{ - std::random_device rd; - std::mt19937 gen(rd()); - - boost::variant o_bv1 = random_value(gen); - boost::variant o_bv2 = random_value(gen); - boost::variant o_bv3 = random_basic_string(gen); - - std::ostringstream os; - { - OArchive oar(os); - - oar(o_bv1); - oar(o_bv2); - oar(o_bv3); - } - - decltype(o_bv1) i_bv1; - decltype(o_bv2) i_bv2; - decltype(o_bv3) i_bv3; +TEST_SUITE("boost_variant"); - std::istringstream is(os.str()); - { - IArchive iar(is); - - iar(i_bv1); - iar(i_bv2); - iar(i_bv3); - } - - BOOST_CHECK_EQUAL( boost::get(i_bv1), boost::get(o_bv1) ); - BOOST_CHECK_CLOSE( boost::get(i_bv2), boost::get(o_bv2), 1e-5 ); - BOOST_CHECK_EQUAL( boost::get(i_bv3), boost::get(o_bv3) ); -} - -BOOST_AUTO_TEST_CASE( binary_boost_variant ) +TEST_CASE("binary_boost_variant") { test_boost_variant(); } -BOOST_AUTO_TEST_CASE( portable_binary_boost_variant ) +TEST_CASE("portable_binary_boost_variant") { test_boost_variant(); } -BOOST_AUTO_TEST_CASE( xml_boost_variant ) +TEST_CASE("xml_boost_variant") { test_boost_variant(); } -BOOST_AUTO_TEST_CASE( json_boost_variant ) +TEST_CASE("json_boost_variant") { test_boost_variant(); } - +TEST_SUITE_END(); diff --git a/unittests/boost_variant.hpp b/unittests/boost_variant.hpp new file mode 100644 index 000000000..bedb6a89a --- /dev/null +++ b/unittests/boost_variant.hpp @@ -0,0 +1,70 @@ +/* + Copyright (c) 2015, Kyle Fleming + 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. +*/ +#ifndef CEREAL_TEST_BOOST_VARIANT_H_ +#define CEREAL_TEST_BOOST_VARIANT_H_ + +#include "common.hpp" +#include + +template inline +void test_boost_variant() +{ + std::random_device rd; + std::mt19937 gen(rd()); + + boost::variant o_bv1 = random_value(gen); + boost::variant o_bv2 = random_value(gen); + boost::variant o_bv3 = random_basic_string(gen); + + std::ostringstream os; + { + OArchive oar(os); + + oar(o_bv1); + oar(o_bv2); + oar(o_bv3); + } + + decltype(o_bv1) i_bv1; + decltype(o_bv2) i_bv2; + decltype(o_bv3) i_bv3; + + std::istringstream is(os.str()); + { + IArchive iar(is); + + iar(i_bv1); + iar(i_bv2); + iar(i_bv3); + } + + CHECK_EQ( boost::get(i_bv1), boost::get(o_bv1) ); + CHECK_EQ( boost::get(i_bv2), doctest::Approx(boost::get(o_bv2)).epsilon(1e-5) ); + CHECK_EQ( boost::get(i_bv3), boost::get(o_bv3) ); +} + +#endif // CEREAL_TEST_BOOST_VARIANT_H_ diff --git a/unittests/chrono.cpp b/unittests/chrono.cpp index c71238a6c..32337eb71 100644 --- a/unittests/chrono.cpp +++ b/unittests/chrono.cpp @@ -24,100 +24,25 @@ (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 +#define DOCTEST_CONFIG_IMPLEMENT_WITH_MAIN +#include "chrono.hpp" -template -void test_chrono() -{ - for(int ii=0; ii<100; ++ii) - { - auto o_timePoint1 = std::chrono::system_clock::now(); - #ifndef CEREAL_OLDER_GCC - auto o_timePoint2 = std::chrono::steady_clock::now(); - #endif // CEREAL_OLDER_GCC - auto o_timePoint3 = std::chrono::high_resolution_clock::now(); - - auto o_duration1 = std::chrono::system_clock::now() - o_timePoint1; - #ifndef CEREAL_OLDER_GCC - auto o_duration2 = std::chrono::steady_clock::now() - o_timePoint2; - #endif // CEREAL_OLDER_GCC - auto o_duration3 = std::chrono::high_resolution_clock::now() - o_timePoint3; - - std::ostringstream os; - { - OArchive oar(os); - - oar(o_timePoint1); - #ifndef CEREAL_OLDER_GCC - oar(o_timePoint2); - #endif // CEREAL_OLDER_GCC - oar(o_timePoint3); - oar(o_duration1); - #ifndef CEREAL_OLDER_GCC - oar(o_duration2); - #endif // CEREAL_OLDER_GCC - oar(o_duration3); - } - - decltype(o_timePoint1) i_timePoint1; - #ifndef CEREAL_OLDER_GCC - decltype(o_timePoint2) i_timePoint2; - #endif // CEREAL_OLDER_GCC - decltype(o_timePoint3) i_timePoint3; - decltype(o_duration1) i_duration1; - #ifndef CEREAL_OLDER_GCC - decltype(o_duration2) i_duration2; - #endif // CEREAL_OLDER_GCC - decltype(o_duration3) i_duration3; - - std::istringstream is(os.str()); - { - IArchive iar(is); - - iar(i_timePoint1); - #ifndef CEREAL_OLDER_GCC - iar(i_timePoint2); - #endif // CEREAL_OLDER_GCC - iar(i_timePoint3); - iar(i_duration1); - #ifndef CEREAL_OLDER_GCC - iar(i_duration2); - #endif // CEREAL_OLDER_GCC - iar(i_duration3); - } - - BOOST_CHECK( o_timePoint1 == i_timePoint1 ); - #ifndef CEREAL_OLDER_GCC - BOOST_CHECK( o_timePoint2 == i_timePoint2 ); - #endif // CEREAL_OLDER_GCC - BOOST_CHECK( o_timePoint3 == i_timePoint3 ); - BOOST_CHECK( o_duration1 == i_duration1 ); - #ifndef CEREAL_OLDER_GCC - BOOST_CHECK( o_duration2 == i_duration2 ); - #endif // CEREAL_OLDER_GCC - BOOST_CHECK( o_duration3 == i_duration3 ); - } -} - -BOOST_AUTO_TEST_CASE( binary_chrono ) +TEST_CASE("binary_chrono") { test_chrono(); } -BOOST_AUTO_TEST_CASE( portable_binary_chrono ) +TEST_CASE("portable_binary_chrono") { test_chrono(); } -BOOST_AUTO_TEST_CASE( xml_chrono ) +TEST_CASE("xml_chrono") { test_chrono(); } -BOOST_AUTO_TEST_CASE( json_chrono ) +TEST_CASE("json_chrono") { test_chrono(); } - - diff --git a/unittests/chrono.hpp b/unittests/chrono.hpp new file mode 100644 index 000000000..3e66623a5 --- /dev/null +++ b/unittests/chrono.hpp @@ -0,0 +1,105 @@ +/* + 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. +*/ +#ifndef CEREAL_TEST_CHRONO_H_ +#define CEREAL_TEST_CHRONO_H_ + +#include "common.hpp" + +template inline +void test_chrono() +{ + for(int ii=0; ii<100; ++ii) + { + auto o_timePoint1 = std::chrono::system_clock::now(); + #ifndef CEREAL_OLDER_GCC + auto o_timePoint2 = std::chrono::steady_clock::now(); + #endif // CEREAL_OLDER_GCC + auto o_timePoint3 = std::chrono::high_resolution_clock::now(); + + auto o_duration1 = std::chrono::system_clock::now() - o_timePoint1; + #ifndef CEREAL_OLDER_GCC + auto o_duration2 = std::chrono::steady_clock::now() - o_timePoint2; + #endif // CEREAL_OLDER_GCC + auto o_duration3 = std::chrono::high_resolution_clock::now() - o_timePoint3; + + std::ostringstream os; + { + OArchive oar(os); + + oar(o_timePoint1); + #ifndef CEREAL_OLDER_GCC + oar(o_timePoint2); + #endif // CEREAL_OLDER_GCC + oar(o_timePoint3); + oar(o_duration1); + #ifndef CEREAL_OLDER_GCC + oar(o_duration2); + #endif // CEREAL_OLDER_GCC + oar(o_duration3); + } + + decltype(o_timePoint1) i_timePoint1; + #ifndef CEREAL_OLDER_GCC + decltype(o_timePoint2) i_timePoint2; + #endif // CEREAL_OLDER_GCC + decltype(o_timePoint3) i_timePoint3; + decltype(o_duration1) i_duration1; + #ifndef CEREAL_OLDER_GCC + decltype(o_duration2) i_duration2; + #endif // CEREAL_OLDER_GCC + decltype(o_duration3) i_duration3; + + std::istringstream is(os.str()); + { + IArchive iar(is); + + iar(i_timePoint1); + #ifndef CEREAL_OLDER_GCC + iar(i_timePoint2); + #endif // CEREAL_OLDER_GCC + iar(i_timePoint3); + iar(i_duration1); + #ifndef CEREAL_OLDER_GCC + iar(i_duration2); + #endif // CEREAL_OLDER_GCC + iar(i_duration3); + } + + CHECK_EQ( o_timePoint1, i_timePoint1 ); + #ifndef CEREAL_OLDER_GCC + CHECK_EQ( o_timePoint2, i_timePoint2 ); + #endif // CEREAL_OLDER_GCC + CHECK_EQ( o_timePoint3, i_timePoint3 ); + CHECK_EQ( o_duration1, i_duration1 ); + #ifndef CEREAL_OLDER_GCC + CHECK_EQ( o_duration2, i_duration2 ); + #endif // CEREAL_OLDER_GCC + CHECK_EQ( o_duration3, i_duration3 ); + } +} + +#endif // CEREAL_TEST_CHRONO_H_ diff --git a/unittests/common.hpp b/unittests/common.hpp index 2bf0bbdab..c417f19e0 100644 --- a/unittests/common.hpp +++ b/unittests/common.hpp @@ -47,7 +47,6 @@ #include #include #include -#include #include #include diff --git a/unittests/complex.cpp b/unittests/complex.cpp index 786e0da10..4a418532c 100644 --- a/unittests/complex.cpp +++ b/unittests/complex.cpp @@ -24,73 +24,25 @@ (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 +#define DOCTEST_CONFIG_IMPLEMENT_WITH_MAIN +#include "complex.hpp" -template -void test_complex() -{ - std::random_device rd; - std::mt19937 gen(rd()); - - auto rngF = [&](){ return random_value(gen); }; - auto rngD = [&](){ return random_value(gen); }; - auto rngLD = [&](){ return random_value(gen); }; - - for(int ii=0; ii<100; ++ii) - { - std::complex o_float( rngF(), rngF() ); - std::complex o_double( rngD(), rngD() ); - std::complex o_ldouble( rngLD(), rngLD() ); - - std::ostringstream os; - { - OArchive oar(os); - - oar(o_float); - oar(o_double); - oar(o_ldouble); - } - - std::complex i_float; - std::complex i_double; - std::complex i_ldouble; - - std::istringstream is(os.str()); - { - IArchive iar(is); - - iar(i_float); - iar(i_double); - iar(i_ldouble); - } - - BOOST_CHECK_EQUAL( o_float, i_float ); - BOOST_CHECK_CLOSE( o_double.real(), i_double.real(), 1e-5); - BOOST_CHECK_CLOSE( o_double.imag(), i_double.imag(), 1e-5); - BOOST_CHECK_CLOSE( o_ldouble.real(), i_ldouble.real(), 1e-5); - BOOST_CHECK_CLOSE( o_ldouble.imag(), i_ldouble.imag(), 1e-5); - } -} - -BOOST_AUTO_TEST_CASE( binary_complex ) +TEST_CASE("binary_complex") { test_complex(); } -BOOST_AUTO_TEST_CASE( portable_binary_complex ) +TEST_CASE("portable_binary_complex") { test_complex(); } -BOOST_AUTO_TEST_CASE( xml_complex ) +TEST_CASE("xml_complex") { test_complex(); } -BOOST_AUTO_TEST_CASE( json_complex ) +TEST_CASE("json_complex") { test_complex(); } - - diff --git a/unittests/complex.hpp b/unittests/complex.hpp new file mode 100644 index 000000000..1f2387900 --- /dev/null +++ b/unittests/complex.hpp @@ -0,0 +1,77 @@ +/* + 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. +*/ +#ifndef CEREAL_TEST_COMPLEX_H_ +#define CEREAL_TEST_COMPLEX_H_ +#include "common.hpp" + +template inline +void test_complex() +{ + std::random_device rd; + std::mt19937 gen(rd()); + + auto rngF = [&](){ return random_value(gen); }; + auto rngD = [&](){ return random_value(gen); }; + auto rngLD = [&](){ return random_value(gen); }; + + for(int ii=0; ii<100; ++ii) + { + std::complex o_float( rngF(), rngF() ); + std::complex o_double( rngD(), rngD() ); + std::complex o_ldouble( rngLD(), rngLD() ); + + std::ostringstream os; + { + OArchive oar(os); + + oar(o_float); + oar(o_double); + oar(o_ldouble); + } + + std::complex i_float; + std::complex i_double; + std::complex i_ldouble; + + std::istringstream is(os.str()); + { + IArchive iar(is); + + iar(i_float); + iar(i_double); + iar(i_ldouble); + } + + CHECK_EQ( o_float, i_float ); + CHECK_EQ( o_double.real(), doctest::Approx(i_double.real()).epsilon(1e-5) ); + CHECK_EQ( o_double.imag(), doctest::Approx(i_double.imag()).epsilon(1e-5) ); + CHECK_EQ( o_ldouble.real(), doctest::Approx(i_ldouble.real()).epsilon(1e-5) ); + CHECK_EQ( o_ldouble.imag(), doctest::Approx(i_ldouble.imag()).epsilon(1e-5) ); + } +} + +#endif // CEREAL_TEST_COMPLEX_H_