from unittest import TestCase, main
from methodOverloading import GetMethodName, MethodOverloading, OverloadedError


class OverloadedInit(object):

    __metaclass__ = MethodOverloading
    
    def __init1__(self, x=int):
        self.test = "integer"
        
    def __init2__(self, x=str):
        self.test = "string"


class OverloadedMethod(object):

    __metaclass__ = MethodOverloading

    def method1(self, w=int, x=float, y=str, z=6):
        self.test = 'method1'

    def method2(self, w=str, x=float):
        self.test = 'method2'

    def method3(self, w=int, x=int, y=int):
        self.test = 'method3'
        

class MethodOverloadingTest(TestCase):
    
    def testGetMethodName(self):
        self.assertEqual(GetMethodName('__x1'), '__x')
        self.assertEqual(GetMethodName('__x1__'), '__x__')
        self.assertEqual(GetMethodName('__x99__'), '__x9__')
        self.assertEqual(GetMethodName('test1'), 'test')
        

    def testOverloadedInitInt(self):
        test = OverloadedInit(3)
        self.assertEqual(test.test, "integer")

    
    def testOverloadedInitString(self):
        test = OverloadedInit("hello")
        self.assertEqual(test.test, "string")


    def testOverloadedMethod(self):
        test = OverloadedMethod()
        test.method(3, 6.0, 'hello')
        self.assertEqual(test.test, 'method1')
        
        test.method('hello', 6.0)
        self.assertEqual(test.test, 'method2')
        
        test.method(3, 6, 9)
        self.assertEqual(test.test, 'method3')
 
 
    def testNoMatchingSignature(self):
        try:
            test = OverloadedInit(3.0)
        except OverloadedError:
            pass
        else:
            self.fail()
    
    
    def testConflictingSignatures(self):
        try:
            class ConflictTest(object):
                __metaclass__ = MethodOverloading
                
                def test1(self, x=int):
                    pass
                
                def test2(self, x=int):
                    pass
        except OverloadedError:
            pass
        else:
            self.fail()
    
    
    def testNoTypedArguments(self):
        try:
            class NoTypedArguments(object):
                __metaclass__ = MethodOverloading
                
                def test1(self, x=int):
                    pass
                
                def test2(self, x='fish'):
                    pass
        except OverloadedError:
            pass
        else:
            self.fail()
    
    
    def testNonKeywordArguments(self):
        try:
            class NonKeywordArguments(object):
                __metaclass__ = MethodOverloading
                
                def test1(self, x, y=4):
                    pass
                
                def test2(self, x=float):
                    pass
        except OverloadedError:
            pass
        else:
            self.fail()
    
    
    def testOverloadedNameClash(self):
        try:
            class OverloadedNameClash(object):
                __metaclass__ = MethodOverloading
                
                def test(self):
                    pass
                
                def test1(self, x=int, y=int):
                    pass
                
                def test2(self, x=float):
                    pass
        except OverloadedError:
            pass
        else:
            self.fail()

    
    def testNoConflictsWithNonOverloadedMethods(self):
        # If normal methods cause problems, the following calss definition could raise an exception
        class NoConflictsWithNonOverloadedMethods(object):
            __metaclass__ = MethodOverloading
            
            def notTest(self, x, y=3):
                pass
            
            def test1(self, x=int, y=int):
                pass
            
            def test2(self, x=float):
                pass
            
            def anotherTest1(self, x=int, y=int, z='not a type'):
                pass
            
            def anotherTest2(self, x=float):
                pass

            def anotherNotTest(self, x=int):
                pass
        
        test = NoConflictsWithNonOverloadedMethods()
        self.assertTrue(hasattr(test, 'notTest'))
        self.assertTrue(hasattr(test, 'anotherNotTest'))
        self.assertTrue(hasattr(test, 'test'))
        self.assertTrue(hasattr(test, 'anotherTest'))
        self.assertFalse(hasattr(test, 'test1'))
        self.assertFalse(hasattr(test, 'anotherTest1'))
        self.assertFalse(hasattr(test, 'test2'))
        self.assertFalse(hasattr(test, 'anotherTest2'))


if __name__ == '__main__':
    main()