test: add test cases for WordMatching module

tests/test_worldmatching.py

@@ -1,6 +1,7 @@
 import unittest
 import numpy as np
 from aip_trainer import WordMatching
+from tests.lambdas.test_lambdaSpeechToScore import set_seed
 
 
 class TestWordMatching(unittest.TestCase):
@@ -8,15 +9,93 @@ class TestWordMatching(unittest.TestCase):
     def test_get_word_distance_matrix(self):
         words_estimated = ["hello", "world"]
         words_real = ["hello", "word"]
-        expected_matrix = np.array([[0.0, 5.0], [4.0, 1.0], [5.0, 4.0]])
+        expected_matrix = np.array([[0., 5.], [4., 1.], [5., 4.]])
         result_matrix = WordMatching.get_word_distance_matrix(words_estimated, words_real)
         np.testing.assert_array_equal(result_matrix, expected_matrix)
 
     def test_get_best_path_from_distance_matrix(self):
-        word_distance_matrix = np.array([[0, 4], [5, 1], [5, 4]])
-        expected_indices = np.array([0, 1])
-        result_indices = WordMatching.get_best_path_from_distance_matrix(word_distance_matrix)
-        np.testing.assert_array_equal(result_indices, expected_indices)
+        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
+            )
+            np.testing.assert_array_equal(result_indices, expected_result_indices)
 
     def test_get_resulting_string(self):
         mapped_indices = np.array([0, 1])
@@ -44,6 +123,120 @@ class TestWordMatching(unittest.TestCase):
         self.assertEqual(result_words, expected_words)
         self.assertEqual(result_indices, expected_indices)
 
+        expected_mapped_letters = ['e', 's', 's', 'e', 'n', '-']
+        expected_mapped_words_indices = [np.int64(0), np.int64(1), np.int64(2), np.int64(3), np.int64(4), -1]
+        output_mapped_letters, output_mapped_words_indices = WordMatching.get_best_mapped_words("essen", "essen?")
+        assert output_mapped_letters == expected_mapped_letters
+        assert output_mapped_words_indices == expected_mapped_words_indices
+
+    def test_get_word_distance_matrix_with_empty_lists(self):
+        words_estimated = []
+        words_real = []
+        expected_matrix = np.arange(0).reshape((1, 0))
+        result_matrix = WordMatching.get_word_distance_matrix(words_estimated, words_real)
+        np.testing.assert_array_equal(result_matrix, expected_matrix)
+
+    def test_get_word_distance_matrix_with_different_lengths(self):
+        words_estimated = ["hello"]
+        words_real = ["hello", "world"]
+        expected_matrix = np.array([[0., 4.], [5., 5.]])
+        result_matrix = WordMatching.get_word_distance_matrix(words_estimated, words_real)
+        np.testing.assert_array_equal(result_matrix, expected_matrix)
+
+    def test_get_best_path_from_distance_matrix_with_empty_matrix_indexerror(self):
+        word_distance_matrix = np.array([])
+        with self.assertRaises(IndexError):
+            try:
+                WordMatching.get_best_path_from_distance_matrix(word_distance_matrix)
+            except IndexError as e:
+                msg = "tuple index out of range"
+                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 = ""
+        expected_result = []
+        result = WordMatching.getWhichLettersWereTranscribedCorrectly(real_word, transcribed_word)
+        self.assertEqual(result, expected_result)
+
+    def test_getWhichLettersWereTranscribedCorrectly_with_different_lengths(self):
+        real_word = "hello"
+        transcribed_word = "hello oo"
+        expected_result = [1, 1, 1, 1, 1]
+        result = WordMatching.getWhichLettersWereTranscribedCorrectly(real_word, transcribed_word)
+        self.assertEqual(result, expected_result)
+
+    def test_get_best_mapped_words_with_empty_lists(self):
+        expected_words = ["?"]
+        expected_indices = [0]
+        result_words, result_indices = WordMatching.get_best_mapped_words("?", "-")
+        self.assertEqual(result_words, expected_words)
+        self.assertEqual(result_indices, expected_indices)
+        expected_words = ['b', 'i', 'n', '-']
+        expected_indices = [np.int64(0), np.int64(1), np.int64(2), -1]
+        result_words, result_indices = WordMatching.get_best_mapped_words("bin", "bind")
+        self.assertEqual(result_words, expected_words)
+        self.assertEqual(result_indices, expected_indices)
+
+    def test_get_best_mapped_words_with_different_lengths(self):
+        result_words, result_indices = WordMatching.get_best_mapped_words("bin", "")
+        self.assertEqual(result_words, [])
+        self.assertEqual(result_indices, [])
+
+    def test_get_best_mapped_words_with_word_estimated_empty_real_word_not_empty(self):
+        result_words, result_indices = WordMatching.get_best_mapped_words("", "bin")
+        self.assertEqual(result_words, ['', '-', '-'])
+        self.assertEqual(result_indices, [-1, -1, -1])
+
+    def test_get_best_mapped_words_with_word_estimated_real_word_both_empty(self):
+        try:
+            with self.assertRaises(IndexError):
+                try:
+                    WordMatching.get_best_mapped_words("", "")
+                except IndexError as ie:
+                    print("raised IndexError...")
+                    msg = "index -1 is out of bounds for axis 1 with size 0"
+                    assert msg in str(ie)
+                    raise ie
+        except AssertionError:
+            # for some reason executing the test in debug mode from Visual Studio Code raises an AssertionError instead of an IndexError
+            print("raised AssertionError instead than IndexError...")
+            with self.assertRaises(AssertionError):
+                try:
+                    WordMatching.get_best_mapped_words("", "")
+                except AssertionError as ae:
+                    msg = "code object dtw_low at "
+                    assert msg in str(ae)
+                    raise ae
+
+    def test_get_best_mapped_words_survived(self):
+        set_seed()
+
+        word_real = "habe"
+        for word_estimated, expected_letters, expected_indices in [
+            ("habe", ["h", "a", "b", "e"], [0, 1, 2, 3]),
+            ("hobe", ["h", "-", "b", "e"], [0, -1, 2, 3]),
+            ("hone", ["h", "-", "-", "e"], [0, -1, -1, 3]),
+            ("honi", ["h", "-", "-", "-"], [0, -1, -1, -1]),
+            ("koni", ["k", "-", "-", "-"], [0, -1, -1, -1]),
+            ("kabe", ["k", "a", "b", "e"], [0, 1, 2, 3]),
+            ("kane", ["k", "a", "-", "e"], [0, 1, -1, 3]),
+        ]:
+            result_words, result_indices = WordMatching.get_best_mapped_words(word_estimated, word_real)
+            self.assertEqual(result_words, expected_letters)
+            self.assertEqual(result_indices, expected_indices)
+
 
 if __name__ == '__main__':
     unittest.main()