c.new_net_port(Getter, sock_addrs[1], Active).unwrap();

            c.new_net_port(Putter, sock_addrs[2], Passive).unwrap();

            c.connect(SEC5).unwrap();

        });

        s.spawn(|_| {

            let mut c = file_logged_connector(4, test_log_path);

            c.new_net_port(Getter, sock_addrs[2], Active).unwrap();

            c.new_net_port(Putter, sock_addrs[3], Passive).unwrap();

            c.connect(SEC5).unwrap();

        });

        s.spawn(|_| {

            let mut c = file_logged_connector(1, test_log_path);

            c.new_net_port(Getter, sock_addrs[3], Active).unwrap();

            c.connect(SEC5).unwrap();

        });

    })

    .unwrap();

}

#[test]

fn net_self_loop() {

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

    let sock_addrs = [next_test_addr()];

    let mut c = file_logged_connector(0, test_log_path);

    let p = c.new_net_port(Putter, sock_addrs[0], Active).unwrap();

    let g = c.new_net_port(Getter, sock_addrs[0], Passive).unwrap();

    c.connect(SEC1).unwrap();

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

    c.get(g).unwrap();

    c.sync(MS300).unwrap();

}

#[test]

fn nobody_connects_active() {

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

    let sock_addrs = [next_test_addr()];

    let mut c = file_logged_connector(0, test_log_path);

    let _g = c.new_net_port(Getter, sock_addrs[0], Active).unwrap();

    c.connect(Some(Duration::from_secs(5))).unwrap_err();

}

#[test]

fn nobody_connects_passive() {

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

    let sock_addrs = [next_test_addr()];

    let mut c = file_logged_connector(0, test_log_path);

    let _g = c.new_net_port(Getter, sock_addrs[0], Passive).unwrap();

    c.connect(Some(Duration::from_secs(5))).unwrap_err();

}

#[test]

fn together() {

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

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

    scope(|s| {

        s.spawn(|_| {

            let mut c = file_logged_connector(0, test_log_path);

            let [p0, p1] = c.new_port_pair();

            let p2 = c.new_net_port(Getter, sock_addrs[0], Passive).unwrap();

            let p3 = c.new_net_port(Putter, sock_addrs[1], Active).unwrap();

            let [p4, p5] = c.new_port_pair();

            c.add_component(b"together", &[p1, p2, p3, p4]).unwrap();

            c.connect(SEC1).unwrap();

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

            c.get(p5).unwrap();

            c.sync(MS300).unwrap();

            c.gotten(p5).unwrap();

        });

        s.spawn(|_| {

            let mut c = file_logged_connector(1, test_log_path);

            let [p0, p1] = c.new_port_pair();

            let p2 = c.new_net_port(Getter, sock_addrs[1], Passive).unwrap();

            let p3 = c.new_net_port(Putter, sock_addrs[0], Active).unwrap();

            let [p4, p5] = c.new_port_pair();

            c.add_component(b"together", &[p1, p2, p3, p4]).unwrap();

            c.connect(SEC1).unwrap();

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

            c.get(p5).unwrap();

            c.sync(MS300).unwrap();

            c.gotten(p5).unwrap();

        });

    })

    .unwrap();

}

#[test]

fn native_batch_distinguish() {

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

    let mut c = file_logged_connector(0, test_log_path);

    c.connect(SEC1).unwrap();

    c.next_batch().unwrap();

    c.sync(SEC1).unwrap();

}

#[test]

fn multirounds() {

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

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

    scope(|s| {

        s.spawn(|_| {

            let mut c = file_logged_connector(0, test_log_path);

            let p0 = c.new_net_port(Putter, sock_addrs[0], Active).unwrap();

            let p1 = c.new_net_port(Getter, sock_addrs[1], Passive).unwrap();

            c.connect(SEC1).unwrap();

            for _ in 0..10 {

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

                c.get(p1).unwrap();

                c.sync(SEC1).unwrap();

            }

        });

        s.spawn(|_| {

            let mut c = file_logged_connector(1, test_log_path);

            let p0 = c.new_net_port(Getter, sock_addrs[0], Passive).unwrap();

            let p1 = c.new_net_port(Putter, sock_addrs[1], Active).unwrap();

            c.connect(SEC1).unwrap();

            for _ in 0..10 {

                c.get(p0).unwrap();

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

                c.sync(SEC1).unwrap();

            }

        });

    })

    .unwrap();

}

#[test]

fn multi_recover() {

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

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

    let success_iter = [true, false].iter().copied().cycle().take(10);

    scope(|s| {

        s.spawn(|_| {

            let mut c = file_logged_connector(0, test_log_path);

            let p0 = c.new_net_port(Putter, sock_addrs[0], Active).unwrap();

            let p1 = c.new_net_port(Getter, sock_addrs[1], Passive).unwrap();

            c.connect(SEC1).unwrap();

            for succeeds in success_iter.clone() {

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

                if succeeds {

                    c.get(p1).unwrap();

                }

                let res = c.sync(MS300);

                assert_eq!(res.is_ok(), succeeds);

            }

        });

        s.spawn(|_| {

            let mut c = file_logged_connector(1, test_log_path);

            let p0 = c.new_net_port(Getter, sock_addrs[0], Passive).unwrap();

            let p1 = c.new_net_port(Putter, sock_addrs[1], Active).unwrap();

            c.connect(SEC1).unwrap();

            for succeeds in success_iter.clone() {

                c.get(p0).unwrap();

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

                let res = c.sync(MS300);

                assert_eq!(res.is_ok(), succeeds);

            }

        });

    })

    .unwrap();

}

#[test]

fn udp_self_connect() {

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

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

    let mut c = file_logged_connector(0, test_log_path);

    c.new_udp_mediator_component(sock_addrs[0], sock_addrs[1]).unwrap();

    c.new_udp_mediator_component(sock_addrs[1], sock_addrs[0]).unwrap();

    c.connect(SEC1).unwrap();

}

#[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();

                std::thread::sleep(MS100.unwrap());

            }

            barrier.wait();

        });

    })

    .unwrap();

}

#[test]

fn udp_reowolf_swap() {

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

    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, p1] = c.new_udp_mediator_component(sock_addrs[0], sock_addrs[1]).unwrap();

            c.connect(SEC1).unwrap();

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

            c.get(p1).unwrap();

            c.sync(SEC5).unwrap();

            assert_eq!(c.gotten(p1).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();

            let mut buf = new_u8_buffer(256);

            for _ in 0..5 {

                std::thread::sleep(Duration::from_millis(60));

                udp.send(TEST_MSG_BYTES).unwrap();

            }

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

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

            barrier.wait();

        });

    })

    .unwrap();

}

#[test]

fn example_pres_3() {

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

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

    scope(|s| {

        s.spawn(|_| {

            // "amy"

            let mut c = file_logged_connector(0, test_log_path);

            let p0 = c.new_net_port(Putter, sock_addrs[0], Active).unwrap();

            let p1 = c.new_net_port(Putter, sock_addrs[1], Active).unwrap();

            c.connect(SEC1).unwrap();

            // put {A} and FAIL

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

            c.sync(SEC1).unwrap_err();

            // put {B} and FAIL

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

            c.sync(SEC1).unwrap_err();

            // put {A, B} and SUCCEED

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

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

            c.sync(SEC1).unwrap();

        });

        s.spawn(|_| {

            // "bob"

            let mut c = file_logged_connector(1, test_log_path);

            let p0 = c.new_net_port(Getter, sock_addrs[0], Passive).unwrap();

            let p1 = c.new_net_port(Getter, sock_addrs[1], Passive).unwrap();

            c.connect(SEC1).unwrap();

            for _ in 0..2 {

                // get {A, B} and FAIL

                c.get(p0).unwrap();

                c.get(p1).unwrap();

                c.sync(SEC1).unwrap_err();

            }

            // get {A, B} and SUCCEED

            c.get(p0).unwrap();

            c.get(p1).unwrap();

            c.sync(SEC1).unwrap();

        });

    })

    .unwrap();

}

#[test]

fn ac_not_b() {

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

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

    scope(|s| {

        s.spawn(|_| {

            // "amy"

            let mut c = file_logged_connector(0, test_log_path);

            let p0 = c.new_net_port(Putter, sock_addrs[0], Active).unwrap();

            let p1 = c.new_net_port(Putter, sock_addrs[1], Active).unwrap();

            c.connect(SEC1).unwrap();

            // put both A and B

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

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

            c.sync(SEC1).unwrap_err();

        });

        s.spawn(|_| {

            // "bob"

            let pdl = b"

            primitive ac_not_b(in a, in b, out c){

                // forward A to C but keep B silent

                synchronous{ put(c, get(a)); }

            }";

            let pd = Arc::new(reowolf::ProtocolDescription::parse(pdl).unwrap());

            let mut c = file_logged_configured_connector(1, test_log_path, pd);

            let p0 = c.new_net_port(Getter, sock_addrs[0], Passive).unwrap();

            let p1 = c.new_net_port(Getter, sock_addrs[1], Passive).unwrap();

            let [a, b] = c.new_port_pair();

            c.add_component(b"ac_not_b", &[p0, p1, a]).unwrap();

            c.connect(SEC1).unwrap();

            c.get(b).unwrap();

            c.sync(SEC1).unwrap_err();

        });

    })

    .unwrap();

}

#[test]

fn many_rounds_net() {

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

    let sock_addrs = [next_test_addr()];

    const NUM_ROUNDS: usize = 1_000;

    scope(|s| {

        s.spawn(|_| {

            let mut c = file_logged_connector(0, test_log_path);

            let p0 = c.new_net_port(Putter, sock_addrs[0], Active).unwrap();

            c.connect(SEC1).unwrap();

            for _ in 0..NUM_ROUNDS {

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

                c.sync(SEC1).unwrap();

            }

        });

        s.spawn(|_| {

            let mut c = file_logged_connector(1, test_log_path);

            let p0 = c.new_net_port(Getter, sock_addrs[0], Passive).unwrap();

            c.connect(SEC1).unwrap();

            for _ in 0..NUM_ROUNDS {

                c.get(p0).unwrap();

                c.sync(SEC1).unwrap();

            }

        });

    })

    .unwrap();

}

#[test]

fn many_rounds_mem() {

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

    const NUM_ROUNDS: usize = 1_000;

    let mut c = file_logged_connector(0, test_log_path);

    let [p0, p1] = c.new_port_pair();

    c.connect(SEC1).unwrap();

    for _ in 0..NUM_ROUNDS {

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

        c.get(p1).unwrap();

        c.sync(SEC1).unwrap();

    }

}

#[test]