source: trunk/test/weighted_iterator_archetype.cc @ 3379

// $Id: weighted_iterator_archetype.cc 3379 2015-02-13 11:22:36Z peter $

/*
  Copyright (C) 2014, 2015 Peter Johansson

  This file is part of the yat library, http://dev.thep.lu.se/yat

  The yat library is free software; you can redistribute it and/or
  modify it under the terms of the GNU General Public License as
  published by the Free Software Foundation; either version 3 of the
  License, or (at your option) any later version.

  The yat library is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with yat. If not, see <http://www.gnu.org/licenses/>.
*/

// Test that class test::weighted_iterator_archetype works as
// intended. If the class does not work on a system (and this test
// fails), it probably cause many other failures and it probably a
// good idea to fix this test first before the other failures (which
// might be bogus).


#include <config.h>

#include "Suite.h"
#include "weighted_iterator_archetype.h"

#include "yat/utility/concept_check.h"
#include "yat/utility/iterator_traits.h"

#include <boost/iterator/iterator_archetypes.hpp>
#include <boost/iterator/iterator_categories.hpp>
#include <boost/iterator/iterator_concepts.hpp>
#include <boost/static_assert.hpp>
#include <boost/type_traits.hpp>

using namespace theplu::yat;
using namespace boost::iterator_archetypes;

template<typename Iterator>
void test_const_access(Iterator iterator)
{
  BOOST_CONCEPT_ASSERT((boost_concepts::ReadableIterator<Iterator>));
}


template<typename Iterator>
void test_access(Iterator iterator)
{
  BOOST_CONCEPT_ASSERT((boost_concepts::ReadableIterator<Iterator>));
  BOOST_CONCEPT_ASSERT((boost_concepts::WritableIterator<Iterator>));
}


template<typename Iterator>
void test_traversal(Iterator iterator, boost::incrementable_traversal_tag)
{
  BOOST_CONCEPT_ASSERT((boost_concepts::IncrementableIterator<Iterator>));
}


template<typename Iterator>
void test_traversal(Iterator iterator, boost::single_pass_traversal_tag)
{
  BOOST_CONCEPT_ASSERT((boost_concepts::SinglePassIterator<Iterator>));
}


template<typename Iterator>
void test_traversal(Iterator iterator, boost::forward_traversal_tag)
{
  BOOST_CONCEPT_ASSERT((boost_concepts::ForwardTraversal<Iterator>));
}


template<typename Iterator>
void test_traversal(Iterator iterator, boost::bidirectional_traversal_tag)
{
  BOOST_CONCEPT_ASSERT((boost_concepts::BidirectionalTraversal<Iterator>));
}


template<typename Iterator>
void test_traversal(Iterator iterator, boost::random_access_traversal_tag)
{
  BOOST_CONCEPT_ASSERT((boost_concepts::RandomAccessTraversal<Iterator>));
}


template<typename Iterator, typename ConstIterator>
void test_interoperability(Iterator i, ConstIterator ci,
                           boost::single_pass_traversal_tag)
{
  BOOST_CONCEPT_ASSERT((boost_concepts::InteroperableIterator<Iterator, ConstIterator>));
}


template<typename Iterator, typename ConstIterator>
void test_interoperability(Iterator i, ConstIterator ci,
                           boost::incrementable_traversal_tag)
{
}


template<typename TraversalCategory>
void test1(void)
{
  test::ctor_arg arg;
  using boost::iterator_archetypes::readable_iterator_t;
  typedef test::weighted_iterator_archetype<readable_iterator_t,
                                            TraversalCategory>
    ConstIterator;
  typedef typename utility::weighted_iterator_traits<ConstIterator>::type tag1;
  using utility::weighted_iterator_tag;
  using boost::is_same;
  BOOST_STATIC_ASSERT((is_same<tag1, weighted_iterator_tag>::type::value));
  ConstIterator ci(arg);
  test_const_access(ci);
  TraversalCategory traversal;
  test_traversal(ci, traversal);

  using boost::iterator_archetypes::readable_writable_iterator_t;
  typedef test::weighted_iterator_archetype<readable_writable_iterator_t,
                                            TraversalCategory> Iterator;

  typedef typename utility::weighted_iterator_traits<Iterator>::type tag2;
  BOOST_STATIC_ASSERT((is_same<tag2, weighted_iterator_tag>::type::value));
  Iterator i(arg);
  test_access(i);
  test_traversal(i, traversal);

  test_interoperability(i, ci, traversal);
}


int main(void)
{
  // this is a compilation test - do not run
  if (false) {
    //test1<boost::incrementable_traversal_tag>();
    test1<boost::single_pass_traversal_tag>();
    test1<boost::forward_traversal_tag>();
    test1<boost::bidirectional_traversal_tag>();
    test1<boost::random_access_traversal_tag>();
  }

  return 0;
}