Source Code for Module mvpa.tests.test_state

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