///////////////////////////////////////////////////////////////////////////////
// test_typeof.cpp
//
//  Copyright 2008 David Jenkins. 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)

#define BOOST_TYPEOF_LIMIT_SIZE 200
#define BOOST_TYPEOF_EMULATION 1

#include <string>
#include <boost/version.hpp>
#include <boost/xpressive/xpressive_static.hpp>
#include <boost/xpressive/xpressive_typeof.hpp>
#include <boost/test/unit_test.hpp>

// I couldn't find these registrations anywhere else, so I put them here
// They are necessary for this program to compile
#include BOOST_TYPEOF_INCREMENT_REGISTRATION_GROUP()
BOOST_TYPEOF_REGISTER_TEMPLATE(boost::mpl::int_, (int))
BOOST_TYPEOF_REGISTER_TEMPLATE(boost::reference_wrapper, (typename))

// Here's the test for typeof registration, to be used on static regular expressions
#define TYPEOF_TEST(Expr) { BOOST_PROTO_AUTO(Dummy, Expr); }

namespace xp = boost::xpressive;

///////////////////////////////////////////////////////////////////////////////
// test_misc1
//  miscelaneous regular expressions
static void test_misc1()
{
    using namespace boost::xpressive;

    TYPEOF_TEST(epsilon);
    TYPEOF_TEST(nil);
    TYPEOF_TEST(alnum);
    TYPEOF_TEST(bos);
    TYPEOF_TEST(eos);
    TYPEOF_TEST(bol);
    TYPEOF_TEST(eol);
    TYPEOF_TEST(bow);
    TYPEOF_TEST(eow);
    TYPEOF_TEST(_b);
    TYPEOF_TEST(_w);
    TYPEOF_TEST(_d);
    TYPEOF_TEST(_s);
    TYPEOF_TEST(_n);
    TYPEOF_TEST(_ln);
    TYPEOF_TEST(_);
    TYPEOF_TEST(self);
}

///////////////////////////////////////////////////////////////////////////////
// test_misc2
//  miscelaneous regular expressions
static void test_misc2()
{
    using namespace boost::xpressive;

    TYPEOF_TEST(+set[_d | '-' | 'g']);
    TYPEOF_TEST(+set['g' | as_xpr('-') | _d]);
    TYPEOF_TEST(icase(+range('a','g')));
    TYPEOF_TEST(+range('-','/'));
    TYPEOF_TEST(+range('+','-'));
    TYPEOF_TEST(+range('b','b'));
    TYPEOF_TEST(icase((s1= "foo") >> *_ >> '\15'));
    TYPEOF_TEST(repeat<2>(repeat<3>(_d) >> '-') >> repeat<4>(_d));
    TYPEOF_TEST('f' >> +as_xpr('o'));
    TYPEOF_TEST(icase(+(s1= "foo") >> "foobar"));
    cregex parens = '(' >> *( keep( +~(set='(',')') ) | by_ref(parens) ) >> ')';
    TYPEOF_TEST(_b >> "sublist" >> parens);
    TYPEOF_TEST(bos >> "baz" | "bar");
    TYPEOF_TEST(icase(*_ >> "foo"));
    TYPEOF_TEST(icase(*_ >> "boo" | "bar"));
    TYPEOF_TEST(icase("bar"));

    TYPEOF_TEST(('f' >> repeat<1,repeat_max>('o')));
    TYPEOF_TEST("This " >> (s1= "(has)") >> ' ' >> (s2= "parens"));
    TYPEOF_TEST(as_xpr("This (has parens"));
    TYPEOF_TEST(+_d);
    TYPEOF_TEST(+~_d);
    TYPEOF_TEST(+set[_d]);
    TYPEOF_TEST(+set[~_d]);
    TYPEOF_TEST(+~set[~_d]);
    TYPEOF_TEST(+~set[_d]);
    TYPEOF_TEST(+set[~_w | ~_d]);
    TYPEOF_TEST(+~set[_w | _d]);
    TYPEOF_TEST((s1= '(' >> (s2= nil) | '[' >> (s3= nil)) >> -*_ >> (s4= ')') >> s2 | ']' >> s3);
    TYPEOF_TEST(after("foo") >> "bar");
    TYPEOF_TEST(after(s1= 'f' >> _ >> 'o') >> "bar");
    TYPEOF_TEST(icase(after(s1= "fo") >> 'o'));
    TYPEOF_TEST(icase(~after(s1= "fo") >> 'o'));
    TYPEOF_TEST(+alpha);
    TYPEOF_TEST(+set[alpha | digit]);
    TYPEOF_TEST(after(s1= nil) >> 'a');
    TYPEOF_TEST(after(s1= "abc" >> repeat<3>(_d)) >> "foo");
    TYPEOF_TEST(~before(bol) >> 'x');
    TYPEOF_TEST(~before(bos) >> 'x');
}

///////////////////////////////////////////////////////////////////////////////
// test_misc3
//  miscelaneous regular expressions

static void test_misc3()
{
    using namespace boost::xpressive;

    TYPEOF_TEST(as_xpr("foo"));
    TYPEOF_TEST('b' >> *_ >> "ar");
    TYPEOF_TEST('b' >> *_ >> 'r');
    TYPEOF_TEST('b' >> +_ >> "ar");
    TYPEOF_TEST('b' >> +_ >> 'r');
    TYPEOF_TEST('b' >> +_ >> "oo");
    TYPEOF_TEST(bos >> "foo");
    TYPEOF_TEST(bos >> 'b' >> *_ >> "ar");
    TYPEOF_TEST('b' >> +_ >> "ar" >> eos);
    TYPEOF_TEST('b' >> +_ >> 'o' >> eos);
    TYPEOF_TEST(bos >> (s1= !(set='-','+') >> +range('0','9')
                           >> !(s2= '.' >> *range('0','9')))
                           >> (s3= (set='C','F')) >> eos);
    TYPEOF_TEST( !(s1= as_xpr('+')|'-') >> (s2= +range('0','9') >> !as_xpr('.') >> *range('0','9') |
                        '.' >> +range('0','9')) >> !(s3= (set='e','E') >> !(s4= as_xpr('+')|'-') >> +range('0','9')));
    TYPEOF_TEST('f' | icase('g'));
    TYPEOF_TEST(icase(+lower));
    TYPEOF_TEST(icase(+as_xpr('\x61')));
    TYPEOF_TEST(icase(+set['\x61']));
    TYPEOF_TEST(icase(+as_xpr('\x0061')));
    TYPEOF_TEST(icase(+set['\x0061']));
    TYPEOF_TEST('a' >> +(s1= 'b' | (s2= *(s3= 'c'))) >> 'd');
    TYPEOF_TEST('a' >> +(s1= 'b' | (s2= !(s3= 'c'))) >> 'd');
    TYPEOF_TEST(*as_xpr('a') >> *as_xpr('a') >> *as_xpr('a') >> *as_xpr('a') >> *as_xpr('a') >> 'b');
    TYPEOF_TEST(*set[range('a','z') | range('A','Z')]);
}

///////////////////////////////////////////////////////////////////////////////
// test_misc4
//  miscelaneous regular expressions
static void test_misc4()
{
    using namespace boost::xpressive;
    TYPEOF_TEST('a' >> bos >> 'b');
    TYPEOF_TEST(as_xpr("a^b"));
    TYPEOF_TEST('a' >> ~set[' '] >> 'b');
    TYPEOF_TEST('a' >> ~set['^'] >> 'b');
    TYPEOF_TEST('a' >> ~set['^'] >> 'b');
    TYPEOF_TEST('a' >> set['^'] >> 'b');
    TYPEOF_TEST(icase("foo" >> before("bar")));
    TYPEOF_TEST(icase("foo" >> ~before("bar")));
    TYPEOF_TEST(icase("foo" >> ~before("bar")));
    TYPEOF_TEST(icase(+(s1= keep(s2= "foo") >> "bar")));
    TYPEOF_TEST(+(s1= "bar" | (s2= "foo")));
    TYPEOF_TEST(+(s1= (s2= "bar") | "foo"));
    TYPEOF_TEST(+(s1= "foo" | (s2= "bar")));
    TYPEOF_TEST(+(s1= (s2= "foo") | "bar"));
    TYPEOF_TEST((s1= icase("FOO")) >> (s2= -*_) >> s1);
    TYPEOF_TEST((s1= icase("FOO")) >> (s2= -*_) >> icase(s1));
    TYPEOF_TEST(+(s1= "foo" | icase(s1 >> 'O')));
    TYPEOF_TEST((bos >> set[range('A','Z') | range('a','m')]));
    TYPEOF_TEST(('f' >> repeat<2,5>('o')));
    TYPEOF_TEST(('f' >> -repeat<2,5>('o')));
    TYPEOF_TEST(('f' >> repeat<2,5>('o') >> 'o'));
    TYPEOF_TEST(('f' >> -repeat<2,5>('o') >> 'o'));
    TYPEOF_TEST(bos >> '{' >> *_ >> '}' >> eos);
    TYPEOF_TEST(+(set='+','-'));
    TYPEOF_TEST(+(set='-','+'));
}

///////////////////////////////////////////////////////////////////////////////
// test_misc5
//  miscelaneous regular expressions
static void test_misc5()
{
    using namespace boost::xpressive;
    TYPEOF_TEST(bos >> ('(' >> (s1= nil) | (s2= nil)) >> +_w >> (')' >> s1 | s2) >> eos);
    TYPEOF_TEST(+~alpha);
    TYPEOF_TEST(+set[alpha | ~alpha]);
    TYPEOF_TEST(+~set[~alpha]);
    TYPEOF_TEST(as_xpr("[[:alpha:]\\y]+"));
    TYPEOF_TEST(+~set[~alnum | ~digit]);
    TYPEOF_TEST(icase(bos >> repeat<4>(s1= 'a' >> !s1) >> eos));
    TYPEOF_TEST(as_xpr("foo") >> /*This is a comment[*/ "bar");
    TYPEOF_TEST(bos >> "foobar" >> eos);
    TYPEOF_TEST(bos >> 'f' >> *as_xpr('o'));
    TYPEOF_TEST(bos >> 'f' >> *as_xpr('\157'));
    TYPEOF_TEST(bos >> ("foo" >> set[' '] >> "bar") >> eos /*This is a comment*/);
}

///////////////////////////////////////////////////////////////////////////////
// test_misc6
//  miscelaneous regular expressions
static void test_misc6()
{
    using namespace boost::xpressive;
    TYPEOF_TEST(bos >> *(s1= optional('a')) >> eos);
    TYPEOF_TEST(bos >> -*(s1= optional('a')) >> eos);
    TYPEOF_TEST(bos >> repeat<2>(s1= optional('b')) >> "bc" >> eos);
    TYPEOF_TEST(bos >> *(s1= optional('b')) >> 'd' >> eos);
    TYPEOF_TEST(bos >> -repeat<2>(s1= optional('b')) >> "bc" >> eos);
    TYPEOF_TEST(bos >> -*(s1= optional('b')) >> 'd' >> eos);
    TYPEOF_TEST(bos >> repeat<2>(s1= -optional('b')) >> "bc" >> eos);
    TYPEOF_TEST(bos >> *(s1= -optional('b')) >> 'd' >> eos);
    TYPEOF_TEST(bos >> -repeat<2>(s1= -optional('b')) >> "bc" >> eos);
    TYPEOF_TEST(bos >> -*(s1= -optional('b')) >> 'd' >> eos);
    TYPEOF_TEST(bos >> *(s1= nil | nil | nil | 'b') >> "bc" >> eos);
    TYPEOF_TEST(bos >> -*(s1= nil | nil | nil | 'b') >> "bc" >> eos);
    TYPEOF_TEST(icase(+range('Z','a')));
    TYPEOF_TEST(+range('Z','a'));
}

// These functions are defined in test_typeof2.cpp
void test_actions();
void test_symbols();
void test_assert();

using namespace boost::unit_test;

///////////////////////////////////////////////////////////////////////////////
// init_unit_test_suite
//
test_suite* init_unit_test_suite( int argc, char* argv[] )
{
    test_suite *test = BOOST_TEST_SUITE("test_typeof");
    test->add(BOOST_TEST_CASE(&test_misc1));
    test->add(BOOST_TEST_CASE(&test_misc2));
    test->add(BOOST_TEST_CASE(&test_misc3));
    test->add(BOOST_TEST_CASE(&test_misc4));
    test->add(BOOST_TEST_CASE(&test_misc5));
    test->add(BOOST_TEST_CASE(&test_misc6));
    test->add(BOOST_TEST_CASE(&test_actions));
    test->add(BOOST_TEST_CASE(&test_symbols));
    test->add(BOOST_TEST_CASE(&test_assert));
    return test;
}