[Test] Add matrix generator

- Add utils for input/output matrix from/to disk
- Small bug fix into tests
- Add environment variable - TestMatrix_Path
- Add generators for operations and matrix

Author: Krekep

python/tests/test_duplicate.py

@@ -1,17 +1,25 @@
 import unittest
 import test_utils
+import utils.io_file
 
 
 class TestMatrixDuplicate(unittest.TestCase):
+    def setUp(self) -> None:
+        self.input_matrices = [["matrix_1.mtx"], ["matrix_2.mtx"]]
+        self.result_matrices = ["duplicate_res_1.mtx", "duplicate_res_2.mtx"]
+
     def test_duplicate(self):
         """
         Unit test for duplicate of matrix
         """
-        first_matrix = test_utils.build_matrix_from_file("../data/duplicate.mtx")
-
-        actual_matrix = first_matrix.dup()
+        for i in range(len(self.input_matrices)):
+            matrices = list()
+            for matrix in self.input_matrices[i]:
+                matrices.append(utils.io_file.build_matrix_by_name(matrix))
+            expected_matrix = utils.io_file.build_matrix_by_name(self.result_matrices[i])
+            actual_matrix = matrices[0].dup()
 
-        self.assertTrue(test_utils.compare_matrix(first_matrix, actual_matrix))
+            self.assertTrue(test_utils.compare_matrix(expected_matrix, actual_matrix))
 
 
 if __name__ == "__main__":

python/tests/test_extract_matrix.py

@@ -1,18 +1,26 @@
 import unittest
 import test_utils
+import utils.io_file
 
 
 class TestMatrixExtractMatrix(unittest.TestCase):
+    def setUp(self) -> None:
+        self.input_matrices = [["matrix_1.mtx"], ["matrix_2.mtx"]]
+        self.result_matrices = ["extract_res_1.mtx", "extract_res_2.mtx"]
+
     def test_extract_matrix(self):
         """
         Unit test for extract submatrix from left-upper corner of matrix
         """
-        first_matrix = test_utils.build_matrix_from_file("../data/extract_matrix.mtx")
-        expected_matrix = test_utils.build_matrix_from_file("../data/extract_matrix_result.mtx")
+        for i in range(len(self.input_matrices)):
+            matrices = list()
+            for matrix in self.input_matrices[i]:
+                matrices.append(utils.io_file.build_matrix_by_name(matrix))
+            expected_matrix = utils.io_file.build_matrix_by_name(self.result_matrices[i])
 
-        actual_matrix = first_matrix.extract_matrix(0, 0, expected_matrix.shape)
+            actual_matrix = matrices[0].extract_matrix(0, 0, expected_matrix.shape)
 
-        self.assertTrue(expected_matrix, actual_matrix)
+            self.assertTrue(test_utils.compare_matrix(expected_matrix, actual_matrix))
 
 
 if __name__ == "__main__":

python/tests/test_kronecker.py

@@ -1,19 +1,27 @@
 import unittest
 import test_utils
+import utils.io_file
 
 
 class TestMatrixKronecker(unittest.TestCase):
+    def setUp(self) -> None:
+        self.input_matrices = [["matrix_1.mtx", "matrix_2.mtx"], ["matrix_3.mtx", "matrix_4.mtx"]]
+        self.result_matrices = ["kronecker_res_12.mtx", "kronecker_res_34.mtx"]
+
     def test_kronecker(self):
         """
         Unit test for kronecker product of two matrices
         """
-        first_matrix = test_utils.build_matrix_from_file("../data/kronecker_1.mtx")
-        second_matrix = test_utils.build_matrix_from_file("../data/kronecker_2.mtx")
-
-        actual_matrix = first_matrix.kronecker(second_matrix)
-        expected_matrix = test_utils.build_matrix_from_file("../data/kronecker_result.mtx")
+        for i in range(len(self.input_matrices)):
+            matrices = list()
+            for matrix in self.input_matrices[i]:
+                matrices.append(utils.io_file.build_matrix_by_name(matrix))
+            expected_matrix = utils.io_file.build_matrix_by_name(self.result_matrices[i])
+            first_matrix = matrices[0]
+            second_matrix = matrices[1]
+            actual_matrix = first_matrix.kronecker(second_matrix)
 
-        self.assertTrue(test_utils.compare_matrix(expected_matrix, actual_matrix))
+            self.assertTrue(test_utils.compare_matrix(expected_matrix, actual_matrix))
 
 
 if __name__ == "__main__":

python/tests/test_matrix_add.py

@@ -1,19 +1,27 @@
 import unittest
 import test_utils
+import utils.io_file
 
 
 class TestMatrixAdd(unittest.TestCase):
+    def setUp(self) -> None:
+        self.input_matrices = [["matrix_1.mtx", "matrix_2.mtx"], ["matrix_3.mtx", "matrix_4.mtx"]]
+        self.result_matrices = ["add_res_12.mtx", "add_res_34.mtx"]
+
     def test_add(self):
         """
         Unit test for addition of two matrices
         """
-        first_matrix = test_utils.build_matrix_from_file("../data/add_1.mtx")
-        second_matrix = test_utils.build_matrix_from_file("../data/add_2.mtx")
-
-        actual_matrix = first_matrix.ewiseadd(second_matrix)
-        expected_matrix = test_utils.build_matrix_from_file("../data/add_result.mtx")
+        for i in range(len(self.input_matrices)):
+            matrices = list()
+            for matrix in self.input_matrices[i]:
+                matrices.append(utils.io_file.build_matrix_by_name(matrix))
+            expected_matrix = utils.io_file.build_matrix_by_name(self.result_matrices[i])
+            first_matrix = matrices[0]
+            second_matrix = matrices[1]
+            actual_matrix = first_matrix.ewiseadd(second_matrix)
 
-        self.assertTrue(test_utils.compare_matrix(expected_matrix, actual_matrix))
+            self.assertTrue(test_utils.compare_matrix(expected_matrix, actual_matrix))
 
 
 if __name__ == "__main__":

python/tests/test_matrix_mxm.py

@@ -1,19 +1,27 @@
 import unittest
 import test_utils
+import utils.io_file
 
 
 class TestMatrixMxm(unittest.TestCase):
+    def setUp(self) -> None:
+        self.input_matrices = [["matrix_1.mtx", "matrix_2.mtx"], ["matrix_3.mtx", "matrix_4.mtx"]]
+        self.result_matrices = ["mxm_res_12.mtx", "mxm_res_34.mtx"]
+
     def test_mxm(self):
         """
         Unit test for multiplication of two matrices
         """
-        first_matrix = test_utils.build_matrix_from_file("../data/mxm_1.mtx")
-        second_matrix = test_utils.build_matrix_from_file("../data/mxm_2.mtx")
-
-        actual_matrix = first_matrix.mxm(second_matrix)
-        expected_matrix = test_utils.build_matrix_from_file("../data/mxm_result.mtx")
+        for i in range(len(self.input_matrices)):
+            matrices = list()
+            for matrix in self.input_matrices[i]:
+                matrices.append(utils.io_file.build_matrix_by_name(matrix))
+            expected_matrix = utils.io_file.build_matrix_by_name(self.result_matrices[i])
+            first_matrix = matrices[0]
+            second_matrix = matrices[1]
+            actual_matrix = first_matrix.mxm(second_matrix)
 
-        self.assertTrue(test_utils.compare_matrix(expected_matrix, actual_matrix))
+            self.assertTrue(test_utils.compare_matrix(expected_matrix, actual_matrix))
 
 
 if __name__ == "__main__":

python/tests/test_matrix_properties.py

@@ -1,15 +1,20 @@
 import unittest
-import test_utils
+import utils.io_file
 
 
 class TestMatrixMethods(unittest.TestCase):
-
     def setUp(self) -> None:
-        self.matrix = test_utils.build_matrix_from_file("../data/property.mtx")
+        self.input_matrices = [["matrix_1.mtx"], ["matrix_2.mtx"]]
+        self.result_matrices = ["property_res_1.mtx", "property_res_2.mtx"]
+
+        self.matrices = list()
         self.result_property = list()
-        with open("/matrices/property_result.mtx", 'r') as _file:
-            line = list(map(int, _file.readline().split()))
-            self.result_property.append(line)
+        for i in range(len(self.input_matrices)):
+            for matrix in self.input_matrices[i]:
+                self.matrices.append(utils.io_file.build_matrix_by_name(matrix))
+
+        for i in range(len(self.result_matrices)):
+            self.result_property.append(utils.io_file.build_matrix_by_name(self.result_matrices[i]))
 
     def tearDown(self) -> None:
         """
@@ -20,16 +25,20 @@ def tearDown(self) -> None:
         pass
 
     def test_nrows(self):
-        self.assertEqual(self.result_property[0][0], self.matrix.nrows)
+        for i in range(len(self.matrices)):
+            self.assertEqual(self.result_property[i].nrows, self.matrices[i].nrows)
 
     def test_ncols(self):
-        self.assertEqual(self.result_property[1][0], self.matrix.ncols)
+        for i in range(len(self.matrices)):
+            self.assertEqual(self.result_property[i].ncols, self.matrices[i].ncols)
 
     def test_nvals(self):
-        self.assertEqual(self.result_property[2][0], self.matrix.nvals)
+        for i in range(len(self.matrices)):
+            self.assertEqual(self.result_property[i].nvals, self.matrices[i].nvals)
 
     def test_shape(self):
-        self.assertEqual(self.result_property[0], self.matrix.shape)
+        for i in range(len(self.matrices)):
+            self.assertEqual(self.result_property[i].shape, self.matrices[i].shape)
 
 
 if __name__ == "__main__":

python/tests/test_reduce.py

@@ -1,18 +1,25 @@
 import unittest
 import test_utils
+import utils.io_file
 
 
 class TestMatrixReduce(unittest.TestCase):
+    def setUp(self) -> None:
+        self.input_matrices = [["matrix_1.mtx"], ["matrix_2.mtx"]]
+        self.result_matrices = ["reduce_res_1.mtx", "reduce_res_2.mtx"]
+
     def test_reduce(self):
         """
         Unit test for reduce of matrix
         """
-        first_matrix = test_utils.build_matrix_from_file("../data/reduce.mtx")
-
-        actual_matrix = first_matrix.reduce()
-        expected_matrix = test_utils.build_matrix_from_file("../data/reduce_result.mtx")
+        for i in range(len(self.input_matrices)):
+            matrices = list()
+            for matrix in self.input_matrices[i]:
+                matrices.append(utils.io_file.build_matrix_by_name(matrix))
+            expected_matrix = utils.io_file.build_matrix_by_name(self.result_matrices[i])
+            actual_matrix = matrices[0].reduce()
 
-        self.assertTrue(test_utils.compare_matrix(expected_matrix, actual_matrix))
+            self.assertTrue(test_utils.compare_matrix(expected_matrix, actual_matrix))
 
 
 if __name__ == "__main__":

python/tests/test_to_lists.py

@@ -1,24 +1,36 @@
 import unittest
-import test_utils
+import utils.io_file
 
 
 class TestMatrixToLists(unittest.TestCase):
     def setUp(self) -> None:
-        self.matrix = test_utils.build_matrix_from_file("../data/to_lists.mtx")
+        self.input_matrices = [["matrix_1.mtx"], ["matrix_2.mtx"]]
+        self.result_matrices = ["to_lists_res_1.mtx", "to_lists_res_2.mtx"]
+
+        self.matrices = list()
         self.result_lists = list()
-        with open("../data/to_lists_result.mtx", 'r') as _file:
-            line = list(map(int, _file.readline().split()))
-            self.result_lists.append(line)
+        for i in range(len(self.input_matrices)):
+            for matrix in self.input_matrices[i]:
+                self.matrices.append(utils.io_file.build_matrix_by_name(matrix))
+
+        for i in range(len(self.result_matrices)):
+            self.result_lists.append(utils.io_file.build_matrix_by_name(self.result_matrices[i]))
 
     def test_to_lists(self):
         """
         Unit test to extract a matrix as two lists
         """
+        for i in range(len(self.matrices)):
 
-        actual_rows, actual_cols = self.matrix.to_lists()
+            actual_rows, actual_cols = self.matrices[i].to_lists()
+            expected_rows, expected_cols = self.result_lists[i].to_lists()
 
-        self.assertListEqual(self.result_lists[0], actual_rows)
-        self.assertListEqual(self.result_lists[1], actual_cols)
+            # element-wise compare
+            if len(actual_cols) != len(expected_cols) and len(expected_rows) != len(actual_rows):
+                self.assertTrue(False, msg="Length of lists doesn't match")
+            for j in range(len(actual_cols)):
+                self.assertEqual(expected_rows[j], actual_rows[j])
+                self.assertEqual(expected_cols[j], actual_cols[j])
 
 
 if __name__ == "__main__":

python/tests/test_transpose.py

@@ -1,18 +1,25 @@
 import unittest
 import test_utils
+import utils.io_file
 
 
 class TestMatrixTranspose(unittest.TestCase):
+    def setUp(self) -> None:
+        self.input_matrices = [["matrix_1.mtx"], ["matrix_2.mtx"]]
+        self.result_matrices = ["transpose_res_1.mtx", "transpose_res_2.mtx"]
+
     def test_transpose(self):
         """
         Unit test for transpose of matrix
         """
-        first_matrix = test_utils.build_matrix_from_file("../data/transpose.mtx")
-
-        actual_matrix = first_matrix.transpose()
-        expected_matrix = test_utils.build_matrix_from_file("../data/transpose_result.mtx")
+        for i in range(len(self.input_matrices)):
+            matrices = list()
+            for matrix in self.input_matrices[i]:
+                matrices.append(utils.io_file.build_matrix_by_name(matrix))
+            expected_matrix = utils.io_file.build_matrix_by_name(self.result_matrices[i])
+            actual_matrix = matrices[0].transpose()
 
-        self.assertTrue(test_utils.compare_matrix(expected_matrix, actual_matrix))
+            self.assertTrue(test_utils.compare_matrix(expected_matrix, actual_matrix))
 
 
 if __name__ == "__main__":

python/tests/test_utils.py

@@ -1,44 +1,20 @@
 import pycubool
 
 
-def _read_matrix_mtx(path: str):
-    """
-    Read matrix from file
-    """
-    with open(path, 'r') as file:
-        n, m, nvals = map(int, file.readline().split())
-        rows = list()
-        cols = list()
-        for k in range(nvals):
-            i, j = map(int, file.readline().split())
-            rows.append(i)
-            cols.append(j)
-    return n, m, [rows, cols]
-
-
-def build_matrix_from_file(path: str) -> pycubool.Matrix:
-    n, m, matrix = _read_matrix_mtx(path)
-    nvals = len(matrix[0])
-    result = pycubool.Matrix.empty([n, m])
-    result.build(matrix[0], matrix[1], nvals)
-
-    return result
-
-
 def compare_matrix(a: pycubool.Matrix, b: pycubool.Matrix) -> bool:
     a_rows, a_cols = a.to_lists()
     b_rows, b_cols = b.to_lists()
 
     if len(a_rows) != len(b_rows):
         return False
-    n = a_rows
+    n = len(a_rows)
     for i in range(n):
         if a_rows[i] != b_rows[i]:
             return False
 
     if len(a_cols) != len(b_cols):
         return False
-    m = a_cols
+    m = len(a_cols)
     for i in range(m):
         if a_cols[i] != b_cols[i]:
             return False