Merge pull request loli#62 from cancan101/py3_tests

update tests to work on python3

Author: cancan101

tests/features_/__init__.py

@@ -1,3 +1,3 @@
-from histogram import TestHistogramFeatures
-from intensity import TestIntensityFeatures
-from texture import TestTextureFeatures
+from .histogram import TestHistogramFeatures
+from .intensity import TestIntensityFeatures
+from .texture import TestTextureFeatures

tests/filter_/__init__.py

@@ -1,2 +1,2 @@
-from houghtransform import TestHoughTransform
-from IntensityRangeStandardization import TestIntensityRangeStandardization
+from .houghtransform import TestHoughTransform
+from .IntensityRangeStandardization import TestIntensityRangeStandardization

tests/graphcut_/__init__.py

@@ -1,4 +1,4 @@
-#from cut import TestCut # deactivated since faulty
-from graph import TestGraph
-from energy_label import TestEnergyLabel
-from energy_voxel import TestEnergyVoxel
+#from cut import TestCut # deactivated since faulty
+from .graph import TestGraph
+from .energy_label import TestEnergyLabel
+from .energy_voxel import TestEnergyVoxel

tests/graphcut_/cut.py

@@ -129,9 +129,9 @@ def test_region_based(self):
         # build graph cut graph from graph
         gcgraph = GraphDouble(len(graph_new.get_nodes()), len(graph_new.get_nweights()))
         gcgraph.add_node(len(graph_new.get_nodes()))
-        for node, weight in graph_new.get_tweights().iteritems():
+        for node, weight in graph_new.get_tweights().items():
             gcgraph.add_tweights(int(node - 1), weight[0], weight[1])
-        for edge, weight in graph_new.get_nweights().iteritems():
+        for edge, weight in graph_new.get_nweights().items():
             gcgraph.add_edge(int(edge[0] - 1), int(edge[1] - 1), weight[0], weight[1])    
 
         # execute min-cut / executing BK_MFMC
@@ -153,7 +153,7 @@ def test_region_based(self):
     def __boundary_term(graph, label_image, boundary_term_args):
         "The boundary term function used for this tests."
         dic = TestCut.__get_mapping()
-        for key, value in dic.iteritems():
+        for key, value in dic.items():
             dic[key] = (value, value)
         return dic
 

tests/graphcut_/energy_label.py

@@ -167,7 +167,7 @@ def validate_nweights(self, unittest, expected_result, msg_base = ''):
         """Compares the nweights hold by the graph with the once provided (as a dict)."""
         unittest.assertTrue(len(self.__nweights) == len(expected_result), '{}: Expected {} edges, but {} were added.'.format(msg_base, len(expected_result), len(self.__nweights)))
         node_id_set = set()
-        for key in self.__nweights.iterkeys():
+        for key in self.__nweights.keys():
             node_id_set.add(key[0])
             node_id_set.add(key[1])
         unittest.assertTrue(len(node_id_set) == self.__nodes), '{}: Not all {} node-ids appeared in the edges, but only {}. Missing are {}.'.format(msg_base, self.__nodes, len(node_id_set), set(range(0, self.__nodes)) - node_id_set)
@@ -176,15 +176,15 @@ def validate_nweights(self, unittest, expected_result, msg_base = ''):
     def __compare_dictionaries(self, unittest, result, expected_result, msg_base = ''):
         """Evaluates the returned results."""
         unittest.assertEqual(len(expected_result), len(result), '{}: The expected result dict contains {} entries (for 4-connectedness), instead found {}.'.format(msg_base, len(expected_result), len(result)))
-        for key, value in result.iteritems():
+        for key, value in result.items():
             unittest.assertTrue(key in expected_result, '{}: Region border {} unexpectedly found in expected results.'.format(msg_base, key))
             if key in expected_result:
                 unittest.assertAlmostEqual(value[0], expected_result[key][0], msg='{}: Weight for region border {} is {}. Expected {}.'.format(msg_base, key, value, expected_result[key]), delta=sys.float_info.epsilon)
                 unittest.assertAlmostEqual(value[1], expected_result[key][1], msg='{}: Weight for region border {} is {}. Expected {}.'.format(msg_base, key, value, expected_result[key]), delta=sys.float_info.epsilon)
                 unittest.assertGreater(value[0], 0.0, '{}: Encountered a weight {} <= 0.0 for key {}.'.format(msg_base, value, key))
                 unittest.assertGreater(value[1], 0.0, '{}: Encountered a weight {} <= 0.0 for key {}.'.format(msg_base, value, key))
 
-        for key, value in expected_result.iteritems():
+        for key, value in expected_result.items():
             unittest.assertTrue(key in result, '{}: Region border {} expectedly but not found in results.'.format(msg_base, key))
 
 

tests/graphcut_/energy_voxel.py

@@ -170,4 +170,4 @@ def __print_nweights(self, graph):
         for i in range(n):
             for j in range(i, n):
                 if not i == j:
-                    print i, j, graph.get_edge(i, j)
+                    print(i, j, graph.get_edge(i, j))

tests/graphcut_/graph.py

@@ -36,11 +36,11 @@ def test_GCGraph(self):
 
         # SETTER TESTS
         # set_source_nodes should accept a sequence and raise an error if an invalid node id was passed
-        graph.set_source_nodes(range(0, nodes))
+        graph.set_source_nodes(list(range(0, nodes)))
         self.assertRaises(ValueError, graph.set_source_nodes, [-1])
         self.assertRaises(ValueError, graph.set_source_nodes, [nodes])
         # set_sink_nodes should accept a sequence and raise an error if an invalid node id was passed
-        graph.set_sink_nodes(range(0, nodes))
+        graph.set_sink_nodes(list(range(0, nodes)))
         self.assertRaises(ValueError, graph.set_sink_nodes, [-1])
         self.assertRaises(ValueError, graph.set_sink_nodes, [nodes])
         # set_nweight should accept integers resp. floats and raise an error if an invalid node id was passed or the weight is zero or negative
@@ -79,7 +79,7 @@ def test_GCGraph(self):
         # SOME MINOR GETTERS
         self.assertEqual(graph.get_node_count(), nodes)
         self.assertEqual(graph.get_edge_count(), edges)
-        self.assertSequenceEqual(graph.get_nodes(), range(0, nodes))
+        self.assertSequenceEqual(graph.get_nodes(), list(range(0, nodes)))
 
 if __name__ == '__main__':
     unittest.main()

tests/io_/__init__.py

@@ -1,2 +1,2 @@
-from loadsave import TestIOFacilities
-from metadata import TestMetadataConsistency
+from .loadsave import TestIOFacilities
+from .metadata import TestMetadataConsistency

tests/io_/loadsave.py

@@ -174,7 +174,7 @@ def test_SaveLoad(self):
         try:
             for ndim in __ndims:
                 logger.debug('Testing for dimension {}...'.format(ndim))
-                arr_base = scipy.random.randint(0, 10, range(10, ndim + 10))
+                arr_base = scipy.random.randint(0, 10, list(range(10, ndim + 10)))
                 for dtype in __dtypes:
                     arr_save = arr_base.astype(dtype)
                     for suffix in __suffixes:
@@ -212,29 +212,29 @@ def test_SaveLoad(self):
             raise
 
         if supported:
-            print '\nsave() and load() support (at least) the following image configurations:'
-            print 'type\tndim\tdtypes'
+            print('\nsave() and load() support (at least) the following image configurations:')
+            print('type\tndim\tdtypes')
             for suffix in valid_types:
-                for ndim, dtypes in valid_types[suffix].iteritems():
+                for ndim, dtypes in valid_types[suffix].items():
                     if list == type(dtypes) and not 0 == len(dtypes):
-                        print '{}\t{}D\t{}'.format(suffix, ndim, map(lambda x: str(x).split('.')[-1][:-2], dtypes))
+                        print('{}\t{}D\t{}'.format(suffix, ndim, [str(x).split('.')[-1][:-2] for x in dtypes]))
         if notsupported:
-            print '\nthe following configurations are not supported:'
-            print 'type\tndim\tdtype\t\terror'
+            print('\nthe following configurations are not supported:')
+            print('type\tndim\tdtype\t\terror')
             for suffix in unsupported_type:
                 for ndim in unsupported_type[suffix]:
-                    for dtype, msg in unsupported_type[suffix][ndim].iteritems():
+                    for dtype, msg in unsupported_type[suffix][ndim].items():
                         if msg:
-                            print '{}\t{}D\t{}\t\t{}'.format(suffix, ndim, str(dtype).split('.')[-1][:-2], msg)
+                            print('{}\t{}D\t{}\t\t{}'.format(suffix, ndim, str(dtype).split('.')[-1][:-2], msg))
 
         if inconsistent:
-            print '\nthe following configurations show inconsistent saving and loading behaviour:'
-            print 'type\tndim\tdtype\t\terror'
+            print('\nthe following configurations show inconsistent saving and loading behaviour:')
+            print('type\tndim\tdtype\t\terror')
             for suffix in invalid_types:
                 for ndim in invalid_types[suffix]:
-                    for dtype, msg in invalid_types[suffix][ndim].iteritems():
+                    for dtype, msg in invalid_types[suffix][ndim].items():
                         if msg:
-                            print '{}\t{}D\t{}\t\t{}'.format(suffix, ndim, str(dtype).split('.')[-1][:-2], msg)
+                            print('{}\t{}D\t{}\t\t{}'.format(suffix, ndim, str(dtype).split('.')[-1][:-2], msg))
 
     def __diff(self, arr1, arr2):
         """

tests/io_/metadata.py

@@ -189,7 +189,7 @@ def test_MetadataConsistency(self):
         try:
             for ndim in __ndims:
                 logger.debug('Testing for dimension {}...'.format(ndim))
-                arr_base = scipy.random.randint(0, 10, range(10, ndim + 10))
+                arr_base = scipy.random.randint(0, 10, list(range(10, ndim + 10)))
                 for dtype in __dtypes:
                     arr_save = arr_base.astype(dtype)
                     for suffix_from in __suffixes:
@@ -264,32 +264,32 @@ def test_MetadataConsistency(self):
             raise
 
         if consistent:
-            print '\nthe following format conversions are meta-data consistent:'
-            print 'from\tto\tndim\tdtypes'
+            print('\nthe following format conversions are meta-data consistent:')
+            print('from\tto\tndim\tdtypes')
             for suffix_from in consistent_types:
                 for suffix_to in consistent_types[suffix_from]:
-                    for ndim, dtypes in consistent_types[suffix_from][suffix_to].iteritems():
+                    for ndim, dtypes in consistent_types[suffix_from][suffix_to].items():
                         if list == type(dtypes) and not 0 == len(dtypes):
-                            print '{}\t{}\t{}D\t{}'.format(suffix_from, suffix_to, ndim, map(lambda x: str(x).split('.')[-1][:-2], dtypes))
+                            print('{}\t{}\t{}D\t{}'.format(suffix_from, suffix_to, ndim, [str(x).split('.')[-1][:-2] for x in dtypes]))
         if inconsistent:
-            print '\nthe following form conversions are not meta-data consistent:'
-            print 'from\tto\tndim\tdtype\t\terror'
+            print('\nthe following form conversions are not meta-data consistent:')
+            print('from\tto\tndim\tdtype\t\terror')
             for suffix_from in inconsistent_types:
                 for suffix_to in inconsistent_types[suffix_from]:
                     for ndim in inconsistent_types[suffix_from][suffix_to]:
-                        for dtype, msg in inconsistent_types[suffix_from][suffix_to][ndim].iteritems():
+                        for dtype, msg in inconsistent_types[suffix_from][suffix_to][ndim].items():
                             if msg:
-                                print '{}\t{}\t{}D\t{}\t\t{}'.format(suffix_from, suffix_to, ndim, str(dtype).split('.')[-1][:-2], msg)
+                                print('{}\t{}\t{}D\t{}\t\t{}'.format(suffix_from, suffix_to, ndim, str(dtype).split('.')[-1][:-2], msg))
 
         if unsupported:
-            print '\nthe following form conversions could not be tested due to errors:'
-            print 'from\tto\tndim\tdtype\t\terror'
+            print('\nthe following form conversions could not be tested due to errors:')
+            print('from\tto\tndim\tdtype\t\terror')
             for suffix_from in unsupported_types:
                 for suffix_to in unsupported_types[suffix_from]:
                     for ndim in unsupported_types[suffix_from][suffix_to]:
-                        for dtype, msg in unsupported_types[suffix_from][suffix_to][ndim].iteritems():
+                        for dtype, msg in unsupported_types[suffix_from][suffix_to][ndim].items():
                             if msg:
-                                print '{}\t{}\t{}D\t{}\t\t{}'.format(suffix_from, suffix_to, ndim, str(dtype).split('.')[-1][:-2], msg)
+                                print('{}\t{}\t{}D\t{}\t\t{}'.format(suffix_from, suffix_to, ndim, str(dtype).split('.')[-1][:-2], msg))
 
     def __diff(self, hdr1, hdr2):
         """