@@ -138,11 +138,118 @@ pub fn u64_from_be_bytes(data: &[u8],
138
138
139
139
#[ cfg( test) ]
140
140
mod test {
141
- use option:: { Some , None } ;
142
- use cell:: Cell ;
141
+ use option:: { None , Option , Some } ;
143
142
use rt:: io:: mem:: { MemReader , MemWriter } ;
144
- use rt:: io:: mock:: MockReader ;
145
- use rt:: io:: { io_error, placeholder_error} ;
143
+ use rt:: io:: { Reader , io_error, placeholder_error} ;
144
+
145
+ struct InitialZeroByteReader {
146
+ count : int ,
147
+ }
148
+
149
+ impl Reader for InitialZeroByteReader {
150
+ fn read ( & mut self , buf : & mut [ u8 ] ) -> Option < uint > {
151
+ if self . count == 0 {
152
+ self . count = 1 ;
153
+ Some ( 0 )
154
+ } else {
155
+ buf[ 0 ] = 10 ;
156
+ Some ( 1 )
157
+ }
158
+ }
159
+ fn eof ( & mut self ) -> bool {
160
+ false
161
+ }
162
+ }
163
+
164
+ struct EofReader ;
165
+
166
+ impl Reader for EofReader {
167
+ fn read ( & mut self , _: & mut [ u8 ] ) -> Option < uint > {
168
+ None
169
+ }
170
+ fn eof ( & mut self ) -> bool {
171
+ false
172
+ }
173
+ }
174
+
175
+ struct ErroringReader ;
176
+
177
+ impl Reader for ErroringReader {
178
+ fn read ( & mut self , _: & mut [ u8 ] ) -> Option < uint > {
179
+ io_error:: cond. raise ( placeholder_error ( ) ) ;
180
+ None
181
+ }
182
+ fn eof ( & mut self ) -> bool {
183
+ false
184
+ }
185
+ }
186
+
187
+ struct PartialReader {
188
+ count : int ,
189
+ }
190
+
191
+ impl Reader for PartialReader {
192
+ fn read ( & mut self , buf : & mut [ u8 ] ) -> Option < uint > {
193
+ if self . count == 0 {
194
+ self . count = 1 ;
195
+ buf[ 0 ] = 10 ;
196
+ buf[ 1 ] = 11 ;
197
+ Some ( 2 )
198
+ } else {
199
+ buf[ 0 ] = 12 ;
200
+ buf[ 1 ] = 13 ;
201
+ Some ( 2 )
202
+ }
203
+ }
204
+ fn eof ( & mut self ) -> bool {
205
+ false
206
+ }
207
+ }
208
+
209
+ struct ErroringLaterReader {
210
+ count : int ,
211
+ }
212
+
213
+ impl Reader for ErroringLaterReader {
214
+ fn read ( & mut self , buf : & mut [ u8 ] ) -> Option < uint > {
215
+ if self . count == 0 {
216
+ self . count = 1 ;
217
+ buf[ 0 ] = 10 ;
218
+ Some ( 1 )
219
+ } else {
220
+ io_error:: cond. raise ( placeholder_error ( ) ) ;
221
+ None
222
+ }
223
+ }
224
+ fn eof ( & mut self ) -> bool {
225
+ false
226
+ }
227
+ }
228
+
229
+ struct ThreeChunkReader {
230
+ count : int ,
231
+ }
232
+
233
+ impl Reader for ThreeChunkReader {
234
+ fn read ( & mut self , buf : & mut [ u8 ] ) -> Option < uint > {
235
+ if self . count == 0 {
236
+ self . count = 1 ;
237
+ buf[ 0 ] = 10 ;
238
+ buf[ 1 ] = 11 ;
239
+ Some ( 2 )
240
+ } else if self . count == 1 {
241
+ self . count = 2 ;
242
+ buf[ 0 ] = 12 ;
243
+ buf[ 1 ] = 13 ;
244
+ Some ( 2 )
245
+ } else {
246
+ None
247
+ }
248
+ }
249
+ fn eof ( & mut self ) -> bool {
250
+ false
251
+ }
252
+ }
146
253
147
254
#[ test]
148
255
fn read_byte ( ) {
@@ -153,38 +260,23 @@ mod test {
153
260
154
261
#[ test]
155
262
fn read_byte_0_bytes ( ) {
156
- let mut reader = MockReader :: new ( ) ;
157
- let count = Cell :: new ( 0 ) ;
158
- reader. read = |buf| {
159
- do count. with_mut_ref |count| {
160
- if * count == 0 {
161
- * count = 1 ;
162
- Some ( 0 )
163
- } else {
164
- buf[ 0 ] = 10 ;
165
- Some ( 1 )
166
- }
167
- }
263
+ let mut reader = InitialZeroByteReader {
264
+ count : 0 ,
168
265
} ;
169
266
let byte = reader. read_byte ( ) ;
170
267
assert ! ( byte == Some ( 10 ) ) ;
171
268
}
172
269
173
270
#[ test]
174
271
fn read_byte_eof ( ) {
175
- let mut reader = MockReader :: new ( ) ;
176
- reader. read = |_| None ;
272
+ let mut reader = EofReader ;
177
273
let byte = reader. read_byte ( ) ;
178
274
assert ! ( byte == None ) ;
179
275
}
180
276
181
277
#[ test]
182
278
fn read_byte_error ( ) {
183
- let mut reader = MockReader :: new ( ) ;
184
- reader. read = |_| {
185
- io_error:: cond. raise ( placeholder_error ( ) ) ;
186
- None
187
- } ;
279
+ let mut reader = ErroringReader ;
188
280
do io_error:: cond. trap ( |_| {
189
281
} ) . inside {
190
282
let byte = reader. read_byte ( ) ;
@@ -194,46 +286,30 @@ mod test {
194
286
195
287
#[ test]
196
288
fn bytes_0_bytes ( ) {
197
- let mut reader = MockReader :: new ( ) ;
198
- let count = Cell :: new ( 0 ) ;
199
- reader. read = |buf| {
200
- do count. with_mut_ref |count| {
201
- if * count == 0 {
202
- * count = 1 ;
203
- Some ( 0 )
204
- } else {
205
- buf[ 0 ] = 10 ;
206
- Some ( 1 )
207
- }
208
- }
289
+ let reader = InitialZeroByteReader {
290
+ count : 0 ,
209
291
} ;
210
292
let byte = reader. bytes ( ) . next ( ) ;
211
293
assert ! ( byte == Some ( 10 ) ) ;
212
294
}
213
295
214
296
#[ test]
215
297
fn bytes_eof ( ) {
216
- let mut reader = MockReader :: new ( ) ;
217
- reader. read = |_| None ;
298
+ let reader = EofReader ;
218
299
let byte = reader. bytes ( ) . next ( ) ;
219
300
assert ! ( byte == None ) ;
220
301
}
221
302
222
303
#[ test]
223
304
fn bytes_error ( ) {
224
- let mut reader = MockReader :: new ( ) ;
225
- reader. read = |_| {
226
- io_error:: cond. raise ( placeholder_error ( ) ) ;
227
- None
228
- } ;
305
+ let reader = ErroringReader ;
229
306
let mut it = reader. bytes ( ) ;
230
307
do io_error:: cond. trap ( |_| ( ) ) . inside {
231
308
let byte = it. next ( ) ;
232
309
assert ! ( byte == None ) ;
233
310
}
234
311
}
235
312
236
-
237
313
#[ test]
238
314
fn read_bytes ( ) {
239
315
let mut reader = MemReader :: new ( ~[ 10 , 11 , 12 , 13 ] ) ;
@@ -243,21 +319,8 @@ mod test {
243
319
244
320
#[ test]
245
321
fn read_bytes_partial ( ) {
246
- let mut reader = MockReader :: new ( ) ;
247
- let count = Cell :: new ( 0 ) ;
248
- reader. read = |buf| {
249
- do count. with_mut_ref |count| {
250
- if * count == 0 {
251
- * count = 1 ;
252
- buf[ 0 ] = 10 ;
253
- buf[ 1 ] = 11 ;
254
- Some ( 2 )
255
- } else {
256
- buf[ 0 ] = 12 ;
257
- buf[ 1 ] = 13 ;
258
- Some ( 2 )
259
- }
260
- }
322
+ let mut reader = PartialReader {
323
+ count : 0 ,
261
324
} ;
262
325
let bytes = reader. read_bytes ( 4 ) ;
263
326
assert ! ( bytes == ~[ 10 , 11 , 12 , 13 ] ) ;
@@ -282,21 +345,8 @@ mod test {
282
345
283
346
#[ test]
284
347
fn push_bytes_partial ( ) {
285
- let mut reader = MockReader :: new ( ) ;
286
- let count = Cell :: new ( 0 ) ;
287
- reader. read = |buf| {
288
- do count. with_mut_ref |count| {
289
- if * count == 0 {
290
- * count = 1 ;
291
- buf[ 0 ] = 10 ;
292
- buf[ 1 ] = 11 ;
293
- Some ( 2 )
294
- } else {
295
- buf[ 0 ] = 12 ;
296
- buf[ 1 ] = 13 ;
297
- Some ( 2 )
298
- }
299
- }
348
+ let mut reader = PartialReader {
349
+ count : 0 ,
300
350
} ;
301
351
let mut buf = ~[ 8 , 9 ] ;
302
352
reader. push_bytes ( & mut buf, 4 ) ;
@@ -316,19 +366,8 @@ mod test {
316
366
317
367
#[ test]
318
368
fn push_bytes_error ( ) {
319
- let mut reader = MockReader :: new ( ) ;
320
- let count = Cell :: new ( 0 ) ;
321
- reader. read = |buf| {
322
- do count. with_mut_ref |count| {
323
- if * count == 0 {
324
- * count = 1 ;
325
- buf[ 0 ] = 10 ;
326
- Some ( 1 )
327
- } else {
328
- io_error:: cond. raise ( placeholder_error ( ) ) ;
329
- None
330
- }
331
- }
369
+ let mut reader = ErroringLaterReader {
370
+ count : 0 ,
332
371
} ;
333
372
let mut buf = ~[ 8 , 9 ] ;
334
373
do io_error:: cond. trap ( |_| { } ) . inside {
@@ -342,19 +381,8 @@ mod test {
342
381
fn push_bytes_fail_reset_len ( ) {
343
382
// push_bytes unsafely sets the vector length. This is testing that
344
383
// upon failure the length is reset correctly.
345
- let mut reader = MockReader :: new ( ) ;
346
- let count = Cell :: new ( 0 ) ;
347
- reader. read = |buf| {
348
- do count. with_mut_ref |count| {
349
- if * count == 0 {
350
- * count = 1 ;
351
- buf[ 0 ] = 10 ;
352
- Some ( 1 )
353
- } else {
354
- io_error:: cond. raise ( placeholder_error ( ) ) ;
355
- None
356
- }
357
- }
384
+ let mut reader = ErroringLaterReader {
385
+ count : 0 ,
358
386
} ;
359
387
let buf = @mut ~[ 8 , 9 ] ;
360
388
do ( || {
@@ -368,24 +396,8 @@ mod test {
368
396
369
397
#[ test]
370
398
fn read_to_end ( ) {
371
- let mut reader = MockReader :: new ( ) ;
372
- let count = Cell :: new ( 0 ) ;
373
- reader. read = |buf| {
374
- do count. with_mut_ref |count| {
375
- if * count == 0 {
376
- * count = 1 ;
377
- buf[ 0 ] = 10 ;
378
- buf[ 1 ] = 11 ;
379
- Some ( 2 )
380
- } else if * count == 1 {
381
- * count = 2 ;
382
- buf[ 0 ] = 12 ;
383
- buf[ 1 ] = 13 ;
384
- Some ( 2 )
385
- } else {
386
- None
387
- }
388
- }
399
+ let mut reader = ThreeChunkReader {
400
+ count : 0 ,
389
401
} ;
390
402
let buf = reader. read_to_end ( ) ;
391
403
assert ! ( buf == ~[ 10 , 11 , 12 , 13 ] ) ;
@@ -394,20 +406,8 @@ mod test {
394
406
#[ test]
395
407
#[ should_fail]
396
408
fn read_to_end_error ( ) {
397
- let mut reader = MockReader :: new ( ) ;
398
- let count = Cell :: new ( 0 ) ;
399
- reader. read = |buf| {
400
- do count. with_mut_ref |count| {
401
- if * count == 0 {
402
- * count = 1 ;
403
- buf[ 0 ] = 10 ;
404
- buf[ 1 ] = 11 ;
405
- Some ( 2 )
406
- } else {
407
- io_error:: cond. raise ( placeholder_error ( ) ) ;
408
- None
409
- }
410
- }
409
+ let mut reader = ThreeChunkReader {
410
+ count : 0 ,
411
411
} ;
412
412
let buf = reader. read_to_end ( ) ;
413
413
assert ! ( buf == ~[ 10 , 11 ] ) ;
0 commit comments