Source Code for Module mvpa.tests.test_verbosity

  1  # emacs: -*- mode: python; py-indent-offset: 4; indent-tabs-mode: nil -*- 
  2  # vi: set ft=python 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, error 
 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 -    def testError(self): 
132          """Test error message""" 
133          error(self.msg, critical=False) # should not exit 
134          self.failUnless(self.sout.getvalue().startswith("ERROR")) 
135   
136   
137      if __debug__: 
138 -        def testDebug(self): 
139              verbose.handlers = []           # so debug doesn't spoil it 
140              debug.active = ['1', '2', 'SLC'] 
141              # do not offset for this test 
142              debug('SLC', self.msg, lf=False) 
143              self.failUnlessRaises(ValueError, debug, 3, 'bugga') 
144              #Should complain about unknown debug id 
145              svalue = self.sout.getvalue() 
146              regexp = "\[SLC\] DBG(?:{.*})?: %s" % self.msg 
147              rematch = re.match(regexp, svalue) 
148              self.failUnless(rematch, msg="Cannot match %s with regexp %s" % 
149                              (svalue, regexp)) 
150   
151   
152 -        def testDebugRgexp(self): 
153              verbose.handlers = []           # so debug doesn't spoil it 
154              debug.active = ['.*'] 
155              # we should have enabled all of them 
156              self.failUnlessEqual(Set(debug.active), 
157                                   Set(debug.registered.keys())) 
158              debug.active = ['S.*', 'CLF'] 
159              self.failUnlessEqual(Set(debug.active), 
160                                   Set(filter(lambda x:x.startswith('S'), 
161                                              debug.registered.keys())+['CLF'])) 
162              debug.active = ['SG', 'CLF'] 
163              self.failUnlessEqual(Set(debug.active), Set(['SG', 'CLF']), 
164                                   msg="debug should do full line matching") 
165   
166              debug.offsetbydepth = True 
167   
168   
169          # TODO: More tests needed for debug output testing 
170   
171 -def suite(): 
172      return unittest.makeSuite(VerboseOutputTest) 
173   
174   
175  if __name__ == '__main__': 
176      import runner 
177