#format python
"""Shape OOP test for PythonVsJava
"""
import unittest, math

class Shape:
    """Abstract class for entire shape
    """
    def area(self):
        raise NotImplementedError
    def circumference(self):
        raise NotImplementedError

class Circle(Shape):
    def __init__(self, aRadius):
        self.setRadius(aRadius)
    def setRadius(self, aRadius):
        assert type(aRadius) in (int, float) and aRadius >= 0
        self.r = aRadius
    def getRadius(self):
        return self.r
    def area(self):
        return math.pi * self.r * self.r
    def circumference(self):
        return 2 * math.pi * self.r

class Rectangle(Shape):
    def __init__(self, aWidth, aHeight):
        self.setWidth(aWidth)
        self.setHeight(aHeight)
    def setWidth(self, aWidth):
        assert type(aWidth) in (int, float) and aWidth >= 0
        self.w = aWidth
    def setHeight(self, aHeight):
        assert type(aHeight) in (int, float) and aHeight >= 0
        self.h = aHeight
    def getWidth(self):
        return self.w
    def getHeight(self):
        return self.h
    def area(self):
        return self.w * self.h
    def circumference(self):
        return 2 * (self.w + self.h)

class Square(Shape):
    def __init__(self, aSide):
        self.setSide(aSide)
    def setSide(self, aSide):
        assert type(aSide) in (int, float) and aSide>=0
        self.s = aSide
    def getSide(self):
        return self.s
    def area(self):
        return self.s * self.s
    def circumference(self):
        return 4 * self.s

class Centered:
    def __init__(self, aX, aY):
        self.setCenter(aX, aY)
    def setCenter(self, aX, aY):
        self.x = aX
        self.y = aY
    def getCenterX(self):
        return self.x
    def getCenterY(self):
        return self.y
    def getDistanceFromOrigin(self):
        return math.sqrt(self.x*self.x + self.y*self.y)

class CenteredCircle(Centered, Circle):
    def __init__(self, aX, aY, aRadius):
        Centered.__init__(self, aX, aY)
        Circle.__init__(self, aRadius)

class CenteredRectangle(Centered, Rectangle):
    def __init__(self, aX, aY, aWidth, aHeight):
        Centered.__init__(self, aX, aY)
        Rectangle.__init__(self, aWidth, aHeight)

class CenteredSquare(Centered, Square):
    def __init__(self, aX, aY, aSide):
        Centered.__init__(self, aX, aY)
        Square.__init__(self, aSide)

class ShapeTest(unittest.TestCase):
    def testShape(self):
        myShape = Shape()
        self.assertRaises(NotImplementedError, myShape.area)
    def testCircle(self):
        myCircle = Circle(5.5)
        self.assertEquals(5.5, myCircle.getRadius())
        self.assert_(myCircle.area())
        self.assert_(myCircle.circumference())
        self.assertRaises(AssertionError, myCircle.setRadius, -1)
        self.assertRaises(AssertionError, myCircle.setRadius, 'a')
    def testRectangle(self):
        myRec = Rectangle(3,4)
        self.assertEquals(3, myRec.getWidth())
    def testAbstractClass(self):
        myShapes = [Circle(2.0), Rectangle(1,3.0), Rectangle(4.0, 2.0)]
        totalArea = 0
        for myShape in myShapes:
            totalArea += myShape.area()
        self.assertEquals(23.566, round(totalArea,3))
    def testSquare(self):
        mySquare = Square(2.0)
        self.assertEquals(8.0, mySquare.circumference())
    def testMultipleInheritance(self):
        myShapes = [CenteredCircle(1,1,1),
                    CenteredRectangle(2.3, 4.5, 3, 4),
                    CenteredSquare(2.5, 2, 3),
                   ]
        totalArea = 0; totalDistance = 0
        for myShape in myShapes:
            totalArea += myShape.area()
            totalDistance += myShape.getDistanceFromOrigin()
        self.assertEquals(24.142, round(totalArea,3))
        self.assertEquals(9.669, round(totalDistance,3))

if __name__=='__main__':
    unittest.main(argv=('','-v'))