test: add more test cases about WordMatching module

tests/constants_wordmatching.py

@@ -0,0 +1,105 @@
+import numpy as np
+
+
+get_best_path_from_distance_matrix_constants = [
+    (np.array([[0, 4], [5, 1], [5, 4]]), np.array([0, 1])),
+    (
+        np.array([[0.0, 1.0, 1.0], [1.0, 0.0, 1.0], [1.0, 1.0, 0.0], [1.0, 1.0, 1.0]]),
+        np.array([0, 1, 2]),
+    ),
+    (
+        np.array(
+            [
+                [2.0, 5.0, 5.0, 5.0, 5.0],
+                [6.0, 0.0, 4.0, 3.0, 3.0],
+                [6.0, 4.0, 0.0, 3.0, 4.0],
+                [6.0, 3.0, 3.0, 0.0, 4.0],
+                [6.0, 2.0, 4.0, 3.0, 1.0],
+                [6.0, 3.0, 4.0, 2.0, 4.0],
+            ]
+        ),
+        np.array([0, 1, 2, 3, 4]),
+    ),
+    (
+        np.array(
+            [
+                [1.0, 6.0, 3.0, 3.0, 4.0],
+                [5.0, 1.0, 4.0, 3.0, 5.0],
+                [3.0, 5.0, 0.0, 3.0, 3.0],
+                [3.0, 4.0, 3.0, 0.0, 4.0],
+                [3.0, 6.0, 2.0, 3.0, 1.0],
+                [2.0, 6.0, 3.0, 3.0, 4.0],
+            ]
+        ),
+        np.array([0, 1, 2, 3, 4]),
+    ),
+    (
+        np.array(
+            [
+                [0.0, 2.0, 3.0],
+                [2.0, 0.0, 1.0],
+                [3.0, 1.0, 0.0],
+            ]
+        ),
+        np.array([0, 1, 1]),
+    ),
+    (
+        np.array(
+            [
+                [0.0, 1.0, 2.0, 3.0],
+                [1.0, 0.0, 1.0, 2.0],
+                [2.0, 1.0, 0.0, 1.0],
+                [3.0, 2.0, 1.0, 0.0],
+            ]
+        ),
+        np.array([0, 1, 2, 2]),
+    ),
+    (
+        np.array(
+            [
+                [0.0, 1.0, 2.0],
+                [1.0, 0.0, 1.0],
+                [2.0, 1.0, 0.0],
+                [3.0, 2.0, 1.0],
+            ]
+        ),
+        np.array([0, 1, 2]),
+    ),
+    (
+        np.array(
+            [
+                [0.0, 1.0],
+                [1.0, 0.0],
+                [2.0, 1.0],
+                [3.0, 2.0],
+            ]
+        ),
+        np.array([0, 1, 2]),
+    ),
+    (
+        np.array(
+            [
+                [0, 1, 2, 3, 4, 5, 6, 7, 8, 9],
+                [90, 91, 92, 93, 94, 95, 96, 97, 98, 99],
+            ]
+        ),
+        np.array([9, 9, 9, 9, 9, 9, 9, 9, 9, 9])
+    ),
+    (
+        np.array(
+            [
+                [-50, -49, -48, -47, -46, -45, -44, -43, -42, -41],
+                [-10, -9, -8, -7, -6, -5, -4, -3, -2, -1],
+                [0, 1, 2, 3, 4, 5, 6, 7, 8, 9],
+                [40, 41, 42, 43, 44, 45, 46, 47, 48, 49],
+            ]
+        ),
+        np.array([0, 1, 8, 8, 8, 8, 8, 8, 8, 8]),
+    ),
+    (
+        np.array([[-2, -1.5, -1, -0.5, 0, 0.5, 1, 1.5, 2]]),
+        np.array([0, 0, 0, 0, 0, 0, 0, 0, 0]),
+    ),
+    (np.array([[0, 0, 0], [0, 0, 0], [0, 0, 0]]), np.array([0, 0, 0])),
+    (np.array([[0.5, 0.6, 3], [1.3, 2, -1], [-2, 0, 33], [0, 0, 0], [4, 6, -2], [-2, -1, 3]]), np.array([0, 0, 0, 2, 2]))
+]

tests/test_worldmatching.py

@@ -2,6 +2,7 @@ import unittest
 import numpy as np
 from aip_trainer import WordMatching
 from tests.lambdas.test_lambdaSpeechToScore import set_seed
+from tests import constants_wordmatching as const
 
 
 class TestWordMatching(unittest.TestCase):
@@ -14,89 +15,28 @@ class TestWordMatching(unittest.TestCase):
         np.testing.assert_array_equal(result_matrix, expected_matrix)
 
     def test_get_best_path_from_distance_matrix(self):
-        for word_distance_matrix, expected_result_indices in [
-            (np.array([[0, 4], [5, 1], [5, 4]]), np.array([0, 1])),
-            (
-                np.array(
-                    [[0.0, 1.0, 1.0], [1.0, 0.0, 1.0], [1.0, 1.0, 0.0], [1.0, 1.0, 1.0]]
-                ),
-                np.array([0, 1, 2]),
-            ),
-            (
-                np.array(
-                    [
-                        [2.0, 5.0, 5.0, 5.0, 5.0],
-                        [6.0, 0.0, 4.0, 3.0, 3.0],
-                        [6.0, 4.0, 0.0, 3.0, 4.0],
-                        [6.0, 3.0, 3.0, 0.0, 4.0],
-                        [6.0, 2.0, 4.0, 3.0, 1.0],
-                        [6.0, 3.0, 4.0, 2.0, 4.0],
-                    ]
-                ),
-                np.array([0, 1, 2, 3, 4]),
-            ),
-            (
-                np.array(
-                    [
-                        [1.0, 6.0, 3.0, 3.0, 4.0],
-                        [5.0, 1.0, 4.0, 3.0, 5.0],
-                        [3.0, 5.0, 0.0, 3.0, 3.0],
-                        [3.0, 4.0, 3.0, 0.0, 4.0],
-                        [3.0, 6.0, 2.0, 3.0, 1.0],
-                        [2.0, 6.0, 3.0, 3.0, 4.0],
-                    ]
-                ),
-                np.array([0, 1, 2, 3, 4]),
-            ),
-            (
-                np.array(
-                    [
-                        [0.0, 2.0, 3.0],
-                        [2.0, 0.0, 1.0],
-                        [3.0, 1.0, 0.0],
-                    ]
-                ),
-                np.array([0, 1, 1]),
-            ),
-            (
-                np.array(
-                    [
-                        [0.0, 1.0, 2.0, 3.0],
-                        [1.0, 0.0, 1.0, 2.0],
-                        [2.0, 1.0, 0.0, 1.0],
-                        [3.0, 2.0, 1.0, 0.0],
-                    ]
-                ),
-                np.array([0, 1, 2, 2]),
-            ),
-            (
-                np.array(
-                    [
-                        [0.0, 1.0, 2.0],
-                        [1.0, 0.0, 1.0],
-                        [2.0, 1.0, 0.0],
-                        [3.0, 2.0, 1.0],
-                    ]
-                ),
-                np.array([0, 1, 2]),
-            ),
-            (
-                np.array(
-                    [
-                        [0.0, 1.0],
-                        [1.0, 0.0],
-                        [2.0, 1.0],
-                        [3.0, 2.0],
-                    ]
-                ),
-                np.array([0, 1, 2]),
-            ),
-        ]:
-            result_indices = WordMatching.get_best_path_from_distance_matrix(
-                word_distance_matrix
-            )
+        for word_distance_matrix, expected_result_indices in const.get_best_path_from_distance_matrix_constants:
+            set_seed()
+            result_indices = WordMatching.get_best_path_from_distance_matrix(word_distance_matrix)
             np.testing.assert_array_equal(result_indices, expected_result_indices)
 
+    def test_get_best_path_from_distance_matrix_with_inf_values(self):        
+        word_distance_matrix = np.array([[np.inf, 1, 2]])
+        result_indices = WordMatching.get_best_path_from_distance_matrix(word_distance_matrix)
+        self.assertEqual(result_indices, [])
+
+        word_distance_matrix = np.array([[-1, np.inf, 3]])
+        result_indices = WordMatching.get_best_path_from_distance_matrix(word_distance_matrix)
+        self.assertEqual(result_indices, [])
+        
+        word_distance_matrix = np.array([[2, -1, np.inf]])
+        result_indices = WordMatching.get_best_path_from_distance_matrix(word_distance_matrix)
+        self.assertEqual(result_indices, [])
+        
+        word_distance_matrix = np.array([[np.inf, 1, 2], [1, np.inf, 3], [2, 3, np.inf], [-1, -np.inf, 1]])
+        result_indices = WordMatching.get_best_path_from_distance_matrix(word_distance_matrix)
+        self.assertEqual(result_indices, [])
+
     def test_get_resulting_string(self):
         mapped_indices = np.array([0, 1])
         words_estimated = ["hello", "world"]
@@ -153,16 +93,6 @@ class TestWordMatching(unittest.TestCase):
                 assert msg in str(e)
                 raise e
 
-    def test_get_resulting_string_with_empty_lists(self):
-        mapped_indices = np.array([])
-        words_estimated = []
-        words_real = []
-        expected_words = []
-        expected_indices = []
-        result_words, result_indices = WordMatching.get_resulting_string(mapped_indices, words_estimated, words_real)
-        self.assertEqual(result_words, expected_words)
-        self.assertEqual(result_indices, expected_indices)
-
     def test_getWhichLettersWereTranscribedCorrectly_with_empty_strings(self):
         real_word = ""
         transcribed_word = ""
@@ -177,6 +107,23 @@ class TestWordMatching(unittest.TestCase):
         result = WordMatching.getWhichLettersWereTranscribedCorrectly(real_word, transcribed_word)
         self.assertEqual(result, expected_result)
 
+    def test_getWhichLettersWereTranscribedCorrectly_wrong_number_elements_mapped_letters(self):
+        word_real = "ich"
+        mapped_letters=['i', 'c', 'h', "z"]
+        is_letter_correct1 = WordMatching.getWhichLettersWereTranscribedCorrectly(word_real, mapped_letters)  # , mapped_letters_indices)
+        self.assertEqual(is_letter_correct1, [1, 1, 1])
+        
+    def test_getWhichLettersWereTranscribedCorrectly_wrong_number_elements_mapped_letters(self):
+        word_real = "ichh"
+        mapped_letters=['i', 'c', 'h']
+        with self.assertRaises(IndexError):
+            try:
+                WordMatching.getWhichLettersWereTranscribedCorrectly(word_real, mapped_letters)  # , mapped_letters_indices)
+            except IndexError as e:
+                msg = 'list index out of range'
+                assert msg in str(e)
+                raise e
+
     def test_get_best_mapped_words_with_empty_lists(self):
         expected_words = ["?"]
         expected_indices = [0]
@@ -237,6 +184,94 @@ class TestWordMatching(unittest.TestCase):
             self.assertEqual(result_words, expected_letters)
             self.assertEqual(result_indices, expected_indices)
 
+    def test_inner_get_resulting_string(self):
+        error = 99999
+        best_possible_combination = ''
+        best_possible_idx = -1
+        position_of_real_word_indices = np.array([2, 3])
+        word_idx = 2
+        words_estimated = ['ich', 'bin', 'om', 'werbst', 'du', 'wille', 'freude', 'wo', 'no', 'wie', 'essen']
+        words_real = ['Ich', 'bin', 'Tom,', 'wer', 'bist', 'du?', 'Viel', 'Freude.', 'Wollen', 'wir', 'essen?']
+        best_possible_combination, best_possible_idx = WordMatching.inner_get_resulting_string(
+                best_possible_combination, best_possible_idx, error, position_of_real_word_indices,
+                word_idx, words_estimated, words_real
+            )
+        self.assertEqual(best_possible_combination, "om")
+        self.assertEqual(best_possible_idx, 2)
+    
+    def test_inner_get_resulting_string_one_single_word(self):
+        error = 99999
+        best_possible_combination = ''
+        best_possible_idx = -1
+        position_of_real_word_indices = np.array([2, 3])
+        word_idx = 2
+        words_estimated = ['I', "hov-", 'inconsistencess']
+        words_real = ['I', "have", 'inconsistencies']
+        best_possible_combination, best_possible_idx = WordMatching.inner_get_resulting_string(
+                best_possible_combination, best_possible_idx, error, position_of_real_word_indices,
+                word_idx, words_estimated, words_real
+            )
+        self.assertEqual(best_possible_combination, "inconsistencess")
+        self.assertEqual(best_possible_idx, 2)
+
+    def test_inner_get_resulting_string_empty_args(self):
+        error = 99999
+        best_possible_combination = ''
+        best_possible_idx = -1
+        best_possible_combination2, best_possible_idx2 = WordMatching.inner_get_resulting_string(
+            best_possible_combination, best_possible_idx, error, np.array([2, 3]), 0, [], [])
+        self.assertEqual(best_possible_combination2, "")
+        self.assertEqual(best_possible_idx2, -1)
+
+    def test_get_resulting_string(self):
+        set_seed()
+        mapped_indices = np.array([0, 1])
+        words_estimated = ["hollo", "uorld"]
+        words_real = ["hello", "word"]
+        expected_words = ['hollo', 'uorld']
+        expected_indices = [0, 1]
+        result_words, result_indices = WordMatching.get_resulting_string(mapped_indices, words_estimated, words_real)
+        self.assertEqual(result_words, expected_words)
+        self.assertEqual(result_indices, expected_indices)
+
+        mapped_indices = np.array([1, 1])
+        expected_words = ['-', 'uorld']
+        expected_indices = [-1, 1]
+        result_words, result_indices = WordMatching.get_resulting_string(mapped_indices, words_estimated, words_real)
+        self.assertEqual(result_words, expected_words)
+        self.assertEqual(result_indices, expected_indices)
+
+        mapped_indices = np.array([0, 0])
+        expected_words = ['hollo', '-']
+        expected_indices = [0, -1]
+        result_words, result_indices = WordMatching.get_resulting_string(mapped_indices, words_estimated, words_real)
+        self.assertEqual(result_words, expected_words)
+        self.assertEqual(result_indices, expected_indices)
+
+        mapped_indices = np.array([0, -1])
+        expected_words = ["hollo", "-"]
+        expected_indices = [0, -1]
+        result_words, result_indices = WordMatching.get_resulting_string(mapped_indices, words_estimated, words_real)
+        self.assertEqual(result_words, expected_words)
+        self.assertEqual(result_indices, expected_indices)
+        
+        mapped_indices = np.array([-1, -1])
+        expected_words = ["-", "-"]
+        expected_indices = [-1, -1]
+        result_words, result_indices = WordMatching.get_resulting_string(mapped_indices, words_estimated, words_real)
+        self.assertEqual(result_words, expected_words)
+        self.assertEqual(result_indices, expected_indices)
+
+    def test_get_resulting_string_with_empty_lists(self):
+        mapped_indices = np.array([])
+        words_estimated = []
+        words_real = []
+        expected_words = []
+        expected_indices = []
+        result_words, result_indices = WordMatching.get_resulting_string(mapped_indices, words_estimated, words_real)
+        self.assertEqual(result_words, expected_words)
+        self.assertEqual(result_indices, expected_indices)
+
 
 if __name__ == '__main__':
     unittest.main()