vendor/mio-extras/test/test_timer.rs

   1 use mio::{Events, Poll, PollOpt, Ready, Token};
   2 use mio_extras::timer::{self, Timer};
   3
   4 use std::thread;
   5 use std::time::Duration;
   6
   7 #[test]
   8 fn test_basic_timer_without_poll() {
   9     let mut timer = Timer::default();
  10
  11     // Set the timeout
  12     timer.set_timeout(Duration::from_millis(200), "hello");
  13
  14     // Nothing when polled immediately
  15     assert!(timer.poll().is_none());
  16
  17     // Wait for the timeout
  18     thread::sleep(Duration::from_millis(250));
  19
  20     assert_eq!(Some("hello"), timer.poll());
  21     assert!(timer.poll().is_none());
  22 }
  23
  24 #[test]
  25 fn test_basic_timer_with_poll_edge_set_timeout_after_register() {
  26     let poll = Poll::new().unwrap();
  27     let mut events = Events::with_capacity(1024);
  28     let mut timer = Timer::default();
  29
  30     poll.register(&timer, Token(0), Ready::readable(), PollOpt::edge())
  31         .unwrap();
  32     timer.set_timeout(Duration::from_millis(200), "hello");
  33
  34     let elapsed = elapsed(|| {
  35         let num = poll.poll(&mut events, None).unwrap();
  36
  37         assert_eq!(num, 1);
  38         let event = events.iter().next().unwrap();
  39         assert_eq!(Token(0), event.token());
  40         assert_eq!(Ready::readable(), event.readiness());
  41     });
  42
  43     assert!(is_about(200, elapsed), "actual={:?}", elapsed);
  44     assert_eq!("hello", timer.poll().unwrap());
  45     assert_eq!(None, timer.poll());
  46 }
  47
  48 #[test]
  49 fn test_basic_timer_with_poll_edge_set_timeout_before_register() {
  50     let poll = Poll::new().unwrap();
  51     let mut events = Events::with_capacity(1024);
  52     let mut timer = Timer::default();
  53
  54     timer.set_timeout(Duration::from_millis(200), "hello");
  55     poll.register(&timer, Token(0), Ready::readable(), PollOpt::edge())
  56         .unwrap();
  57
  58     let elapsed = elapsed(|| {
  59         let num = poll.poll(&mut events, None).unwrap();
  60
  61         assert_eq!(num, 1);
  62         let event = events.iter().next().unwrap();
  63         assert_eq!(Token(0), event.token());
  64         assert_eq!(Ready::readable(), event.readiness());
  65     });
  66
  67     assert!(is_about(200, elapsed), "actual={:?}", elapsed);
  68     assert_eq!("hello", timer.poll().unwrap());
  69     assert_eq!(None, timer.poll());
  70 }
  71
  72 #[test]
  73 fn test_setting_later_timeout_then_earlier_one() {
  74     let poll = Poll::new().unwrap();
  75     let mut events = Events::with_capacity(1024);
  76     let mut timer = Timer::default();
  77
  78     poll.register(&timer, Token(0), Ready::readable(), PollOpt::edge())
  79         .unwrap();
  80
  81     timer.set_timeout(Duration::from_millis(600), "hello");
  82     timer.set_timeout(Duration::from_millis(200), "world");
  83
  84     let elapsed = elapsed(|| {
  85         let num = poll.poll(&mut events, None).unwrap();
  86
  87         assert_eq!(num, 1);
  88         let event = events.iter().next().unwrap();
  89         assert_eq!(Token(0), event.token());
  90         assert_eq!(Ready::readable(), event.readiness());
  91     });
  92
  93     assert!(is_about(200, elapsed), "actual={:?}", elapsed);
  94     assert_eq!("world", timer.poll().unwrap());
  95     assert_eq!(None, timer.poll());
  96
  97     let elapsed = self::elapsed(|| {
  98         let num = poll.poll(&mut events, None).unwrap();
  99
 100         assert_eq!(num, 1);
 101         let event = events.iter().next().unwrap();
 102         assert_eq!(Token(0), event.token());
 103         assert_eq!(Ready::readable(), event.readiness());
 104     });
 105
 106     assert!(is_about(400, elapsed), "actual={:?}", elapsed);
 107     assert_eq!("hello", timer.poll().unwrap());
 108     assert_eq!(None, timer.poll());
 109 }
 110
 111 #[test]
 112 fn test_timer_with_looping_wheel() {
 113     let poll = Poll::new().unwrap();
 114     let mut events = Events::with_capacity(1024);
 115     let mut timer = timer::Builder::default().num_slots(2).build();
 116
 117     poll.register(&timer, Token(0), Ready::readable(), PollOpt::edge())
 118         .unwrap();
 119
 120     const TOKENS: &[&str] = &["hello", "world", "some", "thing"];
 121
 122     for (i, msg) in TOKENS.iter().enumerate() {
 123         timer.set_timeout(Duration::from_millis(500 * (i as u64 + 1)), msg);
 124     }
 125
 126     for msg in TOKENS {
 127         let elapsed = elapsed(|| {
 128             let num = poll.poll(&mut events, None).unwrap();
 129
 130             assert_eq!(num, 1);
 131             let event = events.iter().next().unwrap();
 132             assert_eq!(Token(0), event.token());
 133             assert_eq!(Ready::readable(), event.readiness());
 134         });
 135
 136         assert!(
 137             is_about(500, elapsed),
 138             "actual={:?}; msg={:?}",
 139             elapsed,
 140             msg
 141         );
 142         assert_eq!(Some(msg), timer.poll());
 143         assert_eq!(None, timer.poll());
 144     }
 145 }
 146
 147 #[test]
 148 fn test_edge_without_polling() {
 149     let poll = Poll::new().unwrap();
 150     let mut events = Events::with_capacity(1024);
 151     let mut timer = Timer::default();
 152
 153     poll.register(&timer, Token(0), Ready::readable(), PollOpt::edge())
 154         .unwrap();
 155
 156     timer.set_timeout(Duration::from_millis(400), "hello");
 157
 158     let ms = elapsed(|| {
 159         let num = poll.poll(&mut events, None).unwrap();
 160         assert_eq!(num, 1);
 161         let event = events.iter().next().unwrap();
 162         assert_eq!(Token(0), event.token());
 163         assert_eq!(Ready::readable(), event.readiness());
 164     });
 165
 166     assert!(is_about(400, ms), "actual={:?}", ms);
 167
 168     let ms = elapsed(|| {
 169         let num = poll
 170             .poll(&mut events, Some(Duration::from_millis(300)))
 171             .unwrap();
 172         assert_eq!(num, 0);
 173     });
 174
 175     assert!(is_about(300, ms), "actual={:?}", ms);
 176 }
 177
 178 #[test]
 179 fn test_level_triggered() {
 180     let poll = Poll::new().unwrap();
 181     let mut events = Events::with_capacity(1024);
 182     let mut timer = Timer::default();
 183
 184     poll.register(&timer, Token(0), Ready::readable(), PollOpt::level())
 185         .unwrap();
 186
 187     timer.set_timeout(Duration::from_millis(400), "hello");
 188
 189     let ms = elapsed(|| {
 190         let num = poll.poll(&mut events, None).unwrap();
 191         assert_eq!(num, 1);
 192         let event = events.iter().next().unwrap();
 193         assert_eq!(Token(0), event.token());
 194         assert_eq!(Ready::readable(), event.readiness());
 195     });
 196
 197     assert!(is_about(400, ms), "actual={:?}", ms);
 198
 199     let ms = elapsed(|| {
 200         let num = poll.poll(&mut events, None).unwrap();
 201         assert_eq!(num, 1);
 202         let event = events.iter().next().unwrap();
 203         assert_eq!(Token(0), event.token());
 204         assert_eq!(Ready::readable(), event.readiness());
 205     });
 206
 207     assert!(is_about(0, ms), "actual={:?}", ms);
 208 }
 209
 210 #[test]
 211 fn test_edge_oneshot_triggered() {
 212     let poll = Poll::new().unwrap();
 213     let mut events = Events::with_capacity(1024);
 214     let mut timer = Timer::default();
 215
 216     poll.register(
 217         &timer,
 218         Token(0),
 219         Ready::readable(),
 220         PollOpt::edge() | PollOpt::oneshot(),
 221     )
 222     .unwrap();
 223
 224     timer.set_timeout(Duration::from_millis(200), "hello");
 225
 226     let ms = elapsed(|| {
 227         let num = poll.poll(&mut events, None).unwrap();
 228         assert_eq!(num, 1);
 229     });
 230
 231     assert!(is_about(200, ms), "actual={:?}", ms);
 232
 233     let ms = elapsed(|| {
 234         let num = poll
 235             .poll(&mut events, Some(Duration::from_millis(300)))
 236             .unwrap();
 237         assert_eq!(num, 0);
 238     });
 239
 240     assert!(is_about(300, ms), "actual={:?}", ms);
 241
 242     poll.reregister(
 243         &timer,
 244         Token(0),
 245         Ready::readable(),
 246         PollOpt::edge() | PollOpt::oneshot(),
 247     )
 248     .unwrap();
 249
 250     let ms = elapsed(|| {
 251         let num = poll.poll(&mut events, None).unwrap();
 252         assert_eq!(num, 1);
 253     });
 254
 255     assert!(is_about(0, ms));
 256 }
 257
 258 #[test]
 259 fn test_cancel_timeout() {
 260     use std::time::Instant;
 261
 262     let mut timer: Timer<u32> = Default::default();
 263     let timeout = timer.set_timeout(Duration::from_millis(200), 1);
 264     timer.cancel_timeout(&timeout);
 265
 266     let poll = Poll::new().unwrap();
 267     poll.register(&timer, Token(0), Ready::readable(), PollOpt::edge())
 268         .unwrap();
 269
 270     let mut events = Events::with_capacity(16);
 271
 272     let now = Instant::now();
 273     let dur = Duration::from_millis(500);
 274     let mut i = 0;
 275
 276     while Instant::now() - now < dur {
 277         if i > 10 {
 278             panic!("iterated too many times");
 279         }
 280
 281         i += 1;
 282
 283         let elapsed = Instant::now() - now;
 284
 285         poll.poll(&mut events, Some(dur - elapsed)).unwrap();
 286
 287         while let Some(_) = timer.poll() {
 288             panic!("did not expect to receive timeout");
 289         }
 290     }
 291 }
 292
 293 fn elapsed<F: FnMut()>(mut f: F) -> u64 {
 294     use std::time::Instant;
 295
 296     let now = Instant::now();
 297
 298     f();
 299
 300     let elapsed = now.elapsed();
 301     elapsed.as_secs() * 1000 + u64::from(elapsed.subsec_millis())
 302 }
 303
 304 fn is_about(expect: u64, val: u64) -> bool {
 305     const WINDOW: i64 = 200;
 306
 307     ((expect as i64) - (val as i64)).abs() <= WINDOW
 308 }