Changeset - b7be5c34cd3a
Parent rev.
Child rev.
[Not reviewed]
0 3 0
Christopher Esterhuyse - 5 years ago 2020-02-06 15:24:47
christopheresterhuyse@gmail.com
cleaned up tests
3 files changed with 77 insertions and 95 deletions:
src/test/connector.rs
29
40
src/test/mod.rs
21
6
src/test/setup.rs
27
49
0 comments (0 inline, 0 general)
src/test/connector.rs
➞
Show inline comments
 
@@ -2,24 +2,12 @@ extern crate test_generator;
 

			




	
	
	
		
 
use super::*;

			




	
	
	
		
 

			




	
	
	
		
 
use crate::common::*;

			




	
	
	
		
 
use crate::runtime::{errors::*, PortBinding::*};

			




	
	
	
		
 

			




	
	
	
		
 
// using a static AtomicU16, shared between all tests in the binary,

			




	
	
	
		
 
// allocate and return a socketaddr of the form 127.0.0.1:X where X in 7000..

			




	
	
	
		
 
fn next_addr() -> SocketAddr {

			




	
	
	
		
 
    use std::{

			




	
	
	
		
 
        net::{Ipv4Addr, SocketAddrV4},

			




	
	
	
		
 
        sync::atomic::{AtomicU16, Ordering::SeqCst},

			




	
	
	
		
 
    };

			




	
	
	
		
 
    static TEST_PORT: AtomicU16 = AtomicU16::new(7_000);

			




	
	
	
		
 
    let port = TEST_PORT.fetch_add(1, SeqCst);

			




	
	
	
		
 
    SocketAddrV4::new(Ipv4Addr::new(127, 0, 0, 1), port).into()

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
static PDL: &[u8] = b"

			




	
	
	
		
 
primitive blocked(in i, out o) {

			




	
	
	
		
 
    while(true) synchronous {}

			




	
	
	
		
 
}

			




	
	
	
		
 
primitive forward(in i, out o) {

			




	
	
	
		
 
    while(true) synchronous {

			




	
	
		
 
@@ -72,13 +60,13 @@ fn connects_ok() {

			




	
	
	
		
 
    // Test if we can connect natives using the given PDL

			




	
	
	
		
 
    /*

			




	
	
	
		
 
    Alice -->silence--P|A-->silence--> Bob

			




	
	
	
		
 
    */

			




	
	
	
		
 
    let timeout = Duration::from_millis(1_500);

			




	
	
	
		
 
    let addrs = [next_addr()];

			




	
	
	
		
 
    do_all(&[

			




	
	
	
		
 
    assert!(do_all(&[

			




	
	
	
		
 
        &|x| {

			




	
	
	
		
 
            // Alice

			




	
	
	
		
 
            x.configure(PDL, b"blocked").unwrap();

			




	
	
	
		
 
            x.bind_port(0, Native).unwrap();

			




	
	
	
		
 
            x.bind_port(1, Passive(addrs[0])).unwrap();

			




	
	
	
		
 
            x.connect(timeout).unwrap();

			




	
	
		
 
@@ -87,24 +75,24 @@ fn connects_ok() {

			




	
	
	
		
 
            // Bob

			




	
	
	
		
 
            x.configure(PDL, b"blocked").unwrap();

			




	
	
	
		
 
            x.bind_port(0, Active(addrs[0])).unwrap();

			




	
	
	
		
 
            x.bind_port(1, Native).unwrap();

			




	
	
	
		
 
            x.connect(timeout).unwrap();

			




	
	
	
		
 
        },

			




	
	
	
		
 
    ]);

			




	
	
	
		
 
    ]));

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
#[test]

			




	
	
	
		
 
fn connected_but_silent_natives() {

			




	
	
	
		
 
    // Test if we can connect natives and have a trivial sync round

			




	
	
	
		
 
    /*

			




	
	
	
		
 
    Alice -->silence--P|A-->silence--> Bob

			




	
	
	
		
 
    */

			




	
	
	
		
 
    let timeout = Duration::from_millis(1_500);

			




	
	
	
		
 
    let addrs = [next_addr()];

			




	
	
	
		
 
    do_all(&[

			




	
	
	
		
 
    assert!(do_all(&[

			




	
	
	
		
 
        &|x| {

			




	
	
	
		
 
            // Alice

			




	
	
	
		
 
            x.configure(PDL, b"blocked").unwrap();

			




	
	
	
		
 
            x.bind_port(0, Native).unwrap();

			




	
	
	
		
 
            x.bind_port(1, Passive(addrs[0])).unwrap();

			




	
	
	
		
 
            x.connect(timeout).unwrap();

			




	
	
		
 
@@ -115,13 +103,13 @@ fn connected_but_silent_natives() {

			




	
	
	
		
 
            x.configure(PDL, b"blocked").unwrap();

			




	
	
	
		
 
            x.bind_port(0, Active(addrs[0])).unwrap();

			




	
	
	
		
 
            x.bind_port(1, Native).unwrap();

			




	
	
	
		
 
            x.connect(timeout).unwrap();

			




	
	
	
		
 
            assert_eq!(Ok(0), x.sync(timeout));

			




	
	
	
		
 
        },

			




	
	
	
		
 
    ]);

			




	
	
	
		
 
    ]));

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
#[test]

			




	
	
	
		
 
fn self_forward_ok() {

			




	
	
	
		
 
    // Test a deterministic system

			




	
	
	
		
 
    // where a native has no network bindings

			




	
	
		
 
@@ -131,13 +119,13 @@ fn self_forward_ok() {

			




	
	
	
		
 
    Alice   forward

			




	
	
	
		
 
        \<--/

			




	
	
	
		
 
    */

			




	
	
	
		
 
    let timeout = Duration::from_millis(1_500);

			




	
	
	
		
 
    const N: usize = 5;

			




	
	
	
		
 
    static MSG: &[u8] = b"Echo!";

			




	
	
	
		
 
    do_all(&[

			




	
	
	
		
 
    assert!(do_all(&[

			




	
	
	
		
 
        //

			




	
	
	
		
 
        &|x| {

			




	
	
	
		
 
            // Alice

			




	
	
	
		
 
            x.configure(PDL, b"forward").unwrap();

			




	
	
	
		
 
            x.bind_port(0, Native).unwrap();

			




	
	
	
		
 
            x.bind_port(1, Native).unwrap();

			




	
	
		
 
@@ -146,48 +134,48 @@ fn self_forward_ok() {

			




	
	
	
		
 
                x.put(0, MSG.to_vec()).unwrap();

			




	
	
	
		
 
                x.get(1).unwrap();

			




	
	
	
		
 
                assert_eq!(Ok(0), x.sync(timeout));

			




	
	
	
		
 
                assert_eq!(Ok(MSG), x.read_gotten(1));

			




	
	
	
		
 
            }

			




	
	
	
		
 
        },

			




	
	
	
		
 
    ]);

			




	
	
	
		
 
    ]));

			




	
	
	
		
 
}

			




	
	
	
		
 
#[test]

			




	
	
	
		
 
fn token_spout_ok() {

			




	
	
	
		
 
    // Test a deterministic system where the proto

			




	
	
	
		
 
    // creates token messages

			




	
	
	
		
 
    /*

			




	
	
	
		
 
    Alice<--token_spout

			




	
	
	
		
 
    */

			




	
	
	
		
 
    let timeout = Duration::from_millis(1_500);

			




	
	
	
		
 
    const N: usize = 5;

			




	
	
	
		
 
    do_all(&[

			




	
	
	
		
 
    assert!(do_all(&[

			




	
	
	
		
 
        //

			




	
	
	
		
 
        &|x| {

			




	
	
	
		
 
            // Alice

			




	
	
	
		
 
            x.configure(PDL, b"token_spout").unwrap();

			




	
	
	
		
 
            x.bind_port(0, Native).unwrap();

			




	
	
	
		
 
            x.connect(timeout).unwrap();

			




	
	
	
		
 
            for _ in 0..N {

			




	
	
	
		
 
                x.get(0).unwrap();

			




	
	
	
		
 
                assert_eq!(Ok(0), x.sync(timeout));

			




	
	
	
		
 
                assert_eq!(Ok(&[] as &[u8]), x.read_gotten(0));

			




	
	
	
		
 
            }

			




	
	
	
		
 
        },

			




	
	
	
		
 
    ]);

			




	
	
	
		
 
    ]));

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
#[test]

			




	
	
	
		
 
fn waiter_ok() {

			




	
	
	
		
 
    // Test a stateful proto that blocks port 0 for 10 rounds

			




	
	
	
		
 
    // and then sends a single token on the 11th

			




	
	
	
		
 
    /*

			




	
	
	
		
 
    Alice<--token_spout

			




	
	
	
		
 
    */

			




	
	
	
		
 
    let timeout = Duration::from_millis(1_500);

			




	
	
	
		
 
    do_all(&[

			




	
	
	
		
 
    assert!(do_all(&[

			




	
	
	
		
 
        //

			




	
	
	
		
 
        &|x| {

			




	
	
	
		
 
            // Alice

			




	
	
	
		
 
            x.configure(PDL, b"wait_10").unwrap();

			




	
	
	
		
 
            x.bind_port(0, Native).unwrap();

			




	
	
	
		
 
            x.connect(timeout).unwrap();

			




	
	
		
 
@@ -196,13 +184,13 @@ fn waiter_ok() {

			




	
	
	
		
 
                assert_eq!(Err(ReadGottenErr::DidNotGet), x.read_gotten(0));

			




	
	
	
		
 
            }

			




	
	
	
		
 
            x.get(0).unwrap();

			




	
	
	
		
 
            assert_eq!(Ok(0), x.sync(timeout));

			




	
	
	
		
 
            assert_eq!(Ok(&[] as &[u8]), x.read_gotten(0));

			




	
	
	
		
 
        },

			




	
	
	
		
 
    ]);

			




	
	
	
		
 
    ]));

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
#[test]

			




	
	
	
		
 
fn self_forward_timeout() {

			




	
	
	
		
 
    // Test a deterministic system

			




	
	
	
		
 
    // where a native has no network bindings

			




	
	
		
 
@@ -211,38 +199,39 @@ fn self_forward_timeout() {

			




	
	
	
		
 
        /-->\

			




	
	
	
		
 
    Alice   forward

			




	
	
	
		
 
        \<--/

			




	
	
	
		
 
    */

			




	
	
	
		
 
    let timeout = Duration::from_millis(500);

			




	
	
	
		
 
    static MSG: &[u8] = b"Echo!";

			




	
	
	
		
 
    do_all(&[

			




	
	
	
		
 
    assert!(do_all(&[

			




	
	
	
		
 
        //

			




	
	
	
		
 
        &|x| {

			




	
	
	
		
 
            // Sender

			




	
	
	
		
 
            x.configure(PDL, b"forward").unwrap();

			




	
	
	
		
 
            x.bind_port(0, Native).unwrap();

			




	
	
	
		
 
            x.bind_port(1, Native).unwrap();

			




	
	
	
		
 
            x.connect(timeout).unwrap();

			




	
	
	
		
 
            x.put(0, MSG.to_vec()).unwrap();

			




	
	
	
		
 
            // native and forward components cannot find a solution

			




	
	
	
		
 
            assert_eq!(Err(SyncErr::Timeout), x.sync(timeout));

			




	
	
	
		
 
        },

			




	
	
	
		
 
    ]);

			




	
	
	
		
 
    ]));

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
#[test]

			




	
	
	
		
 
fn forward_det() {

			




	
	
	
		
 
    // Test if a deterministic protocol and natives can pass one message

			




	
	
	
		
 
    /*

			




	
	
	
		
 
    Alice -->forward--P|A-->forward--> Bob

			




	
	
	
		
 
    */

			




	
	
	
		
 
    let timeout = Duration::from_millis(1_500);

			




	
	
	
		
 
    let addrs = [next_addr()];

			




	
	
	
		
 
    const N: usize = 5;

			




	
	
	
		
 
    static MSG: &[u8] = b"Hello!";

			




	
	
	
		
 
    do_all(&[

			




	
	
	
		
 

			




	
	
	
		
 
    assert!(do_all(&[

			




	
	
	
		
 
        &|x| {

			




	
	
	
		
 
            x.configure(PDL, b"forward").unwrap();

			




	
	
	
		
 
            x.bind_port(0, Native).unwrap();

			




	
	
	
		
 
            x.bind_port(1, Passive(addrs[0])).unwrap();

			




	
	
	
		
 
            x.connect(timeout).unwrap();

			




	
	
	
		
 
            for _ in 0..N {

			




	
	
		
 
@@ -258,13 +247,13 @@ fn forward_det() {

			




	
	
	
		
 
            for _ in 0..N {

			




	
	
	
		
 
                x.get(0).unwrap();

			




	
	
	
		
 
                assert_eq!(Ok(0), x.sync(timeout));

			




	
	
	
		
 
                assert_eq!(Ok(MSG), x.read_gotten(0));

			




	
	
	
		
 
            }

			




	
	
	
		
 
        },

			




	
	
	
		
 
    ]);

			




	
	
	
		
 
    ]));

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
#[test]

			




	
	
	
		
 
fn nondet_proto_det_natives() {

			




	
	
	
		
 
    // Test the use of a nondeterministic protocol

			




	
	
	
		
 
    // where Alice decides the choice and the others conform

			




	
	
		
 
@@ -272,13 +261,13 @@ fn nondet_proto_det_natives() {

			




	
	
	
		
 
    Alice -->sync--A|P-->sync--> Bob

			




	
	
	
		
 
    */

			




	
	
	
		
 
    let timeout = Duration::from_millis(1_500);

			




	
	
	
		
 
    let addrs = [next_addr()];

			




	
	
	
		
 
    const N: usize = 5;

			




	
	
	
		
 
    static MSG: &[u8] = b"Message, here!";

			




	
	
	
		
 
    do_all(&[

			




	
	
	
		
 
    assert!(do_all(&[

			




	
	
	
		
 
        &|x| {

			




	
	
	
		
 
            // Alice

			




	
	
	
		
 
            x.configure(PDL, b"sync").unwrap();

			




	
	
	
		
 
            x.bind_port(0, Native).unwrap();

			




	
	
	
		
 
            x.bind_port(1, Active(addrs[0])).unwrap();

			




	
	
	
		
 
            x.connect(timeout).unwrap();

			




	
	
		
 
@@ -296,26 +285,26 @@ fn nondet_proto_det_natives() {

			




	
	
	
		
 
            for _i in 0..N {

			




	
	
	
		
 
                x.get(0).unwrap();

			




	
	
	
		
 
                assert_eq!(Ok(0), x.sync(timeout));

			




	
	
	
		
 
                assert_eq!(Ok(MSG), x.read_gotten(0));

			




	
	
	
		
 
            }

			




	
	
	
		
 
        },

			




	
	
	
		
 
    ]);

			




	
	
	
		
 
    ]));

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
#[test]

			




	
	
	
		
 
fn putter_determines() {

			




	
	
	
		
 
    // putter and getter

			




	
	
	
		
 
    /*

			




	
	
	
		
 
    Alice -->sync--A|P-->sync--> Bob

			




	
	
	
		
 
    */

			




	
	
	
		
 
    let timeout = Duration::from_millis(1_500);

			




	
	
	
		
 
    let addrs = [next_addr()];

			




	
	
	
		
 
    const N: usize = 3;

			




	
	
	
		
 
    static MSG: &[u8] = b"Hidey ho!";

			




	
	
	
		
 
    do_all(&[

			




	
	
	
		
 
    assert!(do_all(&[

			




	
	
	
		
 
        //

			




	
	
	
		
 
        &|x| {

			




	
	
	
		
 
            // Alice

			




	
	
	
		
 
            x.configure(PDL, b"sync").unwrap();

			




	
	
	
		
 
            x.bind_port(0, Native).unwrap();

			




	
	
	
		
 
            x.bind_port(1, Active(addrs[0])).unwrap();

			




	
	
		
 
@@ -336,26 +325,26 @@ fn putter_determines() {

			




	
	
	
		
 
                x.get(0).unwrap();

			




	
	
	
		
 
                x.next_batch().unwrap();

			




	
	
	
		
 
                assert_eq!(Ok(0), x.sync(timeout));

			




	
	
	
		
 
                assert_eq!(Ok(MSG), x.read_gotten(0));

			




	
	
	
		
 
            }

			




	
	
	
		
 
        },

			




	
	
	
		
 
    ]);

			




	
	
	
		
 
    ]));

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
#[test]

			




	
	
	
		
 
fn getter_determines() {

			




	
	
	
		
 
    // putter and getter

			




	
	
	
		
 
    /*

			




	
	
	
		
 
    Alice -->sync--A|P-->sync--> Bob

			




	
	
	
		
 
    */

			




	
	
	
		
 
    let timeout = Duration::from_millis(1_500);

			




	
	
	
		
 
    let addrs = [next_addr()];

			




	
	
	
		
 
    const N: usize = 5;

			




	
	
	
		
 
    static MSG: &[u8] = b"Hidey ho!";

			




	
	
	
		
 
    do_all(&[

			




	
	
	
		
 
    assert!(do_all(&[

			




	
	
	
		
 
        //

			




	
	
	
		
 
        &|x| {

			




	
	
	
		
 
            // Alice

			




	
	
	
		
 
            x.configure(PDL, b"sync").unwrap();

			




	
	
	
		
 
            x.bind_port(0, Native).unwrap();

			




	
	
	
		
 
            x.bind_port(1, Active(addrs[0])).unwrap();

			




	
	
		
 
@@ -377,13 +366,13 @@ fn getter_determines() {

			




	
	
	
		
 
            for _i in 0..N {

			




	
	
	
		
 
                x.get(0).unwrap();

			




	
	
	
		
 
                assert_eq!(Ok(0), x.sync(timeout));

			




	
	
	
		
 
                assert_eq!(Ok(MSG), x.read_gotten(0));

			




	
	
	
		
 
            }

			




	
	
	
		
 
        },

			




	
	
	
		
 
    ]);

			




	
	
	
		
 
    ]));

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
#[test]

			




	
	
	
		
 
fn alternator_2() {

			




	
	
	
		
 
    // Test a deterministic system which

			




	
	
	
		
 
    // alternates sending Sender's messages to A or B

			




	
	
		
 
@@ -392,13 +381,13 @@ fn alternator_2() {

			




	
	
	
		
 
                          \--|-->B

			




	
	
	
		
 
    */

			




	
	
	
		
 
    let timeout = Duration::from_millis(1_500);

			




	
	
	
		
 
    let addrs = [next_addr(), next_addr()];

			




	
	
	
		
 
    const N: usize = 5;

			




	
	
	
		
 
    static MSG: &[u8] = b"message";

			




	
	
	
		
 
    do_all(&[

			




	
	
	
		
 
    assert!(do_all(&[

			




	
	
	
		
 
        //

			




	
	
	
		
 
        &|x| {

			




	
	
	
		
 
            // Sender

			




	
	
	
		
 
            x.configure(PDL, b"alternator_2").unwrap();

			




	
	
	
		
 
            x.bind_port(0, Native).unwrap();

			




	
	
	
		
 
            x.bind_port(1, Passive(addrs[0])).unwrap();

			




	
	
		
 
@@ -444,13 +433,13 @@ fn alternator_2() {

			




	
	
	
		
 
                // get msg round

			




	
	
	
		
 
                x.get(0).unwrap();

			




	
	
	
		
 
                assert_eq!(Ok(0), x.sync(timeout)); // GET ONE

			




	
	
	
		
 
                assert_eq!(Ok(MSG), x.read_gotten(0));

			




	
	
	
		
 
            }

			




	
	
	
		
 
        },

			




	
	
	
		
 
    ]);

			




	
	
	
		
 
    ]));

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
#[test]

			




	
	
	
		
 
// PANIC TODO: eval::1536

			




	
	
	
		
 
fn composite_chain() {

			




	
	
	
		
 
    // Check if composition works. Forward messages through long chains

			




	
	
		
 
@@ -458,13 +447,13 @@ fn composite_chain() {

			




	
	
	
		
 
    Alice -->sync-->sync-->A|P-->sync-->sync--> Bob

			




	
	
	
		
 
    */

			




	
	
	
		
 
    let timeout = Duration::from_millis(1_500);

			




	
	
	
		
 
    let addrs = [next_addr(), next_addr()];

			




	
	
	
		
 
    const N: usize = 1;

			




	
	
	
		
 
    static MSG: &[u8] = b"Hippity Hoppity";

			




	
	
	
		
 
    do_all(&[

			




	
	
	
		
 
    assert!(do_all(&[

			




	
	
	
		
 
        //

			




	
	
	
		
 
        &|x| {

			




	
	
	
		
 
            // Alice

			




	
	
	
		
 
            x.configure(PDL, b"sync_2").unwrap();

			




	
	
	
		
 
            x.bind_port(0, Native).unwrap();

			




	
	
	
		
 
            x.bind_port(1, Active(addrs[0])).unwrap();

			




	
	
		
 
@@ -484,13 +473,13 @@ fn composite_chain() {

			




	
	
	
		
 
                // get msg round

			




	
	
	
		
 
                x.get(0).unwrap();

			




	
	
	
		
 
                assert_eq!(Ok(0), x.sync(timeout));

			




	
	
	
		
 
                assert_eq!(Ok(MSG), x.read_gotten(0));

			




	
	
	
		
 
            }

			




	
	
	
		
 
        },

			




	
	
	
		
 
    ]);

			




	
	
	
		
 
    ]));

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
#[test]

			




	
	
	
		
 
// PANIC TODO: eval::1605

			




	
	
	
		
 
fn exchange() {

			




	
	
	
		
 
    /*

			




	
	
		
 
@@ -498,13 +487,13 @@ fn exchange() {

			




	
	
	
		
 
    Alice                             Bob

			




	
	
	
		
 
        \<--forward<--P|A<--forward<--/

			




	
	
	
		
 
    */

			




	
	
	
		
 
    let timeout = Duration::from_millis(1_500);

			




	
	
	
		
 
    let addrs = [next_addr(), next_addr()];

			




	
	
	
		
 
    const N: usize = 1;

			




	
	
	
		
 
    do_all(&[

			




	
	
	
		
 
    assert!(do_all(&[

			




	
	
	
		
 
        //

			




	
	
	
		
 
        &|x| {

			




	
	
	
		
 
            // Alice

			




	
	
	
		
 
            x.configure(PDL, b"forward_pair").unwrap();

			




	
	
	
		
 
            x.bind_port(0, Native).unwrap(); // native in

			




	
	
	
		
 
            x.bind_port(1, Passive(addrs[0])).unwrap(); // peer out

			




	
	
		
 
@@ -530,13 +519,13 @@ fn exchange() {

			




	
	
	
		
 
                x.put(0, b"B->A".to_vec()).unwrap();

			




	
	
	
		
 
                x.get(1).unwrap();

			




	
	
	
		
 
                assert_eq!(Ok(0), x.sync(timeout));

			




	
	
	
		
 
                assert_eq!(Ok(b"A->B" as &[u8]), x.read_gotten(0));

			




	
	
	
		
 
            }

			




	
	
	
		
 
        },

			




	
	
	
		
 
    ]);

			




	
	
	
		
 
    ]));

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
#[test]

			




	
	
	
		
 
// THIS DOES NOT YET WORK. TODOS are hit

			




	
	
	
		
 
fn filter_messages() {

			




	
	
	
		
 
    // Make a protocol whose behavior depends on the contents of messages

			




	
	
		
 
@@ -545,13 +534,13 @@ fn filter_messages() {

			




	
	
	
		
 
    /*

			




	
	
	
		
 
    Sender -->forward-->P|A-->forward_nonzero--> Receiver

			




	
	
	
		
 
    */

			




	
	
	
		
 
    let timeout = Duration::from_millis(1_500);

			




	
	
	
		
 
    let addrs = [next_addr()];

			




	
	
	
		
 
    const N: usize = 1;

			




	
	
	
		
 
    do_all(&[

			




	
	
	
		
 
    assert!(do_all(&[

			




	
	
	
		
 
        //

			




	
	
	
		
 
        &|x| {

			




	
	
	
		
 
            // Sender

			




	
	
	
		
 
            x.configure(PDL, b"forward").unwrap();

			




	
	
	
		
 
            x.bind_port(0, Native).unwrap();

			




	
	
	
		
 
            x.bind_port(1, Passive(addrs[0])).unwrap();

			




	
	
		
 
@@ -596,8 +585,8 @@ fn filter_messages() {

			




	
	
	
		
 
                        assert_ne!(&[0u8], x.read_gotten(0).unwrap());

			




	
	
	
		
 
                    }

			




	
	
	
		
 
                    _ => unreachable!(),

			




	
	
	
		
 
                }

			




	
	
	
		
 
            }

			




	
	
	
		
 
        },

			




	
	
	
		
 
    ]);

			




	
	
	
		
 
    ]));

			




	
	
	
		
 
}

			




        

    


    
    

    

        

                

                    src/test/mod.rs
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
	
		
 
use crate::common::ControllerId;

			




	
	
	
		
 
use crate::runtime::Connector;

			




	
	
	
		
 
use crate::runtime::Unconfigured;

			




	
	
	
		
 
use core::fmt::Debug;

			




	
	
	
		
 
use std::net::SocketAddr;

			




	
	
	
		
 

			




	
	
	
		
 
mod connector;

			




	
	
	
		
 
mod setup;

			




	
	
	
		
 

			




	
	
	
		
 
// using a static AtomicU16, shared between all tests in the binary,

			




	
	
	
		
 
// allocate and return a socketaddr of the form 127.0.0.1:X where X in 7000..

			




	
	
	
		
 
fn next_addr() -> SocketAddr {

			




	
	
	
		
 
    use std::{

			




	
	
	
		
 
        net::{Ipv4Addr, SocketAddrV4},

			




	
	
	
		
 
        sync::atomic::{AtomicU16, Ordering::SeqCst},

			




	
	
	
		
 
    };

			




	
	
	
		
 
    static TEST_PORT: AtomicU16 = AtomicU16::new(7_000);

			




	
	
	
		
 
    let port = TEST_PORT.fetch_add(1, SeqCst);

			




	
	
	
		
 
    SocketAddrV4::new(Ipv4Addr::new(127, 0, 0, 1), port).into()

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
struct Panicked(Box<dyn std::any::Any>);

			




	
	
	
		
 
impl Debug for Panicked {

			




	
	
	
		
 
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {

			




	
	
	
		
 
        if let Some(str_slice) = self.0.downcast_ref::<&'static str>() {

			




	
	
	
		
 
            f.pad(str_slice)

			




	
	
	
		
 
        } else if let Some(string) = self.0.downcast_ref::<String>() {

			




	
	
		
 
@@ -21,13 +34,17 @@ impl Debug for Panicked {

			




	
	
	
		
 
fn handle(result: Result<(), Box<(dyn std::any::Any + Send + 'static)>>) {

			




	
	
	
		
 
    if let Err(x) = result {

			




	
	
	
		
 
        panic!("Worker panicked: {:?}", Panicked(x))

			




	
	
	
		
 
    }

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
fn do_all(i: &[&(dyn Fn(&mut Connector) + Sync)]) {

			




	
	
	
		
 
// Given a set of tasks (where each is some function that interacts with a connector)

			




	
	
	
		
 
// run each task in in its own thread.

			




	
	
	
		
 
// print the log and OK/PANIC result of each thread

			




	
	
	
		
 
// then finally, return true IFF no threads panicked

			




	
	
	
		
 
fn do_all(i: &[&(dyn Fn(&mut Connector) + Sync)]) -> bool {

			




	
	
	
		
 
    let cid_iter = 0..(i.len() as ControllerId);

			




	
	
	
		
 
    let mut connectors = cid_iter

			




	
	
	
		
 
        .clone()

			




	
	
	
		
 
        .map(|controller_id| Connector::Unconfigured(Unconfigured { controller_id }))

			




	
	
	
		
 
        .collect::<Vec<_>>();

			




	
	
	
		
 

			




	
	
		
 
@@ -41,28 +58,26 @@ fn do_all(i: &[&(dyn Fn(&mut Connector) + Sync)]) {

			




	
	
	
		
 
        for h in handles {

			




	
	
	
		
 
            results.push(h.join());

			




	
	
	
		
 
        }

			




	
	
	
		
 
    })

			




	
	
	
		
 
    .unwrap();

			




	
	
	
		
 

			




	
	
	
		
 
    let mut failures = false;

			




	
	
	
		
 
    let mut alright = true;

			




	
	
	
		
 

			




	
	
	
		
 
    for ((controller_id, connector), res) in

			




	
	
	
		
 
        cid_iter.zip(connectors.iter_mut()).zip(results.into_iter())

			




	
	
	
		
 
    {

			




	
	
	
		
 
        println!("\n\n====================\n CID {:?} ...", controller_id);

			




	
	
	
		
 
        match connector.get_mut_logger() {

			




	
	
	
		
 
            Some(logger) => println!("{}", logger),

			




	
	
	
		
 
            None => println!("<No Log>"),

			




	
	
	
		
 
        }

			




	
	
	
		
 
        match res {

			




	
	
	
		
 
            Ok(()) => println!("CID {:?} OK!", controller_id),

			




	
	
	
		
 
            Err(e) => {

			




	
	
	
		
 
                failures = true;

			




	
	
	
		
 
                alright = false;

			




	
	
	
		
 
                println!("CI {:?} PANIC! {:?}", controller_id, Panicked(e));

			




	
	
	
		
 
            }

			




	
	
	
		
 
        };

			




	
	
	
		
 
    }

			




	
	
	
		
 
    if failures {

			




	
	
	
		
 
        panic!("FAILURES!");

			




	
	
	
		
 
    }

			




	
	
	
		
 
    alright

			




	
	
	
		
 
}

			




        

    


    
    

    

        

                

                    src/test/setup.rs
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
	
		
 
use super::*;

			




	
	
	
		
 
use crate::common::*;

			




	
	
	
		
 
use crate::runtime::*;

			




	
	
	
		
 

			




	
	
	
		
 
use PortBinding::*;

			




	
	
	
		
 

			




	
	
	
		
 
use super::*;

			




	
	
	
		
 

			




	
	
	
		
 
#[test]

			




	
	
	
		
 
fn config_ok_0() {

			




	
	
	
		
 
    let pdl = b"primitive main() {}";

			




	
	
	
		
 
    let d = ProtocolD::parse(pdl).unwrap();

			




	
	
	
		
 
    let pol = d.component_polarities(b"main").unwrap();

			




	
	
	
		
 
    assert_eq!(&pol[..], &[]);

			




	
	
		
 
@@ -25,87 +23,67 @@ fn config_ok_2() {

			




	
	
	
		
 
#[should_panic]

			




	
	
	
		
 
fn config_non_port() {

			




	
	
	
		
 
    let pdl = b"primitive main(in q, int q) {}";

			




	
	
	
		
 
    ProtocolD::parse(pdl).unwrap();

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
#[test]

			




	
	
	
		
 
fn bind_too_much() {

			




	
	
	
		
 
    let mut x = Connector::Unconfigured(Unconfigured { controller_id: 0 });

			




	
	
	
		
 
    x.configure(b"primitive main(in a) {}", b"main").unwrap();

			




	
	
	
		
 
    x.bind_port(0, Native).unwrap();

			




	
	
	
		
 
    assert!(x.bind_port(1, Native).is_err());

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
#[test]

			




	
	
	
		
 
fn config_and_connect_2() {

			




	
	
	
		
 
    let timeout = Duration::from_millis(1_500);

			




	
	
	
		
 
    let addrs = ["127.0.0.1:9000".parse().unwrap(), "127.0.0.1:9001".parse().unwrap()];

			




	
	
	
		
 
    use std::thread;

			




	
	
	
		
 
    let handles = vec![

			




	
	
	
		
 
        //

			




	
	
	
		
 
        thread::spawn(move || {

			




	
	
	
		
 
            let mut x = Connector::Unconfigured(Unconfigured { controller_id: 0 });

			




	
	
	
		
 
    let addrs = [next_addr(), next_addr()];

			




	
	
	
		
 
    assert!(do_all(&[

			




	
	
	
		
 
        &|x| {

			




	
	
	
		
 
            x.configure(b"primitive main(in a, out b) {}", b"main").unwrap();

			




	
	
	
		
 
            x.bind_port(0, Passive(addrs[0])).unwrap();

			




	
	
	
		
 
            x.bind_port(1, Passive(addrs[1])).unwrap();

			




	
	
	
		
 
            x.connect(timeout).unwrap();

			




	
	
	
		
 
        }),

			




	
	
	
		
 
        thread::spawn(move || {

			




	
	
	
		
 
            let mut x = Connector::Unconfigured(Unconfigured { controller_id: 1 });

			




	
	
	
		
 
        },

			




	
	
	
		
 
        &|x| {

			




	
	
	
		
 
            x.configure(b"primitive main(out a, in b) {}", b"main").unwrap();

			




	
	
	
		
 
            x.bind_port(0, Active(addrs[0])).unwrap();

			




	
	
	
		
 
            x.bind_port(1, Active(addrs[1])).unwrap();

			




	
	
	
		
 
            x.connect(timeout).unwrap();

			




	
	
	
		
 
        }),

			




	
	
	
		
 
    ];

			




	
	
	
		
 
    for h in handles {

			




	
	
	
		
 
        handle(h.join())

			




	
	
	
		
 
    }

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
#[test]

			




	
	
	
		
 
fn bind_too_much() {

			




	
	
	
		
 
    let mut x = Connector::Unconfigured(Unconfigured { controller_id: 0 });

			




	
	
	
		
 
    x.configure(b"primitive main(in a) {}", b"main").unwrap();

			




	
	
	
		
 
    x.bind_port(0, Native).unwrap();

			




	
	
	
		
 
    assert!(x.bind_port(1, Native).is_err());

			




	
	
	
		
 
        },

			




	
	
	
		
 
    ]));

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
#[test]

			




	
	
	
		
 
fn config_and_connect_chain() {

			




	
	
	
		
 
    let timeout = Duration::from_millis(1_500);

			




	
	
	
		
 
    let addrs = [

			




	
	
	
		
 
        "127.0.0.1:9002".parse().unwrap(),

			




	
	
	
		
 
        "127.0.0.1:9003".parse().unwrap(),

			




	
	
	
		
 
        "127.0.0.1:9004".parse().unwrap(),

			




	
	
	
		
 
    ];

			




	
	
	
		
 
    use std::thread;

			




	
	
	
		
 
    let handles = vec![

			




	
	
	
		
 
        //

			




	
	
	
		
 
        thread::spawn(move || {

			




	
	
	
		
 
    let addrs = [next_addr(), next_addr(), next_addr()];

			




	
	
	
		
 
    assert!(do_all(&[

			




	
	
	
		
 
        &|x| {

			




	
	
	
		
 
            // PRODUCER A->

			




	
	
	
		
 
            let mut x = Connector::Unconfigured(Unconfigured { controller_id: 0 });

			




	
	
	
		
 
            x.configure(b"primitive main(out a) {}", b"main").unwrap();

			




	
	
	
		
 
            x.bind_port(0, Active(addrs[0])).unwrap();

			




	
	
	
		
 
            x.connect(timeout).unwrap();

			




	
	
	
		
 
        }),

			




	
	
	
		
 
        thread::spawn(move || {

			




	
	
	
		
 
        },

			




	
	
	
		
 
        &|x| {

			




	
	
	
		
 
            // FORWARDER ->B->

			




	
	
	
		
 
            let mut x = Connector::Unconfigured(Unconfigured { controller_id: 1 });

			




	
	
	
		
 
            x.configure(b"primitive main(in a, out b) {}", b"main").unwrap();

			




	
	
	
		
 
            x.bind_port(0, Passive(addrs[0])).unwrap();

			




	
	
	
		
 
            x.bind_port(1, Active(addrs[1])).unwrap();

			




	
	
	
		
 
            x.connect(timeout).unwrap();

			




	
	
	
		
 
        }),

			




	
	
	
		
 
        thread::spawn(move || {

			




	
	
	
		
 
        },

			




	
	
	
		
 
        &|x| {

			




	
	
	
		
 
            // FORWARDER ->C->

			




	
	
	
		
 
            let mut x = Connector::Unconfigured(Unconfigured { controller_id: 2 });

			




	
	
	
		
 
            x.configure(b"primitive main(in a, out b) {}", b"main").unwrap();

			




	
	
	
		
 
            x.bind_port(0, Passive(addrs[1])).unwrap();

			




	
	
	
		
 
            x.bind_port(1, Active(addrs[2])).unwrap();

			




	
	
	
		
 
            x.connect(timeout).unwrap();

			




	
	
	
		
 
        }),

			




	
	
	
		
 
        thread::spawn(move || {

			




	
	
	
		
 
        },

			




	
	
	
		
 
        &|x| {

			




	
	
	
		
 
            // CONSUMER ->D

			




	
	
	
		
 
            let mut x = Connector::Unconfigured(Unconfigured { controller_id: 3 });

			




	
	
	
		
 
            x.configure(b"primitive main(in a) {}", b"main").unwrap();

			




	
	
	
		
 
            x.bind_port(0, Passive(addrs[2])).unwrap();

			




	
	
	
		
 
            x.connect(timeout).unwrap();

			




	
	
	
		
 
        }),

			




	
	
	
		
 
    ];

			




	
	
	
		
 
    for h in handles {

			




	
	
	
		
 
        handle(h.join())

			




	
	
	
		
 
    }

			




	
	
	
		
 
        },

			




	
	
	
		
 
    ]));

			




	
	
	
		
 
}

			




        

    



    


    



    



      

      





    
    0 comments (0 inline, 0 general)
    





    


  

  







  


    




    








    
        Server instance: kalli-1039567
    
    
        This site is powered by
            Kallithea,
        which is
        © 2010–2022 by various authors & licensed under GPLv3.
            – Support