zonai 0.0.2

Synchronous packet-framed TCP clients and servers
Documentation
#![allow(clippy::expect_used)]

use std::{
    io::{self, Read, Write},
    thread,
    time::{Duration, Instant},
};

use zonai::{
    client::Client,
    packet::{PacketIn, PacketOut},
    server::{Server, ServerEvent},
};

#[derive(Debug, PartialEq, Eq)]
struct BytePacket(u8);

impl PacketIn for BytePacket {
    fn read(reader: &mut impl Read) -> io::Result<Self> {
        let mut byte = [0];
        reader.read_exact(&mut byte)?;
        Ok(Self(byte[0]))
    }
}

impl PacketOut for BytePacket {
    fn write(&self, writer: &mut impl Write) -> io::Result<()> {
        writer.write_all(&[self.0])
    }
}

#[test]
fn library_client_and_server_exchange_packets() {
    let server =
        Server::<BytePacket, BytePacket>::bind("127.0.0.1:0".parse().expect("server address"))
            .expect("bind server");
    let mut client =
        Client::<BytePacket, BytePacket>::connect(server.local_addr()).expect("connect client");

    let deadline = Instant::now() + Duration::from_secs(2);
    let server_client = loop {
        match server.poll().expect("poll server") {
            Some(ServerEvent::Accept { client, .. }) => break client,
            Some(_) | None if Instant::now() < deadline => thread::sleep(Duration::from_millis(1)),
            event => panic!("timed out waiting for accept: {event:?}"),
        }
    };

    server
        .send(server_client, BytePacket(7))
        .expect("server send");
    assert_eq!(client.receive().expect("client receive"), BytePacket(7));

    client.send(&BytePacket(9)).expect("client send");
    let deadline = Instant::now() + Duration::from_secs(2);
    loop {
        match server.poll().expect("poll server") {
            Some(ServerEvent::Packet {
                client,
                packet: BytePacket(9),
            }) if client == server_client => break,
            Some(_) | None if Instant::now() < deadline => thread::sleep(Duration::from_millis(1)),
            event => panic!("timed out waiting for packet: {event:?}"),
        }
    }

    client.shutdown().expect("client shutdown");
    server.shutdown_and_wait().expect("server shutdown");
}