boost_mirror/geometry
1
0
Fork 0
mirror of https://github.com/boostorg/geometry.git synced 2025-05-09 23:24:02 +00:00
Code Issues Packages Projects Releases Wiki Activity

[test][util][tuples] Add tests.

Browse Source
This commit is contained in:
Adam Wulkiewicz 2019-11-18 23:52:52 +01:00
parent fa5ce6d08d
commit 7efff6a996
2 changed files with 144 additions and 2 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
test/util/Jamfile.v2
View File

@ -4,8 +4,8 @@
# Copyright (c) 2008-2015 Bruno Lalande, Paris, France.
# Copyright (c) 2009-2015 Mateusz Loskot, London, UK.
#
# This file was modified by Oracle on 2014, 2015.
# Modifications copyright (c) 2014-2015, Oracle and/or its affiliates.
# This file was modified by Oracle on 2014, 2015, 2019.
# Modifications copyright (c) 2014-2019, Oracle and/or its affiliates.
#
# Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
# Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
@ -25,5 +25,6 @@ test-suite boost-geometry-util
[ run range.cpp : : : : util_range ]
[ run rational.cpp : : : : util_rational ]
[ run select_most_precise.cpp : : : : util_select_most_precise ]
[ run tuples.cpp : : : : util_tuples ]
[ run write_dsv.cpp : : : : util_write_dsv ]
;

141
test/util/tuples.cpp Normal file
View File

@ -0,0 +1,141 @@
// Boost.Geometry
// Unit Test
// Copyright (c) 2019 Oracle and/or its affiliates.
// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
// Use, modification and distribution is subject to 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 <geometry_test_common.hpp>
#include <boost/geometry/util/tuples.hpp>
namespace bt = boost::tuples;
namespace bgt = boost::geometry::tuples;
namespace bm = boost::mpl;
template <typename T>
struct is_double
: boost::is_same<T, double>
{};
template <typename T>
struct is_float
: boost::is_same<T, float>
{};
template <typename Tuple>
struct is_boost_tuple
: boost::integral_constant<bool, false>
{};
template <class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9>
struct is_boost_tuple<boost::tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> >
: boost::integral_constant<bool, true>
{};
template <typename Tuple>
struct is_boost_tuples_cons
: boost::integral_constant<bool, false>
{};
template <typename HT, typename TT>
struct is_boost_tuples_cons<boost::tuples::cons<HT, TT> >
: boost::integral_constant<bool, true>
{};
template <typename Tuple>
struct is_std_pair
: boost::integral_constant<bool, false>
{};
template <typename F, typename S>
struct is_std_pair<std::pair<F, S> >
: boost::integral_constant<bool, true>
{};
#if !defined(BOOST_NO_CXX11_HDR_TUPLE) && !defined(BOOST_NO_VARIADIC_TEMPLATES)
template <typename Tuple>
struct is_std_tuple
: boost::integral_constant<bool, false>
{};
template <typename ...Ts>
struct is_std_tuple<std::tuple<Ts...> >
: boost::integral_constant<bool, true>
{};
#endif
template <typename Tuple>
void test_all()
{
typedef Tuple tuple_id;
tuple_id tup_id(1, 2.0);
BOOST_CHECK_EQUAL((bgt::get<0>(tup_id)), 1);
BOOST_CHECK_EQUAL((bgt::get<1>(tup_id)), 2.0);
BOOST_CHECK_EQUAL(int(bgt::size<tuple_id>::value), 2);
BOOST_CHECK_EQUAL((bgt::find_index_if<tuple_id, is_double>::value), 1);
BOOST_CHECK((boost::is_same<typename bgt::find_if<tuple_id, is_double>::type, double>::value));
BOOST_CHECK_EQUAL((bgt::find_index_if<tuple_id, is_float>::value), 2);
BOOST_CHECK((boost::is_same<typename bgt::find_if<tuple_id, is_float>::type, boost::tuples::null_type>::value));
typedef typename bgt::push_back<tuple_id, float>::type tuple_idf;
tuple_idf tup_idf = bgt::push_back<tuple_id, float>::apply(tup_id, 3.0f);
BOOST_CHECK_EQUAL((bgt::get<0>(tup_idf)), 1);
BOOST_CHECK_EQUAL((bgt::get<1>(tup_idf)), 2.0);
BOOST_CHECK_EQUAL((bgt::get<2>(tup_idf)), 3.0f);
BOOST_CHECK_EQUAL(int(bgt::size<tuple_idf>::value), 3);
BOOST_CHECK_EQUAL((bgt::find_index_if<tuple_idf, is_float>::value), 2);
BOOST_CHECK((boost::is_same<typename bgt::find_if<tuple_idf, is_float>::type, float>::value));
#if !defined(BOOST_NO_CXX11_HDR_TUPLE) && !defined(BOOST_NO_VARIADIC_TEMPLATES)
BOOST_CHECK((
(is_boost_tuple<tuple_id>::value && is_boost_tuples_cons<tuple_idf>::value)
|| (!is_boost_tuple<tuple_id>::value && is_std_tuple<tuple_idf>::value)
));
#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
tup_idf = bgt::push_back<tuple_id, float>::apply(std::move(tup_id), 3.0f);
BOOST_CHECK_EQUAL((bgt::get<0>(tup_idf)), 1);
BOOST_CHECK_EQUAL((bgt::get<1>(tup_idf)), 2.0);
BOOST_CHECK_EQUAL((bgt::get<2>(tup_idf)), 3.0f);
#endif
#else
BOOST_CHECK((is_boost_tuples_cons<tuple_idf>::type, float>::value));
#endif
}
int test_main(int, char* [])
{
test_all<boost::tuple<int, double> >();
test_all<std::pair<int, double> >();
#if !defined(BOOST_NO_CXX11_HDR_TUPLE) && !defined(BOOST_NO_VARIADIC_TEMPLATES)
test_all<std::tuple<int, double> >();
#endif
return 0;
}