}

#[test]

fn solo_udp_put_success() {

    let test_log_path = Path::new("./logs/solo_udp_put_success");

    let sock_addrs = [next_test_addr(), next_test_addr()];

    let mut c = file_logged_connector(0, test_log_path);

    let [p0, _] = c.new_udp_mediator_component(sock_addrs[0], sock_addrs[1]).unwrap();

    c.connect(SEC1).unwrap();

    c.put(p0, TEST_MSG.clone()).unwrap();

    c.sync(MS300).unwrap();

}

#[test]

fn solo_udp_get_fail() {

    let test_log_path = Path::new("./logs/solo_udp_get_fail");

    let sock_addrs = [next_test_addr(), next_test_addr()];

    let mut c = file_logged_connector(0, test_log_path);

    let [_, p0] = c.new_udp_mediator_component(sock_addrs[0], sock_addrs[1]).unwrap();

    c.connect(SEC1).unwrap();

    c.get(p0).unwrap();

    c.sync(MS300).unwrap_err();

}

#[test]

fn reowolf_to_udp() {

    let test_log_path = Path::new("./logs/reowolf_to_udp");

    let sock_addrs = [next_test_addr(), next_test_addr()];

    let barrier = std::sync::Barrier::new(2);

    scope(|s| {

        s.spawn(|_| {

            barrier.wait();

            // reowolf thread

            let mut c = file_logged_connector(0, test_log_path);

            let [p0, _] = c.new_udp_mediator_component(sock_addrs[0], sock_addrs[1]).unwrap();

            c.connect(SEC1).unwrap();

            c.put(p0, TEST_MSG.clone()).unwrap();

            c.sync(MS300).unwrap();

            barrier.wait();

        });

        s.spawn(|_| {

            barrier.wait();

            // udp thread

            let udp = std::net::UdpSocket::bind(sock_addrs[1]).unwrap();

            udp.connect(sock_addrs[0]).unwrap();

            let mut buf = new_u8_buffer(256);

            let len = udp.recv(&mut buf).unwrap();

            assert_eq!(TEST_MSG_BYTES, &buf[0..len]);

            barrier.wait();

        });

    })

    .unwrap();

}

#[test]

fn udp_to_reowolf() {

    let test_log_path = Path::new("./logs/udp_to_reowolf");

    let sock_addrs = [next_test_addr(), next_test_addr()];

    let barrier = std::sync::Barrier::new(2);

    scope(|s| {

        s.spawn(|_| {

            barrier.wait();

            // reowolf thread

            let mut c = file_logged_connector(0, test_log_path);

            let [_, p0] = c.new_udp_mediator_component(sock_addrs[0], sock_addrs[1]).unwrap();

            c.connect(SEC1).unwrap();

            c.get(p0).unwrap();

            c.sync(SEC5).unwrap();

            assert_eq!(c.gotten(p0).unwrap().as_slice(), TEST_MSG_BYTES);

            barrier.wait();

        });

        s.spawn(|_| {

            barrier.wait();

            // udp thread

            let udp = std::net::UdpSocket::bind(sock_addrs[1]).unwrap();

            udp.connect(sock_addrs[0]).unwrap();

            for _ in 0..15 {

                udp.send(TEST_MSG_BYTES).unwrap();