Skip to content

Commit a6f776d

Browse files
pcwaltonpcwalton
committed
libstd: Remove mocks.
1 parent f27272d commit a6f776d

File tree

3 files changed

+131
-181
lines changed

3 files changed

+131
-181
lines changed

‎src/libstd/rt/io/extensions.rs

Lines changed: 131 additions & 131 deletions
Original file line numberDiff line numberDiff line change
@@ -138,11 +138,118 @@ pub fn u64_from_be_bytes(data: &[u8],
138138

139139
#[cfg(test)]
140140
mod test {
141-
use option::{Some, None};
142-
use cell::Cell;
141+
use option::{None, Option, Some};
143142
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+
}
146253

147254
#[test]
148255
fn read_byte() {
@@ -153,38 +260,23 @@ mod test {
153260

154261
#[test]
155262
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,
168265
};
169266
let byte = reader.read_byte();
170267
assert!(byte == Some(10));
171268
}
172269

173270
#[test]
174271
fn read_byte_eof() {
175-
let mut reader = MockReader::new();
176-
reader.read = |_| None;
272+
let mut reader = EofReader;
177273
let byte = reader.read_byte();
178274
assert!(byte == None);
179275
}
180276

181277
#[test]
182278
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;
188280
do io_error::cond.trap(|_| {
189281
}).inside {
190282
let byte = reader.read_byte();
@@ -194,46 +286,30 @@ mod test {
194286

195287
#[test]
196288
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,
209291
};
210292
let byte = reader.bytes().next();
211293
assert!(byte == Some(10));
212294
}
213295

214296
#[test]
215297
fn bytes_eof() {
216-
let mut reader = MockReader::new();
217-
reader.read = |_| None;
298+
let reader = EofReader;
218299
let byte = reader.bytes().next();
219300
assert!(byte == None);
220301
}
221302

222303
#[test]
223304
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;
229306
let mut it = reader.bytes();
230307
do io_error::cond.trap(|_| ()).inside {
231308
let byte = it.next();
232309
assert!(byte == None);
233310
}
234311
}
235312

236-
237313
#[test]
238314
fn read_bytes() {
239315
let mut reader = MemReader::new(~[10, 11, 12, 13]);
@@ -243,21 +319,8 @@ mod test {
243319

244320
#[test]
245321
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,
261324
};
262325
let bytes = reader.read_bytes(4);
263326
assert!(bytes == ~[10, 11, 12, 13]);
@@ -282,21 +345,8 @@ mod test {
282345

283346
#[test]
284347
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,
300350
};
301351
let mut buf = ~[8, 9];
302352
reader.push_bytes(&mut buf, 4);
@@ -316,19 +366,8 @@ mod test {
316366

317367
#[test]
318368
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,
332371
};
333372
let mut buf = ~[8, 9];
334373
do io_error::cond.trap(|_| { } ).inside {
@@ -342,19 +381,8 @@ mod test {
342381
fn push_bytes_fail_reset_len() {
343382
// push_bytes unsafely sets the vector length. This is testing that
344383
// 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,
358386
};
359387
let buf = @mut ~[8, 9];
360388
do (|| {
@@ -368,24 +396,8 @@ mod test {
368396

369397
#[test]
370398
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,
389401
};
390402
let buf = reader.read_to_end();
391403
assert!(buf == ~[10, 11, 12, 13]);
@@ -394,20 +406,8 @@ mod test {
394406
#[test]
395407
#[should_fail]
396408
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,
411411
};
412412
let buf = reader.read_to_end();
413413
assert!(buf == ~[10, 11]);

0 commit comments

Comments
 (0)