Source Code for Module mvpa.tests.test_state

  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 State parent class""" 
 10   
 11  import unittest, copy 
 12   
 13  import numpy as N 
 14   
 15  from mvpa.base import externals 
 16   
 17  from mvpa.misc.state import StateVariable, ClassWithCollections, \ 
 18       ParameterCollection, _def_sep 
 19  from mvpa.misc.param import * 
 20  from mvpa.misc.exceptions import UnknownStateError 
 21   
 22  if __debug__: 
 23      from mvpa.base import debug 
 24   
 25 -class TestClassEmpty(ClassWithCollections): 
 26      pass 
 27   
 28 -class TestClassBlank(ClassWithCollections): 
 29      # We can force to have 'states' present even though we don't have 
 30      # any StateVariable defined here -- it might be added later on at run time 
 31      _ATTRIBUTE_COLLECTIONS = ['states'] 
 32      pass 
 33   
 34 -class TestClassBlankNoExplicitStates(ClassWithCollections): 
 35      pass 
 36   
 37 -class TestClassProper(ClassWithCollections): 
 38   
 39      state1 = StateVariable(enabled=False, doc="state1 doc") 
 40      state2 = StateVariable(enabled=True, doc="state2 doc") 
 41   
 42   
 43 -class TestClassProperChild(TestClassProper): 
 44   
 45      state4 = StateVariable(enabled=False, doc="state4 doc") 
 46   
 47   
 48 -class TestClassParametrized(TestClassProper, ClassWithCollections): 
 49      p1 = Parameter(0) 
 50      state0 = StateVariable(enabled=False) 
 51   
 52 -    def __init__(self, **kwargs): 
 53          # XXX make such example when we actually need to invoke 
 54          # constructor 
 55          # TestClassProper.__init__(self, **kwargs) 
 56          ClassWithCollections.__init__(self, **kwargs) 
 57   
 58   
 59 -class StateTests(unittest.TestCase): 
 60   
 61 -    def testBlankState(self): 
 62          empty  = TestClassEmpty() 
 63          blank  = TestClassBlank() 
 64          blank2 = TestClassBlank() 
 65   
 66          self.failUnlessRaises(AttributeError, empty.__getattribute__, 'states') 
 67   
 68          self.failUnlessEqual(blank.states.items, {}) 
 69          self.failUnless(blank.states.enabled == []) 
 70          self.failUnlessRaises(AttributeError, blank.__getattribute__, 'dummy') 
 71          self.failUnlessRaises(AttributeError, blank.__getattribute__, '_') 
 72   
 73          # we shouldn't use _registerState now since metaclass statecollector wouldn't 
 74          # update the states... may be will be implemented in the future if necessity comes 
 75          return 
 76   
 77          # add some state variable 
 78          blank._registerState('state1', False) 
 79          self.failUnless(blank.states == ['state1']) 
 80   
 81          self.failUnless(blank.states.isEnabled('state1') == False) 
 82          self.failUnless(blank.states.enabled == []) 
 83          self.failUnlessRaises(UnknownStateError, blank.__getattribute__, 'state1') 
 84   
 85          # assign value now 
 86          blank.state1 = 123 
 87          # should have no effect since the state variable wasn't enabled 
 88          self.failUnlessRaises(UnknownStateError, blank.__getattribute__, 'state1') 
 89   
 90          # lets enable and assign 
 91          blank.states.enable('state1') 
 92          blank.state1 = 123 
 93          self.failUnless(blank.state1 == 123) 
 94   
 95          # we should not share states across instances at the moment, so an arbitrary 
 96          # object could carry some custom states 
 97          self.failUnless(blank2.states == []) 
 98          self.failUnlessRaises(AttributeError, blank2.__getattribute__, 'state1') 
 99   
100   
101 -    def testProperState(self): 
102          proper   = TestClassProper() 
103          proper2  = TestClassProper(enable_states=['state1'], disable_states=['state2']) 
104   
105          # disable_states should override anything in enable_states 
106          proper3 = TestClassProper(enable_states=['all'], disable_states='all') 
107   
108          self.failUnlessEqual(len(proper3.states.enabled), 0, 
109              msg="disable_states should override anything in enable_states") 
110   
111          proper.state2 = 1000 
112          value = proper.state2 
113          self.failUnlessEqual(proper.state2, 1000, msg="Simple assignment/retrieval") 
114   
115          proper.states.disable('state2') 
116          proper.state2 = 10000 
117          self.failUnlessEqual(proper.state2, 1000, msg="Simple assignment after being disabled") 
118   
119          proper4 = copy.deepcopy(proper) 
120   
121          proper.states.reset('state2') 
122          self.failUnlessRaises(UnknownStateError, proper.__getattribute__, 'state2') 
123          """Must be blank after being reset""" 
124   
125          self.failUnlessEqual(proper4.state2, 1000, 
126              msg="Simple assignment after being reset in original instance") 
127   
128   
129          proper.states.enable(['state2']) 
130          self.failUnlessEqual(set(proper.states.names), set(['state1', 'state2'])) 
131          if __debug__ and 'ENFORCE_STATES_ENABLED' in debug.active: 
132              # skip testing since all states are on now 
133              return 
134          self.failUnless(proper.states.enabled == ['state2']) 
135   
136          self.failUnless(set(proper2.states.enabled) == set(['state1'])) 
137   
138          self.failUnlessRaises(AttributeError, proper.__getattribute__, 'state12') 
139   
140          # if documentary on the state is appropriate 
141          self.failUnlessEqual(proper2.states.listing, 
142                               ['%sstate1+%s: state1 doc' % (_def_sep, _def_sep), 
143                                '%sstate2%s: state2 doc' % (_def_sep, _def_sep)]) 
144   
145          # if __str__ lists correct number of states 
146          str_ = str(proper2) 
147          self.failUnless(str_.find('2 states:') != -1) 
148   
149          # check if disable works 
150          self.failUnless(set(proper2.states.enabled), set(['state1'])) 
151   
152          proper2.states.disable("all") 
153          self.failUnlessEqual(set(proper2.states.enabled), set()) 
154   
155          proper2.states.enable("all") 
156          self.failUnlessEqual(len(proper2.states.enabled), 2) 
157   
158          proper2.state1, proper2.state2 = 1,2 
159          self.failUnlessEqual(proper2.state1, 1) 
160          self.failUnlessEqual(proper2.state2, 2) 
161   
162          # now reset them 
163          proper2.states.reset('all') 
164          self.failUnlessRaises(UnknownStateError, proper2.__getattribute__, 'state1') 
165          self.failUnlessRaises(UnknownStateError, proper2.__getattribute__, 'state2') 
166   
167   
168 -    def testGetSaveEnabled(self): 
169          """Check if we can store/restore set of enabled states""" 
170   
171          if __debug__ and 'ENFORCE_STATES_ENABLED' in debug.active: 
172              # skip testing since all states are on now 
173              return 
174   
175          proper  = TestClassProper() 
176          enabled_states = proper.states.enabled 
177          proper.states.enable('state1') 
178   
179          self.failUnless(enabled_states != proper.states.enabled, 
180                          msg="New enabled states should differ from previous") 
181   
182          self.failUnless(set(proper.states.enabled) == set(['state1', 'state2']), 
183                          msg="Making sure that we enabled all states of interest") 
184   
185          proper.states.enabled = enabled_states 
186          self.failUnless(enabled_states == proper.states.enabled, 
187                          msg="List of enabled states should return to original one") 
188   
189   
190      # TODO: make test for _copy_states_ or whatever comes as an alternative 
191   
192 -    def testStoredTemporarily(self): 
193          proper   = TestClassProper() 
194          properch = TestClassProperChild(enable_states=["state1"]) 
195   
196          if __debug__ and 'ENFORCE_STATES_ENABLED' in debug.active: 
197              # skip testing since all states are on now 
198              return 
199   
200          self.failUnlessEqual(proper.states.enabled, ["state2"]) 
201          proper.states._changeTemporarily( 
202              enable_states=["state1"], other=properch) 
203          self.failUnlessEqual(set(proper.states.enabled), 
204                               set(["state1", "state2"])) 
205          proper.states._resetEnabledTemporarily() 
206          self.failUnlessEqual(proper.states.enabled, ["state2"]) 
207   
208          # allow to enable disable without other instance 
209          proper.states._changeTemporarily( 
210              enable_states=["state1", "state2"]) 
211          self.failUnlessEqual(set(proper.states.enabled), 
212                               set(["state1", "state2"])) 
213          proper.states._resetEnabledTemporarily() 
214          self.failUnlessEqual(proper.states.enabled, ["state2"]) 
215   
216   
217 -    def testProperStateChild(self): 
218          """ 
219          Simple test if child gets state variables from the parent as well 
220          """ 
221          proper = TestClassProperChild() 
222          self.failUnlessEqual(set(proper.states.names), 
223                               set(['state1', 'state2', 'state4'])) 
224   
225   
226 -    def testStateVariables(self): 
227          """To test new states""" 
228   
229          class S1(ClassWithCollections): 
230              v1 = StateVariable(enabled=True, doc="values1 is ...") 
231              v1XXX = StateVariable(enabled=False, doc="values1 is ...") 
232   
233   
234          class S2(ClassWithCollections): 
235              v2 = StateVariable(enabled=True, doc="values12 is ...") 
236   
237          class S1_(S1): 
238              pass 
239   
240          class S1__(S1_): 
241              v1__ = StateVariable(enabled=False) 
242   
243          class S12(S1__, S2): 
244              v12 = StateVariable() 
245   
246          s1, s2, s1_, s1__, s12 = S1(), S2(), S1_(), S1__(), S12() 
247   
248          self.failUnlessEqual(s1.states.isEnabled("v1"), True) 
249          s1.v1 = 12 
250          s12.v1 = 120 
251          s2.v2 = 100 
252   
253          self.failUnlessEqual(len(s2.states.listing), 1) 
254   
255          self.failUnlessEqual(s1.v1, 12) 
256          try: 
257              tempvalue = s1__.v1__ 
258              self.fail("Should have puked since values were not enabled yet") 
259          except: 
260              pass 
261   
262   
263 -    def testParametrized(self): 
264   
265          self.failUnlessRaises(TypeError, TestClassParametrized, 
266              p2=34, enable_states=['state1'], 
267              msg="Should raise an exception if argument doesn't correspond to" 
268                  "any parameter") 
269          a = TestClassParametrized(p1=123, enable_states=['state1']) 
270          self.failUnlessEqual(a.p1, 123, msg="We must have assigned value to instance") 
271          self.failUnless('state1' in a.states.enabled, 
272                          msg="state1 must have been enabled") 
273   
274          if (__debug__ and 'ID_IN_REPR' in debug.active): 
275              # next tests would fail due to ID in the tails 
276              return 
277   
278          # validate that string representation of the object is valid and consistent 
279          a_str = `a` 
280          try: 
281              import test_state 
282              exec "a2=%s" % a_str 
283          except Exception, e: 
284              self.fail(msg="Failed to generate an instance out of " 
285                        "representation %s. Got exception: %s" % (a_str, e)) 
286   
287          a2_str = `a2` 
288          self.failUnless(a2_str == a_str, 
289              msg="Generated object must have the same repr. Got %s and %s" % 
290              (a_str, a2_str)) 
291   
292          # Test at least that repr of collection is of correct syntax 
293          aparams_str = `a.params` 
294          try: 
295              import test_state 
296              exec "aparams2=%s" % aparams_str 
297          except Exception, e: 
298              self.fail(msg="Failed to generate an instance out of " 
299                        "representation  %s of params. Got exception: %s" % (aparams_str, e)) 
300   
301   
302 -def suite(): 
303      return unittest.makeSuite(StateTests) 
304   
305   
306  if __name__ == '__main__': 
307      import runner 
308