/*
 * bufilt -- A Boost.Units C++ compiler messages filter
 *
 * Copyright (C) 2008--2011 Torsten Maehne
 *
 * Distributed under 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)
 */

/*!
 * \file    test_boost_fusion_adaption_with_karma.cpp
 *
 * \brief   Test of Boost.Fusion adapted ADTs and structs in Boost.Spirit.Karma rules.
 *
 * \author  Torsten Maehne
 * \date    2011-08-12
 * \version $Id$
 */
#define BOOST_TEST_MODULE test_boost_rational_adaption
#include <boost/test/included/unit_test.hpp>
#include <boost/test/output_test_stream.hpp>
#include <boost/rational.hpp>
#include <boost/version.hpp>
#if BOOST_VERSION < 104500
// Until Boost 1.44 use BOOST_FUSION_ADAPT_CLASS
#include <boost/fusion/include/adapt_class.hpp>
#else
// Since Boost 1.45 BOOST_FUSION_ADAPT_CLASS is named BOOST_FUSION_ADAPT_ADT
#include <boost/fusion/include/adapt_adt.hpp>
#endif

#include <boost/fusion/include/adapt_struct.hpp>
// Include only the strictly necessary parts of Boost.Spirit.Karma to reduce compile time.
#include <boost/spirit/include/karma_char.hpp>
#include <boost/spirit/include/karma_nonterminal.hpp>
#include <boost/spirit/include/karma_numeric.hpp>
#include <boost/spirit/include/karma_operator.hpp>
#include <boost/spirit/include/karma_generate.hpp>

namespace {

typedef boost::rational<long> rational_adt;

struct rational_struct {
  long numerator, denominator;
  
  explicit rational_struct(long num = 0l, long den = 1l)
  : numerator(num), denominator(den)
  {}
};

} // namespace bufilt


#if BOOST_VERSION < 104500
// Adapt class boost::rational<long> to a Fusion sequence.
BOOST_FUSION_ADAPT_CLASS(
  ::rational_adt,
  (long, long, obj.numerator(), obj.numerator(val))
  (long, long, obj.denominator(), obj.denominator(val))
)
#else
// Adapt ADT boost::rational<long> to a Fusion sequence.
BOOST_FUSION_ADAPT_ADT(
  ::rational_adt,
  (long, long, obj.numerator(), obj.numerator(val))
  (long, long, obj.denominator(), obj.denominator(val))
)
#endif


// Adapt struct ::rational_struct to a Fusion sequence.
BOOST_FUSION_ADAPT_STRUCT(
  ::rational_struct,
  (long, numerator)
  (long, denominator)
)


//! \test Test the usage of the adapted ADT and struct in Karma rules.
BOOST_AUTO_TEST_CASE(test_boost_fusion_adaption_with_karma)
{
  // Namespace alias for Boost Spirit Karma.
  namespace karma = boost::spirit::karma;
  // Namespace alias for Boost Spirit Phoenix.
  namespace phx = boost::phoenix;
  
  using karma::long_;

  using boost::spirit::karma::generate;

  using boost::test_tools::output_test_stream;
  output_test_stream tout;
  typedef std::ostream_iterator<char> tout_iter_type;

  // Output iterator type used as sink for the Boost.Spirit.Karma generator to the output test stream.
  tout_iter_type tout_iter(tout);

  // Karma rules with adapted ADT does not compile against Boost >= 1.45
  // Output generation rule for ::rational_adt.
  karma::rule<tout_iter_type, rational_adt()> rational_adt_;
  rational_adt_.name("rational_adt_");
  rational_adt_ = long_ << '/' << long_;

  // The Karma rule with an equivalent adapted struct compiles against Boost >= 1.45
  // Output generation rule for ::rational_struct.
  karma::rule<tout_iter_type, rational_struct()> rational_struct_;
  rational_struct_.name("rational_struct_");
  rational_struct_ = long_ << '/' << long_;

  // Check the Karma generator rules.

  // Karma rules with adapted ADT does not compile against Boost >= 1.45
  rational_adt rat1(1, 2);
  BOOST_CHECK(generate(tout_iter, rational_adt_, rat1));
  BOOST_CHECK(tout.is_equal("1/2"));

  rational_struct rat2(1, 3);
  BOOST_CHECK(generate(tout_iter, rational_struct_, rat2));
  BOOST_CHECK(tout.is_equal("1/3"));
}