/***
    mockcpp is a generic C/C++ mock framework.
    Copyright (C) <2009>  <Darwin Yuan: darwin.yuan@gmail.com>

    This program 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.

    This program 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 this program.  If not, see <http://www.gnu.org/licenses/>.
***/

#include <testcpp/testcpp.hpp>

#include <mockcpp/Exception.h>
#include <mockcpp/MethodInfoReader.h>

class TestMethodInfoReader : public TESTCPP_NS::TestFixture
{
	struct Base0
   {
      virtual int  base00() = 0;
      virtual bool base01(int) const = 0;
      virtual ~Base0() {}
   };

   struct Base1
   {
      virtual void base10() = 0;
      virtual long base11(bool) const = 0;

      virtual ~Base1() {}
   };

   struct Interface: public Base0, public Base1
   {
      virtual void a() {}
      virtual void b(bool) {}
      void c() {}
   };
public:
	void setUp() { }
	void tearDown() { }

	/////////////////////////////////////////////////////////

   template <typename Method>
   int getIndexOfMethod(Method m)
   {
		return MOCKCPP_NS::getIndexOfMethod<Interface, Method>(m);
   }

	void testShouldBeAbleToCalcVptrIndex()
	{
      TS_ASSERT(getIndexOfMethod(&Interface::base00) >= 0);
      TS_ASSERT(getIndexOfMethod(&Interface::base01) >= 0);
      TS_ASSERT(getIndexOfMethod(&Interface::base10) >= 0);
      TS_ASSERT(getIndexOfMethod(&Interface::base11) >= 0);
      TS_ASSERT(getIndexOfMethod(&Interface::a) >= 0);
      TS_ASSERT(getIndexOfMethod(&Interface::b) >= 0);

      TS_ASSERT(getIndexOfMethod(&Interface::base00) < 10);
      TS_ASSERT(getIndexOfMethod(&Interface::base01) < 10);
      TS_ASSERT(getIndexOfMethod(&Interface::base10) < 10);
      TS_ASSERT(getIndexOfMethod(&Interface::base11) < 10);
      TS_ASSERT(getIndexOfMethod(&Interface::a) < 10);
      TS_ASSERT(getIndexOfMethod(&Interface::b) < 10);

      TS_ASSERT(getIndexOfMethod(&Interface::base00) != getIndexOfMethod(&Interface::base01));
      TS_ASSERT(getIndexOfMethod(&Interface::base10) != getIndexOfMethod(&Interface::base11));

      TS_ASSERT((getIndexOfMethod(&Interface::base00) != getIndexOfMethod(&Interface::a)) ||
                (getIndexOfMethod(&Interface::base10) != getIndexOfMethod(&Interface::a)));

      TS_ASSERT((getIndexOfMethod(&Interface::base01) != getIndexOfMethod(&Interface::a)) ||
                (getIndexOfMethod(&Interface::base11) != getIndexOfMethod(&Interface::a)));
	}

   void testShouldBeAbleToCalcVptrByBaseClass()
   {
      TS_ASSERT(getIndexOfMethod(&Base0::base00) >= 0);
      TS_ASSERT(getIndexOfMethod(&Base0::base01) >= 0);

      TS_ASSERT(getIndexOfMethod(&Base0::base00) < 10);
      TS_ASSERT(getIndexOfMethod(&Base0::base01) < 10);

      TS_ASSERT(getIndexOfMethod(&Base1::base10) >= 0);
      TS_ASSERT(getIndexOfMethod(&Base1::base11) >= 0);

      TS_ASSERT(getIndexOfMethod(&Base1::base10) < 10);
      TS_ASSERT(getIndexOfMethod(&Base1::base11) < 10);
   }

   template <typename Method>
   int getDeltaOfMethod(Method m)
   {
		return MOCKCPP_NS::getDeltaOfMethod<Interface, Method>(m);
   }

	void testShouldBeAbleToGetVtblIndex()
   {
      TS_ASSERT(getDeltaOfMethod(&Interface::base00) == 0 || \
                getDeltaOfMethod(&Interface::base00) == 1);

      TS_ASSERT(getDeltaOfMethod(&Interface::base10) == 0 || \
                getDeltaOfMethod(&Interface::base10) == 1);

      TS_ASSERT(getDeltaOfMethod(&Interface::a) == 0 || \
                getDeltaOfMethod(&Interface::a) == 1);
   }

	void testShouldBeEqualIf2MethodsDefinedInOneInterface()
   {
      TS_ASSERT(getDeltaOfMethod(&Interface::base00) == getDeltaOfMethod(&Interface::base01));
      TS_ASSERT(getDeltaOfMethod(&Interface::base10) == getDeltaOfMethod(&Interface::base11));
   }

	void testShouldNotBeEqualIf2MethodsDefinedInDifferentBaseInterface()
   {
      TS_ASSERT(getDeltaOfMethod(&Interface::base00) != getDeltaOfMethod(&Interface::base10));
   }

   void testShouldThrowAnExceptionIfTryToGetVtblIndexOfANonVirtualMethod()
   {
      TS_ASSERT_THROWS(getIndexOfMethod(&Interface::c), MOCKCPP_NS::Exception);
   }

   void testShouldThrowAnExceptionIfTryToGetVptrIndexOfANonVirtualMethod()
   {
      TS_ASSERT_THROWS(getDeltaOfMethod(&Interface::c), MOCKCPP_NS::Exception);
   }

   void testShouldThrowAnExceptionIfTryToGetAddressOfAVirtualMethod()
   {
      TS_ASSERT_THROWS(MOCKCPP_NS::getAddrOfMethod(&Interface::base00), MOCKCPP_NS::Exception);
   }
};