183 lines
4.6 KiB
Rust
183 lines
4.6 KiB
Rust
use crate::worker::{operate, ReadWrapper, WriteWrapper};
|
|
use std::io::{self, Read, Write};
|
|
use std::sync::mpsc::{channel, Receiver, Sender};
|
|
use std::thread::JoinHandle;
|
|
|
|
enum Request {
|
|
Read(u32, usize, Sender<Vec<u8>>),
|
|
Write(Vec<u8>),
|
|
}
|
|
|
|
struct FakeReader {
|
|
channel: Sender<Request>,
|
|
number: u32,
|
|
}
|
|
|
|
impl Read for FakeReader {
|
|
fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
|
|
let (tx, rx) = channel();
|
|
self.channel.send(Request::Read(
|
|
self.number,
|
|
buf.len(),
|
|
tx,
|
|
)).unwrap();
|
|
let result = rx.recv().unwrap();
|
|
buf[0..result.len()].copy_from_slice(&result[..]);
|
|
Ok(result.len())
|
|
}
|
|
}
|
|
|
|
struct FakeWriter {
|
|
channel: Sender<Request>,
|
|
}
|
|
|
|
impl Write for FakeWriter {
|
|
fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
|
|
self.channel.send(Request::Write(
|
|
Vec::from(buf),
|
|
)).unwrap();
|
|
Ok(buf.len())
|
|
}
|
|
fn flush(&mut self) -> io::Result<()> {
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
struct Test {
|
|
join_handle: JoinHandle<Result<(), String>>,
|
|
recv: Receiver<Request>,
|
|
}
|
|
|
|
impl Test {
|
|
fn new() -> Test {
|
|
let (tx, rx) = channel();
|
|
let rd1 = FakeReader {
|
|
channel: tx.clone(),
|
|
number: 0
|
|
};
|
|
let rd2 = FakeReader {
|
|
channel: tx.clone(),
|
|
number: 1,
|
|
};
|
|
let wr = FakeWriter {
|
|
channel: tx,
|
|
};
|
|
let join_handle = std::thread::spawn(move || -> Result<(), String> {
|
|
let in1 = ReadWrapper {
|
|
stream: rd1,
|
|
name: "reader1",
|
|
};
|
|
let in2 = ReadWrapper {
|
|
stream: rd2,
|
|
name: "reader2",
|
|
};
|
|
let out = WriteWrapper {
|
|
stream: wr,
|
|
name: "writer",
|
|
};
|
|
|
|
operate(in1, in2, out)
|
|
});
|
|
Test {
|
|
join_handle,
|
|
recv: rx,
|
|
}
|
|
}
|
|
fn reading(&mut self, reader_nr: u32, size: usize, data: Vec<u8>) {
|
|
let req = self.recv.recv().unwrap();
|
|
match req {
|
|
Request::Read(req_nr, req_size, back) => {
|
|
assert_eq!(reader_nr, req_nr);
|
|
assert_eq!(size, req_size);
|
|
back.send(data).unwrap();
|
|
},
|
|
_ => panic!("Unexpected behaviour"),
|
|
}
|
|
}
|
|
fn writing(&mut self, data: Vec<u8>) {
|
|
let req = self.recv.recv().unwrap();
|
|
match req {
|
|
Request::Write(req_data) => {
|
|
assert_eq!(req_data, data);
|
|
},
|
|
_ => panic!("Unexpected behaviour"),
|
|
}
|
|
}
|
|
fn terminate(self, return_val: Result<(), String>) {
|
|
let result = self.join_handle.join().unwrap();
|
|
assert_eq!(return_val, result);
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn parallel_reading() {
|
|
let mut t = Test::new();
|
|
t.reading(0, 65536, vec![0x01, 0x02, 0x03]);
|
|
t.reading(1, 3, vec![0x50, 0x60, 0x70]);
|
|
t.writing(vec![0x51, 0x62, 0x73]);
|
|
t.reading(0, 65536, vec![]);
|
|
t.terminate(Ok(()));
|
|
}
|
|
|
|
#[test]
|
|
#[should_panic]
|
|
fn panic_on_wrong_reader() {
|
|
let mut t = Test::new();
|
|
t.reading(0, 65536, vec![0x01, 0x02, 0x03]);
|
|
t.reading(1, 3, vec![0x50, 0x60, 0x70]);
|
|
t.writing(vec![0x51, 0x62, 0x73]);
|
|
t.reading(1, 65536, vec![]);
|
|
t.terminate(Ok(()));
|
|
}
|
|
|
|
#[test]
|
|
#[should_panic]
|
|
fn panic_on_wrong_reading_size() {
|
|
let mut t = Test::new();
|
|
t.reading(0, 65536, vec![0x01, 0x02, 0x03]);
|
|
t.reading(1, 4, vec![0x50, 0x60, 0x70]);
|
|
t.writing(vec![0x51, 0x62, 0x73]);
|
|
t.reading(0, 65536, vec![]);
|
|
t.terminate(Ok(()));
|
|
}
|
|
|
|
#[test]
|
|
#[should_panic]
|
|
fn panic_on_wrong_output_data() {
|
|
let mut t = Test::new();
|
|
t.reading(0, 65536, vec![0x01, 0x02, 0x03]);
|
|
t.reading(1, 3, vec![0x50, 0x60, 0x70]);
|
|
t.writing(vec![0x51, 0x62, 0x74]);
|
|
t.reading(0, 65536, vec![]);
|
|
t.terminate(Ok(()));
|
|
}
|
|
|
|
#[test]
|
|
fn left_reads_more() {
|
|
let mut t = Test::new();
|
|
t.reading(0, 65536, vec![0x01, 0x02, 0x03]);
|
|
t.reading(1, 3, vec![0x50]);
|
|
t.writing(vec![0x51]);
|
|
t.reading(1, 2, vec![0x60]);
|
|
t.writing(vec![0x62]);
|
|
t.reading(1, 1, vec![0x70]);
|
|
t.writing(vec![0x73]);
|
|
t.reading(0, 65536, vec![]);
|
|
t.terminate(Ok(()));
|
|
}
|
|
|
|
#[test]
|
|
fn left_is_larger() {
|
|
let mut t = Test::new();
|
|
t.reading(0, 65536, vec![0x01, 0x02, 0x03]);
|
|
t.reading(1, 3, vec![0x50, 0x60, 0x70]);
|
|
t.writing(vec![0x51, 0x62, 0x73]);
|
|
t.reading(0, 65536, vec![0x04, 0x05, 0x06]);
|
|
t.reading(1, 3, vec![]);
|
|
t.writing(vec![0x04, 0x05, 0x06]);
|
|
t.reading(0, 65536, vec![0x07, 0x08, 0x09]);
|
|
t.writing(vec![0x07, 0x08, 0x09]);
|
|
t.reading(0, 65536, vec![]);
|
|
t.terminate(Ok(()));
|
|
}
|