Source Code for Module mvpa.tests.test_verbosity

  1  #emacs: -*- mode: python-mode; py-indent-offset: 4; indent-tabs-mode: nil -*- 
  2  #ex: set sts=4 ts=4 sw=4 et: 
  3  ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ## 
  4  # 
  5  #   See COPYING file distributed along with the PyMVPA package for the 
  6  #   copyright and license terms. 
  7  # 
  8  ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ## 
  9  """Unit tests for PyMVPA verbose and debug output""" 
 10   
 11  import unittest, re 
 12  from StringIO import StringIO 
 13   
 14  from mvpa.base.verbosity import OnceLogger 
 15   
 16  from mvpa.base import verbose 
 17   
 18  if __debug__: 
 19      from mvpa.base import debug 
 20      debug.register('1', 'id 1')           # needed for testing 
 21      debug.register('2', 'id 2') 
 22   
 23      from sets import Set 
 24   
 25  ## XXX There must be smth analogous in python... don't know it yet 
 26  # And it is StringIO 
 27  #class StringStream(object): 
 28  #    def __init__(self): 
 29  #        self.__str = "" 
 30  # 
 31  #    def __repr__(self): 
 32  #        return self.__str 
 33  # 
 34  #    def write(self, s): 
 35  #        self.__str += s 
 36  # 
 37  #    def clean(self): 
 38  #        self.__str = "" 
 39  # 
 40 -class VerboseOutputTest(unittest.TestCase): 
 41   
 42 -    def setUp(self): 
 43          self.msg = "Test level 2" 
 44          # output stream 
 45          self.sout = StringIO() 
 46   
 47          self.once = OnceLogger(handlers=[self.sout]) 
 48   
 49          # set verbose to 4th level 
 50          self.__oldverbosehandlers = verbose.handlers 
 51          verbose.handlers = []           # so debug doesn't spoil it 
 52          verbose.level = 4 
 53          if __debug__: 
 54              self.__olddebughandlers = debug.handlers 
 55              self.__olddebugactive = debug.active 
 56              debug.active = ['1', '2', 'SLC'] 
 57              debug.handlers = [self.sout] 
 58              debug.offsetbydepth = False 
 59   
 60          verbose.handlers = [self.sout] 
 61   
 62 -    def tearDown(self): 
 63          if __debug__: 
 64              debug.active = self.__olddebugactive 
 65              debug.handlers = self.__olddebughandlers 
 66              debug.offsetbydepth = True 
 67          verbose.handlers = self.__oldverbosehandlers 
 68          self.sout.close() 
 69   
 70   
 71 -    def testVerboseAbove(self): 
 72          """Test if it doesn't output at higher levels""" 
 73          verbose(5, self.msg) 
 74          self.failUnlessEqual(self.sout.getvalue(), "") 
 75   
 76   
 77 -    def testVerboseBelow(self): 
 78          """Test if outputs at lower levels and indents 
 79          by default with spaces 
 80          """ 
 81          verbose(2, self.msg) 
 82          self.failUnlessEqual(self.sout.getvalue(), 
 83                               "  %s\n" % self.msg) 
 84   
 85 -    def testVerboseIndent(self): 
 86          """Test indent symbol 
 87          """ 
 88          verbose.indent = "." 
 89          verbose(2, self.msg) 
 90          self.failUnlessEqual(self.sout.getvalue(), "..%s\n" % self.msg) 
 91          verbose.indent = " "            # restore 
 92   
 93 -    def testVerboseNegative(self): 
 94          """Test if chokes on negative level""" 
 95          self.failUnlessRaises( ValueError, 
 96                                 verbose._setLevel, -10 ) 
 97   
 98 -    def testNoLF(self): 
 99          """Test if it works fine with no newline (LF) symbol""" 
100          verbose(2, self.msg, lf=False) 
101          verbose(2, " continue ", lf=False) 
102          verbose(2, "end") 
103          verbose(0, "new %s" % self.msg) 
104          self.failUnlessEqual(self.sout.getvalue(), 
105                               "  %s continue end\nnew %s\n" % \ 
106                               (self.msg, self.msg)) 
107   
108 -    def testCR(self): 
109          """Test if works fine with carriage return (cr) symbol""" 
110          verbose(2, self.msg, cr=True) 
111          verbose(2, "rewrite", cr=True) 
112          verbose(1, "rewrite 2", cr=True) 
113          verbose(1, " add", cr=False, lf=False) 
114          verbose(1, " finish") 
115          target = '\r  %s\r              \rrewrite' % self.msg + \ 
116                   '\r       \rrewrite 2 add finish\n' 
117          self.failUnlessEqual(self.sout.getvalue(), target) 
118   
119 -    def testOnceLogger(self): 
120          """Test once logger""" 
121          self.once("X", self.msg) 
122          self.once("X", self.msg) 
123          self.failUnlessEqual(self.sout.getvalue(), self.msg+"\n") 
124   
125          self.once("Y", "XXX", 2) 
126          self.once("Y", "XXX", 2) 
127          self.once("Y", "XXX", 2) 
128          self.failUnlessEqual(self.sout.getvalue(), self.msg+"\nXXX\nXXX\n") 
129   
130   
131      if __debug__: 
132 -        def testDebug(self): 
133              verbose.handlers = []           # so debug doesn't spoil it 
134              debug.active = ['1', '2', 'SLC'] 
135              # do not offset for this test 
136              debug('SLC', self.msg, lf=False) 
137              self.failUnlessRaises(ValueError, debug, 3, 'bugga') 
138              #Should complain about unknown debug id 
139              svalue = self.sout.getvalue() 
140              regexp = "\[SLC\] DBG(?:{.*})?: %s" % self.msg 
141              rematch = re.match(regexp, svalue) 
142              self.failUnless(rematch, msg="Cannot match %s with regexp %s" % 
143                              (svalue, regexp)) 
144   
145   
146 -        def testDebugRgexp(self): 
147              verbose.handlers = []           # so debug doesn't spoil it 
148              debug.active = ['.*'] 
149              # we should have enabled all of them 
150              self.failUnlessEqual(Set(debug.active), 
151                                   Set(debug.registered.keys())) 
152              debug.active = ['S.*', 'CLF'] 
153              self.failUnlessEqual(Set(debug.active), 
154                                   Set(filter(lambda x:x.startswith('S'), 
155                                              debug.registered.keys())+['CLF'])) 
156              debug.active = ['SG', 'CLF'] 
157              self.failUnlessEqual(Set(debug.active), Set(['SG', 'CLF']), 
158                                   msg="debug should do full line matching") 
159   
160              debug.offsetbydepth = True 
161   
162   
163          # TODO: More tests needed for debug output testing 
164   
165 -def suite(): 
166      return unittest.makeSuite(VerboseOutputTest) 
167   
168   
169  if __name__ == '__main__': 
170      import runner 
171