4 io
::{AsyncReadExt, AsyncSeekExt, AsyncWriteExt}
,
6 use mockall
::{predicate::eq, Sequence}
;
7 use tokio_test
::{assert_pending, assert_ready_err, assert_ready_ok, task}
;
9 const HELLO
: &[u8] = b
"hello world...";
10 const FOO
: &[u8] = b
"foo bar baz...";
14 let mut file
= MockFile
::default();
15 file
.expect_inner_read().once().returning(|buf
| {
16 buf
[0..HELLO
.len()].copy_from_slice(HELLO
);
19 let mut file
= File
::from_std(file
);
21 let mut buf
= [0; 1024];
22 let mut t
= task
::spawn(file
.read(&mut buf
));
24 assert_eq
!(0, pool
::len());
25 assert_pending
!(t
.poll());
27 assert_eq
!(1, pool
::len());
31 assert
!(t
.is_woken());
33 let n
= assert_ready_ok
!(t
.poll());
34 assert_eq
!(n
, HELLO
.len());
35 assert_eq
!(&buf
[..n
], HELLO
);
39 fn read_twice_before_dispatch() {
40 let mut file
= MockFile
::default();
41 file
.expect_inner_read().once().returning(|buf
| {
42 buf
[0..HELLO
.len()].copy_from_slice(HELLO
);
45 let mut file
= File
::from_std(file
);
47 let mut buf
= [0; 1024];
48 let mut t
= task
::spawn(file
.read(&mut buf
));
50 assert_pending
!(t
.poll());
51 assert_pending
!(t
.poll());
53 assert_eq
!(pool
::len(), 1);
56 assert
!(t
.is_woken());
58 let n
= assert_ready_ok
!(t
.poll());
59 assert_eq
!(&buf
[..n
], HELLO
);
63 fn read_with_smaller_buf() {
64 let mut file
= MockFile
::default();
65 file
.expect_inner_read().once().returning(|buf
| {
66 buf
[0..HELLO
.len()].copy_from_slice(HELLO
);
70 let mut file
= File
::from_std(file
);
73 let mut buf
= [0; 32];
74 let mut t
= task
::spawn(file
.read(&mut buf
));
75 assert_pending
!(t
.poll());
82 let mut t
= task
::spawn(file
.read(&mut buf
));
83 let n
= assert_ready_ok
!(t
.poll());
85 assert_eq
!(&buf
[..], &HELLO
[..n
]);
88 // Calling again immediately succeeds with the rest of the buffer
89 let mut buf
= [0; 32];
90 let mut t
= task
::spawn(file
.read(&mut buf
));
91 let n
= assert_ready_ok
!(t
.poll());
93 assert_eq
!(&buf
[..n
], &HELLO
[4..]);
95 assert_eq
!(0, pool
::len());
99 fn read_with_bigger_buf() {
100 let mut seq
= Sequence
::new();
101 let mut file
= MockFile
::default();
102 file
.expect_inner_read()
104 .in_sequence(&mut seq
)
106 buf
[0..4].copy_from_slice(&HELLO
[..4]);
109 file
.expect_inner_read()
111 .in_sequence(&mut seq
)
113 buf
[0..HELLO
.len() - 4].copy_from_slice(&HELLO
[4..]);
117 let mut file
= File
::from_std(file
);
120 let mut buf
= [0; 4];
121 let mut t
= task
::spawn(file
.read(&mut buf
));
122 assert_pending
!(t
.poll());
128 let mut buf
= [0; 32];
129 let mut t
= task
::spawn(file
.read(&mut buf
));
130 let n
= assert_ready_ok
!(t
.poll());
132 assert_eq
!(&buf
[..n
], &HELLO
[..n
]);
135 // Calling again immediately succeeds with the rest of the buffer
136 let mut buf
= [0; 32];
137 let mut t
= task
::spawn(file
.read(&mut buf
));
139 assert_pending
!(t
.poll());
141 assert_eq
!(1, pool
::len());
144 assert
!(t
.is_woken());
146 let n
= assert_ready_ok
!(t
.poll());
148 assert_eq
!(&buf
[..n
], &HELLO
[4..]);
150 assert_eq
!(0, pool
::len());
154 fn read_err_then_read_success() {
155 let mut file
= MockFile
::default();
156 let mut seq
= Sequence
::new();
157 file
.expect_inner_read()
159 .in_sequence(&mut seq
)
160 .returning(|_
| Err(io
::ErrorKind
::Other
.into()));
161 file
.expect_inner_read()
163 .in_sequence(&mut seq
)
165 buf
[0..HELLO
.len()].copy_from_slice(HELLO
);
169 let mut file
= File
::from_std(file
);
172 let mut buf
= [0; 32];
173 let mut t
= task
::spawn(file
.read(&mut buf
));
174 assert_pending
!(t
.poll());
178 assert_ready_err
!(t
.poll());
182 let mut buf
= [0; 32];
183 let mut t
= task
::spawn(file
.read(&mut buf
));
184 assert_pending
!(t
.poll());
188 let n
= assert_ready_ok
!(t
.poll());
190 assert_eq
!(n
, HELLO
.len());
191 assert_eq
!(&buf
[..n
], HELLO
);
197 let mut file
= MockFile
::default();
198 file
.expect_inner_write()
201 .returning(|buf
| Ok(buf
.len()));
203 let mut file
= File
::from_std(file
);
205 let mut t
= task
::spawn(file
.write(HELLO
));
207 assert_eq
!(0, pool
::len());
208 assert_ready_ok
!(t
.poll());
210 assert_eq
!(1, pool
::len());
214 assert
!(!t
.is_woken());
216 let mut t
= task
::spawn(file
.flush());
217 assert_ready_ok
!(t
.poll());
221 fn flush_while_idle() {
222 let file
= MockFile
::default();
224 let mut file
= File
::from_std(file
);
226 let mut t
= task
::spawn(file
.flush());
227 assert_ready_ok
!(t
.poll());
231 #[cfg_attr(miri, ignore)] // takes a really long time with miri
232 fn read_with_buffer_larger_than_max() {
234 let chunk_a
= crate::io
::blocking
::MAX_BUF
;
235 let chunk_b
= chunk_a
* 2;
236 let chunk_c
= chunk_a
* 3;
237 let chunk_d
= chunk_a
* 4;
239 assert_eq
!(chunk_d
/ 1024 / 1024, 8);
241 let mut data
= vec
![];
242 for i
in 0..(chunk_d
- 1) {
243 data
.push((i
% 151) as u8);
245 let data
= Arc
::new(data
);
246 let d0
= data
.clone();
247 let d1
= data
.clone();
248 let d2
= data
.clone();
249 let d3
= data
.clone();
251 let mut seq
= Sequence
::new();
252 let mut file
= MockFile
::default();
253 file
.expect_inner_read()
255 .in_sequence(&mut seq
)
256 .returning(move |buf
| {
257 buf
[0..chunk_a
].copy_from_slice(&d0
[0..chunk_a
]);
260 file
.expect_inner_read()
262 .in_sequence(&mut seq
)
263 .returning(move |buf
| {
264 buf
[..chunk_a
].copy_from_slice(&d1
[chunk_a
..chunk_b
]);
265 Ok(chunk_b
- chunk_a
)
267 file
.expect_inner_read()
269 .in_sequence(&mut seq
)
270 .returning(move |buf
| {
271 buf
[..chunk_a
].copy_from_slice(&d2
[chunk_b
..chunk_c
]);
272 Ok(chunk_c
- chunk_b
)
274 file
.expect_inner_read()
276 .in_sequence(&mut seq
)
277 .returning(move |buf
| {
278 buf
[..chunk_a
- 1].copy_from_slice(&d3
[chunk_c
..]);
281 let mut file
= File
::from_std(file
);
283 let mut actual
= vec
![0; chunk_d
];
286 while pos
< data
.len() {
287 let mut t
= task
::spawn(file
.read(&mut actual
[pos
..]));
289 assert_pending
!(t
.poll());
291 assert
!(t
.is_woken());
293 let n
= assert_ready_ok
!(t
.poll());
294 assert
!(n
<= chunk_a
);
299 assert_eq
!(&data
[..], &actual
[..data
.len()]);
303 #[cfg_attr(miri, ignore)] // takes a really long time with miri
304 fn write_with_buffer_larger_than_max() {
306 let chunk_a
= crate::io
::blocking
::MAX_BUF
;
307 let chunk_b
= chunk_a
* 2;
308 let chunk_c
= chunk_a
* 3;
309 let chunk_d
= chunk_a
* 4;
311 assert_eq
!(chunk_d
/ 1024 / 1024, 8);
313 let mut data
= vec
![];
314 for i
in 0..(chunk_d
- 1) {
315 data
.push((i
% 151) as u8);
317 let data
= Arc
::new(data
);
318 let d0
= data
.clone();
319 let d1
= data
.clone();
320 let d2
= data
.clone();
321 let d3
= data
.clone();
323 let mut file
= MockFile
::default();
324 let mut seq
= Sequence
::new();
325 file
.expect_inner_write()
327 .in_sequence(&mut seq
)
328 .withf(move |buf
| buf
== &d0
[0..chunk_a
])
329 .returning(|buf
| Ok(buf
.len()));
330 file
.expect_inner_write()
332 .in_sequence(&mut seq
)
333 .withf(move |buf
| buf
== &d1
[chunk_a
..chunk_b
])
334 .returning(|buf
| Ok(buf
.len()));
335 file
.expect_inner_write()
337 .in_sequence(&mut seq
)
338 .withf(move |buf
| buf
== &d2
[chunk_b
..chunk_c
])
339 .returning(|buf
| Ok(buf
.len()));
340 file
.expect_inner_write()
342 .in_sequence(&mut seq
)
343 .withf(move |buf
| buf
== &d3
[chunk_c
..chunk_d
- 1])
344 .returning(|buf
| Ok(buf
.len()));
346 let mut file
= File
::from_std(file
);
348 let mut rem
= &data
[..];
350 let mut first
= true;
352 while !rem
.is_empty() {
353 let mut task
= task
::spawn(file
.write(rem
));
356 assert_pending
!(task
.poll());
358 assert
!(task
.is_woken());
363 let n
= assert_ready_ok
!(task
.poll());
372 fn write_twice_before_dispatch() {
373 let mut file
= MockFile
::default();
374 let mut seq
= Sequence
::new();
375 file
.expect_inner_write()
377 .in_sequence(&mut seq
)
379 .returning(|buf
| Ok(buf
.len()));
380 file
.expect_inner_write()
382 .in_sequence(&mut seq
)
384 .returning(|buf
| Ok(buf
.len()));
386 let mut file
= File
::from_std(file
);
388 let mut t
= task
::spawn(file
.write(HELLO
));
389 assert_ready_ok
!(t
.poll());
391 let mut t
= task
::spawn(file
.write(FOO
));
392 assert_pending
!(t
.poll());
394 assert_eq
!(pool
::len(), 1);
397 assert
!(t
.is_woken());
399 assert_ready_ok
!(t
.poll());
401 let mut t
= task
::spawn(file
.flush());
402 assert_pending
!(t
.poll());
404 assert_eq
!(pool
::len(), 1);
407 assert
!(t
.is_woken());
408 assert_ready_ok
!(t
.poll());
412 fn incomplete_read_followed_by_write() {
413 let mut file
= MockFile
::default();
414 let mut seq
= Sequence
::new();
415 file
.expect_inner_read()
417 .in_sequence(&mut seq
)
419 buf
[0..HELLO
.len()].copy_from_slice(HELLO
);
422 file
.expect_inner_seek()
424 .with(eq(SeekFrom
::Current(-(HELLO
.len() as i64))))
425 .in_sequence(&mut seq
)
426 .returning(|_
| Ok(0));
427 file
.expect_inner_write()
430 .returning(|_
| Ok(FOO
.len()));
432 let mut file
= File
::from_std(file
);
434 let mut buf
= [0; 32];
436 let mut t
= task
::spawn(file
.read(&mut buf
));
437 assert_pending
!(t
.poll());
441 let mut t
= task
::spawn(file
.write(FOO
));
442 assert_ready_ok
!(t
.poll());
444 assert_eq
!(pool
::len(), 1);
447 let mut t
= task
::spawn(file
.flush());
448 assert_ready_ok
!(t
.poll());
452 fn incomplete_partial_read_followed_by_write() {
453 let mut file
= MockFile
::default();
454 let mut seq
= Sequence
::new();
455 file
.expect_inner_read()
457 .in_sequence(&mut seq
)
459 buf
[0..HELLO
.len()].copy_from_slice(HELLO
);
462 file
.expect_inner_seek()
464 .in_sequence(&mut seq
)
465 .with(eq(SeekFrom
::Current(-10)))
466 .returning(|_
| Ok(0));
467 file
.expect_inner_write()
469 .in_sequence(&mut seq
)
471 .returning(|_
| Ok(FOO
.len()));
473 let mut file
= File
::from_std(file
);
475 let mut buf
= [0; 32];
476 let mut t
= task
::spawn(file
.read(&mut buf
));
477 assert_pending
!(t
.poll());
481 let mut buf
= [0; 4];
482 let mut t
= task
::spawn(file
.read(&mut buf
));
483 assert_ready_ok
!(t
.poll());
485 let mut t
= task
::spawn(file
.write(FOO
));
486 assert_ready_ok
!(t
.poll());
488 assert_eq
!(pool
::len(), 1);
491 let mut t
= task
::spawn(file
.flush());
492 assert_ready_ok
!(t
.poll());
496 fn incomplete_read_followed_by_flush() {
497 let mut file
= MockFile
::default();
498 let mut seq
= Sequence
::new();
499 file
.expect_inner_read()
501 .in_sequence(&mut seq
)
503 buf
[0..HELLO
.len()].copy_from_slice(HELLO
);
506 file
.expect_inner_seek()
508 .in_sequence(&mut seq
)
509 .with(eq(SeekFrom
::Current(-(HELLO
.len() as i64))))
510 .returning(|_
| Ok(0));
511 file
.expect_inner_write()
513 .in_sequence(&mut seq
)
515 .returning(|_
| Ok(FOO
.len()));
517 let mut file
= File
::from_std(file
);
519 let mut buf
= [0; 32];
521 let mut t
= task
::spawn(file
.read(&mut buf
));
522 assert_pending
!(t
.poll());
526 let mut t
= task
::spawn(file
.flush());
527 assert_ready_ok
!(t
.poll());
529 let mut t
= task
::spawn(file
.write(FOO
));
530 assert_ready_ok
!(t
.poll());
536 fn incomplete_flush_followed_by_write() {
537 let mut file
= MockFile
::default();
538 let mut seq
= Sequence
::new();
539 file
.expect_inner_write()
541 .in_sequence(&mut seq
)
543 .returning(|_
| Ok(HELLO
.len()));
544 file
.expect_inner_write()
546 .in_sequence(&mut seq
)
548 .returning(|_
| Ok(FOO
.len()));
550 let mut file
= File
::from_std(file
);
552 let mut t
= task
::spawn(file
.write(HELLO
));
553 let n
= assert_ready_ok
!(t
.poll());
554 assert_eq
!(n
, HELLO
.len());
556 let mut t
= task
::spawn(file
.flush());
557 assert_pending
!(t
.poll());
559 // TODO: Move under write
562 let mut t
= task
::spawn(file
.write(FOO
));
563 assert_ready_ok
!(t
.poll());
567 let mut t
= task
::spawn(file
.flush());
568 assert_ready_ok
!(t
.poll());
573 let mut file
= MockFile
::default();
574 file
.expect_inner_read()
576 .returning(|_
| Err(io
::ErrorKind
::Other
.into()));
578 let mut file
= File
::from_std(file
);
580 let mut buf
= [0; 1024];
581 let mut t
= task
::spawn(file
.read(&mut buf
));
583 assert_pending
!(t
.poll());
586 assert
!(t
.is_woken());
588 assert_ready_err
!(t
.poll());
592 fn write_write_err() {
593 let mut file
= MockFile
::default();
594 file
.expect_inner_write()
596 .returning(|_
| Err(io
::ErrorKind
::Other
.into()));
598 let mut file
= File
::from_std(file
);
600 let mut t
= task
::spawn(file
.write(HELLO
));
601 assert_ready_ok
!(t
.poll());
605 let mut t
= task
::spawn(file
.write(FOO
));
606 assert_ready_err
!(t
.poll());
610 fn write_read_write_err() {
611 let mut file
= MockFile
::default();
612 let mut seq
= Sequence
::new();
613 file
.expect_inner_write()
615 .in_sequence(&mut seq
)
616 .returning(|_
| Err(io
::ErrorKind
::Other
.into()));
617 file
.expect_inner_read()
619 .in_sequence(&mut seq
)
621 buf
[0..HELLO
.len()].copy_from_slice(HELLO
);
625 let mut file
= File
::from_std(file
);
627 let mut t
= task
::spawn(file
.write(HELLO
));
628 assert_ready_ok
!(t
.poll());
632 let mut buf
= [0; 1024];
633 let mut t
= task
::spawn(file
.read(&mut buf
));
635 assert_pending
!(t
.poll());
639 let mut t
= task
::spawn(file
.write(FOO
));
640 assert_ready_err
!(t
.poll());
644 fn write_read_flush_err() {
645 let mut file
= MockFile
::default();
646 let mut seq
= Sequence
::new();
647 file
.expect_inner_write()
649 .in_sequence(&mut seq
)
650 .returning(|_
| Err(io
::ErrorKind
::Other
.into()));
651 file
.expect_inner_read()
653 .in_sequence(&mut seq
)
655 buf
[0..HELLO
.len()].copy_from_slice(HELLO
);
659 let mut file
= File
::from_std(file
);
661 let mut t
= task
::spawn(file
.write(HELLO
));
662 assert_ready_ok
!(t
.poll());
666 let mut buf
= [0; 1024];
667 let mut t
= task
::spawn(file
.read(&mut buf
));
669 assert_pending
!(t
.poll());
673 let mut t
= task
::spawn(file
.flush());
674 assert_ready_err
!(t
.poll());
678 fn write_seek_write_err() {
679 let mut file
= MockFile
::default();
680 let mut seq
= Sequence
::new();
681 file
.expect_inner_write()
683 .in_sequence(&mut seq
)
684 .returning(|_
| Err(io
::ErrorKind
::Other
.into()));
685 file
.expect_inner_seek()
687 .with(eq(SeekFrom
::Start(0)))
688 .in_sequence(&mut seq
)
689 .returning(|_
| Ok(0));
691 let mut file
= File
::from_std(file
);
693 let mut t
= task
::spawn(file
.write(HELLO
));
694 assert_ready_ok
!(t
.poll());
699 let mut t
= task
::spawn(file
.seek(SeekFrom
::Start(0)));
700 assert_pending
!(t
.poll());
705 let mut t
= task
::spawn(file
.write(FOO
));
706 assert_ready_err
!(t
.poll());
710 fn write_seek_flush_err() {
711 let mut file
= MockFile
::default();
712 let mut seq
= Sequence
::new();
713 file
.expect_inner_write()
715 .in_sequence(&mut seq
)
716 .returning(|_
| Err(io
::ErrorKind
::Other
.into()));
717 file
.expect_inner_seek()
719 .with(eq(SeekFrom
::Start(0)))
720 .in_sequence(&mut seq
)
721 .returning(|_
| Ok(0));
723 let mut file
= File
::from_std(file
);
725 let mut t
= task
::spawn(file
.write(HELLO
));
726 assert_ready_ok
!(t
.poll());
731 let mut t
= task
::spawn(file
.seek(SeekFrom
::Start(0)));
732 assert_pending
!(t
.poll());
737 let mut t
= task
::spawn(file
.flush());
738 assert_ready_err
!(t
.poll());
742 fn sync_all_ordered_after_write() {
743 let mut file
= MockFile
::default();
744 let mut seq
= Sequence
::new();
745 file
.expect_inner_write()
747 .in_sequence(&mut seq
)
749 .returning(|_
| Ok(HELLO
.len()));
750 file
.expect_sync_all().once().returning(|| Ok(()));
752 let mut file
= File
::from_std(file
);
753 let mut t
= task
::spawn(file
.write(HELLO
));
754 assert_ready_ok
!(t
.poll());
756 let mut t
= task
::spawn(file
.sync_all());
757 assert_pending
!(t
.poll());
759 assert_eq
!(1, pool
::len());
762 assert
!(t
.is_woken());
763 assert_pending
!(t
.poll());
765 assert_eq
!(1, pool
::len());
768 assert
!(t
.is_woken());
769 assert_ready_ok
!(t
.poll());
773 fn sync_all_err_ordered_after_write() {
774 let mut file
= MockFile
::default();
775 let mut seq
= Sequence
::new();
776 file
.expect_inner_write()
778 .in_sequence(&mut seq
)
780 .returning(|_
| Ok(HELLO
.len()));
781 file
.expect_sync_all()
783 .returning(|| Err(io
::ErrorKind
::Other
.into()));
785 let mut file
= File
::from_std(file
);
786 let mut t
= task
::spawn(file
.write(HELLO
));
787 assert_ready_ok
!(t
.poll());
789 let mut t
= task
::spawn(file
.sync_all());
790 assert_pending
!(t
.poll());
792 assert_eq
!(1, pool
::len());
795 assert
!(t
.is_woken());
796 assert_pending
!(t
.poll());
798 assert_eq
!(1, pool
::len());
801 assert
!(t
.is_woken());
802 assert_ready_err
!(t
.poll());
806 fn sync_data_ordered_after_write() {
807 let mut file
= MockFile
::default();
808 let mut seq
= Sequence
::new();
809 file
.expect_inner_write()
811 .in_sequence(&mut seq
)
813 .returning(|_
| Ok(HELLO
.len()));
814 file
.expect_sync_data().once().returning(|| Ok(()));
816 let mut file
= File
::from_std(file
);
817 let mut t
= task
::spawn(file
.write(HELLO
));
818 assert_ready_ok
!(t
.poll());
820 let mut t
= task
::spawn(file
.sync_data());
821 assert_pending
!(t
.poll());
823 assert_eq
!(1, pool
::len());
826 assert
!(t
.is_woken());
827 assert_pending
!(t
.poll());
829 assert_eq
!(1, pool
::len());
832 assert
!(t
.is_woken());
833 assert_ready_ok
!(t
.poll());
837 fn sync_data_err_ordered_after_write() {
838 let mut file
= MockFile
::default();
839 let mut seq
= Sequence
::new();
840 file
.expect_inner_write()
842 .in_sequence(&mut seq
)
844 .returning(|_
| Ok(HELLO
.len()));
845 file
.expect_sync_data()
847 .returning(|| Err(io
::ErrorKind
::Other
.into()));
849 let mut file
= File
::from_std(file
);
850 let mut t
= task
::spawn(file
.write(HELLO
));
851 assert_ready_ok
!(t
.poll());
853 let mut t
= task
::spawn(file
.sync_data());
854 assert_pending
!(t
.poll());
856 assert_eq
!(1, pool
::len());
859 assert
!(t
.is_woken());
860 assert_pending
!(t
.poll());
862 assert_eq
!(1, pool
::len());
865 assert
!(t
.is_woken());
866 assert_ready_err
!(t
.poll());
870 fn open_set_len_ok() {
871 let mut file
= MockFile
::default();
872 file
.expect_set_len().with(eq(123)).returning(|_
| Ok(()));
874 let file
= File
::from_std(file
);
875 let mut t
= task
::spawn(file
.set_len(123));
877 assert_pending
!(t
.poll());
881 assert
!(t
.is_woken());
882 assert_ready_ok
!(t
.poll());
886 fn open_set_len_err() {
887 let mut file
= MockFile
::default();
888 file
.expect_set_len()
890 .returning(|_
| Err(io
::ErrorKind
::Other
.into()));
892 let file
= File
::from_std(file
);
893 let mut t
= task
::spawn(file
.set_len(123));
895 assert_pending
!(t
.poll());
899 assert
!(t
.is_woken());
900 assert_ready_err
!(t
.poll());
904 fn partial_read_set_len_ok() {
905 let mut file
= MockFile
::default();
906 let mut seq
= Sequence
::new();
907 file
.expect_inner_read()
909 .in_sequence(&mut seq
)
911 buf
[0..HELLO
.len()].copy_from_slice(HELLO
);
914 file
.expect_inner_seek()
916 .with(eq(SeekFrom
::Current(-(HELLO
.len() as i64))))
917 .in_sequence(&mut seq
)
918 .returning(|_
| Ok(0));
919 file
.expect_set_len()
921 .in_sequence(&mut seq
)
923 .returning(|_
| Ok(()));
924 file
.expect_inner_read()
926 .in_sequence(&mut seq
)
928 buf
[0..FOO
.len()].copy_from_slice(FOO
);
932 let mut buf
= [0; 32];
933 let mut file
= File
::from_std(file
);
936 let mut t
= task
::spawn(file
.read(&mut buf
));
937 assert_pending
!(t
.poll());
943 let mut t
= task
::spawn(file
.set_len(123));
945 assert_pending
!(t
.poll());
947 assert_ready_ok
!(t
.poll());
950 let mut t
= task
::spawn(file
.read(&mut buf
));
951 assert_pending
!(t
.poll());
953 let n
= assert_ready_ok
!(t
.poll());
955 assert_eq
!(n
, FOO
.len());
956 assert_eq
!(&buf
[..n
], FOO
);
960 fn busy_file_seek_error() {
961 let mut file
= MockFile
::default();
962 let mut seq
= Sequence
::new();
963 file
.expect_inner_write()
965 .in_sequence(&mut seq
)
966 .returning(|_
| Err(io
::ErrorKind
::Other
.into()));
968 let mut file
= crate::io
::BufReader
::new(File
::from_std(file
));
970 let mut t
= task
::spawn(file
.write(HELLO
));
971 assert_ready_ok
!(t
.poll());
976 let mut t
= task
::spawn(file
.seek(SeekFrom
::Start(0)));
977 assert_ready_err
!(t
.poll());