← Back to branch summary

~wavemol/wavemol/wavemol.core

« back to all changes in this revision

Viewing changes to lib/wavemol/core/tests/TestFileReader.py

  • Committer: Stefano Borini
  • Date: 2009-11-28 16:44:11 UTC
  • Revision ID: stefano.borini@gmail.com-20091128164411-ptk9cx7pcrgzq15k
commit basic functionality 

Show diffs side-by-side

added added

removed removed

Lines of Context:
lib/wavemol/core/tests/TestFileReader.py
 
1
# @author Stefano Borini
 
2
from wavemol.core import io
 
3
 
 
4
import os
 
5
import unittest
 
6
import tempfile
 
7
 
 
8
 
 
9
def moduleDir():
 
10
    return os.path.dirname(__file__)
 
11
 
 
12
    
 
13
class TestFileReader(unittest.TestCase):
 
14
    def testFileReaderOpen(self): # fold>>
 
15
        f = io.FileReader(os.path.join(moduleDir(),"testfile.txt"))
 
16
        
 
17
        self.assertEqual(f.__class__, io.FileReader)
 
18
        f.close()
 
19
        # <<fold
 
20
    def testFileReadLine(self): # fold>>
 
21
        f = io.FileReader(os.path.join(moduleDir(),"testfile.txt"))
 
22
 
 
23
        l = f.readline()
 
24
        self.assertEqual(l,"1st line\n")
 
25
        l = f.readline()
 
26
        self.assertEqual(l,"2nd line\n")
 
27
        l = f.readline()
 
28
        self.assertEqual(l,"3rd line\n")
 
29
 
 
30
        # now the pointer is at end of file
 
31
        self.assertEqual(f.readline(), '')
 
32
        f.close()
 
33
        # <<fold
 
34
 
 
35
    def testLen(self): # fold>>
 
36
        f = io.FileReader(os.path.join(moduleDir(),"testfile.txt"))
 
37
        self.assertEqual(len(f),3)
 
38
        f.close()
 
39
        # <<fold
 
40
    def testGetItem(self): # fold>>
 
41
         
 
42
        f = io.FileReader(os.path.join(moduleDir(),"testfile.txt"))
 
43
        
 
44
        self.assertEqual(f[0],"1st line\n")
 
45
        self.assertEqual(f[1],"2nd line\n")
 
46
        self.assertEqual(f[2],"3rd line\n")
 
47
        f.close()
 
48
        # <<fold
 
49
 
 
50
 
 
51
    def testGetItemOutOfBounds(self): # fold>>
 
52
        f = io.FileReader(os.path.join(moduleDir(),"testfile.txt"))
 
53
 
 
54
        # move at BOF with big negative num
 
55
        self.assertEqual(f[-999999],'')
 
56
        self.assertEqual(f.isAtBOF(), True)
 
57
        # move at EOF with big positive num
 
58
        self.assertEqual(f[9999999], '')
 
59
        self.assertEqual(f.isAtEOF(), True)
 
60
        # move at BOF with -1
 
61
        self.assertEqual(f[-1], '')
 
62
        self.assertEqual(f.isAtBOF(), True)
 
63
        # move at EOF with len
 
64
        self.assertEqual(f[len(f)], '')
 
65
        self.assertEqual(f.isAtEOF(), True)
 
66
        f.close()
 
67
        # <<fold
 
68
    def testGetItemCurrentPos(self): # fold>>
 
69
        f = io.FileReader(os.path.join(moduleDir(),"testfile.txt"))
 
70
        l = f[2]
 
71
        
 
72
        self.assertEqual(f.currentPos(), 2)
 
73
        # <<fold
 
74
 
 
75
    def testFileReadlineBackward(self): # fold>>
 
76
        f = io.FileReader(os.path.join(moduleDir(),"testfile.txt"))
 
77
     
 
78
        f.toEOF()
 
79
        l = f.readbackline()
 
80
        self.assertEqual(l,"3rd line\n")
 
81
        l = f.readbackline()
 
82
        self.assertEqual(l,"2nd line\n")
 
83
        l = f.readbackline()
 
84
        self.assertEqual(l,"1st line\n")
 
85
        
 
86
        # now the pointer is at begin of file
 
87
        self.assertEqual(f.readbackline(), '')
 
88
        # <<fold
 
89
 
 
90
    def testCurrentLine(self): # fold>>
 
91
        f = io.FileReader(os.path.join(moduleDir(),"testfile.txt"))
 
92
        self.assertEqual(f.currentLine(), '')
 
93
        f[1]
 
94
        # now we're at line 1
 
95
        self.assertEqual(f.currentLine(),"2nd line\n")
 
96
        # <<fold
 
97
    def testCurrentPos(self): # fold>>
 
98
        
 
99
        f = io.FileReader(os.path.join(moduleDir(),"testfile.txt"))
 
100
        self.assertEqual(f.currentPos(),-1)
 
101
        f[1]
 
102
        self.assertEqual(f.currentPos(),1)
 
103
        # <<fold
 
104
 
 
105
    def testFileSeeks(self): # fold>>
 
106
        f = io.FileReader(os.path.join(moduleDir(),"testfile.txt"))
 
107
        self.assertEqual(f.currentPos(),-1)
 
108
        self.assertEqual(f.isAtBOF(), True)
 
109
        f.toEOF()
 
110
        self.assertEqual( f.currentPos(), 3)
 
111
        self.assertEqual( f.isAtEOF(), True)
 
112
        f.toBOF()
 
113
        self.assertEqual( f.currentPos(), -1)
 
114
        self.assertEqual( f.isAtBOF(), True)
 
115
        f.toPos(2)
 
116
        self.assertEqual( f.currentPos(), 2)
 
117
        self.assertEqual( f.isAtPos(2), True)
 
118
        # <<fold
 
119
    def testSkipLines(self): # fold>>
 
120
        "Seeking with relative jumps"
 
121
        f = io.FileReader(os.path.join(moduleDir(),"testfile.txt"))
 
122
        self.assertEqual( f.currentPos(), -1)
 
123
        f.skipLines(3)
 
124
        self.assertEqual( f.currentPos(), 2)
 
125
        f.skipLines(-1)
 
126
        self.assertEqual( f.currentPos(), 1)
 
127
        f.skipLines(10)
 
128
        self.assertEqual( f.isAtEOF(), True)
 
129
        f.skipLines(-10)
 
130
        self.assertEqual( f.isAtBOF(), True)
 
131
        # <<fold
 
132
    def testOccurrences(self): # fold>>
 
133
        "Seeking with relative jumps"
 
134
        f = io.FileReader(os.path.join(moduleDir(),"testfile.txt"))
 
135
        f.skipLines(1)
 
136
        self.assertEqual(f.isAtPos(0), True)
 
137
        self.assertEqual(f.occurrences('line'), [1, 2])
 
138
        self.assertEqual(f.isAtPos(0), True)
 
139
        f.skipLines(2)
 
140
        self.assertEqual(f.isAtPos(2), True)
 
141
        self.assertEqual(f.occurrences('line', backward=True),[1, 0])
 
142
        self.assertEqual(f.isAtPos(2), True)
 
143
        f.toBOF()
 
144
        self.assertEqual(f.occurrences('not found'), [])
 
145
        # <<fold
 
146
    def testFindStringBasic(self): # fold>>
 
147
        "Findstring functionality/basic search"
 
148
        f = io.FileReader(os.path.join(moduleDir(),"testfile.txt"))
 
149
        self.assertEqual( f.findString("3rd"),"3rd line\n")
 
150
        self.assertEqual( f.currentLine(), "3rd line\n")
 
151
        f.toEOF()
 
152
        self.assertEqual( f.findString("1st", backward=True),"1st line\n")
 
153
        self.assertEqual( f.currentLine(),"1st line\n")
 
154
        # <<fold 
 
155
    def testFindStringCounted(self): # fold>>
 
156
        "Findstring functionality/counted search"
 
157
        f = io.FileReader(os.path.join(moduleDir(),"testfile.txt"))
 
158
        self.assertEqual(f.findString("line", 2), "2nd line\n")
 
159
        self.assertEqual(f.currentLine(), "2nd line\n")
 
160
        f.toEOF()
 
161
        self.assertEqual(f.findString("line", 2, backward=True), "2nd line\n")
 
162
        self.assertEqual(f.currentLine(), "2nd line\n")
 
163
    # <<fold
 
164
    def testFindStringNotFound(self): # fold>>
 
165
        "Findstring functionality/not found case"
 
166
        f = io.FileReader(os.path.join(moduleDir(),"testfile.txt"))
 
167
        self.assertEqual(f.findString('notfound'),'')
 
168
        self.assertEqual(f.isAtEOF(), True)
 
169
        self.assertEqual(f.findString('notfound', backward=True), '')
 
170
        self.assertEqual(f.isAtBOF(), True)
 
171
        # <<fold 
 
172
    def testFindStringCurlineNeverEvaluated(self): # fold>>
 
173
        "Findstring functionality/curline never evaluated"
 
174
        f = io.FileReader(os.path.join(moduleDir(),"testfile.txt"))
 
175
        f.toPos(0)
 
176
        self.assertEqual( f.findString('line'),"2nd line\n")
 
177
        self.assertEqual( f.currentLine(), "2nd line\n")
 
178
        f.toPos(2)
 
179
        self.assertEqual( f.findString('line', backward=True), "2nd line\n")
 
180
        self.assertEqual( f.currentLine(), "2nd line\n")
 
181
        # <<fold 
 
182
    def testRegexpBasic(self): # fold>>
 
183
        "Findregexp functionality/basic search"
 
184
        f = io.FileReader(os.path.join(moduleDir(),"testfile.txt"))
 
185
        self.assertEqual( f.findRegexp("3rd"), ("3rd line\n",))
 
186
        self.assertEqual( f.currentLine(), "3rd line\n")
 
187
        f.toEOF()
 
188
        self.assertEqual( f.findRegexp("1st", backward=True), ("1st line\n",))
 
189
        self.assertEqual( f.currentLine(), "1st line\n")
 
190
        # <<fold 
 
191
    def testRegexpCounted(self): # fold>>
 
192
        "Findregexp functionality/counted search"
 
193
        f = io.FileReader(os.path.join(moduleDir(),"testfile.txt"))
 
194
        self.assertEqual(f.findRegexp("line", 2), ("2nd line\n",))
 
195
        self.assertEqual(f.currentLine(), "2nd line\n")
 
196
        f.toEOF()
 
197
        self.assertEqual(f.findRegexp("line", 2, backward=True), ("2nd line\n",))
 
198
        self.assertEqual(f.currentLine(),"2nd line\n")
 
199
    # <<fold
 
200
    def testRegexpNotFound(self): # fold>>
 
201
        f = io.FileReader(os.path.join(moduleDir(),"testfile.txt"))
 
202
        self.assertEqual( f.findRegexp('notfound'), None)
 
203
        self.assertEqual( f.isAtEOF(), True)
 
204
        self.assertEqual( f.findRegexp('notfound', backward=True), None)
 
205
        self.assertEqual( f.isAtBOF(), True)
 
206
        # <<fold 
 
207
    def testRegexpCurlineNeverEvaluated(self): # fold>>
 
208
        f = io.FileReader(os.path.join(moduleDir(),"testfile.txt"))
 
209
        f.toPos(0)
 
210
        self.assertEqual(f.findRegexp('line'), ("2nd line\n",))
 
211
        self.assertEqual(f.currentLine(), "2nd line\n")
 
212
        f.toPos(2)
 
213
        self.assertEqual(f.findRegexp('line', backward=True), ("2nd line\n",))
 
214
        self.assertEqual(f.currentLine(),"2nd line\n")
 
215
        # <<fold 
 
216
    def testRegexp(self): # fold>>
 
217
        f = io.FileReader(os.path.join(moduleDir(),"testfile.txt"))
 
218
        (line, match) = f.findRegexp('1(.*) line')
 
219
        self.assertEqual( line, "1st line\n")
 
220
        self.assertEqual( match, 'st')
 
221
        # <<fold 
 
222
 
 
223
    def testEmptyFileGetItemLen(self): # fold>>
 
224
        f = io.FileReader(os.path.join(moduleDir(),"emptytestfile.txt"))
 
225
        # has the same length
 
226
        self.assertEqual(len(f), 0)
 
227
    # <<fold
 
228
    def testEmptyFileGetItemOutOfBounds(self): # fold>>
 
229
        f = io.FileReader(os.path.join(moduleDir(),"emptytestfile.txt"))
 
230
        # move at BOF with big negative num
 
231
        self.assertEqual(f[-999999], '')
 
232
        self.assertEqual(f.isAtBOF(),True)
 
233
        # move at EOF with big positive num
 
234
        self.assertEqual(f[9999999], '')
 
235
        self.assertEqual(f.isAtEOF(),True)
 
236
        # move at BOF with -1
 
237
        self.assertEqual(f[-1], '')
 
238
        self.assertEqual(f.isAtBOF(),True)
 
239
        # move at EOF with len
 
240
        self.assertEqual(f[len(f)], '')
 
241
        self.assertEqual(f.isAtEOF(),True)
 
242
        # <<fold 
 
243
    def testEmptyFileReadLine(self): # fold>>
 
244
        f = io.FileReader(os.path.join(moduleDir(),"emptytestfile.txt"))
 
245
        self.assertEqual(f.readline(),'')
 
246
        # <<fold 
 
247
    def testEmptyFileReadlineBackward(self): # fold>>
 
248
        f = io.FileReader(os.path.join(moduleDir(),"emptytestfile.txt"))
 
249
        f.toEOF()
 
250
        self.assertEqual(f.readbackline(), '')
 
251
            # <<fold 
 
252
    def testEmptyFileCurrentLine(self): # fold>>
 
253
        f = io.FileReader(os.path.join(moduleDir(),"emptytestfile.txt"))
 
254
        self.assertEqual(f.currentLine(), '')
 
255
        # <<fold 
 
256
    def testEmptyFileCurrentPos(self): # fold>>
 
257
        f = io.FileReader(os.path.join(moduleDir(),"emptytestfile.txt"))
 
258
        self.assertEqual(f.currentPos(), -1)
 
259
        # <<fold 
 
260
    def testEmptyFileSeeks(self): # fold>>
 
261
        f = io.FileReader(os.path.join(moduleDir(),"emptytestfile.txt"))
 
262
        self.assertEqual(f.currentPos(), -1)
 
263
        self.assertEqual(f.isAtBOF(), True)
 
264
        f.toEOF()
 
265
        self.assertEqual(f.currentPos(), 0)
 
266
        self.assertEqual(f.isAtEOF(), True)
 
267
        f.toBOF()
 
268
        self.assertEqual(f.currentPos(), -1)
 
269
        self.assertEqual(f.isAtBOF(), True)
 
270
    # <<fold
 
271
    def testEmptyFileSkipLines(self): # fold>>
 
272
        f = io.FileReader(os.path.join(moduleDir(),"emptytestfile.txt"))
 
273
        self.assertEqual(f.currentPos(), -1)
 
274
        f.skipLines(10)
 
275
        self.assertEqual(f.isAtEOF(), True)
 
276
        f.skipLines(-10)
 
277
        self.assertEqual(f.isAtBOF(), True)
 
278
        # <<fold 
 
279
    def testEmptyFileOccurrences(self): # fold>>
 
280
        f = io.FileReader(os.path.join(moduleDir(),"emptytestfile.txt"))
 
281
        self.assertEqual(f.occurrences('not found'), [])
 
282
    # <<fold
 
283
    def testEmptyFileFindStringNotFound(self): # fold>>
 
284
        f = io.FileReader(os.path.join(moduleDir(),"emptytestfile.txt"))
 
285
        self.assertEqual( f.findString('notfound'), '')
 
286
        self.assertEqual( f.isAtEOF(), True)
 
287
        self.assertEqual( f.findString('notfound', backward=True), '')
 
288
        self.assertEqual( f.isAtBOF(), True)
 
289
    # <<fold
 
290
    def testEmptyFileRegexpNotFound(self): # fold>>
 
291
        f = io.FileReader(os.path.join(moduleDir(),"emptytestfile.txt"))
 
292
        self.assertEqual(f.findRegexp('notfound'),None)
 
293
        self.assertEqual(f.isAtEOF(), True)
 
294
        self.assertEqual(f.findRegexp('notfound', backward=True), None)
 
295
        self.assertEqual(f.isAtBOF(), True)
 
296
    # <<fold 
 
297
 
 
298
if __name__ == '__main__':
 
299
    unittest.main()
 
300