def test_get_quad(self):
        ret = get_quadrilateral_type('h', 5, 5, 4)
        self.assertEqual(ret, "invalid")

        ret2 = get_quadrilateral_type(5, 5, 5, 4, 90, 90, 90, 'f')
        self.assertEqual(ret2, "invalid")

        ret2 = get_quadrilateral_type(1, 5, 5, 9, 90, 90, 90, 90)
        self.assertEqual(ret2, "disconnected")

 def test_get_quad_parrallelogram(self):
     """
     Check for invalid return. Non rhombus parrallelogram.
     :return:
     """
     result = get_quadrilateral_type(4, 5, 4, 5, 110, 70, 110, 70)
     self.assertEqual(result, 'invalid')

 def test_get_quad_angover_all_float(self):
     """
     Check for invalid return. Angles over 360 degrees total. float
     :return:
     """
     result = get_quadrilateral_type(2, 2, 2, 2, 180.1, .1, 180.1, .1)
     self.assertEqual(result, 'invalid')

 def test_get_quad_angl180_all_float(self):
     """
     Check for invalid, opposite angles 180 degrees.
     :return:
     """
     result = get_quadrilateral_type(2, 2, 2, 2, 180.0, 0, 180.0, 0)
     self.assertEqual(result, 'invalid')

 def test_get_quad_under_all_float(self):
     """
     Check for rhombus return. float angles.
     :return:
     """
     result = get_quadrilateral_type(2, 2, 2, 2, 179.9, .1, 179.9, .1)
     self.assertEqual(result, 'rhombus')

 def test_get_quad_rhombus_all_float(self):
     """
     Test quadrilateral rhombus all float input
     :return: assertion: rhombus
     """
     result = get_quadrilateral_type(1.1, 1.1, 1.1, 1.1, 139.5, 40.5, 40.5, 139.5)
     self.assertEqual(result, 'rhombus')

 def test_get_quad_square_char(self):
     """
     Test quadrilateral invalid char input
     :return: assertion: invalid
     """
     result = get_quadrilateral_type('a', 1, 1, 1, 'b', 90, 90, 90)
     self.assertEqual(result, 'invalid')

 def test_get_quad_disconnected(self):
     """
     Test quadrilateral disconnected all int input
     :return: assertion: disconnected
     """
     result = get_quadrilateral_type(1, 1, 1, 1, 41, 40, 140, 140)
     self.assertEqual(result, 'disconnected')

 def test_get_quad_rect_all_int(self):
     """
     check for rectangle return. int sides.
     :return:
     """
     result = get_quadrilateral_type(2, 4, 2, 4, 90, 90, 90, 90)
     self.assertEqual(result, 'rectangle')

 def test_get_quad_square_all_float(self):
     """
     Check returns square with floats sides.
     :return:
     """
     result = get_quadrilateral_type(2.4, 2.4, 2.4, 2.4, 90, 90, 90, 90)
     self.assertEqual(result, 'square')

 def test_get_quad_gtr180_all_int(self):
     """
     Check for invalid return. Angle greater than 180 degrees.
     :return:
     """
     result = get_quadrilateral_type(2, 2, 2, 2, 190, 90, 90, 90)
     self.assertEqual(result, 'invalid')

 def test_get_quad_angleltz_all_int(self):
     """
     Check for invalid return. Angles less than zero.
     :return:
     """
     result = get_quadrilateral_type(2, 2, 2, 2, -5, -5, -5, -5)
     self.assertEqual(result, 'invalid')

 def test_get_quad_sideltz_all_int(self):
     """
     Check for invalid return. Sides less than zero.
     :return:
     """
     result = get_quadrilateral_type(-1, -1, -1, -1, 90, 90, 90, 90)
     self.assertEqual(result, 'invalid')

 def test_get_quad_angle_char(self):
     """
     check for invalid return. Char inputs for angles.
     :return:
     """
     result = get_quadrilateral_type(14, 5, 14, 5, 'w', 'x', 'y', 'z')
     self.assertEqual(result, 'invalid')

 def test_get_quad_side_char(self):
     """
     check for invalid return. Char inputs for sides.
     :return:
     """
     result = get_quadrilateral_type('a', 'b', 'c', 'd', 90, 90, 90, 90)
     self.assertEqual(result, 'invalid')

 def test_get_quad_rhombus_all_int(self):
     """
     Test quadrilateral rhombus all int input
     :return: assertion: rhombus
     """
     result = get_quadrilateral_type(1, 1, 1, 1, 40, 40, 140, 140)
     self.assertEqual(result, 'rhombus')

 def test_get_quad_rhombus_all_int(self):
     """
     Check for rhombus return, int sides.
     :return:
     """
     result = get_quadrilateral_type(3, 3, 3, 3, 44, 136, 44, 136)
     self.assertEqual(result, 'rhombus')

 def test_get_quad_neg(self):
     """
     Test quadrilateral negative int input
     :return: assertion: invalid
     """
     result = get_quadrilateral_type(-1, 1, 1, 1, -90, 90, 90, 90)
     self.assertEqual(result, 'invalid')

 def test_get_quad_sidedisc_all_int(self):
     """
     Check for disconnected return, sides.
     :return:
     """
     result = get_quadrilateral_type(2, 2, 2, 4, 50, 130, 50, 130)
     self.assertEqual(result, 'disconnected')

 def test_get_quad_square_all_float(self):
     """
     Test quadrilateral square all float input
     :return: assertion: square
     """
     result = get_quadrilateral_type(1.1, 1.1, 1.1, 1.1, 90, 90, 90, 90)
     self.assertEqual(result, 'square')