//-----------------------------------------------------------------------------
// boost-libs variant/test/variant_multivisit_test.cpp source file
// See http://www.boost.org for updates, documentation, and revision history.
//-----------------------------------------------------------------------------
//
// Copyright (c) 2013
// Antony Polukhin
//
// 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)

#include "boost/config.hpp"
#define BOOST_VARAINT_MAX_MULTIVIZITOR_PARAMS 6
#include "../../../margot/applications/common/functions/multivisitors.hpp"

#include "boost/test/minimal.hpp"

typedef boost::variant<char, unsigned char, signed char>                                            variant3_t;
typedef boost::variant<char, unsigned char, signed char, unsigned short>                            variant4_t;
typedef boost::variant<char, unsigned char, signed char, unsigned short, int>                       variant5_t;
typedef boost::variant<char, unsigned char, signed char, unsigned short, int, unsigned int>         variant6_t;

struct test_visitor: boost::static_visitor<> {
    // operators that shall not be called
    template <class  T1, class  T2, class  T3>
    void operator()(T1, T2, T3) const 
    {
        BOOST_CHECK(false);
    }

    template <class  T1, class  T2, class  T3, class  T4>
    void operator()(T1, T2, T3, T4) const 
    {
        BOOST_CHECK(false);
    }

    template <class  T1, class  T2, class  T3, class  T4, class  T5>
    void operator()(T1, T2, T3, T4, T5) const 
    {
        BOOST_CHECK(false);
    }

    template <class  T1, class  T2, class  T3, class  T4, class  T5, class  T6>
    void operator()(T1, T2, T3, T4, T5, T6) const 
    {
        BOOST_CHECK(false);
    }

    // operators that are OK to call
    void operator()(char, unsigned char, signed char) const 
    {
        BOOST_CHECK(true);
    }

    void operator()(char, unsigned char, signed char, unsigned short) const 
    {
        BOOST_CHECK(true);
    }

    void operator()(char, unsigned char, signed char, unsigned short, int) const 
    {
        BOOST_CHECK(true);
    }

    void operator()(char, unsigned char, signed char, unsigned short, int, unsigned int) const 
    {
        BOOST_CHECK(true);
    }
};

int test_main(int , char* [])
{
    test_visitor v;

    variant3_t v_array3[] = {
        char(), unsigned char(), signed char()
    };
    boost::apply_visitor(v, v_array3[0], v_array3[1], v_array3[2]);
    boost::apply_visitor(test_visitor(), v_array3[0], v_array3[1], v_array3[2]);

    variant4_t v_array4[] = {
        char(), unsigned char(), signed char(), unsigned short()
    };
    boost::apply_visitor(v, v_array4[0], v_array4[1], v_array4[2], v_array4[3]);
    boost::apply_visitor(test_visitor(), v_array4[0], v_array4[1], v_array4[2], v_array4[3]);

// Following test also pass, but requires many Gigabytes of RAM for compilation and compile for about 45 minutes
//#define BOOST_VARIANT_MULTIVISITORS_TEST_VERY_EXTREME
#ifdef BOOST_VARIANT_MULTIVISITORS_TEST_VERY_EXTREME    
    variant5_t v_array5[] = {
        char(), unsigned char(), signed char(), unsigned short(), int()
    };
    boost::apply_visitor(v, v_array5[0], v_array5[1], v_array5[2], v_array5[3], v_array5[4]);
    boost::apply_visitor(test_visitor(), v_array5[0], v_array5[1], v_array5[2], v_array5[3], v_array5[4]);
  
    variant6_t v_array6[] = {
        char(), unsigned char(), signed char(), unsigned short(), int(), unsigned int()
    };
    boost::apply_visitor(v, v_array6[0], v_array6[1], v_array6[2], v_array6[3], v_array6[4], v_array6[5]);
    boost::apply_visitor(test_visitor(), v_array6[0], v_array6[1], v_array6[2], v_array6[3], v_array6[4], v_array6[5]);
#endif

    return boost::exit_success;
}