Changeset 10278:f3b1ffae9c29 in orange


Ignore:
Timestamp:
02/17/12 13:27:15 (2 years ago)
Author:
Miha Stajdohar <miha.stajdohar@…>
Branch:
default
rebase_source:
0a770acc57c43270dedd0ddeebb4b7c806f4d191
Message:

Unittest2 for python 2.6.

Location:
Orange/testing
Files:
32 edited

Legend:

Unmodified
Added
Removed
  • Orange/testing/doctest/dtest.py

    r10015 r10278  
    11import os 
    22import doctest 
    3 import unittest 
     3try: 
     4    import unittest2 as unittest 
     5except: 
     6    import unittest 
    47import sys 
    58 
  • Orange/testing/unit/test-examples.py

    r9679 r10278  
    1 import unittest 
     1try: 
     2    import unittest2 as unittest 
     3except: 
     4    import unittest 
    25import os, sys 
    36from optparse import OptionParser 
     
    2225    print "Unknown module name!" 
    2326    sys.exit(1) 
    24      
     27 
    2528orangedir = os.path.dirname(orange.__file__) 
    26      
     29 
    2730from Orange.testing import test_suite_scripts 
    2831 
  • Orange/testing/unit/test_all.py

    r10183 r10278  
    11import os.path 
    2 import unittest 
     2try: 
     3    import unittest2 as unittest 
     4except: 
     5    import unittest 
    36 
    47 
  • Orange/testing/unit/tests/test_c45.py

    r10153 r10278  
    11from Orange.misc import testing 
    2 import unittest 
     2try: 
     3    import unittest2 as unittest 
     4except: 
     5    import unittest 
    36import orange 
    47 
     
    710    def setUp(self): 
    811        self.learner = orange.C45Learner 
    9          
     12 
    1013    @testing.test_on_data 
    1114    def test_learner_on(self, dataset): 
     
    1518            raise unittest.SkipTest("C45 dll not found") 
    1619        testing.LearnerTestCase.test_learner_on(self, dataset) 
    17         
     20 
    1821    @testing.test_on_data 
    1922    def test_pickling_on(self, dataset): 
  • Orange/testing/unit/tests/test_data_utils.py

    r9679 r10278  
    33import Orange 
    44 
    5 import unittest 
     5try: 
     6    import unittest2 as unittest 
     7except: 
     8    import unittest 
    69import random 
    710 
     
    1417        indices = range(size) 
    1518        to_mask = lambda inds: [i for i in indices if i in inds] 
    16          
     19 
    1720        indices1 = [random.randrange(size)] 
    1821        indices2 = indices1 + [random.randrange(size)] 
    1922        indices3 = indices1 + [random.randrange(size)] 
    20          
     23 
    2124        mask1 = to_mask(indices1) 
    2225        mask2 = to_mask(indices2) 
    2326        mask3 = to_mask(indices3) 
    24          
     27 
    2528        data1 = utils.take(data, indices1, axis=1) 
    2629        data1m = utils.take(data, mask1, axis=1) 
     
    2831        self.assertEquals(len(data1m.domain), len(set(indices1))) 
    2932#        self.assertEquals(list(data1), list(data1m)) 
    30          
     33 
    3134        data2 = utils.take(data, indices2, axis=1) 
    3235        data2m = utils.take(data, mask2, axis=1) 
     
    3437        self.assertEquals(len(data2m.domain), len(set(indices2))) 
    3538#        self.assertEquals(list(data2), list(data2m)) 
    36          
     39 
    3740        data3 = utils.take(data, indices3, axis=1) 
    3841        data3m = utils.take(data, mask3, axis=1) 
     
    4649        indices = range(len(data)) 
    4750        to_mask = lambda inds: [i for i in indices if i in inds] 
    48          
     51 
    4952        indices1 = [random.randrange(size)] 
    5053        indices2 = indices1 + [random.randrange(size)] 
    5154        indices3 = indices1 + [random.randrange(size)] 
    52          
     55 
    5356        mask1 = to_mask(indices1) 
    5457        mask2 = to_mask(indices2) 
    5558        mask3 = to_mask(indices3) 
    56          
     59 
    5760        data1 = utils.take(data, indices1, axis=0) 
    5861        data1m = utils.take(data, mask1, axis=0) 
    5962        self.assertEquals(len(data1), len(indices1)) 
    6063        self.assertEquals(len(data1m), len(set(indices1))) 
    61          
     64 
    6265        data2 = utils.take(data, indices2, axis=0) 
    6366        data2m = utils.take(data, mask2, axis=0) 
    6467        self.assertEquals(len(data2), len(indices2)) 
    6568        self.assertEquals(len(data2m), len(set(indices2))) 
    66          
     69 
    6770        data3 = utils.take(data, indices3, axis=0) 
    6871        data3m = utils.take(data, mask3, axis=0) 
     
    7477    indices = range(size) 
    7578    to_mask = lambda inds: [i for i in indices if i in inds] 
    76      
     79 
    7780    indices = [random.randrange(size) for i in range(2)] 
    7881    part1 = utils.take(table, indices, axis=1) 
    7982    complement = [i for i in range(len(table.domain)) if i not in indices] 
    8083    part2 = utils.take(table, complement, axis=1) 
    81      
     84 
    8285    return part1, part2 
    8386 
    84 @testing.datasets_driven         
     87@testing.datasets_driven 
    8588class TestJoins(unittest.TestCase): 
    8689    @testing.test_on_data 
     
    8992        part1, part2 = split(table) 
    9093        utils.left_join(part1, part2, utils._row_meta_id, utils._row_meta_id) 
    91          
     94 
    9295    @testing.test_on_data 
    9396    def test_right_join(self, table): 
     
    9598        part1, part2 = split(table) 
    9699        utils.right_join(part1, part2, utils._row_meta_id, utils._row_meta_id) 
    97      
     100 
    98101if __name__ == "__main__": 
    99102    unittest.main() 
  • Orange/testing/unit/tests/test_demo.py

    r9679 r10278  
    11from Orange.misc import testing 
    22from Orange.misc.testing import data_driven, datasets_driven, test_on_data 
    3 import unittest 
     3try: 
     4    import unittest2 as unittest 
     5except: 
     6    import unittest 
    47 
    5 data = [("one", (1, )), 
    6         ("two", (2, ))] 
     8data = [("one", (1,)), 
     9        ("two", (2,))] 
    710 
    811# Data driven with data_iter arg 
     
    1316        print arg 
    1417        self.assertIsInstance(arg, int) 
    15          
     18 
    1619    @testing.test_on_data 
    1720    def test_add(self, arg): 
    1821        print arg 
    1922        res = arg + arg 
    20          
     23 
    2124# data_driven without arg 
    22 @data_driven  
     25@data_driven 
    2326class TestDemo1(unittest.TestCase): 
    2427    @test_on_data(data_iter=data) 
    2528    def test_instance_on(self, arg): 
    2629        self.assertIsInstance(arg, int) 
    27          
     30 
    2831    @test_on_data(data_iter=data) 
    2932    def test_add(self, arg): 
     
    3134 
    3235# data_driven without arg, using a static data_iter method 
    33 @data_driven  
     36@data_driven 
    3437class TestDemo2(unittest.TestCase): 
    3538    @test_on_data 
    3639    def test_instance_on(self, arg): 
    3740        self.assertIsInstance(arg, int) 
    38          
     41 
    3942    @test_on_data 
    4043    def test_add(self, arg): 
    4144        res = arg + arg 
    42          
     45 
    4346    @staticmethod 
    4447    def data_iter(): 
    4548        return data 
    46      
    47 @datasets_driven(datasets=testing.CLASSIFICATION_DATASETS +\ 
     49 
     50@datasets_driven(datasets=testing.CLASSIFICATION_DATASETS + \ 
    4851                 testing.CLASSLES_DATASETS) 
    4952class TestDefaultLearner(unittest.TestCase): 
     
    5255        import Orange 
    5356        Orange.classification.majority.MajorityLearner(dataset) 
    54          
     57 
    5558    # this overloads the class decorator's data_iter 
    5659    @test_on_data(data_iter=testing.datasets_iter(testing.CLASSLES_DATASETS)) 
     
    5861        import Orange 
    5962        self.assertRaises(Exception, Orange.classification.majority.MajorityLearner, dataset) 
    60          
     63 
    6164if __name__ == "__main__": 
    6265    unittest.main() 
    63          
    64          
    65   
     66 
     67 
  • Orange/testing/unit/tests/test_display_name_mapping.py

    r10248 r10278  
    1 import unittest  
     1try: 
     2    import unittest2 as unittest 
     3except: 
     4    import unittest 
    25 
    36import orange, Orange 
     
    1619                    self.assertTrue(False, cls.__module__ + "." + \ 
    1720                                    cls.__name__ + " does not exist") 
    18                  
     21 
    1922                self.assertEqual(cls2, cls) 
    2023#                if cls2 != cls: 
  • Orange/testing/unit/tests/test_distance.py

    r9724 r10278  
    1 import unittest 
     1try: 
     2    import unittest2 as unittest 
     3except: 
     4    import unittest 
    25from Orange.misc import testing 
    36from Orange.misc.testing import datasets_driven, test_on_data 
     
    912    DISTANCE_CONSTRUCTOR = Euclidean() 
    1013 
    11 @datasets_driven     
     14@datasets_driven 
    1215class TestMannhatanDistance(testing.DistanceTestCase): 
    1316    DISTANCE_CONSTRUCTOR = Manhattan() 
    14      
     17 
    1518@datasets_driven 
    1619class TestHammingDistance(testing.DistanceTestCase): 
    1720    DISTANCE_CONSTRUCTOR = Hamming() 
    18      
     21 
    1922@datasets_driven 
    2023class TestReliefDistance(testing.DistanceTestCase): 
     
    2831class TestSpearmanRDistance(testing.DistanceTestCase): 
    2932    DISTANCE_CONSTRUCTOR = SpearmanR() 
    30      
     33 
    3134@datasets_driven 
    3235class TestPearsonRAbsoluteDistance(testing.DistanceTestCase): 
    3336    DISTANCE_CONSTRUCTOR = PearsonRAbsolute() 
    34      
     37 
    3538@datasets_driven 
    3639class TestSpearmanRAbsoluteDistance(testing.DistanceTestCase): 
    3740    DISTANCE_CONSTRUCTOR = SpearmanRAbsolute() 
    38      
     41 
    3942@datasets_driven 
    4043class TestMahalanobisDistance(testing.DistanceTestCase): 
    4144    DISTANCE_CONSTRUCTOR = Mahalanobis() 
    42      
     45 
    4346if __name__ == "__main__": 
    4447    unittest.main() 
  • Orange/testing/unit/tests/test_earth.py

    r9679 r10278  
    33from Orange.regression import earth 
    44import Orange 
    5 import unittest 
     5try: 
     6    import unittest2 as unittest 
     7except: 
     8    import unittest 
    69 
    7 @datasets_driven(datasets=testing.REGRESSION_DATASETS +\ 
     10@datasets_driven(datasets=testing.REGRESSION_DATASETS + \ 
    811                 testing.CLASSIFICATION_DATASETS) 
    912class TestEarthLearner(testing.LearnerTestCase): 
    10      
     13 
    1114    def setUp(self): 
    1215        self.learner = earth.EarthLearner(degree=2, terms=10) 
    13      
     16 
    1417    @test_on_data 
    1518    def test_learner_on(self, dataset): 
     
    1922        str = self.classifier.to_string() 
    2023        evimp = self.classifier.evimp() 
    21          
     24 
    2225    @test_on_data 
    2326    def test_bagged_evimp(self, dataset): 
     
    2528        bagged = BaggedLearner(earth.EarthLearner(terms=10, degree=2), t=5)(dataset) 
    2629        evimp = earth.bagged_evimp(bagged, used_only=False) 
    27      
    28      
    29 @datasets_driven(datasets=testing.REGRESSION_DATASETS +\ 
     30 
     31 
     32@datasets_driven(datasets=testing.REGRESSION_DATASETS + \ 
    3033                 testing.CLASSIFICATION_DATASETS) 
    3134class TestScoreEarthImportance(testing.MeasureAttributeTestCase): 
     
    3336        from Orange.regression.earth import ScoreEarthImportance 
    3437        self.measure = ScoreEarthImportance(t=5, score_what="rss") 
    35          
    36          
     38 
     39 
    3740#@datasets_driven(datasets=testing.REGRESSION_DATASETS,) 
    3841#class TestScoreRSS(testing.MeasureAttributeTestCase): 
     
    4043#        from Orange.regression.earth import ScoreRSS 
    4144#        self.measure = ScoreRSS() 
    42          
    43          
     45 
     46 
    4447if __name__ == "__main__": 
    4548    unittest.main() 
    46          
     49 
  • Orange/testing/unit/tests/test_ensemble.py

    r10253 r10278  
    1 import unittest 
     1try: 
     2    import unittest2 as unittest 
     3except: 
     4    import unittest 
    25 
    36from Orange.misc import testing 
     
    58 
    69@datasets_driven(datasets=testing.CLASSIFICATION_DATASETS) 
    7 class TestBoosting(testing.LearnerTestCase):     
    8     def setUp(self):  
     10class TestBoosting(testing.LearnerTestCase): 
     11    def setUp(self): 
    912        import orngEnsemble, orngTree 
    1013        self.learner = orngEnsemble.BoostedLearner(orngTree.TreeLearner) 
    11          
     14 
    1215    @test_on_datasets(datasets=["iris"]) 
    1316    def test_pickling_on(self, dataset): 
    1417        testing.LearnerTestCase.test_pickling_on(self, dataset) 
    15          
    16 @datasets_driven(datasets=testing.CLASSIFICATION_DATASETS +\ 
     18 
     19@datasets_driven(datasets=testing.CLASSIFICATION_DATASETS + \ 
    1720                 testing.REGRESSION_DATASETS) 
    1821class TestBagging(testing.LearnerTestCase): 
    19     def setUp(self):  
     22    def setUp(self): 
    2023        import orngEnsemble, orngTree 
    2124        self.learner = orngEnsemble.BaggedLearner(orngTree.TreeLearner) 
     
    2831@datasets_driven(datasets=testing.CLASSIFICATION_DATASETS) 
    2932class TestRandomForest(testing.LearnerTestCase): 
    30     def setUp(self):  
     33    def setUp(self): 
    3134        import orngEnsemble, orngTree 
    3235        self.learner = orngEnsemble.RandomForestLearner() 
    33          
     36 
    3437    @test_on_datasets(datasets=testing.CLASSIFICATION_DATASETS + \ 
    3538                      testing.REGRESSION_DATASETS) 
    3639    def test_pickling_on(self, dataset): 
    3740        testing.LearnerTestCase.test_pickling_on(self, dataset) 
    38          
    39          
    40          
     41 
     42 
     43 
    4144if __name__ == "__main__": 
    4245    import unittest 
    4346    unittest.main() 
    44                  
  • Orange/testing/unit/tests/test_hclustering.py

    r10251 r10278  
    11from Orange.clustering.hierarchical import clustering, \ 
    2     clustering_features,  cluster_to_list, \ 
     2    clustering_features, cluster_to_list, \ 
    33    top_clusters, HierarchicalClustering, order_leaves_py, \ 
    44    order_leaves_cpp, instance_distance_matrix 
    5                        
    6 from Orange.clustering import hierarchical as hier      
     5 
     6from Orange.clustering import hierarchical as hier 
    77from Orange.distance import * 
    8                             
     8 
    99import Orange.misc.testing as testing 
    1010import Orange 
    11 import unittest 
     11try: 
     12    import unittest2 as unittest 
     13except: 
     14    import unittest 
    1215 
    1316import cPickle as pickle 
    1417 
    1518@testing.datasets_driven 
    16 class TestHClustering(testing.DataTestCase):     
     19class TestHClustering(testing.DataTestCase): 
    1720    @testing.test_on_data 
    1821    def test_example_clustering_on(self, data): 
     
    2528            top_clust = top_clusters(clust, 5) 
    2629            cluster_list = cluster_to_list(clust, 5) 
    27              
     30 
    2831    @testing.test_on_data 
    2932    def test_attribute_clustering_on(self, data): 
    3033        clust = clustering_features(data) 
    3134        cluster_list = cluster_to_list(clust, 5) 
    32              
     35 
    3336    @testing.test_on_datasets(datasets=["iris"]) 
    3437    def test_pickling_on(self, data): 
     
    3841        self.assertEqual(len(cluster), len(cluster_clone)) 
    3942        self.assertEqual(cluster.mapping, cluster_clone.mapping) 
    40          
     43 
    4144    @testing.test_on_data 
    4245    def test_ordering_on(self, data): 
    4346        def p(val, obj=None): 
    44             self.assert_(val >= 0 and val <=100) 
     47            self.assert_(val >= 0 and val <= 100) 
    4548            self.assertIsInstance(val, float) 
    4649        matrix = instance_distance_matrix(data, Euclidean(), progress_callback=p) 
    4750        root1 = HierarchicalClustering(matrix, progress_callback=p) 
    4851        root2 = hier.clone(root1) 
    49          
     52 
    5053        order_leaves_py(root1, matrix, progress_callback=p) 
    5154        order_leaves_cpp(root2, matrix, progress_callback=p) 
    52          
     55 
    5356        def score(mapping): 
    5457            sum = 0.0 
    5558            for i in range(matrix.dim - 1): 
    56                sum += matrix[mapping[i], mapping[i+1]] 
     59               sum += matrix[mapping[i], mapping[i + 1]] 
    5760            return sum 
    58          
     61 
    5962        # Slight differences are possible due to the float/double precision. 
    6063        self.assertAlmostEqual(score(root1.mapping), score(root2.mapping), 
    6164                               places=3) 
    62          
     65 
    6366 
    6467class TestHClusteringUtility(unittest.TestCase): 
     
    6669        m = [[], 
    6770             [ 3], 
    68              [ 2,  4], 
    69              [17,  5, 4], 
    70              [ 2,  8,  3, 8], 
    71              [ 7,  5, 10, 11, 2], 
    72              [ 8,  4,  1, 5, 11, 13], 
    73              [ 4,  7, 12,  8, 10,  1, 5], 
    74              [13,  9, 14, 15,  7,  8,  4, 6], 
    75              [12, 10, 11, 15,  2,  5,  7,  3, 1]] 
     71             [ 2, 4], 
     72             [17, 5, 4], 
     73             [ 2, 8, 3, 8], 
     74             [ 7, 5, 10, 11, 2], 
     75             [ 8, 4, 1, 5, 11, 13], 
     76             [ 4, 7, 12, 8, 10, 1, 5], 
     77             [13, 9, 14, 15, 7, 8, 4, 6], 
     78             [12, 10, 11, 15, 2, 5, 7, 3, 1]] 
    7679        self.matrix = Orange.misc.SymMatrix(m) 
    7780        self.matrix.setattr("objects", ["Ann", "Bob", "Curt", "Danny", "Eve", "Fred", "Greg", "Hue", "Ivy", "Jon"]) 
    7881        self.cluster = hier.HierarchicalClustering(self.matrix) 
    79          
     82 
    8083    def test_objects_mapping(self): 
    8184        objects = self.cluster.mapping.objects 
    8285        self.assertEqual(list(self.cluster), 
    8386                         [objects[i] for i in self.cluster.mapping]) 
    84          
     87 
    8588    def test_clone(self): 
    8689        cloned_cluster = hier.clone(self.cluster) 
     
    8891        self.assertEqual(self.cluster.mapping, cloned_cluster.mapping) 
    8992        self.assertEqual(list(self.cluster), list(cloned_cluster)) 
    90          
     93 
    9194    def test_order(self): 
    9295        post = hier.postorder(self.cluster) 
    9396        pre = hier.preorder(self.cluster) 
    94          
     97 
    9598    def test_prunning(self): 
    9699        pruned1 = hier.pruned(self.cluster, level=2) 
    97100        depths = hier.cluster_depths(pruned1) 
    98101        self.assertTrue(all(d <= 2 for d in depths.values())) 
    99          
     102 
    100103        pruned2 = hier.pruned(self.cluster, height=10) 
    101104        self.assertTrue(c.height >= 10 for c in hier.preorder(pruned2)) 
    102          
     105 
    103106        pruned3 = hier.pruned(self.cluster, condition=lambda cl: len(cl) <= 3) 
    104107        self.assertTrue(len(c) > 3 for c in hier.preorder(pruned3)) 
    105          
     108 
    106109    def test_dendrogram_draw(self): 
    107110        from StringIO import StringIO 
     
    115118        hier.dendrogram_draw(file, self.cluster, format="png") 
    116119        self.assertTrue(len(file.getvalue())) 
    117          
     120 
    118121    def test_dendrogram_layout(self): 
    119122        hier.dendrogram_layout(self.cluster) 
     
    124127        hier.dendrogram_layout(pruned2, expand_leaves=True) 
    125128        hier.dendrogram_layout(pruned2, expand_leaves=False) 
    126          
     129 
    127130    def test_cophenetic(self): 
    128131        cmatrix = hier.cophenetic_distances(self.cluster) 
    129132        self.assertEqual(cmatrix.dim, self.matrix.dim) 
    130133        corr = hier.cophenetic_correlation(self.cluster, self.matrix) 
    131          
     134 
    132135 
    133136if __name__ == "__main__": 
    134137    unittest.main() 
    135          
    136              
     138 
     139 
  • Orange/testing/unit/tests/test_io.py

    r9679 r10278  
    1 import unittest 
     1try: 
     2    import unittest2 as unittest 
     3except: 
     4    import unittest 
    25import Orange 
    36from Orange.misc import testing 
     
    912    for n in datasets: 
    1013        yield n, (n,) 
    11          
     14 
    1215@testing.data_driven(data_iter=names_iter()) 
    1316class TestIO(unittest.TestCase): 
     
    2427            finally: 
    2528                os.remove(filename) 
    26                  
     29 
    2730if __name__ == "__main__": 
    2831    unittest.main() 
  • Orange/testing/unit/tests/test_kmeans.py

    r10257 r10278  
    1 import unittest 
     1try: 
     2    import unittest2 as unittest 
     3except: 
     4    import unittest 
    25from Orange.misc import testing 
    36from Orange.clustering import kmeans 
     
    1316        self.assertEqual(max(set(km.clusters)) + 1, 5) 
    1417        self.assertEqual(len(km.clusters), len(table)) 
    15          
     18 
    1619        self._test_score_functions(km) 
    17      
     20 
    1821    def _test_score_functions(self, km): 
    1922        kmeans.score_distance_to_centroids(km) 
    2023        kmeans.score_fast_silhouette(km, index=None) 
    2124        kmeans.score_silhouette(km, index=None) 
    22          
     25 
    2326    @testing.test_on_data 
    2427    def test_init_functs(self, table): 
     
    2629        for k in [1, 5, 10]: 
    2730            self._test_init_func(table, k, distfunc) 
    28          
     31 
    2932    def _test_init_func(self, table, k, distfunc): 
    3033        centers = kmeans.init_random(table, k, distfunc) 
    3134        self.assertEqual(len(centers), k) 
    3235        self.assertEqual(centers[0].domain, table.domain) 
    33          
     36 
    3437        centers = kmeans.init_diversity(table, k, distfunc) 
    3538        self.assertEqual(len(centers), k) 
    3639        self.assertEqual(centers[0].domain, table.domain) 
    37          
     40 
    3841        centers = kmeans.init_hclustering(n=50)(table, k, distfunc) 
    3942        self.assertEqual(len(centers), k) 
    4043        self.assertEqual(centers[0].domain, table.domain) 
    41          
     44 
    4245    def test_kmeans_fail(self): 
    4346        """ Test the reaction when centroids is larger then example table length 
     
    4952if __name__ == "__main__": 
    5053    unittest.main() 
    51              
     54 
  • Orange/testing/unit/tests/test_knn.py

    r9724 r10278  
    1 import unittest 
     1try: 
     2    import unittest2 as unittest 
     3except: 
     4    import unittest 
    25import Orange 
    36from Orange.misc import testing 
     
    1215    def setUp(self): 
    1316        self.learner = knn.kNNLearner(distance_constructor=Euclidean()) 
    14      
     17 
    1518    @testing.test_on_data 
    1619    def test_learner_on(self, dataset): 
     
    1821        instance = dataset.random_instance() 
    1922        self.assertEqual(len(self.classifier.find_nearest(3, instance)), 3) 
    20          
    21      
    22      
    23      
     23 
     24 
     25 
     26 
  • Orange/testing/unit/tests/test_lasso.py

    r10257 r10278  
    33from Orange.regression import lasso 
    44import Orange 
    5 import unittest 
    6   
     5try: 
     6    import unittest2 as unittest 
     7except: 
     8    import unittest 
     9 
    710@datasets_driven(datasets=testing.REGRESSION_DATASETS) 
    811class TestLassoRegressionLearner(testing.LearnerTestCase): 
    9      
     12 
    1013    def setUp(self): 
    1114        self.learner = lasso.LassoRegressionLearner(n_boot=2, n_perm=2) 
    12      
     15 
    1316    @test_on_data 
    1417    def test_learner_on(self, dataset): 
    1518        testing.LearnerTestCase.test_learner_on(self, dataset) 
    1619        self.assertTrue(isinstance(self.classifier.to_string(), str)) 
    17          
     20 
    1821if __name__ == "__main__": 
    1922    unittest.main() 
  • Orange/testing/unit/tests/test_linear.py

    r9679 r10278  
    33from Orange.misc.testing import datasets_driven 
    44from Orange.classification.svm import LinearLearner 
    5 import unittest 
     5try: 
     6    import unittest2 as unittest 
     7except: 
     8    import unittest 
    69 
    710 
     
    1417    else: 
    1518        self.assertEquals(len(self.classifier.weights), 1) 
    16          
     19 
    1720    n_features = len(dataset.domain.attributes) 
    1821    self.assert_(all(len(w) == n_features for w in self.classifier.weights)) 
    19          
     22 
    2023@datasets_driven(datasets=testing.CLASSIFICATION_DATASETS) 
    2124class TestLinearLearnerL2R_L2LOSS_DUAL(testing.LearnerTestCase): 
    2225    LEARNER = LinearLearner(sover_type=LinearLearner.L2R_L2LOSS_DUAL) 
    23      
    24     test_learner_on=test_learner_on 
    25      
     26 
     27    test_learner_on = test_learner_on 
     28 
    2629@datasets_driven(datasets=testing.CLASSIFICATION_DATASETS) 
    2730class TestLinearLearnerL2R_L2LOSS(testing.LearnerTestCase): 
    2831    LEARNER = LinearLearner(sover_type=LinearLearner.L2R_L2LOSS) 
    29     test_learner_on=test_learner_on 
    30      
     32    test_learner_on = test_learner_on 
     33 
    3134@datasets_driven(datasets=testing.CLASSIFICATION_DATASETS) 
    3235class TestLinearLearnerL2R_L1LOSS_DUAL(testing.LearnerTestCase): 
    3336    LEARNER = LinearLearner(sover_type=LinearLearner.L2R_L1LOSS_DUAL) 
    34     test_learner_on=test_learner_on 
    35      
     37    test_learner_on = test_learner_on 
     38 
    3639@datasets_driven(datasets=testing.CLASSIFICATION_DATASETS) 
    3740class TestLinearLearnerL2R_L1LOSS(testing.LearnerTestCase): 
    3841    LEARNER = LinearLearner(sover_type=LinearLearner.L2R_L2LOSS) 
    39     test_learner_on=test_learner_on 
    40      
     42    test_learner_on = test_learner_on 
     43 
    4144@datasets_driven(datasets=testing.CLASSIFICATION_DATASETS) 
    4245class TestLinearLearnerL1R_L2LOSS(testing.LearnerTestCase): 
    4346    LEARNER = LinearLearner(sover_type=LinearLearner.L1R_L2LOSS) 
    44     test_learner_on=test_learner_on 
    45      
     47    test_learner_on = test_learner_on 
     48 
    4649@datasets_driven(datasets=testing.CLASSIFICATION_DATASETS) 
    4750class TestLinearLearnerL1R_L2LOSS(testing.LearnerTestCase): 
    4851    LEARNER = LinearLearner(sover_type=LinearLearner.MCSVM_CS) 
    49     test_learner_on=test_learner_on 
     52    test_learner_on = test_learner_on 
    5053 
    5154if __name__ == "__main__": 
  • Orange/testing/unit/tests/test_linregression.py

    r10257 r10278  
    33from Orange.regression import linear 
    44import Orange 
    5 import unittest 
     5try: 
     6    import unittest2 as unittest 
     7except: 
     8    import unittest 
    69 
    710@datasets_driven(datasets=testing.REGRESSION_DATASETS) 
    811class TestLinearRegressionLearner(testing.LearnerTestCase): 
    9      
     12 
    1013    def setUp(self): 
    1114        self.learner = linear.LinearRegressionLearner() 
    12      
     15 
    1316    @test_on_data 
    1417    def test_learner_on(self, dataset): 
    1518        testing.LearnerTestCase.test_learner_on(self, dataset) 
    1619        self.assertTrue(isinstance(self.classifier.to_string(), str)) 
    17          
     20 
    1821@datasets_driven(datasets=testing.REGRESSION_DATASETS) 
    1922class TestRidgeRegressionLearner(testing.LearnerTestCase): 
    20      
     23 
    2124    def setUp(self): 
    2225        self.learner = linear.LinearRegressionLearner(ridge_lambda=2) 
    23      
     26 
    2427    @test_on_data 
    2528    def test_learner_on(self, dataset): 
     
    2730        if self.classifier.p_vals: 
    2831            self.assertTrue(isinstance(self.classifier.to_string(), str)) 
    29      
    30          
     32 
     33 
    3134if __name__ == "__main__": 
    3235    unittest.main() 
  • Orange/testing/unit/tests/test_logreg.py

    r9679 r10278  
    11from Orange.misc import testing 
    2 import unittest 
     2try: 
     3    import unittest2 as unittest 
     4except: 
     5    import unittest 
    36 
    47from orngLR import LogRegLearner, Univariate_LogRegLearner, StepWiseFSS, StepWiseFSS_Filter 
     
    811        if len(data.domain.class_var.values) == 2: 
    912            yield name, (data,) 
    10              
    11      
     13 
     14 
    1215@testing.data_driven(data_iter=datasets_iter()) 
    1316class TestLogRegLearner(testing.LearnerTestCase): 
     
    4548        new_dataset = StepWiseFSS_Filter(dataset) 
    4649        self.assertTrue([a1 == a2 for a1, a2 in zip(attrs, new_dataset.domain.attributes)]) 
    47          
     50 
    4851if __name__ == "__main__": 
    4952    import Orange, os 
     
    5558    pickle.dumps(var) 
    5659#    unittest.main() 
    57      
  • Orange/testing/unit/tests/test_majority.py

    r9679 r10278  
    11from Orange.misc import testing 
    2 from Orange.misc.testing import datasets_driven, test_on_data  
     2from Orange.misc.testing import datasets_driven, test_on_data 
    33from Orange.classification import majority 
    44from Orange.statistics import distribution 
    55import Orange 
    6 import unittest 
     6try: 
     7    import unittest2 as unittest 
     8except: 
     9    import unittest 
    710 
    811@datasets_driven(datasets=testing.CLASSIFICATION_DATASETS + \ 
     
    1013class TestMajorityLearner(testing.LearnerTestCase): 
    1114    LEARNER = majority.MajorityLearner() 
    12      
     15 
    1316@datasets_driven(datasets=testing.CLASSIFICATION_DATASETS) 
    1417class TestMajorityLearnerWithMEstimator(testing.LearnerTestCase): 
    15     LEARNER = majority.MajorityLearner(estimator_constructor= \ 
     18    LEARNER = majority.MajorityLearner(estimator_constructor=\ 
    1619                    Orange.core.ProbabilityEstimatorConstructor_m(m=3)) 
    17      
     20 
    1821@datasets_driven(datasets=testing.CLASSIFICATION_DATASETS) 
    1922class TestMajorityLearnerWithLaplaceEstimator(testing.LearnerTestCase): 
    20     LEARNER = majority.MajorityLearner(estimator_constructor= \ 
     23    LEARNER = majority.MajorityLearner(estimator_constructor=\ 
    2124                    Orange.core.ProbabilityEstimatorConstructor_Laplace()) 
    22      
     25 
    2326@datasets_driven(datasets=testing.REGRESSION_DATASETS) 
    2427class TestMajorityLearnerWithKernelEstimator(testing.LearnerTestCase): 
    25     LEARNER = majority.MajorityLearner(estimator_constructor= \ 
     28    LEARNER = majority.MajorityLearner(estimator_constructor=\ 
    2629                    Orange.core.ProbabilityEstimatorConstructor_kernel()) 
    2730 
    2831@datasets_driven(datasets=testing.REGRESSION_DATASETS) 
    2932class TestMajorityLearnerWithLoessEstimator(testing.LearnerTestCase): 
    30     LEARNER = majority.MajorityLearner(estimator_constructor= \ 
     33    LEARNER = majority.MajorityLearner(estimator_constructor=\ 
    3134                    Orange.core.ProbabilityEstimatorConstructor_loess()) 
    32      
     35 
    3336#@datasets_driven(datasets=testing.CLASSIFICATION_DATASETS + \ 
    3437#                 testing.REGRESSION_DATASETS) 
    3538#class TestMajorityLearner(testing.LearnerTestCase): 
    3639#    LEARNER = majority.MajorityLearner() 
    37       
     40 
    3841 
    3942if __name__ == "__main__": 
  • Orange/testing/unit/tests/test_mds.py

    r10038 r10278  
    22from Orange.misc.testing import test_on_data, datasets_driven 
    33 
    4 import unittest 
     4try: 
     5    import unittest2 as unittest 
     6except: 
     7    import unittest 
    58from Orange.projection import mds 
    69from Orange.distance import distance_matrix, Euclidean 
    7      
     10 
    811@datasets_driven 
    912class TestMDS(unittest.TestCase): 
    10      
     13 
    1114    @test_on_data 
    1215    def test_mds_on(self, data): 
     
    1518        self.__mds_test_helper(matrix, proj_dim=2) 
    1619        self.__mds_test_helper(matrix, proj_dim=3) 
    17          
     20 
    1821    def __mds_test_helper(self, matrix, proj_dim): 
    1922        proj = mds.MDS(matrix, dim=proj_dim) 
     
    2730                        "The input distance matrix was changed in place") 
    2831        self.assertEquals(matrix.dim, proj.projected_distances.dim) 
    29          
    30          
    31          
     32 
     33 
     34 
    3235if __name__ == "__main__": 
    3336    unittest.main() 
  • Orange/testing/unit/tests/test_measures.py

    r10241 r10278  
    22from Orange.misc.testing import datasets_driven, test_on_data 
    33from Orange.feature import scoring 
    4 import unittest     
    5      
     4try: 
     5    import unittest2 as unittest 
     6except: 
     7    import unittest 
     8 
    69 
    710@datasets_driven(datasets=testing.CLASSIFICATION_DATASETS, 
     
    912class TestMeasureAttr_GainRatio(testing.MeasureAttributeTestCase): 
    1013    MEASURE = scoring.GainRatio() 
    11      
    12      
     14 
     15 
    1316@datasets_driven(datasets=testing.CLASSIFICATION_DATASETS, 
    1417                 preprocess=testing.DISCRETIZE_DOMAIN) 
    1518class TestMeasureAttr_InfoGain(testing.MeasureAttributeTestCase): 
    1619    MEASURE = scoring.InfoGain() 
    17      
     20 
    1821 
    1922# TODO: Relevance, Cost 
     
    2427    MEASURE = scoring.Distance() 
    2528 
    26      
     29 
    2730@datasets_driven(datasets=testing.CLASSIFICATION_DATASETS, 
    2831                 preprocess=testing.DISCRETIZE_DOMAIN) 
     
    3134 
    3235 
    33 @datasets_driven(datasets=testing.CLASSIFICATION_DATASETS +\ 
     36@datasets_driven(datasets=testing.CLASSIFICATION_DATASETS + \ 
    3437                 testing.REGRESSION_DATASETS) 
    3538class TestMeasureAttr_Relief(testing.MeasureAttributeTestCase): 
     
    4144class TestMeasureAttr_MSE(testing.MeasureAttributeTestCase): 
    4245    MEASURE = scoring.MSE() 
    43      
     46 
    4447 
    4548@datasets_driven(datasets=testing.CLASSIFICATION_DATASETS) 
     
    4952        order = scoring.OrderAttributes(scoring.Relief()) 
    5053        orderes_attrs = order(dataset, 0) 
    51          
     54 
    5255    @test_on_data 
    5356    def test_score_all(self, dataset): 
    5457        scoring.score_all(dataset, score=scoring.Relief()) 
    55           
    56          
     58 
     59 
    5760if __name__ == "__main__": 
    5861    unittest.main() 
  • Orange/testing/unit/tests/test_preprocessors.py

    r9679 r10278  
    1 import unittest 
     1try: 
     2    import unittest2 as unittest 
     3except: 
     4    import unittest 
    25 
    36from Orange.preprocess import (Preprocessor_addCensorWeight, 
    47         Preprocessor_addClassNoise, 
    5          Preprocessor_addClassWeight,  
     8         Preprocessor_addClassWeight, 
    69         Preprocessor_addGaussianClassNoise, 
    710         Preprocessor_addGaussianNoise, 
     
    3639 
    3740import Orange.misc.testing as testing 
    38      
     41 
    3942@testing.datasets_driven(datasets=testing.CLASSIFICATION_DATASETS) 
    4043class TestAddClassNoise(testing.PreprocessorTestCase): 
     
    4245    """ 
    4346    PREPROCESSOR = Preprocessor_addClassNoise 
    44      
     47 
    4548 
    4649@testing.datasets_driven(datasets=testing.CLASSIFICATION_DATASETS) 
     
    6265    PREPROCESSOR = Preprocessor_addGaussianNoise 
    6366 
    64      
     67 
    6568@testing.datasets_driven 
    6669class TestAddMissing(testing.PreprocessorTestCase): 
     
    7376    PREPROCESSOR = Preprocessor_addMissingClasses 
    7477 
    75      
     78 
    7679@testing.datasets_driven 
    7780class TestAddMissing(testing.PreprocessorTestCase): 
     
    8386    PREPROCESSOR = Preprocessor_addNoise 
    8487 
    85      
     88 
    8689@testing.datasets_driven 
    8790class TestDiscretizeEquiN(testing.PreprocessorTestCase): 
     
    9295class TestDiscretizeEquiDist(testing.PreprocessorTestCase): 
    9396    PREPROCESSOR = Preprocessor_discretize(method=orange.EquiDistDiscretization()) 
    94      
    95      
     97 
     98 
    9699@testing.datasets_driven(datasets=testing.CLASSIFICATION_DATASETS) 
    97100class TestDiscretizeEntropy(testing.PreprocessorTestCase): 
     
    111114#class TestFilter(testing.PreprocessorTestCase): 
    112115#    PREPROCESSOR = Preprocessor_filter(filter=orange.Filter_random(prob = 0.7, randomGenerator = 24)) 
    113      
     116 
    114117@testing.datasets_driven 
    115118class TestDropMissingClasses(testing.PreprocessorTestCase): 
    116119    PREPROCESSOR = Preprocessor_dropMissingClasses 
    117      
     120 
    118121@testing.datasets_driven 
    119122class TestIgnore(testing.PreprocessorTestCase): 
    120123    PREPROCESSOR = Preprocessor_ignore 
    121      
     124 
    122125@testing.datasets_driven 
    123126class TestImputeByLearner(testing.PreprocessorTestCase): 
    124127    PREPROCESSOR = Preprocessor_imputeByLearner(learner=orange.MajorityLearner()) 
    125      
     128 
    126129@testing.datasets_driven(datasets=testing.ALL_DATASETS + ["lenses"]) 
    127130class TestRemoveDuplicates(testing.PreprocessorTestCase): 
    128131    PREPROCESSOR = Preprocessor_removeDuplicates 
    129      
     132 
    130133@testing.datasets_driven 
    131134class TestSelect(testing.PreprocessorTestCase): 
    132135    PREPROCESSOR = Preprocessor_select 
    133      
     136 
    134137@testing.datasets_driven 
    135138class TestShuffle(testing.PreprocessorTestCase): 
    136139    PREPROCESSOR = Preprocessor_shuffle 
    137      
     140 
    138141@testing.datasets_driven 
    139142class TestTake(testing.PreprocessorTestCase): 
    140143    PREPROCESSOR = Preprocessor_take 
    141      
     144 
    142145@testing.datasets_driven 
    143146class TestTakeMissing(testing.PreprocessorTestCase): 
    144147    PREPROCESSOR = Preprocessor_takeMissing 
    145      
     148 
    146149@testing.datasets_driven 
    147150class TestTakeMissingClasses(testing.PreprocessorTestCase): 
    148151    PREPROCESSOR = Preprocessor_takeMissingClasses 
    149      
     152 
    150153@testing.datasets_driven(datasets=testing.CLASSIFICATION_DATASETS) 
    151154class TestDiscretizeEntropy(testing.PreprocessorTestCase): 
    152155    PREPROCESSOR = Preprocessor_discretizeEntropy 
    153      
     156 
    154157@testing.datasets_driven 
    155158class TestRemoveContinuous(testing.PreprocessorTestCase): 
    156159    PREPROCESSOR = Preprocessor_removeContinuous 
    157      
     160 
    158161@testing.datasets_driven 
    159162class TestRemoveDiscrete(testing.PreprocessorTestCase): 
    160163    PREPROCESSOR = Preprocessor_removeDiscrete 
    161      
     164 
    162165@testing.datasets_driven 
    163166class TestContinuize(testing.PreprocessorTestCase): 
    164167    PREPROCESSOR = Preprocessor_continuize 
    165      
     168 
    166169@testing.datasets_driven 
    167170class TestImpute(testing.PreprocessorTestCase): 
    168171    PREPROCESSOR = Preprocessor_impute 
    169      
     172 
    170173@testing.datasets_driven(datasets=testing.CLASSIFICATION_DATASETS + \ 
    171174                         testing.REGRESSION_DATASETS) 
    172175class TestFeatureSelection(testing.PreprocessorTestCase): 
    173176    PREPROCESSOR = Preprocessor_featureSelection 
    174      
     177 
    175178@testing.datasets_driven(datasets=testing.CLASSIFICATION_DATASETS) 
    176179class TestRFE(testing.PreprocessorTestCase): 
    177180    PREPROCESSOR = Preprocessor_RFE 
    178      
     181 
    179182@testing.datasets_driven 
    180183class TestSample(testing.PreprocessorTestCase): 
    181184    PREPROCESSOR = Preprocessor_sample 
    182      
     185 
    183186@testing.datasets_driven 
    184187class TestSelect(testing.PreprocessorTestCase): 
    185188    PREPROCESSOR = Preprocessor_preprocessorList(preprocessors=[Preprocessor_sample, Preprocessor_takeMissing]) 
    186      
     189 
    187190if __name__ == "__main__": 
    188191    unittest.main() 
    189192 
    190      
    191           
     193 
  • Orange/testing/unit/tests/test_refactoring.py

    r9910 r10278  
    33 
    44""" 
    5 import unittest 
     5try: 
     6    import unittest2 as unittest 
     7except: 
     8    import unittest 
    69 
    710from Orange.fixes import fix_changed_names 
    811from Orange.fixes import fix_orange_imports 
    9   
     12 
    1013NAME_MAPPING = fix_changed_names.MAPPING 
    1114IMPORT_MAPPING = fix_orange_imports.MAPPING 
     
    2225        mod_name, obj_name = name.rsplit(".", 1) 
    2326    return mod_name, obj_name 
    24      
    25      
     27 
     28 
    2629def rhasattr(obj, name): 
    2730    """ Recursive hasattr. 
     
    4447        else: 
    4548            return None 
    46          
     49 
    4750    return getattr(obj, name) 
    4851 
     
    5659    else: 
    5760        return mod 
    58      
     61 
    5962class TestMapping(unittest.TestCase): 
    6063    """ 
     
    6669            old_mod, old_name = q_name_split(old) 
    6770            new_mod, new_name = q_name_split(new) 
    68              
     71 
    6972            old_mod = import_package(old_mod) 
    7073            new_mod = import_package(new_mod) 
    71              
    72              
    73             self.assertTrue(rhasattr(old_mod, old_name),  
     74 
     75 
     76            self.assertTrue(rhasattr(old_mod, old_name), 
    7477                            "{0} is missing".format(old)) 
    7578            self.assertTrue(rhasattr(new_mod, new_name), 
    7679                            "{0} is missing".format(new)) 
    77              
     80 
    7881    def test_import_mapping(self): 
    7982        for old_import, new_import in IMPORT_MAPPING.items(): 
    8083            __import__(old_import) 
    8184            __import__(new_import) 
    82              
    83      
    84              
     85 
     86 
     87 
    8588if __name__ == "__main__": 
    8689    unittest.main() 
    87      
     90 
  • Orange/testing/unit/tests/test_regression.py

    r10180 r10278  
    11import sys 
    22import os.path 
    3 import unittest 
     3try: 
     4    import unittest2 as unittest 
     5except: 
     6    import unittest 
    47import subprocess 
    58 
  • Orange/testing/unit/tests/test_rules.py

    r9679 r10278  
    1 from Orange.misc import testing       
     1from Orange.misc import testing 
    22from Orange.classification import rules 
    33 
    4 import unittest 
     4try: 
     5    import unittest2 as unittest 
     6except: 
     7    import unittest 
    58 
    69@testing.test_on_data 
     
    912    for r in self.classifier.rules: 
    1013        str = rules.rule_to_string(r, True) 
    11              
     14 
    1215@testing.datasets_driven(datasets=testing.CLASSIFICATION_DATASETS) 
    1316class TestCN2Learner(testing.LearnerTestCase): 
    1417    def setUp(self): 
    1518        self.learner = rules.CN2Learner() 
    16          
     19 
    1720    test_learner_on = test_learner_on 
    18      
     21 
    1922@testing.datasets_driven(datasets=testing.CLASSIFICATION_DATASETS) 
    2023class TestCN2UnorderedLearner(testing.LearnerTestCase): 
    2124    def setUp(self): 
    2225        self.learner = rules.CN2UnorderedLearner() 
    23          
     26 
    2427    test_learner_on = test_learner_on 
    25      
     28 
    2629#@testing.datasets_driven(datasets=testing.CLASSIFICATION_DATASETS) 
    2730#class TestCN2SDUnorderedLearner(testing.LearnerTestCase): 
     
    3033#         
    3134#    test_learner_on = test_learner_on 
    32      
     35 
    3336 
    3437if __name__ == "__main__": 
    3538    unittest.main() 
    36      
  • Orange/testing/unit/tests/test_selection.py

    r10080 r10278  
    1 import unittest 
     1try: 
     2    import unittest2 as unittest 
     3except: 
     4    import unittest 
    25 
    36from Orange.misc import selection 
     
    58 
    69class TestBestOnTheFly(unittest.TestCase): 
    7     def test_compare_on_1st(self):  
     10    def test_compare_on_1st(self): 
    811        best = selection.BestOnTheFly(call_compare_on_1st=True) 
    912        test = [1, 2, 0, 5, 4, 5, 4] 
     
    1114        for t in test: 
    1215            best.candidate((t, str(t))) 
    13              
     16 
    1417        winner = best.winner() 
    1518        self.assertTrue(winner == (5, "5")) 
    1619        self.assertIsInstance(winner, tuple) 
    17          
     20 
    1821        index = best.winner_index() 
    1922        self.assertIsInstance(index, int) 
    20          
    21          
    22     def test_compare_first_bigger(self):  
     23 
     24 
     25    def test_compare_first_bigger(self): 
    2326        best = selection.BestOnTheFly(selection.compare_first_bigger) 
    2427        test = [1, 2, 0, 5, 4, 5, 4] 
     
    2629        for t in test: 
    2730            best.candidate((t, str(t))) 
    28              
     31 
    2932        winner = best.winner() 
    3033        self.assertTrue(winner == (5, "5")) 
    3134        self.assertIsInstance(winner, tuple) 
    32          
     35 
    3336        index = best.winner_index() 
    3437        self.assertIsInstance(index, int) 
    35          
    36      
    37          
     38 
     39 
  • Orange/testing/unit/tests/test_som.py

    r10104 r10278  
    11from Orange.misc import testing 
    22from Orange.misc.testing import datasets_driven, test_on_data 
    3 import unittest 
     3try: 
     4    import unittest2 as unittest 
     5except: 
     6    import unittest 
    47 
    58from Orange.projection import som 
     
    1215    def setUp(self): 
    1316        self.learner = som.SOMLearner 
    14          
     17 
    1518    @test_on_data 
    1619    def test_learner_on(self, dataset): 
     
    2124            self.classifier = self.learner(dataset) 
    2225        test_som_projection_helper(self, self.classifier, dataset) 
    23          
     26 
    2427    @test_on_data 
    2528    def test_pickling_on(self, dataset): 
     
    3134    def setUp(self): 
    3235        self.learner = som.SOMSupervisedLearner() 
    33          
     36 
    3437    @test_on_data 
    3538    def test_learner_on(self, dataset): 
     
    4043            self.classifier = self.learner(dataset) 
    4144        test_som_projection_helper(self, self.classifier, dataset) 
    42          
     45 
    4346    @test_on_data 
    4447    def test_pickling_on(self, dataset): 
    4548        if dataset.domain.class_var: 
    4649            testing.LearnerTestCase.test_pickling_on(self, dataset) 
    47              
    4850 
    49          
     51 
     52 
    5053if __name__ == "__main__": 
    5154    unittest.main() 
  • Orange/testing/unit/tests/test_stepwise_wrapper.py

    r10256 r10278  
    1 import unittest 
     1try: 
     2    import unittest2 as unittest 
     3except: 
     4    import unittest 
    25 
    36import Orange 
     
    1821                ) 
    1922        testing.LearnerTestCase.test_learner_on(self, dataset) 
    20          
     23 
    2124if __name__ == "__main__": 
    2225    unittest.main() 
  • Orange/testing/unit/tests/test_svm.py

    r10249 r10278  
    1111class LinearSVMTestCase(testing.LearnerTestCase): 
    1212    LEARNER = SVMLearner(name="svm-lin", kernel_type=SVMLearner.Linear) 
    13      
    14      
     13 
     14 
    1515@datasets_driven(datasets=datasets) 
    1616class PolySVMTestCase(testing.LearnerTestCase): 
    1717    LEARNER = SVMLearner(name="svm-poly", kernel_type=SVMLearner.Polynomial) 
    18      
    19      
     18 
     19 
    2020@datasets_driven(datasets=datasets) 
    2121class RBFSVMTestCase(testing.LearnerTestCase): 
    2222    LEARNER = SVMLearner(name="svm-RBF", kernel_type=SVMLearner.RBF) 
    23      
    24      
     23 
     24 
    2525@datasets_driven(datasets=datasets) 
    2626class SigmoidSVMTestCase(testing.LearnerTestCase): 
    2727    LEARNER = SVMLearner(name="svm-sig", kernel_type=SVMLearner.Sigmoid) 
    28      
     28 
    2929 
    3030#def to_sparse(data): 
     
    4141#class BagOfWordsSVMTestCase(testing.LearnerTestCase): 
    4242#    LEARNER = SVMLearner(name="svm-bow", kernel_type=SVMLearner.Custom, kernelFunc=BagOfWords()) 
    43      
    44      
     43 
     44 
    4545@datasets_driven(datasets=datasets) 
    4646class CustomWrapperSVMTestCase(testing.LearnerTestCase): 
    4747    LEARNER = SVMLearner 
    48      
     48 
    4949    @test_on_data 
    5050    def test_learner_on(self, data): 
     
    5454        self.learner = self.LEARNER(kernel_type=SVMLearner.Custom, 
    5555                                    kernel_func=RBFKernelWrapper(orange.ExamplesDistanceConstructor_Euclidean(data), gamma=0.5)) 
    56          
     56 
    5757        testing.LearnerTestCase.test_learner_on(self, data) 
    58      
    59      
     58 
     59 
    6060@datasets_driven(datasets=testing.CLASSIFICATION_DATASETS) 
    6161class TestLinLearner(testing.LearnerTestCase): 
    6262    LEARNER = LinearLearner 
    63      
    64      
     63 
     64 
    6565@datasets_driven(datasets=datasets) 
    6666class TestMeasureAttr_LinWeights(testing.MeasureAttributeTestCase): 
     
    7979        self.assertEqual(len(data.domain.attributes) - num_selected, len(scores)) 
    8080        self.assertTrue(set(reduced.domain.attributes).isdisjoint(scores.keys())) 
    81          
     81 
    8282    def test_pickle(self): 
    8383        import cPickle 
     
    8686 
    8787if __name__ == "__main__": 
    88     import unittest 
     88    try: 
     89        import unittest2 as unittest 
     90    except: 
     91        import unittest 
    8992    unittest.main() 
  • Orange/testing/unit/tests/test_table.py

    r9679 r10278  
    11""" Orange.data.Table related unit-tests 
    22""" 
    3 import unittest 
     3try: 
     4    import unittest2 as unittest 
     5except: 
     6    import unittest 
    47from Orange.misc import testing 
    58import Orange 
     
    1114        table[i] = [v.native() for v in table[i].native()] 
    1215    return table 
    13          
     16 
    1417def names_iter(): 
    1518    for name in testing.ALL_DATASETS: 
    1619        yield name.replace(" ", "_").replace("-", "_"), (name,) 
    17          
     20 
    1821@testing.data_driven(data_iter=names_iter()) 
    1922class TestLoading(unittest.TestCase): 
    20      
     23 
    2124    @testing.test_on_data 
    2225    def test_load_on(self, name): 
     
    2528        table = Orange.data.Table(name) 
    2629        self.assertIsNotNone(getattr(table, "attributeLoadStatus"), "No attributeLoadStatus") 
    27          
     30 
    2831    @testing.test_on_data 
    2932    def test_pickling_on(self, name): 
     
    3639#        self.assertEqual(table.domain.class_var, table_clone.domain.class_var) 
    3740        self.assertEqual(native(table), native(table_clone), "Native representation is not equal!") 
    38          
    39          
     41 
     42 
    4043import tempfile 
    4144 
     
    4750        with tempfile.NamedTemporaryFile(suffix=".R") as f: 
    4851            data.save(f.name) 
    49      
     52 
    5053#    @testing.test_on_data 
    5154#    def test_toC50(self, name): 
    5255#        data = Orange.data.Table(name) 
    5356 
    54     @testing.test_on_datasets(datasets=testing.CLASSIFICATION_DATASETS +\ 
     57    @testing.test_on_datasets(datasets=testing.CLASSIFICATION_DATASETS + \ 
    5558                              testing.REGRESSION_DATASETS) 
    5659    def test_arff_on(self, data): 
     
    5962            f.flush() 
    6063            data_arff = Orange.data.Table(f.name) 
    61     @testing.test_on_datasets(datasets=testing.CLASSIFICATION_DATASETS +\ 
     64    @testing.test_on_datasets(datasets=testing.CLASSIFICATION_DATASETS + \ 
    6265                              testing.REGRESSION_DATASETS) 
    6366    def test_svm_on(self, data): 
     
    6669            f.flush() 
    6770            data_svm = Orange.data.Table(f.name) 
    68          
     71 
    6972    @testing.test_on_datasets 
    7073    def test_csv_on(self, data): 
     
    7477            f.seek(0) 
    7578            Orange.data.io.load_csv(f) 
    76              
    77          
    78              
    79          
     79 
     80 
     81 
     82 
    8083if __name__ == "__main__": 
    8184    unittest.main() 
    82      
  • Orange/testing/unit/tests/test_tree.py

    r9679 r10278  
    11from Orange.misc import testing 
    22from Orange.misc.testing import datasets_driven, test_on_data 
    3 import unittest 
     3try: 
     4    import unittest2 as unittest 
     5except: 
     6    import unittest 
    47from Orange.classification import tree as ctree 
    58from Orange.regression import tree as rtree 
     
    1215 
    1316 
    14 @datasets_driven(datasets=testing.REGRESSION_DATASETS)     
     17@datasets_driven(datasets=testing.REGRESSION_DATASETS) 
    1518class TestRegression(testing.LearnerTestCase): 
    1619    LEARNER = rtree.TreeLearner() 
    17          
     20 
    1821if __name__ == "__main__": 
    1922    unittest.main() 
  • Orange/testing/unit/tests/test_variable.py

    r9927 r10278  
    1 import unittest 
     1try: 
     2    import unittest2 as unittest 
     3except: 
     4    import unittest 
    25import Orange 
    36from Orange.misc import testing 
     
    811        """ 
    912        v1, s = Orange.feature.Descriptor.make("test_variable_a", 
    10                                       Orange.feature.Type.Discrete,["a", "b"]) 
     13                                      Orange.feature.Type.Discrete, ["a", "b"]) 
    1114        v2, s = Orange.feature.Descriptor.make("test_variable_a", 
    1215                                      Orange.feature.Type.Discrete, ["a"], ["c"]) 
    1316        self.assertIs(v2, v1) 
    14          
     17 
    1518        v3, s = Orange.feature.Descriptor.make("test_variable_a", 
    1619                          Orange.feature.Type.Discrete, ["a", "b", "c", "d"]) 
    1720        self.assertIs(v3, v1) 
    18          
     21 
    1922        v4, s = Orange.feature.Descriptor.make("test_variable_a", 
    2023                                     Orange.feature.Type.Discrete, ["b"]) 
    2124        self.assertIsNot(v4, v1) 
    22          
     25 
    2326        v5, s = Orange.feature.Descriptor.make("test_variable_a", 
    2427                             Orange.feature.Type.Discrete, None, ["c", "a"]) 
    2528        self.assertIs(v5, v1) 
    26          
    27         v6, s = Orange.feature.Descriptor.make("test_variable_a",  
     29 
     30        v6, s = Orange.feature.Descriptor.make("test_variable_a", 
    2831                            Orange.feature.Type.Discrete, None, ["e"]) 
    2932        self.assertIs(v6, v1) 
    30          
     33 
    3134        v7, s = Orange.feature.Descriptor.make("test_variable_a", 
    3235                                 Orange.feature.Type.Discrete, None, ["f"], 
    3336                                 Orange.feature.Descriptor.MakeStatus.NoRecognizedValues) 
    3437        self.assertIsNot(v7, v1) 
    35          
     38 
    3639        v8, s = Orange.feature.Descriptor.make("test_variable_a", 
    3740                                     Orange.feature.Type.Discrete, 
     
    3942                                     Orange.feature.Descriptor.MakeStatus.OK) 
    4043        self.assertIsNot(v8, v1) 
    41          
     44 
Note: See TracChangeset for help on using the changeset viewer.