use polling::{Event, Events, PollMode, Poller};
use std::io::{self, prelude::*};
use std::net::{TcpListener, TcpStream};
use std::time::Duration;
#[test]
fn level_triggered() {
let poller1 = Poller::new().unwrap();
let poller2 = Poller::new().unwrap();
let mut events = Events::new();
if !poller1.supports_level() || !poller2.supports_level() {
return;
}
let (mut reader, mut writer) = tcp_pair().unwrap();
unsafe {
poller1
.add_with_mode(&reader, Event::readable(1), PollMode::Level)
.unwrap();
poller2
.add_with_mode(&reader, Event::readable(2), PollMode::Level)
.unwrap();
}
assert_eq!(
poller1
.wait(&mut events, Some(Duration::from_secs(1)))
.unwrap(),
0
);
assert!(events.is_empty());
assert_eq!(
poller2
.wait(&mut events, Some(Duration::from_secs(1)))
.unwrap(),
0
);
assert!(events.is_empty());
writer.write_all(&[1]).unwrap();
assert_eq!(
poller1
.wait(&mut events, Some(Duration::from_secs(1)))
.unwrap(),
1
);
assert_eq!(events.len(), 1);
assert_eq!(
events.iter().next().unwrap().with_no_extra(),
Event::readable(1)
);
events.clear();
match poller2.wait(&mut events, Some(Duration::from_secs(1))) {
Ok(1) => {
assert_eq!(events.len(), 1);
assert_eq!(
events.iter().next().unwrap().with_no_extra(),
Event::readable(2)
);
}
Ok(0) => assert!(events.is_empty()),
_ => panic!("unexpected error"),
}
writer.write_all(&[1]).unwrap();
events.clear();
assert_eq!(
poller1
.wait(&mut events, Some(Duration::from_secs(1)))
.unwrap(),
1
);
assert_eq!(events.len(), 1);
assert_eq!(
events.iter().next().unwrap().with_no_extra(),
Event::readable(1)
);
events.clear();
match poller2.wait(&mut events, Some(Duration::from_secs(1))) {
Ok(1) => {
assert_eq!(events.len(), 1);
assert_eq!(
events.iter().next().unwrap().with_no_extra(),
Event::readable(2)
);
}
Ok(0) => assert!(events.is_empty()),
_ => panic!("unexpected error"),
}
reader.read_exact(&mut [0; 2]).unwrap();
events.clear();
assert_eq!(
poller1
.wait(&mut events, Some(Duration::from_secs(1)))
.unwrap(),
0
);
assert!(events.is_empty());
assert_eq!(
poller2
.wait(&mut events, Some(Duration::from_secs(1)))
.unwrap(),
0
);
assert!(events.is_empty());
poller1.delete(&reader).unwrap();
poller2.delete(&reader).unwrap();
}
#[test]
fn edge_triggered() {
let poller1 = Poller::new().unwrap();
let poller2 = Poller::new().unwrap();
let mut events = Events::new();
if !poller1.supports_edge() || !poller2.supports_edge() {
return;
}
let (mut reader, mut writer) = tcp_pair().unwrap();
unsafe {
poller1
.add_with_mode(&reader, Event::readable(1), PollMode::Edge)
.unwrap();
poller2
.add_with_mode(&reader, Event::readable(2), PollMode::Edge)
.unwrap();
}
assert_eq!(
poller1
.wait(&mut events, Some(Duration::from_secs(1)))
.unwrap(),
0
);
assert!(events.is_empty());
assert_eq!(
poller2
.wait(&mut events, Some(Duration::from_secs(1)))
.unwrap(),
0
);
assert!(events.is_empty());
writer.write_all(&[1]).unwrap();
assert_eq!(
poller1
.wait(&mut events, Some(Duration::from_secs(1)))
.unwrap(),
1
);
assert_eq!(events.len(), 1);
assert_eq!(
events.iter().next().unwrap().with_no_extra(),
Event::readable(1)
);
events.clear();
assert_eq!(
poller2
.wait(&mut events, Some(Duration::from_secs(1)))
.unwrap(),
1
);
assert_eq!(events.len(), 1);
assert_eq!(
events.iter().next().unwrap().with_no_extra(),
Event::readable(2)
);
writer.write_all(&[1]).unwrap();
events.clear();
assert_eq!(
poller1
.wait(&mut events, Some(Duration::from_secs(1)))
.unwrap(),
1
);
assert_eq!(events.len(), 1);
assert_eq!(
events.iter().next().unwrap().with_no_extra(),
Event::readable(1)
);
events.clear();
assert_eq!(
poller2
.wait(&mut events, Some(Duration::from_secs(1)))
.unwrap(),
1
);
assert_eq!(events.len(), 1);
assert_eq!(
events.iter().next().unwrap().with_no_extra(),
Event::readable(2)
);
reader.read_exact(&mut [0; 2]).unwrap();
events.clear();
assert_eq!(
poller1
.wait(&mut events, Some(Duration::from_secs(1)))
.unwrap(),
0
);
assert!(events.is_empty());
assert_eq!(
poller2
.wait(&mut events, Some(Duration::from_secs(1)))
.unwrap(),
0
);
assert!(events.is_empty());
poller1.delete(&reader).unwrap();
poller2.delete(&reader).unwrap();
}
#[test]
fn oneshot_triggered() {
let poller1 = Poller::new().unwrap();
let poller2 = Poller::new().unwrap();
let mut events = Events::new();
let (mut reader, mut writer) = tcp_pair().unwrap();
unsafe {
poller1
.add_with_mode(&reader, Event::readable(1), PollMode::Oneshot)
.unwrap();
poller2
.add_with_mode(&reader, Event::readable(2), PollMode::Oneshot)
.unwrap();
}
assert_eq!(
poller1
.wait(&mut events, Some(Duration::from_secs(1)))
.unwrap(),
0
);
assert!(events.is_empty());
assert_eq!(
poller2
.wait(&mut events, Some(Duration::from_secs(1)))
.unwrap(),
0
);
assert!(events.is_empty());
writer.write_all(&[1]).unwrap();
match poller1.wait(&mut events, Some(Duration::from_secs(1))) {
Ok(1) => {
assert_eq!(events.len(), 1);
assert_eq!(
events.iter().next().unwrap().with_no_extra(),
Event::readable(1)
);
}
Ok(0) => assert!(events.is_empty()),
_ => panic!("unexpected error"),
}
events.clear();
match poller2.wait(&mut events, Some(Duration::from_secs(1))) {
Ok(1) => {
assert_eq!(events.len(), 1);
assert_eq!(
events.iter().next().unwrap().with_no_extra(),
Event::readable(2)
);
}
Ok(0) => assert!(events.is_empty()),
_ => panic!("unexpected error"),
}
events.clear();
writer.write_all(&[1]).unwrap();
assert_eq!(
poller1
.wait(&mut events, Some(Duration::from_secs(1)))
.unwrap(),
0
);
assert!(events.is_empty());
assert_eq!(
poller2
.wait(&mut events, Some(Duration::from_secs(1)))
.unwrap(),
0
);
assert!(events.is_empty());
reader.read_exact(&mut [0; 2]).unwrap();
assert_eq!(
poller1
.wait(&mut events, Some(Duration::from_secs(1)))
.unwrap(),
0
);
assert!(events.is_empty());
assert_eq!(
poller2
.wait(&mut events, Some(Duration::from_secs(1)))
.unwrap(),
0
);
assert!(events.is_empty());
}
fn tcp_pair() -> io::Result<(TcpStream, TcpStream)> {
let listener = TcpListener::bind("127.0.0.1:0")?;
let a = TcpStream::connect(listener.local_addr()?)?;
let (b, _) = listener.accept()?;
Ok((a, b))
}