fn test()

in netbench/src/multiplex.rs [519:587]
61 lines of code
4 McCabe index (conditional complexity)

    fn test(config: Config, scenario: &Scenario) -> (MemoryLogger, MemoryLogger) {
        let traces = &scenario.traces;

        let (client, server) = testing::Connection::pair(10000);

        let mut client = {
            let scenario = &scenario.clients[0].connections[0];
            let conn = Box::pin(client);
            let conn = super::Connection::new(0, conn, config.clone());
            Driver::new(scenario, conn)
        };
        let mut client_trace = MemoryLogger::new(traces.clone());
        let mut client_checkpoints = HashSet::new();
        let mut client_timer = timer::Testing::default();

        let mut server = {
            let scenario = &scenario.servers[0].connections[0];
            let conn = Box::pin(server);
            let conn = super::Connection::new(1, conn, config);
            Driver::new(scenario, conn)
        };
        let mut server_trace = MemoryLogger::new(traces.clone());
        let mut server_checkpoints = HashSet::new();
        let mut server_timer = timer::Testing::default();

        let (waker, count) = new_count_waker();
        let mut prev_count = 0;
        let mut cx = core::task::Context::from_waker(&waker);

        loop {
            let c = client.poll_with_timer(
                &mut client_trace,
                &mut client_checkpoints,
                &mut client_timer,
                &mut cx,
            );
            let s = server.poll_with_timer(
                &mut server_trace,
                &mut server_checkpoints,
                &mut server_timer,
                &mut cx,
            );

            match (c, s) {
                (Poll::Ready(Ok(())), Poll::Ready(Ok(()))) => break,
                (Poll::Ready(Err(e)), _) | (_, Poll::Ready(Err(e))) => panic!("{e}"),
                _ => {
                    let current_count = count.get();
                    if current_count > prev_count {
                        prev_count = current_count;
                        continue;
                    }

                    if client_timer.advance_pair(&mut server_timer).is_none() {
                        eprintln!("the timer did not advance!");
                        eprintln!("server trace:");
                        eprintln!("{}", server_trace.as_str().unwrap());
                        eprintln!("{server:#?}");
                        eprintln!("client trace:");
                        eprintln!("{}", client_trace.as_str().unwrap());
                        eprintln!("{client:#?}");
                        panic!("test is deadlocked");
                    }
                }
            }
        }

        (client_trace, server_trace)
    }