""" Test the ABC functionality.
"""

import unittest

try:
    import abc

    from ..api import ABCHasTraits, ABCMetaHasTraits, HasTraits, Int, Float

    class AbstractFoo(ABCHasTraits):
        x = Int(10)
        y = Float(20.0)

        @abc.abstractmethod
        def foo(self):
            raise NotImplementedError()

        @abc.abstractproperty
        def bar(self):
            raise NotImplementedError()

    class ConcreteFoo(AbstractFoo):
        def foo(self):
            return 'foo'

        @property
        def bar(self):
            return 'bar'

    class FooLike(HasTraits):
        x = Int(10)
        y = Float(20.0)

        def foo(self):
            return 'foo'

        @property
        def bar(self):
            return 'bar'

    AbstractFoo.register(FooLike)


    class AbstractBar(object):
        __metaclass__ = abc.ABCMeta

        @abc.abstractmethod
        def bar(self):
            raise NotImplementedError()


    class TestABC(unittest.TestCase):
        def test_basic_abc(self):
            self.assertRaises(TypeError, AbstractFoo)
            concrete = ConcreteFoo()
            self.assertEquals(concrete.foo(), 'foo')
            self.assertEquals(concrete.bar, 'bar')
            self.assertEquals(concrete.x, 10)
            self.assertEquals(concrete.y, 20.0)
            self.assertTrue(isinstance(concrete, AbstractFoo))

        def test_registered(self):
            foolike = FooLike()
            self.assertTrue(isinstance(foolike, AbstractFoo))

        def test_post_hoc_mixing(self):
            class TraitedBar(HasTraits, AbstractBar):
                __metaclass__ = ABCMetaHasTraits
                x = Int(10)

                def bar(self):
                    return 'bar'

            traited = TraitedBar()
            self.assertTrue(isinstance(traited, AbstractBar))
            self.assertEquals(traited.x, 10)


except ImportError:
    pass

Add some tests for ABCHasTraits.
TST: Add some tests for ABCHasTraits.
