def test_get_triangle_equilateral_all_int(self):
        result = get_triangle_type(1.003, 1.003, 1.003)
        self.assertEqual(result, 'equilateral')

        result = get_triangle_type(1, 2, 3)
        self.assertEqual(result, 'scalene')

        result = get_triangle_type(1, 1, 3)
        self.assertEqual(result, 'isosceles')

    def test_get_triangle(self):
        ret = get_triangle_type(-5, 5, 5)
        self.assertEqual(ret, "invalid")

        my_dict = {
                    1:1,
                    2:2,
                    3:3,
                   }
        ret2 = get_triangle_type(my_dict)
        self.assertEqual(ret2, "scalene")

        my_list = [5,4,6]
        ret = get_triangle_type(my_list)
        self.assertEqual(ret, "scalene")

 def test_get_triangle_type_not_list(self):
     """
     func that test for invalid condition
     :rtype: object
     """
     result = get_triangle_type((1, 2), 2, 5)
     self.assertEqual(result, 'invalid')

 def test_get_triangle_ltz_all_int(self):
     """
     Test that invalid thrown when side value less than zero entered
     :return:
     """
     result = get_triangle_type(-1, -1, -1)
     self.assertEqual(result, 'invalid')

 def test_get_triangle_input_all_int(self):
     """
     Test for invalid input
     :return:
     """
     result = get_triangle_type('a', "DEADBEEF", 'Z')
     self.assertEqual(result, 'invalid')

 def test_get_triangle_equilateral_all_int_performance(self):
     start_time = time.clock()
     result = get_triangle_type(1, 1, 1)
     end_time = time.clock()
     delta_time = end_time - start_time
     self.assertLessEqual(delta_time, 0.00002)
     self.assertEqual(result, 'equilateral')

 def test_tri_invalid_all_char(self):
     """
     Test triangle invalid char input
     :return: assertion: invalid
     """
     result = get_triangle_type('a', 'b', 'c')
     self.assertEqual(result, 'invalid')

 def test_tri_isosceles_neg(self):
     """
     Test triangle isosceles negative input
     :return: assertion: invalid
     """
     result = get_triangle_type(-1, 1, 1)
     self.assertEqual(result, 'invalid')

 def test_get_triangle_iso_all_int(self):
     """
     test for isosceles triangle
     :return:
     """
     result = get_triangle_type(3, 3, 2)
     self.assertEqual(result, 'isosceles')

 def test_tri_scalene_all_int(self):
     """
     Test triangle scalene all integer input
     :return: assertion: scalene
     """
     result = get_triangle_type(1, 2, 3)
     self.assertEqual(result, 'scalene')

 def test_tri_isosceles_all_int(self):
     """
     Test triangle isosceles all integer input
     :return: assertion: isosceles
     """
     result = get_triangle_type(1, 1, 3)
     self.assertEqual(result, 'isosceles')

    def test_get_triangle_equilateral_all_int(self):
        """

        :return:
        """
        result = get_triangle_type(1, 1, 1)
        self.assertEqual(result, 'equilateral')

 def test_tri_equilateral_all_int(self):
     """
     Test triangle equilateral all integer input
     :return: assertion: equilateral
     """
     result = get_triangle_type(1, 1, 1)
     self.assertEqual(result, 'equilateral')

 def test_get_triangle_scal_all_int(self):
     """
     Check that for triangle scalene
     :return:
     """
     result = get_triangle_type(1, 2, 3)
     self.assertEqual(result, 'scalene')

 def test_tri_scalene_all_float(self):
     """
     Test triangle scalene all float input
     :return: assertion: scalene
     """
     result = get_triangle_type(1.2, 1.3, 1.1)
     self.assertEqual(result, 'scalene')

 def test_get_triangle_equil_all_int(self):
     """
     Check correct return for equilateral triangle
     :return:
     """
     result = get_triangle_type(1, 1, 1)
     self.assertEqual(result, 'equilateral')

    def test_get_triangle_type_not_char_third(self):
        """
        func that test for invalid condition
        :rtype: object

        """
        result = get_triangle_type(1, 1, 'a')
        self.assertEqual(result, 'invalid')

 def test_tri_equilateral_list(self):
     """
     Test triangle equilateral list input
     :return: assertion: equilateral
     """
     var_l = [1, 1, 1]
     result = get_triangle_type(var_l)
     self.assertEqual(result, 'equilateral')

 def test_get_triangle_dict_all_int(self):
     """
     Tests retrieving triangle from dict.
     :return:
     """
     triangle = {'a': 1, 'b': 2, 'c': 3}
     result = get_triangle_type(triangle)
     self.assertEqual(result, 'scalene')

 def test_get_triangle_tuple_all_int(self):
     """
     tests triangle type, assert scalene
     :return:
     """
     triangle = (3, 2, 1)
     result = get_triangle_type(triangle)
     self.assertEqual(result, 'scalene')