mirror of
https://github.com/boostorg/spirit.git
synced 2026-01-19 04:42:11 +00:00
214 lines
7.6 KiB
C++
214 lines
7.6 KiB
C++
/*=============================================================================
|
|
Copyright (c) 2001-2003 Joel de Guzman
|
|
|
|
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 <iostream>
|
|
#include <boost/detail/lightweight_test.hpp>
|
|
#include <boost/type_traits/is_same.hpp>
|
|
#include <boost/spirit/fusion/sequence/tuple.hpp>
|
|
#include <boost/spirit/fusion/iterator/tuple_iterator.hpp>
|
|
#include <boost/spirit/fusion/iterator/deref.hpp>
|
|
#include <boost/spirit/fusion/iterator/next.hpp>
|
|
#include <boost/spirit/fusion/iterator/prior.hpp>
|
|
#include <boost/spirit/fusion/iterator/equal_to.hpp>
|
|
#include <boost/spirit/fusion/sequence/begin.hpp>
|
|
#include <boost/spirit/fusion/sequence/end.hpp>
|
|
#include <boost/spirit/fusion/sequence/tuple_element.hpp>
|
|
#include <boost/spirit/fusion/sequence/get.hpp>
|
|
//#include <boost/spirit/fusion/distance.hpp>
|
|
//#include <boost/spirit/fusion/advance.hpp>
|
|
//#include <boost/spirit/fusion/get_pointer.hpp>
|
|
//#include <boost/spirit/fusion/value_of.hpp>
|
|
//#include <boost/spirit/fusion/pointer_of.hpp>
|
|
//#include <boost/spirit/fusion/reference_of.hpp>
|
|
//#include <boost/spirit/fusion/is_readable.hpp>
|
|
//#include <boost/spirit/fusion/is_writable.hpp>
|
|
//#include <boost/spirit/fusion/category_of.hpp>
|
|
|
|
int
|
|
main()
|
|
{
|
|
using namespace boost::fusion;
|
|
using namespace boost;
|
|
|
|
/// Testing the tuple_iterator
|
|
|
|
{ // testing deref, next, prior, begin, end
|
|
|
|
char const* s = "Hello";
|
|
typedef tuple<int, char, double, char const*> tuple_type;
|
|
tuple_type t(1, 'x', 3.3, s);
|
|
tuple_iterator<0, tuple_type> i(t);
|
|
|
|
#if BOOST_WORKAROUND(BOOST_MSVC, <= 1200)
|
|
// ?%$# VC6 I don't know why this is needed! $$$LOOK$$$
|
|
//This is no longer needed...
|
|
//next(i);
|
|
#endif
|
|
|
|
BOOST_TEST(*i == 1);
|
|
BOOST_TEST(*next(i) == 'x');
|
|
BOOST_TEST(*next(next(i)) == 3.3);
|
|
BOOST_TEST(*next(next(next(i))) == s);
|
|
|
|
next(next(next(next(i)))); // end
|
|
|
|
#ifdef FUSION_TEST_COMPILE_FAIL
|
|
next(next(next(next(next(i))))); // past the end: must not compile
|
|
#endif
|
|
|
|
BOOST_TEST(*prior(next(next(next(i)))) == 3.3);
|
|
BOOST_TEST(*prior(prior(next(next(next(i))))) == 'x');
|
|
BOOST_TEST(*prior(prior(prior(next(next(next(i)))))) == 1);
|
|
|
|
BOOST_TEST(*begin(t) == 1);
|
|
BOOST_TEST(*prior(end(t)) == s);
|
|
|
|
*i = 3;
|
|
BOOST_TEST(*i == 3);
|
|
BOOST_TEST(*i == get<0>(t));
|
|
}
|
|
|
|
{ // Testing const tuple and const tuple_iterator
|
|
|
|
char const* s = "Hello";
|
|
typedef tuple<int, char, double, char const*> const tuple_type;
|
|
tuple_type t(1, 'x', 3.3, s);
|
|
tuple_iterator<0, tuple_type> i(t);
|
|
|
|
BOOST_TEST(*i == 1);
|
|
BOOST_TEST(*next(i) == 'x');
|
|
BOOST_TEST(*begin(t) == 1);
|
|
BOOST_TEST(*prior(end(t)) == s);
|
|
|
|
#ifdef FUSION_TEST_COMPILE_FAIL
|
|
*i = 3; // must not compile
|
|
#endif
|
|
}
|
|
|
|
{ // Testing tuple equality
|
|
|
|
typedef tuple<int, char, double, char const*> tuple_type;
|
|
typedef tuple_iterator<0, tuple_type> ti1;
|
|
typedef tuple_iterator<0, tuple_type const> ti2;
|
|
BOOST_STATIC_ASSERT((meta::equal_to<ti1 const, ti1>::value));
|
|
BOOST_STATIC_ASSERT((meta::equal_to<ti1, ti1 const>::value));
|
|
BOOST_STATIC_ASSERT((meta::equal_to<ti1, ti2>::value));
|
|
BOOST_STATIC_ASSERT((meta::equal_to<ti1 const, ti2>::value));
|
|
BOOST_STATIC_ASSERT((meta::equal_to<ti1, ti2 const>::value));
|
|
BOOST_STATIC_ASSERT((meta::equal_to<ti1 const, ti2 const>::value));
|
|
}
|
|
//
|
|
// { // Testing distance
|
|
//
|
|
// typedef tuple<int, char, double, char const*> tuple_type;
|
|
// tuple_type t(1, 'x', 3.3, "Hello");
|
|
//
|
|
// BOOST_STATIC_ASSERT((result_of_distance<
|
|
// tuple_iterator<0, tuple_type>
|
|
// , tuple_iterator<4, tuple_type> >::type::value == 4));
|
|
//
|
|
// BOOST_TEST(distance(begin(t), end(t)).value == 4);
|
|
// }
|
|
//
|
|
// { // Testing advance
|
|
//
|
|
// typedef tuple<int, char, double, char const*> tuple_type;
|
|
// tuple_type t(1, 'x', 3.3, "Hello");
|
|
//
|
|
// BOOST_TEST(*advance<0>(begin(t)) == get<0>(t));
|
|
// BOOST_TEST(*advance<1>(begin(t)) == get<1>(t));
|
|
// BOOST_TEST(*advance<2>(begin(t)) == get<2>(t));
|
|
// BOOST_TEST(*advance<3>(begin(t)) == get<3>(t));
|
|
//
|
|
// BOOST_TEST(*advance<-1>(end(t)) == get<3>(t));
|
|
// BOOST_TEST(*advance<-2>(end(t)) == get<2>(t));
|
|
// BOOST_TEST(*advance<-3>(end(t)) == get<1>(t));
|
|
// BOOST_TEST(*advance<-4>(end(t)) == get<0>(t));
|
|
//
|
|
// BOOST_TEST(&*advance<0>(begin(t)) == &get<0>(t));
|
|
// BOOST_TEST(&*advance<1>(begin(t)) == &get<1>(t));
|
|
// BOOST_TEST(&*advance<2>(begin(t)) == &get<2>(t));
|
|
// BOOST_TEST(&*advance<3>(begin(t)) == &get<3>(t));
|
|
// }
|
|
//
|
|
|
|
#if !BOOST_WORKAROUND(__BORLANDC__, <= 0x551)
|
|
// #$%&@ Borland IS SO DUMB!!! #$%&@
|
|
{
|
|
typedef tuple<int, int> tuple_type;
|
|
typedef meta::begin<tuple_type>::type begin_type;
|
|
typedef meta::end<tuple_type>::type end_type;
|
|
typedef meta::next<begin_type>::type i1;
|
|
typedef meta::next<i1>::type i2;
|
|
|
|
BOOST_STATIC_ASSERT((is_same<end_type, i2>::value));
|
|
}
|
|
#endif
|
|
|
|
{ // Testing constructing tuples from iterators
|
|
|
|
tuple<int, char, double> t1(1, 'x', 3.3);
|
|
|
|
tuple<long, int, double> t2(begin(t1));
|
|
BOOST_TEST(get<0>(t2) == get<0>(t1));
|
|
BOOST_TEST(get<1>(t2) == get<1>(t1));
|
|
BOOST_TEST(get<2>(t2) == get<2>(t1));
|
|
|
|
tuple<char, double> t3(next(begin(t1)));
|
|
BOOST_TEST(get<0>(t3) == get<1>(t1));
|
|
BOOST_TEST(get<1>(t3) == get<2>(t1));
|
|
|
|
tuple<double> t4(prior(end(t1)));
|
|
BOOST_TEST(get<0>(t4) == get<2>(t1));
|
|
|
|
tuple<char, char, char, char, char, char, char, char, char> t5;
|
|
tuple<int, int, int, int, int, int, int, int, int> t6(begin(t5));
|
|
(void)t6;
|
|
}
|
|
|
|
{ // Testing tuple iterator value, reference, pointer, is_readable,
|
|
// is_writable, meta::deref, result_of_get_pointer
|
|
|
|
typedef tuple<int, char&> tuple_type;
|
|
typedef tuple_iterator<0, tuple_type> i0;
|
|
typedef tuple_iterator<1, tuple_type> i1;
|
|
typedef tuple_iterator<1, tuple_type const> i2;
|
|
|
|
BOOST_STATIC_ASSERT((
|
|
is_same<tuple_element<0, tuple_type>::type, int>::value));
|
|
|
|
BOOST_STATIC_ASSERT((
|
|
is_same<tuple_element<1, tuple_type>::type, char&>::value));
|
|
|
|
// BOOST_STATIC_ASSERT((
|
|
// is_same<category_of<i0>::type, random_access_traversal_tag>::value));
|
|
//
|
|
// BOOST_STATIC_ASSERT(is_readable<i0>::value);
|
|
// BOOST_STATIC_ASSERT(is_writable<i0>::value);
|
|
// BOOST_STATIC_ASSERT(is_readable<i2>::value);
|
|
// BOOST_STATIC_ASSERT(!is_writable<i2>::value);
|
|
|
|
BOOST_STATIC_ASSERT((is_same<meta::deref<i0>::type, int&>::value));
|
|
BOOST_STATIC_ASSERT((is_same<meta::deref<i1>::type, char&>::value));
|
|
|
|
// BOOST_STATIC_ASSERT((is_same<result_of_get_pointer<i0>::type, int*>::value));
|
|
// BOOST_STATIC_ASSERT((is_same<result_of_get_pointer<i1>::type, char*>::value));
|
|
//
|
|
// BOOST_STATIC_ASSERT((is_same<value_of<i0>::type, int>::value));
|
|
// BOOST_STATIC_ASSERT((is_same<value_of<i1>::type, char&>::value));
|
|
//
|
|
// BOOST_STATIC_ASSERT((is_same<reference_of<i0>::type, int&>::value));
|
|
// BOOST_STATIC_ASSERT((is_same<reference_of<i1>::type, char&>::value));
|
|
//
|
|
// BOOST_STATIC_ASSERT((is_same<pointer_of<i0>::type, int*>::value));
|
|
// BOOST_STATIC_ASSERT((is_same<pointer_of<i1>::type, char*>::value));
|
|
}
|
|
|
|
return boost::report_errors();
|
|
}
|
|
|