#include "../cmm/dispatch.h"

#include <iostream>
#include <stdexcept>
#include <typeinfo>

struct base
{
    int x;
    base()  : x( 0) {}
    base( const base& rhs) : x( rhs.x) { std::cerr << "base copy ctr called\n"; }
    virtual ~base() {}
};

struct derived : base
{
    int y;
    derived() : base(), y(1) {}
    virtual ~derived() {}
};

struct unrelated
{
    virtual ~unrelated()    {}
};

void foo( base& b)
{
    std::cerr << "foo( base& b) called, x=" << b.x << "\n";
}

void foo( derived& d)
{
    std::cerr << "foo( derived& d) called, y=" << d.y << "\n";
}


void foo( base&, base&)
{
    std::cerr << "foo( derived& b, base& b) called\n";
}

void foo( derived&, base&)
{
    std::cerr << "foo( derived& b, base& b) called\n";
}

void foo( base&, derived&)
{
    std::cerr << "foo( base& b, derived& b) called\n";
}


void bar( derived&, derived&)
{
    std::cerr << "foo( derived& b, derived& b) called\n";
}

// this should be ignored by cmm because it takes no params.
void bar( void)
{
}

int main()
{
    try
    {
        base&       b = *new base;
        base&       d = *new derived;
        unrelated&  u = *new unrelated;
        
        //base    bb;
        //0, foo( virtual bb);
        
        0, foo( virtual b);
        0, foo( virtual d);
        
        try
        {
            0, foo( virtual d, virtual d);
            std::cerr << "*** should have got ambiguous exception\n";
            abort();
        }
        catch( cmm_exception_ambiguous& e)
        {
            std::cerr << "got expected exception:\n" << e.what() << "\n";
        }
        
        try
        {
            0, virtual void foo( virtual d, virtual d);
            std::cerr << "*** should have got ambiguous exception\n";
            abort();
        }
        catch( cmm_exception_ambiguous& e)
        {
            std::cerr << "got expected exception:\n" << e.what() << "\n";
        }
        
        try
        {
            0, virtual int foo( virtual d, virtual d);
            std::cerr << "*** should have got unmatched exception\n";
            abort();
        }
        catch( cmm_exception_unmatched& e)
        {
            std::cerr << "got expected exception:\n" << e.what() << "\n";
        }
        
        0, foo( virtual b, virtual b);
        0, foo( virtual b, virtual d);
        0, foo( virtual d, virtual b);
        
        try
        {
            0, bar( virtual b, virtual d);
            std::cerr << "*** should have got unmatched exception\n";
            abort();
        }
        catch( cmm_exception_unmatched& e)
        {
            std::cerr << "got expected exception:\n" << e.what() << "\n";
        }
        
        0, bar( virtual d, virtual d);
        
        try
        {
            0, foo( virtual u, virtual u);
            std::cerr << "*** should have got unmatched exception\n";
            abort();
        }
        catch( cmm_exception_unmatched& e)
        {
            std::cerr << "got expected exception:\n" << e.what() << "\n";
        }
        
        return 0;
    }
    catch( std::exception& e)
    {
        std::cerr << "main: error: " << e.what() << "\n";
    }
    return 1;
}