Merge pull request #37 from haoxingz/test_more

Test more

Author: arokem

pymatbridge/tests/test_function_processor.py

@@ -0,0 +1,21 @@
+import pymatbridge as pymat
+import numpy.testing as npt
+import test_utils as tu
+
+
+class TestFunctionProcessor:
+
+    # Start a Matlab session before running any tests
+    @classmethod
+    def setup_class(cls):
+        cls.mlab = tu.connect_to_matlab()
+
+    # Tear down the Matlab session after running all the tests
+    @classmethod
+    def teardown_class(cls):
+        tu.stop_matlab(cls.mlab)
+
+    # Test the "is_function_processor_working()" function
+    def test_is_function_processor_working(self):
+        npt.assert_equal(self.mlab.is_function_processor_working(), True)
+

pymatbridge/tests/test_get_variable.py

@@ -0,0 +1,42 @@
+import pymatbridge as pymat
+import numpy.testing as npt
+import test_utils as tu
+
+
+class TestGetVariable:
+
+    # Start a Matlab session before running any tests
+    @classmethod
+    def setup_class(cls):
+        cls.mlab = tu.connect_to_matlab()
+
+    # Tear down the Matlab session after running all the tests
+    @classmethod
+    def teardown_class(cls):
+        tu.stop_matlab(cls.mlab)
+
+
+    # Set up a floating point and get it
+    def test_get_float(self):
+        self.mlab.run_code("a = 456345.345345")
+        self.mlab.run_code("b = 0.39748e3")
+
+        npt.assert_equal(self.mlab.get_variable('a'), unicode("456345.3453"))
+        npt.assert_equal(self.mlab.get_variable('b'), unicode("397.48"))
+
+
+    # Get some arrays
+    def test_get_array(self):
+        self.mlab.run_code("a = [1 2 3 4]")
+        self.mlab.run_code("b = [1 2; 3 4]")
+
+        npt.assert_equal(self.mlab.get_variable('a'), unicode("[1,2,3,4]"))
+        npt.assert_equal(self.mlab.get_variable('b'), unicode("[[1,2],[3,4]]"))
+
+
+    # Try to get a non-existent variable
+    # This one will always fail now since the matlab function cannot handle this situation
+#    def test_nonexistent_var(self):
+#        self.mlab.run_code("clear")
+
+#        npt.assert_equal(self.mlab.get_variable('a'), unicode("456345.3453"))

pymatbridge/tests/test_precision.py

@@ -23,7 +23,7 @@ def test_float64_roundtrip(self):
         for i in range(0,10):
             val = np.float64(rd.random())
             res = self.mlab.run_func('precision_pass.m', {'val':val})['result']
-            npt.assert_almost_equal(res, val, decimal=8, err_msg="Float64 roundtrip error")
+            npt.assert_almost_equal(res, val, decimal=7, err_msg="Float64 roundtrip error")
 
     # Add two 64-bit floating number in Matlab and return the sum
     def test_float64_sum(self):
@@ -32,7 +32,7 @@ def test_float64_sum(self):
             val2 = np.float64(rd.random())
 
             res = self.mlab.run_func('precision_sum.m', {'val1':val1, 'val2':val2})['result']
-            npt.assert_almost_equal(res, val1 + val2, decimal=8, err_msg="Float64 sum error")
+            npt.assert_almost_equal(res, val1 + val2, decimal=7, err_msg="Float64 sum error")
 
     # Multiply two 64-bit floating number in Matlab and return the product
     def test_float64_multiply(self):
@@ -41,7 +41,7 @@ def test_float64_multiply(self):
             val2 = np.float64(rd.random())
 
             res = self.mlab.run_func('precision_multiply.m', {'val1':val1, 'val2':val2})['result']
-            npt.assert_almost_equal(res, val1 * val2, decimal=8, err_msg="Float64 multiply error")
+            npt.assert_almost_equal(res, val1 * val2, decimal=7, err_msg="Float64 multiply error")
 
     # Make a division in Matlab and return the results
     def test_float64_divide(self):
@@ -50,12 +50,12 @@ def test_float64_divide(self):
             val2 = np.float64(rd.random())
 
             res = self.mlab.run_func('precision_divide.m', {'val1':val1, 'val2':val2})['result']
-            npt.assert_almost_equal(res, val1 / val2, decimal=8, err_msg="Float64 divide error")
+            npt.assert_almost_equal(res, val1 / val2, decimal=7, err_msg="Float64 divide error")
 
     # Calculate the square root in Matlab and return the result
     def test_float64_sqrt(self):
         for i in range(0,10):
             val = np.float64(rd.random())
 
             res = self.mlab.run_func('precision_sqrt.m', {'val':val})['result']
-            npt.assert_almost_equal(res, np.sqrt(val), decimal=8, err_msg="Float64 square root error")
+            npt.assert_almost_equal(res, np.sqrt(val), decimal=7, err_msg="Float64 square root error")

pymatbridge/tests/test_run_code.py

@@ -0,0 +1,53 @@
+import pymatbridge as pymat
+import numpy.testing as npt
+import test_utils as tu
+
+
+class TestRunCode:
+
+    # Start a Matlab session before running any tests
+    @classmethod
+    def setup_class(cls):
+        cls.mlab = tu.connect_to_matlab()
+
+    # Tear down the Matlab session after running all the tests
+    @classmethod
+    def teardown_class(cls):
+        tu.stop_matlab(cls.mlab)
+
+    # Running 'disp()' in Matlab command window
+    def test_disp(self):
+        result1 = self.mlab.run_code("disp('Hello world')")['content']['stdout']
+        result2 = self.mlab.run_code("disp('   ')")['content']['stdout']
+        result3 = self.mlab.run_code("disp('')")['content']['stdout']
+
+        npt.assert_equal(result1, "Hello world\n")
+        npt.assert_equal(result2, "   \n")
+        npt.assert_equal(result3, "")
+
+    # Make some assignments and run basic operations
+    def test_basic_operation(self):
+        result_assignment_a = self.mlab.run_code("a = 21.23452261")['content']['stdout']
+        result_assignment_b = self.mlab.run_code("b = 347.745")['content']['stdout']
+        result_sum = self.mlab.run_code("a + b")['content']['stdout']
+        result_diff = self.mlab.run_code("a - b")['content']['stdout']
+        result_product = self.mlab.run_code("a * b")['content']['stdout']
+        result_division = self.mlab.run_code("c = a / b")['content']['stdout']
+
+
+        npt.assert_equal(result_assignment_a, unicode("\na =\n\n   21.2345\n\n"))
+        npt.assert_equal(result_assignment_b, unicode("\nb =\n\n  347.7450\n\n"))
+        npt.assert_equal(result_sum, unicode("\nans =\n\n  368.9795\n\n"))
+        npt.assert_equal(result_diff, unicode("\nans =\n\n -326.5105\n\n"))
+        npt.assert_equal(result_product, unicode("\nans =\n\n   7.3842e+03\n\n"))
+        npt.assert_equal(result_division, unicode("\nc =\n\n    0.0611\n\n"))
+
+    # Put in some undefined code
+    def test_undefined_code(self):
+        success = self.mlab.run_code("this_is_nonsense")['success']
+        message = self.mlab.run_code("this_is_nonsense")['content']['stdout']
+
+        npt.assert_equal(success, "false")
+        npt.assert_equal(message, "Undefined function or variable 'this_is_nonsense'.")
+
+