[xferfcn_input_test.py] Style refactor

don4get · don4get · commit 573191855ab7 · 2019-01-04T23:37:27.000+01:00
- pep8 warnings
- camel case functions to lower case
diff --git a/control/tests/xferfcn_input_test.py b/control/tests/xferfcn_input_test.py
@@ -12,105 +12,105 @@
 
 from control.xferfcn import _clean_part
 
+
 class TestXferFcnInput(unittest.TestCase):
-    """These are tests for functionality of cleaning and validating 
-    XferFucnInput."""
+    """These are tests for functionality of cleaning and validating XferFcnInput."""
 
     # Tests for raising exceptions.
-    def testBadInputType(self):
+    def test_clean_part_bad_input_type(self):
         """Give the part cleaner invalid input type."""
 
         self.assertRaises(TypeError, _clean_part, [[0., 1.], [2., 3.]])
 
-    def testBadInputType2(self):
+    def test_clean_part_bad_input_type2(self):
         """Give the part cleaner another invalid input type."""
         self.assertRaises(TypeError, _clean_part, [1, "a"])
 
-    def testScalar(self):
+    def test_clean_part_scalar(self):
         """Test single scalar value."""
         num = 1
         num_ = _clean_part(num)
-        
+
         assert isinstance(num_, list)
         assert np.all([isinstance(part, list) for part in num_])
         np.testing.assert_array_equal(num_[0][0], array([1.0], dtype=float))
 
-    def testListScalar(self):
+    def test_clean_part_list_scalar(self):
         """Test single scalar value in list."""
         num = [1]
         num_ = _clean_part(num)
-        
+
         assert isinstance(num_, list)
         assert np.all([isinstance(part, list) for part in num_])
         np.testing.assert_array_equal(num_[0][0], array([1.0], dtype=float))
-      
-    def testTupleScalar(self):
+
+    def test_clean_part_tuple_scalar(self):
         """Test single scalar value in tuple."""
         num = (1)
         num_ = _clean_part(num)
-        
+
         assert isinstance(num_, list)
         assert np.all([isinstance(part, list) for part in num_])
         np.testing.assert_array_equal(num_[0][0], array([1.0], dtype=float))
 
-    def testList(self):
+    def test_clean_part_list(self):
         """Test multiple values in a list."""
         num = [1, 2]
         num_ = _clean_part(num)
-        
+
         assert isinstance(num_, list)
         assert np.all([isinstance(part, list) for part in num_])
         np.testing.assert_array_equal(num_[0][0], array([1.0, 2.0], dtype=float))
 
-    def testTuple(self):
+    def test_clean_part_tuple(self):
         """Test multiple values in tuple."""
         num = (1, 2)
         num_ = _clean_part(num)
-        
+
         assert isinstance(num_, list)
         assert np.all([isinstance(part, list) for part in num_])
         np.testing.assert_array_equal(num_[0][0], array([1.0, 2.0], dtype=float))
-            
-    def testAllScalarTypes(self):
+
+    def test_clean_part_all_scalar_types(self):
         """Test single scalar value for all valid data types."""
         for dtype in [int, int8, int16, int32, int64, float, float16, float32, float64, float128]:
             num = dtype(1)
             num_ = _clean_part(num)
-            
+
             assert isinstance(num_, list)
             assert np.all([isinstance(part, list) for part in num_])
             np.testing.assert_array_equal(num_[0][0], array([1.0], dtype=float))
-       
-    def testNpArray(self):
+
+    def test_clean_part_np_array(self):
         """Test multiple values in numpy array."""
         num = np.array([1, 2])
         num_ = _clean_part(num)
-        
+
         assert isinstance(num_, list)
         assert np.all([isinstance(part, list) for part in num_])
         np.testing.assert_array_equal(num_[0][0], array([1.0, 2.0], dtype=float))
-        
-    def testAllNumpyArrayTypes(self):      
+
+    def test_clean_part_all_np_array_types(self):
         """Test scalar value in numpy array of ndim=0 for all data types."""
         for dtype in [int, int8, int16, int32, int64, float, float16, float32, float64, float128]:
             num = np.array(1, dtype=dtype)
             num_ = _clean_part(num)
-            
+
             assert isinstance(num_, list)
             assert np.all([isinstance(part, list) for part in num_])
             np.testing.assert_array_equal(num_[0][0], array([1.0], dtype=float))
 
-    def testAllNumpyArrayTypes2(self):      
+    def test_clean_part_all_np_array_types2(self):
         """Test numpy array for all types."""
         for dtype in [int, int8, int16, int32, int64, float, float16, float32, float64, float128]:
             num = np.array([1, 2], dtype=dtype)
             num_ = _clean_part(num)
-            
+
             assert isinstance(num_, list)
             assert np.all([isinstance(part, list) for part in num_])
             np.testing.assert_array_equal(num_[0][0], array([1.0, 2.0], dtype=float))
-           
-    def testListAllTypes(self):
+
+    def test_clean_part_list_all_types(self):
         """Test list of a single value for all data types."""
         for dtype in [int, int8, int16, int32, int64, float, float16, float32, float64, float128]:
             num = [dtype(1)]
@@ -119,133 +119,133 @@ def testListAllTypes(self):
             assert np.all([isinstance(part, list) for part in num_])
             np.testing.assert_array_equal(num_[0][0], array([1.0], dtype=float))
 
-    def testListAllTypes2(self):
+    def test_clean_part_list_all_types2(self):
         """List of list of numbers of all data types."""
         for dtype in [int, int8, int16, int32, int64, float, float16, float32, float64, float128]:
             num = [dtype(1), dtype(2)]
             num_ = _clean_part(num)
             assert isinstance(num_, list)
             assert np.all([isinstance(part, list) for part in num_])
             np.testing.assert_array_equal(num_[0][0], array([1.0, 2.0], dtype=float))
-            
-    def testTupleAllTypes(self):
+
+    def test_clean_part_tuple_all_types(self):
         """Test tuple of a single value for all data types."""
         for dtype in [int, int8, int16, int32, int64, float, float16, float32, float64, float128]:
             num = (dtype(1),)
             num_ = _clean_part(num)
             assert isinstance(num_, list)
             assert np.all([isinstance(part, list) for part in num_])
             np.testing.assert_array_equal(num_[0][0], array([1.0], dtype=float))
-            
-    def testTupleAllTypes2(self):
+
+    def test_clean_part_tuple_all_types2(self):
         """Test tuple of a single value for all data types."""
         for dtype in [int, int8, int16, int32, int64, float, float16, float32, float64, float128]:
             num = (dtype(1), dtype(2))
             num_ = _clean_part(num)
             assert isinstance(num_, list)
             assert np.all([isinstance(part, list) for part in num_])
             np.testing.assert_array_equal(num_[0][0], array([1, 2], dtype=float))
-    
-    def testListListListInt(self):
+
+    def test_clean_part_list_list_list_int(self):
         """ Test an int in a list of a list of a list."""
         num = [[[1]]]
         num_ = _clean_part(num)
         assert isinstance(num_, list)
         assert np.all([isinstance(part, list) for part in num_])
         np.testing.assert_array_equal(num_[0][0], array([1.0], dtype=float))
 
-    def testListListListFloat(self):
+    def test_clean_part_list_list_list_float(self):
         """ Test a float in a list of a list of a list."""
         num = [[[1.0]]]
         num_ = _clean_part(num)
         assert isinstance(num_, list)
         assert np.all([isinstance(part, list) for part in num_])
         np.testing.assert_array_equal(num_[0][0], array([1.0], dtype=float))
-       
-    def testListListListInts(self):
+
+    def test_clean_part_list_list_list_ints(self):
         """Test 2 lists of ints in a list in a list."""
-        num = [[[1,1],[2,2]]]
+        num = [[[1, 1], [2, 2]]]
         num_ = _clean_part(num)
-        
+
         assert isinstance(num_, list)
         assert np.all([isinstance(part, list) for part in num_])
         np.testing.assert_array_equal(num_[0][0], array([1.0, 1.0], dtype=float))
         np.testing.assert_array_equal(num_[0][1], array([2.0, 2.0], dtype=float))
-        
-    def testListListListFloats(self):
+
+    def test_clean_part_list_list_list_floats(self):
         """Test 2 lists of ints in a list in a list."""
-        num = [[[1.0,1.0],[2.0,2.0]]]
+        num = [[[1.0, 1.0], [2.0, 2.0]]]
         num_ = _clean_part(num)
-        
+
         assert isinstance(num_, list)
         assert np.all([isinstance(part, list) for part in num_])
         np.testing.assert_array_equal(num_[0][0], array([1.0, 1.0], dtype=float))
         np.testing.assert_array_equal(num_[0][1], array([2.0, 2.0], dtype=float))
- 
-    def testListListArray(self):
+
+    def test_clean_part_list_list_array(self):
         """List of list of numpy arrays for all valid types."""
         for dtype in int, int8, int16, int32, int64, float, float16, float32, float64, float128:
-            num = [[array([1,1], dtype=dtype),array([2,2], dtype=dtype)]]
+            num = [[array([1, 1], dtype=dtype), array([2, 2], dtype=dtype)]]
             num_ = _clean_part(num)
-            
+
             assert isinstance(num_, list)
             assert np.all([isinstance(part, list) for part in num_])
             np.testing.assert_array_equal(num_[0][0], array([1.0, 1.0], dtype=float))
             np.testing.assert_array_equal(num_[0][1], array([2.0, 2.0], dtype=float))
 
-    def testTupleListArray(self):
+    def test_clean_part_tuple_list_array(self):
         """Tuple of list of numpy arrays for all valid types."""
         for dtype in int, int8, int16, int32, int64, float, float16, float32, float64, float128:
-            num = ([array([1,1], dtype=dtype),array([2,2], dtype=dtype)],)
+            num = ([array([1, 1], dtype=dtype), array([2, 2], dtype=dtype)],)
             num_ = _clean_part(num)
-            
+
             assert isinstance(num_, list)
             assert np.all([isinstance(part, list) for part in num_])
             np.testing.assert_array_equal(num_[0][0], array([1.0, 1.0], dtype=float))
             np.testing.assert_array_equal(num_[0][1], array([2.0, 2.0], dtype=float))
-            
-    def testListTupleArray(self):
+
+    def test_clean_part_list_tuple_array(self):
         """List of tuple of numpy array for all valid types."""
         for dtype in int, int8, int16, int32, int64, float, float16, float32, float64, float128:
-            num = [(array([1,1], dtype=dtype),array([2,2], dtype=dtype))]
+            num = [(array([1, 1], dtype=dtype), array([2, 2], dtype=dtype))]
             num_ = _clean_part(num)
-            
+
             assert isinstance(num_, list)
             assert np.all([isinstance(part, list) for part in num_])
             np.testing.assert_array_equal(num_[0][0], array([1.0, 1.0], dtype=float))
             np.testing.assert_array_equal(num_[0][1], array([2.0, 2.0], dtype=float))
-    
-    def testTupleTuplesArrays(self):
+
+    def test_clean_part_tuple_tuples_arrays(self):
         """Tuple of tuples of numpy arrays for all valid types."""
         for dtype in int, int8, int16, int32, int64, float, float16, float32, float64, float128:
-            num = ((array([1,1], dtype=dtype),array([2,2], dtype=dtype)),
-                   (array([3,4], dtype=dtype),array([4,4], dtype=dtype)))
+            num = ((array([1, 1], dtype=dtype), array([2, 2], dtype=dtype)),
+                   (array([3, 4], dtype=dtype), array([4, 4], dtype=dtype)))
             num_ = _clean_part(num)
-            
+
             assert isinstance(num_, list)
             assert np.all([isinstance(part, list) for part in num_])
             np.testing.assert_array_equal(num_[0][0], array([1.0, 1.0], dtype=float))
             np.testing.assert_array_equal(num_[0][1], array([2.0, 2.0], dtype=float))
-    
-    def testListTuplesArrays(self):
+
+    def test_clean_part_list_tuples_arrays(self):
         """List of tuples of numpy arrays for all valid types."""
         for dtype in int, int8, int16, int32, int64, float, float16, float32, float64, float128:
-            num = [(array([1,1], dtype=dtype),array([2,2], dtype=dtype)),
-                   (array([3,4], dtype=dtype),array([4,4], dtype=dtype))]
+            num = [(array([1, 1], dtype=dtype), array([2, 2], dtype=dtype)),
+                   (array([3, 4], dtype=dtype), array([4, 4], dtype=dtype))]
             num_ = _clean_part(num)
-            
+
             assert isinstance(num_, list)
             assert np.all([isinstance(part, list) for part in num_])
             np.testing.assert_array_equal(num_[0][0], array([1.0, 1.0], dtype=float))
             np.testing.assert_array_equal(num_[0][1], array([2.0, 2.0], dtype=float))
 
-    def testListListArrays(self):
+    def test_clean_part_list_list_arrays(self):
         """List of list of numpy arrays for all valid types."""
         for dtype in int, int8, int16, int32, int64, float, float16, float32, float64, float128:
-            num = [[array([1,1], dtype=dtype),array([2,2], dtype=dtype)],
-                   [array([3,3], dtype=dtype),array([4,4], dtype=dtype)]]
+            num = [[array([1, 1], dtype=dtype), array([2, 2], dtype=dtype)],
+                   [array([3, 3], dtype=dtype), array([4, 4], dtype=dtype)]]
             num_ = _clean_part(num)
-            
+
             assert len(num_) == 2
             assert np.all([isinstance(part, list) for part in num_])
             assert np.all([len(part) == 2 for part in num_])
@@ -254,8 +254,10 @@ def testListListArrays(self):
             np.testing.assert_array_equal(num_[1][0], array([3.0, 3.0], dtype=float))
             np.testing.assert_array_equal(num_[1][1], array([4.0, 4.0], dtype=float))
 
+
 def suite():
     return unittest.TestLoader().loadTestsFromTestCase(TestXferFcnInput)
 
+
 if __name__ == "__main__":
     unittest.main()
