Source Code for Module mvpa.tests.test_iohelpers

  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 IO helpers""" 
 10   
 11  import os 
 12  import unittest 
 13  from tempfile import mkstemp 
 14  import numpy as N 
 15   
 16  from mvpa import pymvpa_dataroot 
 17  from mvpa.misc.io import * 
 18  from mvpa.misc.fsl import FslEV3 
 19  from mvpa.misc.bv import BrainVoyagerRTC 
 20   
 21   
 22 -class IOHelperTests(unittest.TestCase): 
 23   
 24 -    def testColumnDataFromFile(self): 
 25          ex1 = """eins zwei drei 
 26          0 1 2 
 27          3 4 5 
 28          """ 
 29          file, fpath = mkstemp('mvpa', 'test') 
 30          file = open(fpath, 'w') 
 31          file.write(ex1) 
 32          file.close() 
 33   
 34          # intentionally rely on defaults 
 35          d = ColumnData(fpath, header=True) 
 36   
 37          # check header (sort because order in dict is unpredictable) 
 38          self.failUnless(sorted(d.keys()) == ['drei','eins','zwei']) 
 39   
 40          self.failUnless(d['eins'] == [0, 3]) 
 41          self.failUnless(d['zwei'] == [1, 4]) 
 42          self.failUnless(d['drei'] == [2, 5]) 
 43   
 44          # make a copy 
 45          d2 = ColumnData(d) 
 46   
 47          # check if identical 
 48          self.failUnless(sorted(d2.keys()) == ['drei','eins','zwei']) 
 49          self.failUnless(d2['eins'] == [0, 3]) 
 50          self.failUnless(d2['zwei'] == [1, 4]) 
 51          self.failUnless(d2['drei'] == [2, 5]) 
 52   
 53          # now merge back 
 54          d += d2 
 55   
 56          # same columns? 
 57          self.failUnless(sorted(d.keys()) == ['drei','eins','zwei']) 
 58   
 59          # but more data 
 60          self.failUnlessEqual(d['eins'], [0, 3, 0, 3]) 
 61          self.failUnlessEqual(d['zwei'], [1, 4, 1, 4]) 
 62          self.failUnlessEqual(d['drei'], [2, 5, 2, 5]) 
 63   
 64          # test file write 
 65          # TODO: check if correct 
 66          header_order = ['drei', 'zwei', 'eins'] 
 67          d.tofile(fpath, header_order=header_order) 
 68   
 69          # test sample selection 
 70          dsel = d.selectSamples([0, 2]) 
 71          self.failUnlessEqual(dsel['eins'], [0, 0]) 
 72          self.failUnlessEqual(dsel['zwei'], [1, 1]) 
 73          self.failUnlessEqual(dsel['drei'], [2, 2]) 
 74   
 75          # test if order is read from file when available 
 76          d3 = ColumnData(fpath) 
 77          self.failUnlessEqual(d3._header_order, header_order) 
 78   
 79          # add another column -- should be appended as the last column 
 80          # while storing 
 81          d3['four'] = [0.1] * len(d3['eins']) 
 82          d3.tofile(fpath) 
 83   
 84          d4 = ColumnData(fpath) 
 85          self.failUnlessEqual(d4._header_order, header_order + ['four']) 
 86   
 87          # cleanup and ignore stupidity 
 88          try: 
 89              os.remove(fpath) 
 90          except WindowsError: 
 91              pass 
 92   
 93   
 94 -    def testFslEV(self): 
 95          ex1 = """0.0 2.0 1 
 96          13.89 2 1 
 97          16 2.0 0.5 
 98          """ 
 99          file, fpath = mkstemp('mvpa', 'test') 
100          file = open(fpath, 'w') 
101          file.write(ex1) 
102          file.close() 
103   
104          # intentionally rely on defaults 
105          d = FslEV3(fpath) 
106   
107          # check header (sort because order in dict is unpredictable) 
108          self.failUnless(sorted(d.keys()) == \ 
109              ['durations','intensities','onsets']) 
110   
111          self.failUnless(d['onsets'] == [0.0, 13.89, 16.0]) 
112          self.failUnless(d['durations'] == [2.0, 2.0, 2.0]) 
113          self.failUnless(d['intensities'] == [1.0, 1.0, 0.5]) 
114   
115          self.failUnless(d.getNEVs() == 3) 
116          self.failUnless(d.getEV(1) == (13.89, 2.0, 1.0)) 
117          # cleanup and ignore stupidity 
118          try: 
119              os.remove(fpath) 
120          except WindowsError: 
121              pass 
122   
123          d = FslEV3(os.path.join(pymvpa_dataroot, 'fslev3.txt')) 
124          ev = d.toEvents() 
125          self.failUnless(len(ev) == 3) 
126          self.failUnless([e['duration'] for e in ev] == [9] * 3) 
127          self.failUnless([e['onset'] for e in ev] == [6, 21, 35]) 
128          self.failUnless([e['features'] for e in ev] == [[1],[1],[1]]) 
129   
130          ev = d.toEvents(label='face', chunk=0, crap=True) 
131          ev[0]['label'] = 'house' 
132          self.failUnless(len(ev) == 3) 
133          self.failUnless([e['duration'] for e in ev] == [9] * 3) 
134          self.failUnless([e['onset'] for e in ev] == [6, 21, 35]) 
135          self.failUnless([e['features'] for e in ev] == [[1],[1],[1]]) 
136          self.failUnless([e['label'] for e in ev] == ['house', 'face', 'face']) 
137          self.failUnless([e['chunk'] for e in ev] == [0]*3) 
138          self.failUnless([e['crap'] for e in ev] == [True]*3) 
139   
140   
141 -    def testFslEV2(self): 
142          attr = SampleAttributes(os.path.join(pymvpa_dataroot, 'smpl_attr.txt')) 
143   
144          # check header (sort because order in dict is unpredictable) 
145          self.failUnless(sorted(attr.keys()) == \ 
146              ['chunks','labels']) 
147   
148          self.failUnless(attr.nsamples == 3) 
149   
150 -    def testBVRTC(self): 
151          """Simple testing of reading RTC files from BrainVoyager""" 
152   
153          attr = BrainVoyagerRTC(os.path.join(pymvpa_dataroot, 'bv', 'smpl_model.rtc')) 
154          self.failUnlessEqual(attr.ncolumns, 4, "We must have 4 colums") 
155          self.failUnlessEqual(attr.nrows, 147, "We must have 147 rows") 
156   
157          self.failUnlessEqual(attr._header_order, 
158                  ['l_60 B', 'r_60 B', 'l_80 B', 'r_80 B'], 
159                  "We must got column names correctly") 
160          self.failUnless(len(attr.r_60_B) == attr.nrows, 
161                  "We must have got access to column by property") 
162          self.failUnless(attr.toarray() != None, 
163                  "We must have got access to column by property") 
164   
165 -    def testdesign2labels(self): 
166          """Simple testing of helper Design2Labels""" 
167   
168          attr = BrainVoyagerRTC(os.path.join(pymvpa_dataroot, 'bv', 'smpl_model.rtc')) 
169          labels0 = design2labels(attr, baseline_label='silence') 
170          labels = design2labels(attr, baseline_label='silence', 
171                                  func=lambda x:x>0.5) 
172          Nsilence = lambda x:len(N.where(N.array(x) == 'silence')[0]) 
173   
174          nsilence0 = Nsilence(labels0) 
175          nsilence = Nsilence(labels) 
176          self.failUnless(nsilence0 < nsilence, 
177                          "We must have more silence if thr is higher") 
178          self.failUnlessEqual(len(labels), attr.nrows, 
179                          "We must have the same number of labels as rows") 
180          self.failUnlessRaises(ValueError, design2labels, attr, 
181                          baseline_label='silence', func=lambda x:x>-1.0) 
182   
183   
184 -    def testlabels2chunks(self): 
185          attr = BrainVoyagerRTC(os.path.join(pymvpa_dataroot, 'bv', 'smpl_model.rtc')) 
186          labels = design2labels(attr, baseline_label='silence') 
187          self.failUnlessRaises(ValueError, labels2chunks, labels, 'bugga') 
188          chunks = labels2chunks(labels) 
189          self.failUnlessEqual(len(labels), len(chunks)) 
190          # we must got them in sorted order 
191          chunks_sorted = N.sort(chunks) 
192          self.failUnless((chunks == chunks_sorted).all()) 
193          # for this specific one we must have just 4 chunks 
194          self.failUnless((N.unique(chunks) == range(4)).all()) 
195   
196   
197 -    def testSensorLocations(self): 
198          sl = XAVRSensorLocations(os.path.join(pymvpa_dataroot, 'xavr1010.dat')) 
199   
200          for var in ['names', 'pos_x', 'pos_y', 'pos_z']: 
201              self.failUnless(len(eval('sl.' + var)) == 31) 
202   
203   
204   
205 -def suite(): 
206      return unittest.makeSuite(IOHelperTests) 
207   
208   
209  if __name__ == '__main__': 
210      import runner 
211