Changeset 10180:fff9903010ae in orange


Ignore:
Timestamp:
02/13/12 09:42:57 (2 years ago)
Author:
Miha Stajdohar <miha.stajdohar@…>
Branch:
default
rebase_source:
bef91f896107dbb6c6332ec3c6937a26d2351fe5
Message:

Added auto regression testing to unittests.

Location:
Orange
Files:
1 added
2 edited

Legend:

Unmodified
Added
Removed
  • Orange/misc/testing.py

    r9919 r10180  
    7474import unittest 
    7575import os, sys 
    76  
     76from functools import wraps 
    7777import itertools 
    7878from functools import partial 
     
    114114CLASSIFICATION_DATASETS = ["iris", "brown-selected", "lenses", "monks-1"] 
    115115REGRESSION_DATASETS = ["housing", "auto-mpg", "servo"] 
    116 CLASSLES_DATASETS =  ["water-treatment"] 
    117 ALL_DATASETS  = CLASSIFICATION_DATASETS + REGRESSION_DATASETS + CLASSLES_DATASETS 
     116CLASSLES_DATASETS = ["water-treatment"] 
     117ALL_DATASETS = CLASSIFICATION_DATASETS + REGRESSION_DATASETS + CLASSLES_DATASETS 
    118118 
    119119 
     
    156156        call = partial(partial(func, fixed_args, kwargs), extra_args, extra_kwargs) 
    157157        return call() 
    158      
     158 
    159159    newname = func.__name__ + "_" + name.replace("-", "_") 
    160160    expanded.__name__ = newname 
    161161    return newname, expanded 
    162162 
    163                  
     163 
    164164def _data_driven_cls_decorator(cls, data_iter=None, lazy=False): 
    165165    """ A class decorator that expands TestCase subclass 
     
    167167    decorator. 
    168168     
    169     """  
     169    """ 
    170170    if data_iter is None: 
    171171        data_iter = getattr(cls, "data_iter", None) # data_iter should be a staticmethod or classmethod 
    172172        if data_iter is not None: 
    173173            data_iter = data_iter() 
    174              
     174 
    175175    if data_iter is not None: 
    176176        data_iter = list(data_iter) # Because it needs to be iterated multiple times (each member not overriding it) 
    177      
     177 
    178178    for test_name in dir(cls): 
    179179        val = getattr(cls, test_name) 
     
    187187                else: 
    188188                    lazy_iter = lazy 
    189                      
     189 
    190190            assert(member_data_iter is not None) 
    191191            for name, expand_args in iter(member_data_iter): 
     
    196196                setattr(cls, newname, expanded) 
    197197            setattr(cls, test_name, None) 
    198             setattr(cls, "__" + test_name, val) 
     198            #setattr(cls, "__" + test_name, val) 
    199199    return cls 
    200200 
     
    230230        # class ... 
    231231        return _data_driven_cls_decorator(cls) 
    232       
     232 
    233233 
    234234 
    235235def data_driven_lazy(cls=None, data_iter=None): 
    236     if lazy_data_iter is not None:  
     236    if lazy_data_iter is not None: 
    237237        #Used as 
    238238        # @data_driven_lazy(data_iter= ...) 
     
    244244        # class ... 
    245245        return _data_driven_cls_decorator(cls, lazy=True) 
    246      
     246 
    247247def test_on_data(test_func=None, data_iter=None): 
    248248    """ Decorator for test member of unittest.TestCase, signaling that it 
     
    276276        func._data_iter = data_iter, False 
    277277        return func 
    278      
     278 
    279279    if data_iter is not None: 
    280280        return set_iter 
    281281    else: 
    282282        return set_iter(test_func) 
    283      
    284      
     283 
     284 
    285285def test_on_data_lazy(test_func=None, data_iter=None): 
    286286    """ Same as :func:`test_on_data` except the ``data_iter`` is  
     
    291291        func._data_iter = data_iter, True 
    292292        return func 
    293      
     293 
    294294    if data_iter is not None: 
    295295        return set_iter 
    296296    else: 
    297297        return set_iter(test_func) 
    298      
    299      
     298 
     299 
    300300def datasets_iter(datasets=ALL_DATASETS, preprocess=0): 
    301301    for name in datasets: 
     
    303303        name = name.replace("-", "_") 
    304304        yield name, (data,) 
    305          
    306          
     305 
     306 
    307307def datasets_iter_lazy(datasets=ALL_DATASETS, preprocess=0): 
    308308    for name in datasets: 
    309         data = lambda : (open_data(name, flags=preprocess), ) 
     309        data = lambda : (open_data(name, flags=preprocess),) 
    310310        name = name.replace("-", "_") 
    311311        yield name, data 
    312      
     312 
    313313 
    314314def test_on_datasets(test_func=None, datasets=ALL_DATASETS): 
     
    328328    else: 
    329329        return data_driven(data_iter=datasets_iter(datasets, preprocess))(cls) 
    330      
     330 
    331331 
    332332class DataTestCase(unittest.TestCase): 
    333333    """ Base class for data driven tests. 
    334334    """ 
    335      
     335 
    336336import Orange 
    337337from Orange.evaluation import testing as _testing 
     
    345345    setUp method which sets ``self.learner``. 
    346346     
    347     """  
    348      
     347    """ 
     348 
    349349    LEARNER = None 
    350      
     350 
    351351    def setUp(self): 
    352352        """ Set up the learner for the test from the ``LEARNER`` class member. 
    353353        """ 
    354354        self.learner = self.LEARNER 
    355          
     355 
    356356    @test_on_data 
    357357    def test_learner_on(self, dataset): 
     
    364364        learn = dataset.select(indices, 1) 
    365365        test = dataset.select(indices, 0) 
    366          
     366 
    367367        classifier = self.learner(learn) 
    368          
     368 
    369369        # Test for classVar  
    370370        self.assertTrue(hasattr(classifier, "class_var")) 
    371371        self.assertTrue(classifier.class_var is not None) 
    372          
     372 
    373373        res = _testing.test_on_data([classifier], test) 
    374          
     374 
    375375        for ex in test: 
    376376            self.assertIsInstance(classifier(ex, Orange.core.GetValue), Orange.core.Value) 
    377377            self.assertIsInstance(classifier(ex, Orange.core.GetProbabilities), Orange.core.Distribution) 
    378              
     378 
    379379            value, dist = classifier(ex, Orange.core.GetBoth) 
    380              
     380 
    381381            self.assertIsInstance(value, Orange.core.Value) 
    382382            self.assertIsInstance(dist, Orange.core.Distribution) 
    383              
     383 
    384384            if isinstance(dist, Orange.core.ContDistribution): 
    385385                dist_sum = sum(dist.values()) 
    386386            else: 
    387387                dist_sum = sum(dist) 
    388                  
     388 
    389389            self.assertGreater(dist_sum, 0.0) 
    390390            self.assertLess(abs(dist_sum - 1.0), 1e-3) 
    391              
     391 
    392392            # just for fun also test this 
    393393#            self.assertLess(abs(dist_sum - dist.abs), 1e-3) 
     
    402402        """ 
    403403        classifier = self.learner(dataset) 
    404          
     404 
    405405        s = pickle.dumps(classifier) 
    406406        classifier_clone = pickle.loads(s) 
    407          
     407 
    408408        indices = orange.MakeRandomIndices2(p0=20)(dataset) 
    409409        test = dataset.select(indices, 0) 
    410          
     410 
    411411        for ex in test: 
    412412            if isinstance(dataset.domain.class_var, Orange.feature.Continuous): 
     
    420420                                 classifier_clone(ex, orange.GetValue), 
    421421                                 "Pickled and original classifier return a different value!") 
    422                  
     422 
    423423 
    424424class MeasureAttributeTestCase(DataTestCase): 
     
    432432    """ MEASURE must be defined in the subclass 
    433433    """ 
    434      
     434 
    435435    def setUp(self): 
    436436        self.measure = self.MEASURE 
    437              
     437 
    438438    @test_on_data 
    439439    def test_measure_attribute_on(self, data): 
     
    447447        # any scores actually non zero 
    448448        self.assertTrue(any(score > 0.0 for score in scores)) 
    449              
    450          
     449 
     450 
    451451    def test_pickle(self): 
    452452        """ Test attribute measure pickling support. 
     
    455455        measure = pickle.loads(s) 
    456456        # TODO: make sure measure computes the same scores as measure 
    457           
     457 
    458458 
    459459class PreprocessorTestCase(DataTestCase): 
    460460    """ Test orange.Preprocessor subclass 
    461461     
    462     """  
     462    """ 
    463463    PREPROCESSOR = None 
    464      
     464 
    465465    def setUp(self): 
    466466        self.preprocessor = self.PREPROCESSOR 
     
    471471        """ 
    472472        newdata = self.preprocessor(dataset) 
    473          
     473 
    474474    def test_pickle(self): 
    475475        """ Test preprocessor pickling 
     
    479479            s = pickle.dumps(prep) 
    480480            prep = pickle.loads(s) 
    481                  
     481 
    482482        s = pickle.dumps(self.preprocessor) 
    483483        prep = pickle.loads(s) 
    484          
    485          
     484 
     485 
    486486from Orange.distance import distance_matrix 
    487487from Orange.misc import member_set 
     
    492492    """ 
    493493    DISTANCE_CONSTRUCTOR = None 
    494      
     494 
    495495    def setUp(self): 
    496496        self.distance_constructor = self.DISTANCE_CONSTRUCTOR 
    497          
     497 
    498498    @test_on_data 
    499499    def test_distance_on(self, dataset): 
     
    503503        with member_set(self.distance_constructor, "ignore_class", True): 
    504504            mat = distance_matrix(dataset, self.distance_constructor) 
    505          
     505 
    506506        m = numpy.array(list(mat)) 
    507507        self.assertTrue((m >= 0.0).all()) 
    508          
     508 
    509509        if dataset.domain.class_var: 
    510510            with member_set(self.distance_constructor, "ignore_class", False): 
     
    518518            m1 = numpy.array(list(mat)) 
    519519            self.assertTrue((m1 != m).all() or dataset, "%r does not seem to respect the 'ignore_class' flag") 
    520          
     520 
    521521def test_case_script(path): 
    522522    """ Return a TestCase instance from a script in `path`. 
     
    533533    def tearDown(): 
    534534        os.chdir(_dir["cwd"]) 
    535          
     535 
    536536    def runScript(): 
    537537        execfile(path, {}) 
    538          
     538 
    539539    runScript.__name__ = "runScript %s" % os.path.basename(path) 
    540540    return unittest.FunctionTestCase(runScript, setUp=setUp, tearDown=tearDown) 
     
    549549    import glob 
    550550    return unittest.TestSuite([test_case_script(os.path.join(path, name)) for name in glob.glob1(path, "*.py")]) 
    551      
     551 
    552552 
    553553_default_run = unittest.TestCase.run 
     
    567567    .. warning:: This modifies the unittest.TestCase.run method 
    568568     
    569     """   
    570      
     569    """ 
     570 
    571571    def run(self, result=None): 
    572572        if result is None: 
     
    587587        finally: 
    588588            result.stopTest(self) 
    589              
     589 
    590590    unittest.TestCase.run = run 
    591      
     591 
    592592def disable_pdb(): 
    593593    """ Disables the python pdb postmortem debugger to handle 
     
    596596    """ 
    597597    unittest.TestCase.run = _default_run 
    598      
     598 
    599599try: 
    600600    __IPYTHON__  #We are running tests from ipython 
     
    603603except NameError: 
    604604    pass 
    605      
    606      
     605 
     606 
    607607def test_module(module): 
    608608    """ A helper function to run all tests from a module.   
  • Orange/testing/regression/xtest_one.py

    r10095 r10180  
    113113            print "error" 
    114114            t__message.write(reduce(lambda x, y: x + y, apply(t__traceback.format_exception, t__sys.exc_info()))) 
     115            t__sys.stderr.write(reduce(lambda x, y: x + y, apply(t__traceback.format_exception, t__sys.exc_info()))) 
    115116            t__message.close() 
    116117            t__sys.exit(1) 
     
    152153    t__message.write("changed") 
    153154    print "changed" 
     155    t__message.close() 
    154156    t__sys.exit(3) 
    155157 
    156158t__message.write("OK") 
     159print "OK" 
    157160t__message.close() 
    158 print "OK" 
     161t__sys.exit(0) 
Note: See TracChangeset for help on using the changeset viewer.