1 //use crate::time::driver::{Driver, Entry, Handle}; 2 3 /* 4 macro_rules! poll { 5 ($e:expr) => { 6 $e.enter(|cx, e| e.poll_elapsed(cx)) 7 }; 8 } 9 10 #[test] 11 fn frozen_utility_returns_correct_advanced_duration() { 12 let clock = Clock::new(); 13 clock.pause(); 14 let start = clock.now(); 15 16 clock.advance(ms(10)); 17 assert_eq!(clock.now() - start, ms(10)); 18 } 19 20 #[test] 21 fn immediate_sleep() { 22 let (mut driver, clock, handle) = setup(); 23 let start = clock.now(); 24 25 let when = clock.now(); 26 let mut e = task::spawn(sleep_until(&handle, when)); 27 28 assert_ready_ok!(poll!(e)); 29 30 assert_ok!(driver.park_timeout(Duration::from_millis(1000))); 31 32 // The time has not advanced. The `turn` completed immediately. 33 assert_eq!(clock.now() - start, ms(1000)); 34 } 35 36 #[test] 37 fn delayed_sleep_level_0() { 38 let (mut driver, clock, handle) = setup(); 39 let start = clock.now(); 40 41 for &i in &[1, 10, 60] { 42 // Create a `Sleep` that elapses in the future 43 let mut e = task::spawn(sleep_until(&handle, start + ms(i))); 44 45 // The sleep instance has not elapsed. 46 assert_pending!(poll!(e)); 47 48 assert_ok!(driver.park()); 49 assert_eq!(clock.now() - start, ms(i)); 50 51 assert_ready_ok!(poll!(e)); 52 } 53 } 54 55 #[test] 56 fn sub_ms_delayed_sleep() { 57 let (mut driver, clock, handle) = setup(); 58 59 for _ in 0..5 { 60 let deadline = clock.now() + ms(1) + Duration::new(0, 1); 61 62 let mut e = task::spawn(sleep_until(&handle, deadline)); 63 64 assert_pending!(poll!(e)); 65 66 assert_ok!(driver.park()); 67 assert_ready_ok!(poll!(e)); 68 69 assert!(clock.now() >= deadline); 70 71 clock.advance(Duration::new(0, 1)); 72 } 73 } 74 75 #[test] 76 fn delayed_sleep_wrapping_level_0() { 77 let (mut driver, clock, handle) = setup(); 78 let start = clock.now(); 79 80 assert_ok!(driver.park_timeout(ms(5))); 81 assert_eq!(clock.now() - start, ms(5)); 82 83 let mut e = task::spawn(sleep_until(&handle, clock.now() + ms(60))); 84 85 assert_pending!(poll!(e)); 86 87 assert_ok!(driver.park()); 88 assert_eq!(clock.now() - start, ms(64)); 89 assert_pending!(poll!(e)); 90 91 assert_ok!(driver.park()); 92 assert_eq!(clock.now() - start, ms(65)); 93 94 assert_ready_ok!(poll!(e)); 95 } 96 97 #[test] 98 fn timer_wrapping_with_higher_levels() { 99 let (mut driver, clock, handle) = setup(); 100 let start = clock.now(); 101 102 // Set sleep to hit level 1 103 let mut e1 = task::spawn(sleep_until(&handle, clock.now() + ms(64))); 104 assert_pending!(poll!(e1)); 105 106 // Turn a bit 107 assert_ok!(driver.park_timeout(ms(5))); 108 109 // Set timeout such that it will hit level 0, but wrap 110 let mut e2 = task::spawn(sleep_until(&handle, clock.now() + ms(60))); 111 assert_pending!(poll!(e2)); 112 113 // This should result in s1 firing 114 assert_ok!(driver.park()); 115 assert_eq!(clock.now() - start, ms(64)); 116 117 assert_ready_ok!(poll!(e1)); 118 assert_pending!(poll!(e2)); 119 120 assert_ok!(driver.park()); 121 assert_eq!(clock.now() - start, ms(65)); 122 123 assert_ready_ok!(poll!(e1)); 124 } 125 126 #[test] 127 fn sleep_with_deadline_in_past() { 128 let (mut driver, clock, handle) = setup(); 129 let start = clock.now(); 130 131 // Create `Sleep` that elapsed immediately. 132 let mut e = task::spawn(sleep_until(&handle, clock.now() - ms(100))); 133 134 // Even though the `Sleep` expires in the past, it is not ready yet 135 // because the timer must observe it. 136 assert_ready_ok!(poll!(e)); 137 138 // Turn the timer, it runs for the elapsed time 139 assert_ok!(driver.park_timeout(ms(1000))); 140 141 // The time has not advanced. The `turn` completed immediately. 142 assert_eq!(clock.now() - start, ms(1000)); 143 } 144 145 #[test] 146 fn delayed_sleep_level_1() { 147 let (mut driver, clock, handle) = setup(); 148 let start = clock.now(); 149 150 // Create a `Sleep` that elapses in the future 151 let mut e = task::spawn(sleep_until(&handle, clock.now() + ms(234))); 152 153 // The sleep has not elapsed. 154 assert_pending!(poll!(e)); 155 156 // Turn the timer, this will wake up to cascade the timer down. 157 assert_ok!(driver.park_timeout(ms(1000))); 158 assert_eq!(clock.now() - start, ms(192)); 159 160 // The sleep has not elapsed. 161 assert_pending!(poll!(e)); 162 163 // Turn the timer again 164 assert_ok!(driver.park_timeout(ms(1000))); 165 assert_eq!(clock.now() - start, ms(234)); 166 167 // The sleep has elapsed. 168 assert_ready_ok!(poll!(e)); 169 170 let (mut driver, clock, handle) = setup(); 171 let start = clock.now(); 172 173 // Create a `Sleep` that elapses in the future 174 let mut e = task::spawn(sleep_until(&handle, clock.now() + ms(234))); 175 176 // The sleep has not elapsed. 177 assert_pending!(poll!(e)); 178 179 // Turn the timer with a smaller timeout than the cascade. 180 assert_ok!(driver.park_timeout(ms(100))); 181 assert_eq!(clock.now() - start, ms(100)); 182 183 assert_pending!(poll!(e)); 184 185 // Turn the timer, this will wake up to cascade the timer down. 186 assert_ok!(driver.park_timeout(ms(1000))); 187 assert_eq!(clock.now() - start, ms(192)); 188 189 // The sleep has not elapsed. 190 assert_pending!(poll!(e)); 191 192 // Turn the timer again 193 assert_ok!(driver.park_timeout(ms(1000))); 194 assert_eq!(clock.now() - start, ms(234)); 195 196 // The sleep has elapsed. 197 assert_ready_ok!(poll!(e)); 198 } 199 200 #[test] 201 fn concurrently_set_two_timers_second_one_shorter() { 202 let (mut driver, clock, handle) = setup(); 203 let start = clock.now(); 204 205 let mut e1 = task::spawn(sleep_until(&handle, clock.now() + ms(500))); 206 let mut e2 = task::spawn(sleep_until(&handle, clock.now() + ms(200))); 207 208 // The sleep has not elapsed 209 assert_pending!(poll!(e1)); 210 assert_pending!(poll!(e2)); 211 212 // Sleep until a cascade 213 assert_ok!(driver.park()); 214 assert_eq!(clock.now() - start, ms(192)); 215 216 // Sleep until the second timer. 217 assert_ok!(driver.park()); 218 assert_eq!(clock.now() - start, ms(200)); 219 220 // The shorter sleep fires 221 assert_ready_ok!(poll!(e2)); 222 assert_pending!(poll!(e1)); 223 224 assert_ok!(driver.park()); 225 assert_eq!(clock.now() - start, ms(448)); 226 227 assert_pending!(poll!(e1)); 228 229 // Turn again, this time the time will advance to the second sleep 230 assert_ok!(driver.park()); 231 assert_eq!(clock.now() - start, ms(500)); 232 233 assert_ready_ok!(poll!(e1)); 234 } 235 236 #[test] 237 fn short_sleep() { 238 let (mut driver, clock, handle) = setup(); 239 let start = clock.now(); 240 241 // Create a `Sleep` that elapses in the future 242 let mut e = task::spawn(sleep_until(&handle, clock.now() + ms(1))); 243 244 // The sleep has not elapsed. 245 assert_pending!(poll!(e)); 246 247 // Turn the timer, but not enough time will go by. 248 assert_ok!(driver.park()); 249 250 // The sleep has elapsed. 251 assert_ready_ok!(poll!(e)); 252 253 // The time has advanced to the point of the sleep elapsing. 254 assert_eq!(clock.now() - start, ms(1)); 255 } 256 257 #[test] 258 fn sorta_long_sleep_until() { 259 const MIN_5: u64 = 5 * 60 * 1000; 260 261 let (mut driver, clock, handle) = setup(); 262 let start = clock.now(); 263 264 // Create a `Sleep` that elapses in the future 265 let mut e = task::spawn(sleep_until(&handle, clock.now() + ms(MIN_5))); 266 267 // The sleep has not elapsed. 268 assert_pending!(poll!(e)); 269 270 let cascades = &[262_144, 262_144 + 9 * 4096, 262_144 + 9 * 4096 + 15 * 64]; 271 272 for &elapsed in cascades { 273 assert_ok!(driver.park()); 274 assert_eq!(clock.now() - start, ms(elapsed)); 275 276 assert_pending!(poll!(e)); 277 } 278 279 assert_ok!(driver.park()); 280 assert_eq!(clock.now() - start, ms(MIN_5)); 281 282 // The sleep has elapsed. 283 assert_ready_ok!(poll!(e)); 284 } 285 286 #[test] 287 fn very_long_sleep() { 288 const MO_5: u64 = 5 * 30 * 24 * 60 * 60 * 1000; 289 290 let (mut driver, clock, handle) = setup(); 291 let start = clock.now(); 292 293 // Create a `Sleep` that elapses in the future 294 let mut e = task::spawn(sleep_until(&handle, clock.now() + ms(MO_5))); 295 296 // The sleep has not elapsed. 297 assert_pending!(poll!(e)); 298 299 let cascades = &[ 300 12_884_901_888, 301 12_952_010_752, 302 12_959_875_072, 303 12_959_997_952, 304 ]; 305 306 for &elapsed in cascades { 307 assert_ok!(driver.park()); 308 assert_eq!(clock.now() - start, ms(elapsed)); 309 310 assert_pending!(poll!(e)); 311 } 312 313 // Turn the timer, but not enough time will go by. 314 assert_ok!(driver.park()); 315 316 // The time has advanced to the point of the sleep elapsing. 317 assert_eq!(clock.now() - start, ms(MO_5)); 318 319 // The sleep has elapsed. 320 assert_ready_ok!(poll!(e)); 321 } 322 323 #[test] 324 fn unpark_is_delayed() { 325 // A special park that will take much longer than the requested duration 326 struct MockPark(Clock); 327 328 struct MockUnpark; 329 330 impl Park for MockPark { 331 type Unpark = MockUnpark; 332 type Error = (); 333 334 fn unpark(&self) -> Self::Unpark { 335 MockUnpark 336 } 337 338 fn park(&mut self) -> Result<(), Self::Error> { 339 panic!("parking forever"); 340 } 341 342 fn park_timeout(&mut self, duration: Duration) -> Result<(), Self::Error> { 343 assert_eq!(duration, ms(0)); 344 self.0.advance(ms(436)); 345 Ok(()) 346 } 347 348 fn shutdown(&mut self) {} 349 } 350 351 impl Unpark for MockUnpark { 352 fn unpark(&self) {} 353 } 354 355 let clock = Clock::new(); 356 clock.pause(); 357 let start = clock.now(); 358 let mut driver = Driver::new(MockPark(clock.clone()), clock.clone()); 359 let handle = driver.handle(); 360 361 let mut e1 = task::spawn(sleep_until(&handle, clock.now() + ms(100))); 362 let mut e2 = task::spawn(sleep_until(&handle, clock.now() + ms(101))); 363 let mut e3 = task::spawn(sleep_until(&handle, clock.now() + ms(200))); 364 365 assert_pending!(poll!(e1)); 366 assert_pending!(poll!(e2)); 367 assert_pending!(poll!(e3)); 368 369 assert_ok!(driver.park()); 370 371 assert_eq!(clock.now() - start, ms(500)); 372 373 assert_ready_ok!(poll!(e1)); 374 assert_ready_ok!(poll!(e2)); 375 assert_ready_ok!(poll!(e3)); 376 } 377 378 #[test] 379 fn set_timeout_at_deadline_greater_than_max_timer() { 380 const YR_1: u64 = 365 * 24 * 60 * 60 * 1000; 381 const YR_5: u64 = 5 * YR_1; 382 383 let (mut driver, clock, handle) = setup(); 384 let start = clock.now(); 385 386 for _ in 0..5 { 387 assert_ok!(driver.park_timeout(ms(YR_1))); 388 } 389 390 let mut e = task::spawn(sleep_until(&handle, clock.now() + ms(1))); 391 assert_pending!(poll!(e)); 392 393 assert_ok!(driver.park_timeout(ms(1000))); 394 assert_eq!(clock.now() - start, ms(YR_5) + ms(1)); 395 396 assert_ready_ok!(poll!(e)); 397 } 398 399 fn setup() -> (Driver<MockPark>, Clock, Handle) { 400 let clock = Clock::new(); 401 clock.pause(); 402 let driver = Driver::new(MockPark(clock.clone()), clock.clone()); 403 let handle = driver.handle(); 404 405 (driver, clock, handle) 406 } 407 408 fn sleep_until(handle: &Handle, when: Instant) -> Arc<Entry> { 409 Entry::new(&handle, when, ms(0)) 410 } 411 412 struct MockPark(Clock); 413 414 struct MockUnpark; 415 416 impl Park for MockPark { 417 type Unpark = MockUnpark; 418 type Error = (); 419 420 fn unpark(&self) -> Self::Unpark { 421 MockUnpark 422 } 423 424 fn park(&mut self) -> Result<(), Self::Error> { 425 panic!("parking forever"); 426 } 427 428 fn park_timeout(&mut self, duration: Duration) -> Result<(), Self::Error> { 429 self.0.advance(duration); 430 Ok(()) 431 } 432 433 fn shutdown(&mut self) {} 434 } 435 436 impl Unpark for MockUnpark { 437 fn unpark(&self) {} 438 } 439 440 fn ms(n: u64) -> Duration { 441 Duration::from_millis(n) 442 } 443 */ 444