class TestSquare(unittest.TestCase):
    """test square class"""
    def setUp(self):
        """set up"""
        print('setUp')
        self.s1 = Square(5)
        self.s2 = Square(5, 10)
        self.s3 = Square(5, 10, 15)
        self.s4 = Square(2, 4, 6, 8)

    def tearDown(self):
        """tear down"""
        print('tearDown')
        del self.s1
        del self.s2
        del self.s3
        del self.s4

    def test_aaainit(self):
        """init test"""
        print("test_init")

        # s1 tests
        self.assertIsNotNone(self.s1)
        self.assertIsInstance(self.s1, Base)
        self.assertIsInstance(self.s1, Rectangle)
        self.assertIs(type(self.s1), Square)
        self.assertEqual(self.s1.id, 66)
        self.assertEqual(self.s1.width, 5)
        self.assertEqual(self.s1.height, 5)
        self.assertEqual(self.s1.x, 0)
        self.assertEqual(self.s1.y, 0)
        # s2 tests
        self.assertIsNotNone(self.s2)
        self.assertIsInstance(self.s2, Base)
        self.assertIsInstance(self.s2, Rectangle)
        self.assertIs(type(self.s2), Square)
        self.assertEqual(self.s2.id, 67)
        self.assertEqual(self.s2.width, 5)
        self.assertEqual(self.s2.height, 5)
        self.assertEqual(self.s2.x, 10)
        self.assertEqual(self.s2.y, 0)
        # s3 tests
        self.assertIsNotNone(self.s3)
        self.assertIsInstance(self.s3, Base)
        self.assertIsInstance(self.s3, Rectangle)
        self.assertIs(type(self.s3), Square)
        self.assertEqual(self.s3.id, 68)
        self.assertEqual(self.s3.width, 5)
        self.assertEqual(self.s3.height, 5)
        self.assertEqual(self.s3.x, 10)
        self.assertEqual(self.s3.y, 15)
        # s4 tests
        self.assertIsNotNone(self.s4)
        self.assertIsInstance(self.s4, Base)
        self.assertIsInstance(self.s4, Rectangle)
        self.assertIs(type(self.s4), Square)
        self.assertEqual(self.s4.id, 8)
        self.assertEqual(self.s4.width, 2)
        self.assertEqual(self.s4.height, 2)
        self.assertEqual(self.s4.x, 4)
        self.assertEqual(self.s4.y, 6)

        def test_attributes(self):
            """test raised exceptions"""
            print("test_attributes")
            # s1
            with self.assertRaises(TypeError):
                self.s1.__init__(None, 2)
            with self.assertRaises(TypeError):
                self.s1.__init__("howdy", 17)
            with self.assertRaises(TypeError):
                self.s1.__init__([1, 2, 3], 12, 13, 14)
            # s2
            with self.assertRaises(TypeError):
                self.s2.__init__(4, False, 2)
            with self.assertRaises(TypeError):
                self.s2.__init__(1, 2, (3, ))
            # s3
            with self.assertRaises(ValueError):
                self.s3.__init__(4, -3, 4)
            with self.assertRaises(ValueError):
                self.s3.__init__(0, 0, 0)
            # s4
            with self.assertRaises(TypeError):
                self.s4.__init__(True, 1, 2, 3)
            with self.assertRaises(TypeError):
                self.s4.__init__(1, 2, False, 4)

    def test_area(self):
        """test area method"""
        print("test_area")
        # s1
        self.assertEqual(self.s1.area(), 25)
        # s2
        self.assertEqual(self.s2.area(), 25)
        # s3
        self.assertEqual(self.s3.area(), 25)
        # s4
        self.assertEqual(self.s4.area(), 4)

    def test_display(self):
        """test display method"""
        pass

    def test_astr(self):
        """test str method"""
        print("test_str")
        # s1
        self.assertEqual(self.s1.__str__(),
                         "[Square] ({}) 0/0 - 5".format(self.s1.id))
        # s2
        self.assertEqual(self.s2.__str__(),
                         "[Square] ({}) 10/0 - 5".format(self.s2.id))
        # s3
        self.assertEqual(self.s3.__str__(),
                         "[Square] ({}) 10/15 - 5".format(self.s3.id))
        # s4
        self.assertEqual(self.s4.__str__(), "[Square] (8) 4/6 - 2")

    def test_update_args(self):
        """test update method with args"""
        print("test_update_args")
        self.assertEqual(self.s1.__str__(),
                         "[Square] ({}) 0/0 - 5".format(self.s1.id))
        self.s1.update(69)
        self.assertEqual(self.s1.__str__(), "[Square] (69) 0/0 - 5")
        self.s1.update(2, 4)
        self.assertEqual(self.s1.__str__(), "[Square] (2) 0/0 - 4")
        self.s1.update(2, 4, 6)
        self.assertEqual(self.s1.__str__(), "[Square] (2) 6/0 - 4")
        self.s1.update(2, 4, 6, 8)
        self.assertEqual(self.s1.__str__(), "[Square] (2) 6/8 - 4")

    def test_update_kwargs(self):
        """test update method with kwargs"""
        print("test_update_kwargs")
        self.s1.update(x=69, id=1)
        self.assertEqual(self.s1.__str__(), "[Square] (1) 69/0 - 5")
        self.s1.update(size=2, y=13)
        self.assertEqual(self.s1.__str__(), "[Square] (1) 69/13 - 2")
        self.s1.update(size=7, id=89, y=1)
        self.assertEqual(self.s1.__str__(), "[Square] (89) 69/1 - 7")

    def test_module_docstring(self):
        """Module Docstring Check"""
        print("test_module_docstring")
        result = len(__import__('models.square').__doc__)
        self.assertTrue(result > 0, True)

    def test_class_docstring(self):
        """Class Docstring Test"""
        print("test_class_docstring")
        result = len(Square.__doc__)
        self.assertTrue(result > 0, True)

    def test_init_docstring(self):
        """init Docstring Test"""
        print("test_init_docstring")
        result = len(self.__init__.__doc__)
        self.assertTrue(result > 0, True)

    def test_size_getter_docstring(self):
        """size_getter Docstring Test"""
        print("test_size_getter_docstring")
        result = len(Square.size.__doc__)
        self.assertTrue(result > 0, True)

    def test_x_getter_docstring(self):
        """x_getter Docstring Test"""
        print("test_x_getter_docstring")
        result = len(Square.x.__doc__)
        self.assertTrue(result > 0, True)

    def test_y_getter_docstring(self):
        """y_getter Docstring Test"""
        print("test_y_getter_docstring")
        result = len(Square.y.__doc__)
        self.assertTrue(result > 0, True)

    def test_area_docstring(self):
        """area Docstring Test"""
        print("test_area_docstring")
        result = len(Square.area.__doc__)
        self.assertTrue(result > 0, True)

    def test_display_docstring(self):
        """display Docstring Test"""
        print("test_display_docstring")
        result = len(Square.display.__doc__)
        self.assertTrue(result > 0, True)

    def test_str_docstring(self):
        """str Docstring Test"""
        print("test_str_docstring")
        result = len(Square.__str__.__doc__)
        self.assertTrue(result > 0, True)

    def test_update_docstring(self):
        """update Docstring Test"""
        print("test_update_docstring")
        result = len(Square.update.__doc__)
        self.assertTrue(result > 0, True)

    def test_to_dictionary_docstring(self):
        """to_dictionary Docstring Test"""
        print("test_to_dictionary_docstring")
        result = len(Square.to_dictionary.__doc__)
        self.assertTrue(result > 0, True)
class TestBaseClass(unittest.TestCase):
    """Unit test for Square class"""
    @classmethod
    def setUpClass(cls):
        print('setupClass')

    @classmethod
    def tearDownClass(cls):
        print('tearDownClass')

    def setUp(self):
        """Unit test setup"""
        print('setUp')
        self.s1 = Square(5)
        self.s2 = Square(2, 2)
        self.s3 = Square(3, 1, 3)
        self.s4 = Square(10, 2, 1)
        self.s5 = Square(1, 1)

    def tearDown(self):
        """Unit test tear down"""
        print('tearDown')
        del self.s1
        del self.s2
        del self.s3
        del self.s4
        del self.s5

    def test_a_init(self):
        """Test for init method"""
        print("test_init")
        # s1 tests
        self.assertIsNotNone(self.s1)
        self.assertIsInstance(self.s1, Base)
        self.assertIsInstance(self.s1, Rectangle)
        self.assertIs(type(self.s1), Square)
        self.assertEqual(self.s1.id, 217)
        self.assertEqual(self.s1.width, 5)
        self.assertEqual(self.s1.height, 5)
        self.assertEqual(self.s1.x, 0)
        self.assertEqual(self.s1.y, 0)

        # s2 tests
        self.assertIsNotNone(self.s2)
        self.assertIsInstance(self.s2, Base)
        self.assertIsInstance(self.s2, Rectangle)
        self.assertIs(type(self.s2), Square)
        self.assertEqual(self.s2.id, 218)
        self.assertEqual(self.s2.width, 2)
        self.assertEqual(self.s2.height, 2)
        self.assertEqual(self.s2.x, 2)
        self.assertEqual(self.s2.y, 0)

        # s3 tests
        self.assertIsNotNone(self.s3)
        self.assertIsInstance(self.s3, Base)
        self.assertIsInstance(self.s3, Rectangle)
        self.assertIs(type(self.s3), Square)
        self.assertEqual(self.s3.id, 219)
        self.assertEqual(self.s3.width, 3)
        self.assertEqual(self.s3.height, 3)
        self.assertEqual(self.s3.x, 1)
        self.assertEqual(self.s3.y, 3)

    def test_b_validate_attributes(self):
        """Test exceptions are raised when attribute invalid"""
        print("test_validate_attributes")

        # s1 tests
        with self.assertRaises(TypeError):
            self.s1.__init__("string", 4)
        with self.assertRaises(TypeError):
            self.s1.__init__([1, 2, 3], 4)
        with self.assertRaises(TypeError):
            self.s1.__init__()

        # s2 tests
        with self.assertRaises(TypeError):
            self.s2.__init__(3, True)
        with self.assertRaises(TypeError):
            self.s2.__init__(3, (1, ))

        # s3 tests
        with self.assertRaises(ValueError):
            self.s3.__init__(0, 4)
        with self.assertRaises(ValueError):
            self.s3.__init__(-1, 4)

    def test_c_area(self):
        """Test for area method"""
        print("test_area")

        # s1 tests
        self.assertEqual(self.s1.area(), 25)

        # s2 tests
        self.assertEqual(self.s2.area(), 4)

        # s3 tests
        self.assertEqual(self.s3.area(), 9)

    def test_d_display(self):
        """Test for display method"""
        print("test_display")
        f = io.StringIO()
        with redirect_stdout(f):
            self.s1.display()
        output = f.getvalue()
        self.assertEqual(output, f.getvalue())

    def test_e_str(self):
        """Test for __str__ method"""
        print("test_str")
        self.assertEqual(self.s1.__str__(), "[Square] (252) 0/0 - 5")
        self.assertEqual(self.s2.__str__(), "[Square] (253) 2/0 - 2")
        self.assertEqual(self.s3.__str__(), "[Square] (254) 1/3 - 3")

    def test_f_update_args(self):
        """Test for update args method"""
        print("test_update_args")
        self.assertEqual(self.s1.__str__(), "[Square] (257) 0/0 - 5")
        self.s1.update(10)
        self.assertEqual(self.s1.__str__(), "[Square] (10) 0/0 - 5")
        self.s1.update(1, 2)
        self.assertEqual(self.s1.__str__(), "[Square] (1) 0/0 - 2")
        self.s1.update(1, 2, 3)
        self.assertEqual(self.s1.__str__(), "[Square] (1) 3/0 - 2")
        self.s1.update(1, 2, 3, 4)
        self.assertEqual(self.s1.__str__(), "[Square] (1) 3/4 - 2")

    def test_g_update_kwargs(self):
        """Test for update kwargs method"""
        print("test_update_kwargs")
        self.s1.update(x=12)
        self.assertEqual(self.s1.__str__(), "[Square] (262) 12/0 - 5")
        self.s1.update(size=7, y=1)
        self.assertEqual(self.s1.__str__(), "[Square] (262) 12/1 - 7")
        self.s1.update(size=7, id=89, y=1)
        self.assertEqual(self.s1.__str__(), "[Square] (89) 12/1 - 7")

    def test_h_to_dictionary(self):
        """Test for to_dictionary method"""
        print("test_to_dictionary")
        self.assertEqual(self.s4.__str__(), "[Square] (270) 2/1 - 10")
        s4_dictionary = self.s4.to_dictionary()
        expected = {'id': 270, 'x': 2, 'size': 10, 'y': 1}
        self.assertEqual(s4_dictionary, expected)
        self.assertIs(type(s4_dictionary), dict)

        self.assertEqual(self.s5.__str__(), "[Square] (271) 1/0 - 1")
        self.s5.update(**s4_dictionary)
        self.assertEqual(self.s5.__str__(), "[Square] (270) 2/1 - 10")
        self.assertFalse(self.s4 == self.s5)

    def test_module_docstring(self):
        """Module Docstring Check"""
        print("test_module_docstring")
        result = len(__import__('models.square').__doc__)
        self.assertTrue(result > 0, True)

    def test_class_docstring(self):
        """Class Docstring Test"""
        print("test_class_docstring")
        result = len(Square.__doc__)
        self.assertTrue(result > 0, True)

    def test_init_docstring(self):
        """init Docstring Test"""
        print("test_init_docstring")
        result = len(self.__init__.__doc__)
        self.assertTrue(result > 0, True)

    def test_size_getter_docstring(self):
        """size_getter Docstring Test"""
        print("test_size_getter_docstring")
        result = len(Square.size.__doc__)
        self.assertTrue(result > 0, True)

    def test_x_getter_docstring(self):
        """x_getter Docstring Test"""
        print("test_x_getter_docstring")
        result = len(Square.x.__doc__)
        self.assertTrue(result > 0, True)

    def test_y_getter_docstring(self):
        """y_getter Docstring Test"""
        print("test_y_getter_docstring")
        result = len(Square.y.__doc__)
        self.assertTrue(result > 0, True)

    def test_area_docstring(self):
        """area Docstring Test"""
        print("test_area_docstring")
        result = len(Square.area.__doc__)
        self.assertTrue(result > 0, True)

    def test_display_docstring(self):
        """display Docstring Test"""
        print("test_display_docstring")
        result = len(Square.display.__doc__)
        self.assertTrue(result > 0, True)

    def test_str_docstring(self):
        """str Docstring Test"""
        print("test_str_docstring")
        result = len(Square.__str__.__doc__)
        self.assertTrue(result > 0, True)

    def test_update_docstring(self):
        """update Docstring Test"""
        print("test_update_docstring")
        result = len(Square.update.__doc__)
        self.assertTrue(result > 0, True)

    def test_to_dictionary_docstring(self):
        """to_dictionary Docstring Test"""
        print("test_to_dictionary_docstring")
        result = len(Square.to_dictionary.__doc__)
        self.assertTrue(result > 0, True)

    def test_pep8_conformance(self):
        """load_from_file Docstring Test"""
        print("test_test_pep8_conformance")
        pep8style = pep8.StyleGuide(quiet=True)
        result = pep8style.check_files(['models/square.py'])
        self.assertEqual(result.total_errors, 0)