1 // This file is testing deprecated code.
2 #![allow(deprecated)]
3
4 extern crate futures;
5 extern crate tokio_io;
6
7 use tokio_io::codec::length_delimited::*;
8 use tokio_io::{AsyncRead, AsyncWrite};
9
10 use futures::Async::*;
11 use futures::{Poll, Sink, Stream};
12
13 use std::collections::VecDeque;
14 use std::io;
15
16 macro_rules! mock {
17 ($($x:expr,)*) => {{
18 let mut v = VecDeque::new();
19 v.extend(vec![$($x),*]);
20 Mock { calls: v }
21 }};
22 }
23
24 #[test]
read_empty_io_yields_nothing()25 fn read_empty_io_yields_nothing() {
26 let mut io = FramedRead::new(mock!());
27
28 assert_eq!(io.poll().unwrap(), Ready(None));
29 }
30
31 #[test]
read_single_frame_one_packet()32 fn read_single_frame_one_packet() {
33 let mut io = FramedRead::new(mock! {
34 Ok(b"\x00\x00\x00\x09abcdefghi"[..].into()),
35 });
36
37 assert_eq!(io.poll().unwrap(), Ready(Some(b"abcdefghi"[..].into())));
38 assert_eq!(io.poll().unwrap(), Ready(None));
39 }
40
41 #[test]
read_single_frame_one_packet_little_endian()42 fn read_single_frame_one_packet_little_endian() {
43 let mut io = Builder::new().little_endian().new_read(mock! {
44 Ok(b"\x09\x00\x00\x00abcdefghi"[..].into()),
45 });
46
47 assert_eq!(io.poll().unwrap(), Ready(Some(b"abcdefghi"[..].into())));
48 assert_eq!(io.poll().unwrap(), Ready(None));
49 }
50
51 #[test]
read_single_frame_one_packet_native_endian()52 fn read_single_frame_one_packet_native_endian() {
53 let data = if cfg!(target_endian = "big") {
54 b"\x00\x00\x00\x09abcdefghi"
55 } else {
56 b"\x09\x00\x00\x00abcdefghi"
57 };
58 let mut io = Builder::new().native_endian().new_read(mock! {
59 Ok(data[..].into()),
60 });
61
62 assert_eq!(io.poll().unwrap(), Ready(Some(b"abcdefghi"[..].into())));
63 assert_eq!(io.poll().unwrap(), Ready(None));
64 }
65
66 #[test]
read_single_multi_frame_one_packet()67 fn read_single_multi_frame_one_packet() {
68 let mut data: Vec<u8> = vec![];
69 data.extend_from_slice(b"\x00\x00\x00\x09abcdefghi");
70 data.extend_from_slice(b"\x00\x00\x00\x03123");
71 data.extend_from_slice(b"\x00\x00\x00\x0bhello world");
72
73 let mut io = FramedRead::new(mock! {
74 Ok(data.into()),
75 });
76
77 assert_eq!(io.poll().unwrap(), Ready(Some(b"abcdefghi"[..].into())));
78 assert_eq!(io.poll().unwrap(), Ready(Some(b"123"[..].into())));
79 assert_eq!(io.poll().unwrap(), Ready(Some(b"hello world"[..].into())));
80 assert_eq!(io.poll().unwrap(), Ready(None));
81 }
82
83 #[test]
read_single_frame_multi_packet()84 fn read_single_frame_multi_packet() {
85 let mut io = FramedRead::new(mock! {
86 Ok(b"\x00\x00"[..].into()),
87 Ok(b"\x00\x09abc"[..].into()),
88 Ok(b"defghi"[..].into()),
89 });
90
91 assert_eq!(io.poll().unwrap(), Ready(Some(b"abcdefghi"[..].into())));
92 assert_eq!(io.poll().unwrap(), Ready(None));
93 }
94
95 #[test]
read_multi_frame_multi_packet()96 fn read_multi_frame_multi_packet() {
97 let mut io = FramedRead::new(mock! {
98 Ok(b"\x00\x00"[..].into()),
99 Ok(b"\x00\x09abc"[..].into()),
100 Ok(b"defghi"[..].into()),
101 Ok(b"\x00\x00\x00\x0312"[..].into()),
102 Ok(b"3\x00\x00\x00\x0bhello world"[..].into()),
103 });
104
105 assert_eq!(io.poll().unwrap(), Ready(Some(b"abcdefghi"[..].into())));
106 assert_eq!(io.poll().unwrap(), Ready(Some(b"123"[..].into())));
107 assert_eq!(io.poll().unwrap(), Ready(Some(b"hello world"[..].into())));
108 assert_eq!(io.poll().unwrap(), Ready(None));
109 }
110
111 #[test]
read_single_frame_multi_packet_wait()112 fn read_single_frame_multi_packet_wait() {
113 let mut io = FramedRead::new(mock! {
114 Ok(b"\x00\x00"[..].into()),
115 Err(would_block()),
116 Ok(b"\x00\x09abc"[..].into()),
117 Err(would_block()),
118 Ok(b"defghi"[..].into()),
119 Err(would_block()),
120 });
121
122 assert_eq!(io.poll().unwrap(), NotReady);
123 assert_eq!(io.poll().unwrap(), NotReady);
124 assert_eq!(io.poll().unwrap(), Ready(Some(b"abcdefghi"[..].into())));
125 assert_eq!(io.poll().unwrap(), NotReady);
126 assert_eq!(io.poll().unwrap(), Ready(None));
127 }
128
129 #[test]
read_multi_frame_multi_packet_wait()130 fn read_multi_frame_multi_packet_wait() {
131 let mut io = FramedRead::new(mock! {
132 Ok(b"\x00\x00"[..].into()),
133 Err(would_block()),
134 Ok(b"\x00\x09abc"[..].into()),
135 Err(would_block()),
136 Ok(b"defghi"[..].into()),
137 Err(would_block()),
138 Ok(b"\x00\x00\x00\x0312"[..].into()),
139 Err(would_block()),
140 Ok(b"3\x00\x00\x00\x0bhello world"[..].into()),
141 Err(would_block()),
142 });
143
144 assert_eq!(io.poll().unwrap(), NotReady);
145 assert_eq!(io.poll().unwrap(), NotReady);
146 assert_eq!(io.poll().unwrap(), Ready(Some(b"abcdefghi"[..].into())));
147 assert_eq!(io.poll().unwrap(), NotReady);
148 assert_eq!(io.poll().unwrap(), NotReady);
149 assert_eq!(io.poll().unwrap(), Ready(Some(b"123"[..].into())));
150 assert_eq!(io.poll().unwrap(), Ready(Some(b"hello world"[..].into())));
151 assert_eq!(io.poll().unwrap(), NotReady);
152 assert_eq!(io.poll().unwrap(), Ready(None));
153 }
154
155 #[test]
read_incomplete_head()156 fn read_incomplete_head() {
157 let mut io = FramedRead::new(mock! {
158 Ok(b"\x00\x00"[..].into()),
159 });
160
161 assert!(io.poll().is_err());
162 }
163
164 #[test]
read_incomplete_head_multi()165 fn read_incomplete_head_multi() {
166 let mut io = FramedRead::new(mock! {
167 Err(would_block()),
168 Ok(b"\x00"[..].into()),
169 Err(would_block()),
170 });
171
172 assert_eq!(io.poll().unwrap(), NotReady);
173 assert_eq!(io.poll().unwrap(), NotReady);
174 assert!(io.poll().is_err());
175 }
176
177 #[test]
read_incomplete_payload()178 fn read_incomplete_payload() {
179 let mut io = FramedRead::new(mock! {
180 Ok(b"\x00\x00\x00\x09ab"[..].into()),
181 Err(would_block()),
182 Ok(b"cd"[..].into()),
183 Err(would_block()),
184 });
185
186 assert_eq!(io.poll().unwrap(), NotReady);
187 assert_eq!(io.poll().unwrap(), NotReady);
188 assert!(io.poll().is_err());
189 }
190
191 #[test]
read_max_frame_len()192 fn read_max_frame_len() {
193 let mut io = Builder::new().max_frame_length(5).new_read(mock! {
194 Ok(b"\x00\x00\x00\x09abcdefghi"[..].into()),
195 });
196
197 assert_eq!(io.poll().unwrap_err().kind(), io::ErrorKind::InvalidData);
198 }
199
200 #[test]
read_update_max_frame_len_at_rest()201 fn read_update_max_frame_len_at_rest() {
202 let mut io = Builder::new().new_read(mock! {
203 Ok(b"\x00\x00\x00\x09abcdefghi"[..].into()),
204 Ok(b"\x00\x00\x00\x09abcdefghi"[..].into()),
205 });
206
207 assert_eq!(io.poll().unwrap(), Ready(Some(b"abcdefghi"[..].into())));
208 io.set_max_frame_length(5);
209 assert_eq!(io.poll().unwrap_err().kind(), io::ErrorKind::InvalidData);
210 }
211
212 #[test]
read_update_max_frame_len_in_flight()213 fn read_update_max_frame_len_in_flight() {
214 let mut io = Builder::new().new_read(mock! {
215 Ok(b"\x00\x00\x00\x09abcd"[..].into()),
216 Err(would_block()),
217 Ok(b"efghi"[..].into()),
218 Ok(b"\x00\x00\x00\x09abcdefghi"[..].into()),
219 });
220
221 assert_eq!(io.poll().unwrap(), NotReady);
222 io.set_max_frame_length(5);
223 assert_eq!(io.poll().unwrap(), Ready(Some(b"abcdefghi"[..].into())));
224 assert_eq!(io.poll().unwrap_err().kind(), io::ErrorKind::InvalidData);
225 }
226
227 #[test]
read_one_byte_length_field()228 fn read_one_byte_length_field() {
229 let mut io = Builder::new().length_field_length(1).new_read(mock! {
230 Ok(b"\x09abcdefghi"[..].into()),
231 });
232
233 assert_eq!(io.poll().unwrap(), Ready(Some(b"abcdefghi"[..].into())));
234 assert_eq!(io.poll().unwrap(), Ready(None));
235 }
236
237 #[test]
read_header_offset()238 fn read_header_offset() {
239 let mut io = Builder::new()
240 .length_field_length(2)
241 .length_field_offset(4)
242 .new_read(mock! {
243 Ok(b"zzzz\x00\x09abcdefghi"[..].into()),
244 });
245
246 assert_eq!(io.poll().unwrap(), Ready(Some(b"abcdefghi"[..].into())));
247 assert_eq!(io.poll().unwrap(), Ready(None));
248 }
249
250 #[test]
read_single_multi_frame_one_packet_skip_none_adjusted()251 fn read_single_multi_frame_one_packet_skip_none_adjusted() {
252 let mut data: Vec<u8> = vec![];
253 data.extend_from_slice(b"xx\x00\x09abcdefghi");
254 data.extend_from_slice(b"yy\x00\x03123");
255 data.extend_from_slice(b"zz\x00\x0bhello world");
256
257 let mut io = Builder::new()
258 .length_field_length(2)
259 .length_field_offset(2)
260 .num_skip(0)
261 .length_adjustment(4)
262 .new_read(mock! {
263 Ok(data.into()),
264 });
265
266 assert_eq!(
267 io.poll().unwrap(),
268 Ready(Some(b"xx\x00\x09abcdefghi"[..].into()))
269 );
270 assert_eq!(io.poll().unwrap(), Ready(Some(b"yy\x00\x03123"[..].into())));
271 assert_eq!(
272 io.poll().unwrap(),
273 Ready(Some(b"zz\x00\x0bhello world"[..].into()))
274 );
275 assert_eq!(io.poll().unwrap(), Ready(None));
276 }
277
278 #[test]
read_single_multi_frame_one_packet_length_includes_head()279 fn read_single_multi_frame_one_packet_length_includes_head() {
280 let mut data: Vec<u8> = vec![];
281 data.extend_from_slice(b"\x00\x0babcdefghi");
282 data.extend_from_slice(b"\x00\x05123");
283 data.extend_from_slice(b"\x00\x0dhello world");
284
285 let mut io = Builder::new()
286 .length_field_length(2)
287 .length_adjustment(-2)
288 .new_read(mock! {
289 Ok(data.into()),
290 });
291
292 assert_eq!(io.poll().unwrap(), Ready(Some(b"abcdefghi"[..].into())));
293 assert_eq!(io.poll().unwrap(), Ready(Some(b"123"[..].into())));
294 assert_eq!(io.poll().unwrap(), Ready(Some(b"hello world"[..].into())));
295 assert_eq!(io.poll().unwrap(), Ready(None));
296 }
297
298 #[test]
write_single_frame_length_adjusted()299 fn write_single_frame_length_adjusted() {
300 let mut io = Builder::new().length_adjustment(-2).new_write(mock! {
301 Ok(b"\x00\x00\x00\x0b"[..].into()),
302 Ok(b"abcdefghi"[..].into()),
303 Ok(Flush),
304 });
305 assert!(io.start_send("abcdefghi").unwrap().is_ready());
306 assert!(io.poll_complete().unwrap().is_ready());
307 assert!(io.get_ref().calls.is_empty());
308 }
309
310 #[test]
write_nothing_yields_nothing()311 fn write_nothing_yields_nothing() {
312 let mut io: FramedWrite<_, &'static [u8]> = FramedWrite::new(mock!());
313 assert!(io.poll_complete().unwrap().is_ready());
314 }
315
316 #[test]
write_single_frame_one_packet()317 fn write_single_frame_one_packet() {
318 let mut io = FramedWrite::new(mock! {
319 Ok(b"\x00\x00\x00\x09"[..].into()),
320 Ok(b"abcdefghi"[..].into()),
321 Ok(Flush),
322 });
323
324 assert!(io.start_send("abcdefghi").unwrap().is_ready());
325 assert!(io.poll_complete().unwrap().is_ready());
326 assert!(io.get_ref().calls.is_empty());
327 }
328
329 #[test]
write_single_multi_frame_one_packet()330 fn write_single_multi_frame_one_packet() {
331 let mut io = FramedWrite::new(mock! {
332 Ok(b"\x00\x00\x00\x09"[..].into()),
333 Ok(b"abcdefghi"[..].into()),
334 Ok(b"\x00\x00\x00\x03"[..].into()),
335 Ok(b"123"[..].into()),
336 Ok(b"\x00\x00\x00\x0b"[..].into()),
337 Ok(b"hello world"[..].into()),
338 Ok(Flush),
339 });
340
341 assert!(io.start_send("abcdefghi").unwrap().is_ready());
342 assert!(io.start_send("123").unwrap().is_ready());
343 assert!(io.start_send("hello world").unwrap().is_ready());
344 assert!(io.poll_complete().unwrap().is_ready());
345 assert!(io.get_ref().calls.is_empty());
346 }
347
348 #[test]
write_single_multi_frame_multi_packet()349 fn write_single_multi_frame_multi_packet() {
350 let mut io = FramedWrite::new(mock! {
351 Ok(b"\x00\x00\x00\x09"[..].into()),
352 Ok(b"abcdefghi"[..].into()),
353 Ok(Flush),
354 Ok(b"\x00\x00\x00\x03"[..].into()),
355 Ok(b"123"[..].into()),
356 Ok(Flush),
357 Ok(b"\x00\x00\x00\x0b"[..].into()),
358 Ok(b"hello world"[..].into()),
359 Ok(Flush),
360 });
361
362 assert!(io.start_send("abcdefghi").unwrap().is_ready());
363 assert!(io.poll_complete().unwrap().is_ready());
364 assert!(io.start_send("123").unwrap().is_ready());
365 assert!(io.poll_complete().unwrap().is_ready());
366 assert!(io.start_send("hello world").unwrap().is_ready());
367 assert!(io.poll_complete().unwrap().is_ready());
368 assert!(io.get_ref().calls.is_empty());
369 }
370
371 #[test]
write_single_frame_would_block()372 fn write_single_frame_would_block() {
373 let mut io = FramedWrite::new(mock! {
374 Err(would_block()),
375 Ok(b"\x00\x00"[..].into()),
376 Err(would_block()),
377 Ok(b"\x00\x09"[..].into()),
378 Ok(b"abcdefghi"[..].into()),
379 Ok(Flush),
380 });
381
382 assert!(io.start_send("abcdefghi").unwrap().is_ready());
383 assert!(!io.poll_complete().unwrap().is_ready());
384 assert!(!io.poll_complete().unwrap().is_ready());
385 assert!(io.poll_complete().unwrap().is_ready());
386
387 assert!(io.get_ref().calls.is_empty());
388 }
389
390 #[test]
write_single_frame_little_endian()391 fn write_single_frame_little_endian() {
392 let mut io = Builder::new().little_endian().new_write(mock! {
393 Ok(b"\x09\x00\x00\x00"[..].into()),
394 Ok(b"abcdefghi"[..].into()),
395 Ok(Flush),
396 });
397
398 assert!(io.start_send("abcdefghi").unwrap().is_ready());
399 assert!(io.poll_complete().unwrap().is_ready());
400 assert!(io.get_ref().calls.is_empty());
401 }
402
403 #[test]
write_single_frame_with_short_length_field()404 fn write_single_frame_with_short_length_field() {
405 let mut io = Builder::new().length_field_length(1).new_write(mock! {
406 Ok(b"\x09"[..].into()),
407 Ok(b"abcdefghi"[..].into()),
408 Ok(Flush),
409 });
410
411 assert!(io.start_send("abcdefghi").unwrap().is_ready());
412 assert!(io.poll_complete().unwrap().is_ready());
413 assert!(io.get_ref().calls.is_empty());
414 }
415
416 #[test]
write_max_frame_len()417 fn write_max_frame_len() {
418 let mut io = Builder::new().max_frame_length(5).new_write(mock! {});
419
420 assert_eq!(
421 io.start_send("abcdef").unwrap_err().kind(),
422 io::ErrorKind::InvalidInput
423 );
424 assert!(io.get_ref().calls.is_empty());
425 }
426
427 #[test]
write_zero()428 fn write_zero() {
429 let mut io = Builder::new().new_write(mock! {});
430
431 assert!(io.start_send("abcdef").unwrap().is_ready());
432 assert_eq!(
433 io.poll_complete().unwrap_err().kind(),
434 io::ErrorKind::WriteZero
435 );
436 assert!(io.get_ref().calls.is_empty());
437 }
438
439 #[test]
write_update_max_frame_len_at_rest()440 fn write_update_max_frame_len_at_rest() {
441 let mut io = Builder::new().new_write(mock! {
442 Ok(b"\x00\x00\x00\x06"[..].into()),
443 Ok(b"abcdef"[..].into()),
444 Ok(Flush),
445 });
446
447 assert!(io.start_send("abcdef").unwrap().is_ready());
448 assert!(io.poll_complete().unwrap().is_ready());
449 io.set_max_frame_length(5);
450 assert_eq!(
451 io.start_send("abcdef").unwrap_err().kind(),
452 io::ErrorKind::InvalidInput
453 );
454 assert!(io.get_ref().calls.is_empty());
455 }
456
457 #[test]
write_update_max_frame_len_in_flight()458 fn write_update_max_frame_len_in_flight() {
459 let mut io = Builder::new().new_write(mock! {
460 Ok(b"\x00\x00\x00\x06"[..].into()),
461 Ok(b"ab"[..].into()),
462 Err(would_block()),
463 Ok(b"cdef"[..].into()),
464 Ok(Flush),
465 });
466
467 assert!(io.start_send("abcdef").unwrap().is_ready());
468 assert!(!io.poll_complete().unwrap().is_ready());
469 io.set_max_frame_length(5);
470 assert!(io.poll_complete().unwrap().is_ready());
471 assert_eq!(
472 io.start_send("abcdef").unwrap_err().kind(),
473 io::ErrorKind::InvalidInput
474 );
475 assert!(io.get_ref().calls.is_empty());
476 }
477
478 // ===== Test utils =====
479
would_block() -> io::Error480 fn would_block() -> io::Error {
481 io::Error::new(io::ErrorKind::WouldBlock, "would block")
482 }
483
484 struct Mock {
485 calls: VecDeque<io::Result<Op>>,
486 }
487
488 enum Op {
489 Data(Vec<u8>),
490 Flush,
491 }
492
493 use self::Op::*;
494
495 impl io::Read for Mock {
read(&mut self, dst: &mut [u8]) -> io::Result<usize>496 fn read(&mut self, dst: &mut [u8]) -> io::Result<usize> {
497 match self.calls.pop_front() {
498 Some(Ok(Op::Data(data))) => {
499 debug_assert!(dst.len() >= data.len());
500 dst[..data.len()].copy_from_slice(&data[..]);
501 Ok(data.len())
502 }
503 Some(Ok(_)) => panic!(),
504 Some(Err(e)) => Err(e),
505 None => Ok(0),
506 }
507 }
508 }
509
510 impl AsyncRead for Mock {}
511
512 impl io::Write for Mock {
write(&mut self, src: &[u8]) -> io::Result<usize>513 fn write(&mut self, src: &[u8]) -> io::Result<usize> {
514 match self.calls.pop_front() {
515 Some(Ok(Op::Data(data))) => {
516 let len = data.len();
517 assert!(src.len() >= len, "expect={:?}; actual={:?}", data, src);
518 assert_eq!(&data[..], &src[..len]);
519 Ok(len)
520 }
521 Some(Ok(_)) => panic!(),
522 Some(Err(e)) => Err(e),
523 None => Ok(0),
524 }
525 }
526
flush(&mut self) -> io::Result<()>527 fn flush(&mut self) -> io::Result<()> {
528 match self.calls.pop_front() {
529 Some(Ok(Op::Flush)) => Ok(()),
530 Some(Ok(_)) => panic!(),
531 Some(Err(e)) => Err(e),
532 None => Ok(()),
533 }
534 }
535 }
536
537 impl AsyncWrite for Mock {
shutdown(&mut self) -> Poll<(), io::Error>538 fn shutdown(&mut self) -> Poll<(), io::Error> {
539 Ok(Ready(()))
540 }
541 }
542
543 impl<'a> From<&'a [u8]> for Op {
from(src: &'a [u8]) -> Op544 fn from(src: &'a [u8]) -> Op {
545 Op::Data(src.into())
546 }
547 }
548
549 impl From<Vec<u8>> for Op {
from(src: Vec<u8>) -> Op550 fn from(src: Vec<u8>) -> Op {
551 Op::Data(src)
552 }
553 }
554