def test_hamming_distance_multiple(self):
        test_logger.debug("FindNearestTest - test_hamming_distance_multiple Starts")

        points = ["abcdef", "abcefg", "abcdeg"]
        point = "abcdef"
        find_nearest = FindNearest(points, point, HammingDistance, k=2)
        find_nearest.process()
        nearest = find_nearest.get_result()
        self.assertEquals(['abcdef', 'abcdeg'], nearest)

        points = ["abcXdef", "abcXefg", "abcXdeg"]
        point = "abcdefg"
        find_nearest = FindNearest(points, point, HammingDistance, k=2)
        find_nearest.process()
        nearest = find_nearest.get_result()
        self.assertEquals(['abcXefg', 'abcXdeg'], nearest)

        points = ["abcXdef", "abcXefg", "abcXdeg"]
        point = "1234567"
        find_nearest = FindNearest(points, point, HammingDistance, k=2)
        find_nearest.process()
        nearest = find_nearest.get_result()
        self.assertEquals(['abcXdef', 'abcXdef'], nearest)

        points = ["abcXdef", "abcXefg", "abcXdeg"]
        point = "123456 "
        find_nearest = FindNearest(points, point, HammingDistance, k=2)
        find_nearest.process()
        nearest = find_nearest.get_result()
        self.assertEquals(['abcXdef', 'abcXdef'], nearest)

        test_logger.debug("FindNearestTest - test_hamming_distance_multiple Ends")

    def test_damerau_levenshtein_distance_multiple(self):
        test_logger.debug("FindNearestTest - test_damerau_levenshtein_distance_multiple Starts")

        points = ["abcdef", "abcef", "abcde"]
        point = "abcdefg"
        find_nearest = FindNearest(points, point, DamerauLevenshteinDistance, k=2)
        find_nearest.process()
        nearest = find_nearest.get_result()
        self.assertEquals(['abcdef', 'abcef'], nearest)

        points = ["abcXdef", "abcXef", "abcXde"]
        point = "abcdefg"
        find_nearest = FindNearest(points, point, DamerauLevenshteinDistance, k=2)
        find_nearest.process()
        nearest = find_nearest.get_result()
        self.assertEquals(['abcXdef', 'abcXdef'], nearest)

        points = ["abcXdef", "abcXef", "abcXde"]
        point = "123456"
        find_nearest = FindNearest(points, point, DamerauLevenshteinDistance, k=2)
        find_nearest.process()
        nearest = find_nearest.get_result()
        self.assertEquals(['abcXef', 'abcXef'], nearest)

        points = ["abcXdef", "abcXef", "abcXde"]
        point = "123456 "
        find_nearest = FindNearest(points, point, DamerauLevenshteinDistance, k=2)
        find_nearest.process()
        nearest = find_nearest.get_result()
        self.assertEquals(['abcXdef', 'abcXdef'], nearest)

        test_logger.debug("FindNearestTest - test_damerau_levenshtein_distance_multiple Ends")

    def test_correlation_distance(self):
        test_logger.debug("FindNearestTest - test_correlation_distance Starts")

        points = [(2, 3), (3, 4), (4, 5)]
        point = (2, 1)
        find_nearest = FindNearest(points, point, CorrelationDistance)
        find_nearest.process()
        nearest = find_nearest.get_result()
        self.assertEquals((2, 3), nearest)

        points = [(2, 3), (3, 4), (4, 5)]
        point = (3, 2)
        find_nearest = FindNearest(points, point, CorrelationDistance)
        find_nearest.process()
        nearest = find_nearest.get_result()
        self.assertEquals((2, 3), nearest)

        points = [(2, 3), (3, 4), (4, 5)]
        point = (3, 4)
        find_nearest = FindNearest(points, point, CorrelationDistance)
        find_nearest.process()
        nearest = find_nearest.get_result()
        self.assertEquals((2, 3), nearest)

        test_logger.debug("FindNearestTest - test_correlation_distance Ends")

    def test_correlation_distance_multiple(self):
        test_logger.debug("FindNearestTest - test_correlation_distance_multiple Starts")

        points = [(2, 3), (4, 6), (6, 5)]
        point = (2, 1)
        find_nearest = FindNearest(points, point, CorrelationDistance, k=2)
        find_nearest.process()
        nearest = find_nearest.get_result()
        self.assertEquals([(6, 5), (2, 3)], nearest)

        points = [(2, 3), (4, 6), (6, 5)]
        point = (3, 2)
        find_nearest = FindNearest(points, point, CorrelationDistance, k=2)
        find_nearest.process()
        nearest = find_nearest.get_result()
        self.assertEquals([(6, 5), (2, 3)], nearest)

        points = [(2, 3), (4, 6), (6, 5)]
        point = (3, 1)
        find_nearest = FindNearest(points, point, CorrelationDistance, k=2)
        find_nearest.process()
        nearest = find_nearest.get_result()
        self.assertEquals([(6, 5), (2, 3)], nearest)

        test_logger.debug("FindNearestTest - test_correlation_distance_multiple Ends")

    def test_edit_distance(self):
        test_logger.debug("FindNearestTest - test_edit_distance Starts")

        points = ["abcdef", "abcef", "abcde"]
        point = "abcdefg"
        find_nearest = FindNearest(points, point, EditDistance)
        find_nearest.process()
        nearest = find_nearest.get_result()
        self.assertEquals("abcdef", nearest)

        points = ["abcXdef", "abcXef", "abcXde"]
        point = "abcdefg"
        find_nearest = FindNearest(points, point, EditDistance)
        find_nearest.process()
        nearest = find_nearest.get_result()
        self.assertEquals("abcXdef", nearest)

        points = ["abcXdef", "abcXef", "abcXde"]
        point = "123456"
        find_nearest = FindNearest(points, point, EditDistance)
        find_nearest.process()
        nearest = find_nearest.get_result()
        self.assertEquals("abcXef", nearest)

        points = ["abcXdef", "abcXef", "abcXde"]
        point = "123456 "
        find_nearest = FindNearest(points, point, EditDistance)
        find_nearest.process()
        nearest = find_nearest.get_result()
        self.assertEquals("abcXdef", nearest)

        test_logger.debug("FindNearestTest - test_edit_distance Ends")

 def test_algorithm_with_list(self):
     test_logger.debug("StandartDeviationTest - test_algorithm_with_list Starts")
     standart_deviation = StandartDeviation()
     data_list = [1, 2, 3, 4, 5]
     self.assertEquals(1.5811, standart_deviation.calculate(data_list))
     data_list = [1, 2, 3, 4]
     self.assertEquals(1.291, standart_deviation.calculate(data_list))
     test_logger.debug("StandartDeviationTest - test_algorithm_with_list Ends")

    def test_algorithm_with_tuple(self):
        test_logger.debug("MeanTest - test_algorithm_with_tuple Starts")
        mean = Mean()
        data_list = [("a", 1), ("b", 2), ("c", 3), ( "d", 4), ("e", 5)]
        self.assertEquals(3, mean.calculate(data_list, is_tuple=True, index=1))

        data_list = [("a", "a", 1), ("b", "b", 2), ("c", "c", 3), ("d", "d", 4), ("e", "e", 5)]
        self.assertEquals(3.0, mean.calculate(data_list, is_tuple=True, index=2))
        test_logger.debug("MeanTest - test_algorithm_with_tuple Ends")

    def test_manhattan_distance_multiple(self):
        test_logger.debug("FindNearestTest - test_manhattan_distance_multiple Starts")

        points = [(1, 0, 1, 0, 1, 0), (1, 0, 1, 0, 1, 1), (1, 0, 1, 1, 1, 0)]
        point = (1, 0, 0, 0, 0, 0)
        find_nearest = FindNearest(points, point, ManhattanDistance, k=2)
        find_nearest.process()
        nearest = find_nearest.get_result()
        self.assertEquals([(1, 0, 1, 0, 1, 0), (1, 0, 1, 0, 1, 1)], nearest)

        points = [(1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1), (1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1),
                  (0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 1, 1)]
        point = (0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 1, 1)
        find_nearest = FindNearest(points, point, ManhattanDistance, k=2)
        find_nearest.process()
        nearest = find_nearest.get_result()
        self.assertEquals([(0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 1, 1), (1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1)]
                          , nearest)

        points = [(2, 3), (3, 4), (4, 5)]
        point = (0, 1)
        find_nearest = FindNearest(points, point, ManhattanDistance, k=2)
        find_nearest.process()
        nearest = find_nearest.get_result()
        self.assertEquals([(2, 3), (3, 4)], nearest)

        points = [(2, 3), (3, 4), (4, 5)]
        point = (3, 3)
        find_nearest = FindNearest(points, point, ManhattanDistance, k=2)
        find_nearest.process()
        nearest = find_nearest.get_result()
        self.assertEquals([(2, 3), (2, 3)], nearest)

        points = [(2, 3), (3, 4), (4, 5)]
        point = (3, 4)
        find_nearest = FindNearest(points, point, ManhattanDistance, k=2)
        find_nearest.process()
        nearest = find_nearest.get_result()
        self.assertEquals([(3, 4), (2, 3)], nearest)

        points = [[1], [5], [10]]
        point = [8]
        find_nearest = FindNearest(points, point, ManhattanDistance, k=2)
        find_nearest.process()
        nearest = find_nearest.get_result()
        self.assertEquals([[10], [5]], nearest)

        points = [[1], [5], [10]]
        point = [17]
        find_nearest = FindNearest(points, point, ManhattanDistance, k=2)
        find_nearest.process()
        nearest = find_nearest.get_result()
        self.assertEquals([[10], [5]], nearest)

        test_logger.debug("FindNearestTest - test_manhattan_distance_multiple Ends")

    def test_euclidean_distance(self):
        test_logger.debug("FindNearestTest - test_euclidean_distance Starts")

        points = [(1, 0, 1, 0, 1, 0), (1, 0, 1, 0, 1, 1), (1, 0, 1, 1, 1, 0)]
        point = (1, 0, 0, 0, 0, 0)
        find_nearest = FindNearest(points, point, EuclideanDistance)
        find_nearest.process()
        nearest = find_nearest.get_result()
        self.assertEquals((1, 0, 1, 0, 1, 0), nearest)

        points = [(1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1), (1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1),
                  (0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 1, 1)]
        point = (0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 1, 1)
        find_nearest = FindNearest(points, point, EuclideanDistance)
        find_nearest.process()
        nearest = find_nearest.get_result()
        self.assertEquals((0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 1, 1), nearest)

        points = [(2, 3), (3, 4), (4, 5)]
        point = (0, 1)
        find_nearest = FindNearest(points, point, EuclideanDistance)
        find_nearest.process()
        nearest = find_nearest.get_result()
        self.assertEquals((2, 3), nearest)

        points = [(2, 3), (3, 4), (4, 5)]
        point = (3, 3)
        find_nearest = FindNearest(points, point, EuclideanDistance)
        find_nearest.process()
        nearest = find_nearest.get_result()
        self.assertEquals((2, 3), nearest)

        points = [(2, 3), (3, 4), (4, 5)]
        point = (3, 4)
        find_nearest = FindNearest(points, point, EuclideanDistance)
        find_nearest.process()
        nearest = find_nearest.get_result()
        self.assertEquals((3, 4), nearest)

        points = [[1], [5], [10]]
        point = [8]
        find_nearest = FindNearest(points, point, EuclideanDistance)
        find_nearest.process()
        nearest = find_nearest.get_result()
        self.assertEquals([10], nearest)

        points = [[1], [5], [10]]
        point = [17]
        find_nearest = FindNearest(points, point, EuclideanDistance)
        find_nearest.process()
        nearest = find_nearest.get_result()
        self.assertEquals([10], nearest)

        test_logger.debug("FindNearestTest - test_euclidean_distance Ends")

    def test_algorithm(self):
        test_logger.debug("FindNearestTest - test_algorithm Starts")

        points = "abcdef"
        point = "abcdefg"
        with self.assertRaises(TypeError) as context:
            FindNearest(points, point, "")
        self.assertEqual("You must initialize array and a point",
                         context.exception.message)

        test_logger.debug("FindNearestTest - test_algorithm Starts")

    def test_algorithm(self):
        test_logger.debug("CosineDistanceTest - test_algorithm Starts")
        data = [(1, 2, 3), (3, 5, 7)]
        cosine_distance = CosineDistance(data)
        cosine_distance.process()
        result = cosine_distance.get_result()
        self.assertEquals(0.002585096956942312, result)

        data = [(1, 2, 3, 4), (1, 2, 3, 6)]
        cosine_distance = CosineDistance(data)
        cosine_distance.process()
        result = cosine_distance.get_result()
        self.assertEquals(0.018844218960787695, result)

        data = [(3, 1), (4, 1)]
        cosine_distance = CosineDistance(data)
        cosine_distance.process()
        result = cosine_distance.get_result()
        self.assertEquals(0.002945514498418511, result)

        data = [[3], [4]]
        cosine_distance = CosineDistance(data)
        cosine_distance.process()
        result = cosine_distance.get_result()
        self.assertEquals(0.0, result)

        data = [[3, 4], [6, 8]]
        cosine_distance = CosineDistance(data)
        cosine_distance.process()
        result = cosine_distance.get_result()
        self.assertEquals(0.0, result)

        data = [[3], [4, 5, 6]]
        cosine_distance = CosineDistance(data)
        with self.assertRaises(ArithmeticError) as context:
            cosine_distance.process()
        self.assertEqual('You cant calculate Cosine distance of array has different sizes.',
                         context.exception.message)

        data = [["a"], [4]]
        cosine_distance = CosineDistance(data)
        with self.assertRaises(TypeError) as context:
            cosine_distance.process()
        self.assertEqual("unsupported operand type(s) for +: 'int' and 'str'",
                         context.exception.message)

        data = []
        cosine_distance = CosineDistance(data)
        with self.assertRaises(ArithmeticError) as context:
            cosine_distance.process()
        self.assertEqual('You must enter two array to find Cosine distance.',
                         context.exception.message)

        test_logger.debug("CosineDistanceTest - test_algorithm Ends")

    def test_algorithm(self):
        test_logger.debug("ManhattanDistanceTest - test_algorithm Starts")
        data = [(1, 2, 3, 4), (1, 2, 3, 6)]
        manhattan_distance = ManhattanDistance(data)
        manhattan_distance.process()
        result = manhattan_distance.get_result()
        self.assertEquals(2.0, result)

        data = [(1, 2, 3, 4), (5, 6, 7, 8)]
        manhattan_distance = ManhattanDistance(data)
        manhattan_distance.process()
        result = manhattan_distance.get_result()
        self.assertEquals(16.0, result)

        data = [(3, 1), (4, 1)]
        manhattan_distance = ManhattanDistance(data)
        manhattan_distance.process()
        result = manhattan_distance.get_result()
        self.assertEquals(1.0, result)

        data = [(3, 1, 5), (5, 5, 3)]
        manhattan_distance = ManhattanDistance(data)
        manhattan_distance.process()
        result = manhattan_distance.get_result()
        self.assertEquals(8.0, result)

        data = [[3], [4]]
        manhattan_distance = ManhattanDistance(data)
        manhattan_distance.process()
        result = manhattan_distance.get_result()
        self.assertEquals(1.0, result)

        data = [[3], [4, 5, 6]]
        manhattan_distance = ManhattanDistance(data)
        with self.assertRaises(ArithmeticError) as context:
            manhattan_distance.process()
        self.assertEqual('You cant calculate Manhattan distance of array has different sizes.',
                         context.exception.message)

        data = [["a"], [4]]
        manhattan_distance = ManhattanDistance(data)
        with self.assertRaises(TypeError) as context:
            manhattan_distance.process()
        self.assertEqual("unsupported operand type(s) for -: 'int' and 'str'",
                         context.exception.message)

        data = []
        manhattan_distance = ManhattanDistance(data)
        with self.assertRaises(ArithmeticError) as context:
            manhattan_distance.process()
        self.assertEqual('You must enter two array to find Manhattan distance.',
                         context.exception.message)

        test_logger.debug("ManhattanDistanceTest - test_algorithm Ends")

    def test_algorithm_with_tuple(self):
        test_logger.debug("VarianceTest - test_algorithm_with_tuple Starts")
        variance = Variance()
        data_list = [("a", 1), ("b", 2), ("c", 3), ( "d", 4), ("e", 5)]
        self.assertEquals(2.5, variance.calculate(data_list, is_tuple=True, index=1))

        data_list = [("a", "a", 1), ("b", "b", 2), ("c", "c", 3), ("d", "d", 4), ("e", "e", 5)]
        self.assertEquals(2.5, variance.calculate(data_list, is_tuple=True, index=2))

        data_list = [("a", "a", 1), ("b", "b", 2), ("c", "c", 3), ("d", "d", 4)]
        self.assertEquals(1.6667, variance.calculate(data_list, is_tuple=True, index=2))
        test_logger.debug("VarianceTest - test_algorithm_with_tuple Ends")

    def test_algorithm_with_tuple(self):
        test_logger.debug("StandartDeviationTest - test_algorithm_with_tuple Starts")
        standart_deviation = StandartDeviation()
        data_list = [("a", 1), ("b", 2), ("c", 3), ( "d", 4), ("e", 5)]
        self.assertEquals(1.5811, standart_deviation.calculate(data_list, is_tuple=True, index=1))

        data_list = [("a", "a", 1), ("b", "b", 2), ("c", "c", 3), ("d", "d", 4), ("e", "e", 5)]
        self.assertEquals(1.5811, standart_deviation.calculate(data_list, is_tuple=True, index=2))

        data_list = [("a", "a", 1), ("b", "b", 2), ("c", "c", 3), ("d", "d", 4)]
        self.assertEquals(1.291, standart_deviation.calculate(data_list, is_tuple=True, index=2))
        test_logger.debug("StandartDeviationTest - test_algorithm_with_tuple Ends")

 def test_formula(self):
     test_logger.debug("SumFormulaTest - test_formula Starts")
     sum_formula = SumFormula()
     data_list = [1, 2, 3, 4, 5]
     self.assertEquals(15, sum_formula.calculate(data_list))
     data_list = [1, 2, 3, 4]
     self.assertEquals(10, sum_formula.calculate(data_list))
     data_list = [2]
     self.assertEquals(4, sum_formula.calculate(data_list, power=2))
     data_list = [1, 2, 3, 4]
     self.assertEquals(30, sum_formula.calculate(data_list, power=2))
     test_logger.debug("SumFormulaTest - test_formula Ends")

    def test_algorithm_with_tuple(self):
        test_logger.debug("SumFormulaTest - test_algorithm_with_tuple Starts")
        sum_formula = SumFormula()
        data_list = [("a", 1), ("b", 2), ("c", 3), ( "d", 4), ("e", 5)]
        self.assertEquals(15, sum_formula.calculate(data_list, is_tuple=True, index=1))

        data_list = [("a", "a", 1), ("b", "b", 2), ("c", "c", 3), ("d", "d", 4), ("e", "e", 5)]
        self.assertEquals(15, sum_formula.calculate(data_list, is_tuple=True, index=2))

        data_list = [("a", "a", 1), ("e", "e", 5)]
        self.assertEquals(26, sum_formula.calculate(data_list, is_tuple=True, index=2, power=2))
        test_logger.debug("SumFormulaTest - test_algorithm_with_tuple Ends")

 def test_algorithm_with_list(self):
     test_logger.debug("MeanTest - test_algorithm_with_list Starts")
     mean = Mean()
     data_list = [1, 2, 3, 4, 5]
     self.assertEquals(3, mean.calculate(data_list))
     data_list = [1, 2, 3, 4]
     self.assertEquals(2.5, mean.calculate(data_list))
     data_list = []
     with self.assertRaises(ZeroDivisionError) as context:
         mean.calculate(data_list)
     self.assertEqual("integer division or modulo by zero",
                      context.exception.message)
     test_logger.debug("MeanTest - test_algorithm_with_list Ends")

 def test_algorithm_with_list(self):
     test_logger.debug("VarianceTest - test_algorithm_with_list Starts")
     variance = Variance()
     data_list = [1, 2, 3, 4, 5]
     self.assertEquals(2.5, variance.calculate(data_list))
     data_list = [1, 2, 3, 4]
     self.assertEquals(1.6667, variance.calculate(data_list))
     data_list = []
     with self.assertRaises(ZeroDivisionError) as context:
         variance.calculate(data_list)
     self.assertEqual("integer division or modulo by zero",
                      context.exception.message)
     test_logger.debug("VarianceTest - test_algorithm_with_list Ends")

    def test_algorithm_with_list(self):
        test_logger.debug("MedianTest - test_algorithm_with_list Starts")
        median = Median()
        data_list = [1, 2, 3, 4, 5]
        self.assertEquals(3, median.calculate(data_list))
        data_list = [1, 2, 3, 4]
        self.assertEquals(2, median.calculate(data_list))

        data_list = []
        with self.assertRaises(IndexError) as context:
            median.calculate(data_list)
        self.assertEqual("list index out of range",
                         context.exception.message)

        test_logger.debug("MedianTest - test_algorithm_with_list Ends")

    def test_algorithm(self):
        test_logger.debug("ChessBoardDistanceTest - test_algorithm Starts")
        data = [(1, 2, 3, 4), (1, 2, 3, 8)]
        chessboard_distance = ChessBoardDistance(data)
        chessboard_distance.process()
        result = chessboard_distance.get_result()
        self.assertEquals(4.0, result)

        data = [(3, 1), (4, 1)]
        chessboard_distance = ChessBoardDistance(data)
        chessboard_distance.process()
        result = chessboard_distance.get_result()
        self.assertEquals(1.0, result)

        data = [(-3, 1), (4, 1)]
        chessboard_distance = ChessBoardDistance(data)
        chessboard_distance.process()
        result = chessboard_distance.get_result()
        self.assertEquals(7.0, result)

        data = [[3], [4]]
        chessboard_distance = ChessBoardDistance(data)
        chessboard_distance.process()
        result = chessboard_distance.get_result()
        self.assertEquals(1.0, result)

        data = [[3], [4, 5, 6]]
        chessboard_distance = ChessBoardDistance(data)
        with self.assertRaises(ArithmeticError) as context:
            chessboard_distance.process()
        self.assertEqual('You cant calculate Chess Board distance of array has different sizes.',
                         context.exception.message)

        data = [["a"], [4]]
        chessboard_distance = ChessBoardDistance(data)
        with self.assertRaises(TypeError) as context:
            chessboard_distance.process()
        self.assertEqual("unsupported operand type(s) for -: 'int' and 'str'",
                         context.exception.message)

        data = []
        chessboard_distance = ChessBoardDistance(data)
        with self.assertRaises(ArithmeticError) as context:
            chessboard_distance.process()
        self.assertEqual('You must enter two array to find Chess Board distance.',
                         context.exception.message)

        test_logger.debug("ChessBoardDistanceTest - test_algorithm Ends")