**/*.rs.bk

Cargo.lock

main

examples/*/*.exe

examples/*.dll

examples/reowolf*

logs

        serde_proto_description: SerdeProtocolDescription(

            (A big honkin' protocol description),

        ),

        port_info: PortInfo {

            polarities: {

            },

            peers: {

            },

            routes: {

                    Native,

                ),

                    Native,

                ),

            },

        },

        proto_components: {},

    },

}

	connector_put_bytes(c, putter, "hello", 5);

	// connector_get(c, getter);

	int err = connector_sync(c, 5000);

	printf("Error code %d with string `%s`\n", err, reowolf_error_peek(NULL));

	printf("Let's try again, doing both\n");

	connector_put_bytes(c, putter, "hello", 5);

	connector_get(c, getter);

	err = connector_sync(c, 5000);

	printf("Error code %d with string `%s`\n", err, reowolf_error_peek(NULL));

	size_t msg_len;

	const char * msg_ptr = connector_gotten_bytes(c, getter, &msg_len);

	printf("Got msg `%.*s`\n", msg_len, msg_ptr);

	protocol_description_destroy(pd);

	connector_destroy(c);

	free(pdl_ptr);

	return 0;

}

mod macros;

mod common;

mod protocol;

mod runtime;

pub use protocol::ProtocolDescription;

pub use runtime::{error, Connector, DummyLogger, FileLogger, VecLogger};

                    Route::LocalComponent(ComponentId::Native),

                    predicate.clone(),

                );

            }

            let branch = NativeBranch { index, gotten: Default::default(), to_get };

            if let Some(existing) = branching_native.branches.insert(predicate, branch) {

                return Err(Se::IndistinguishableBatches([index, existing.index]));

            }

        }

        let decision = Self::sync_reach_decision(

            cu,

            comm,

            &mut branching_native,

            &mut branching_proto_components,

            solution_storage,

                    log!(cu.logger, "No parent. Deciding on failure");

                    return Ok(Decision::Failure);

                }

            }

        }

        log!(cu.logger, "Done translating native batches into branches");

        // run all proto components to their sync blocker

        log!(

            cu.logger,

            "Running all {} proto components to their sync blocker...",

            branching_proto_components.len()

mod communication;

mod endpoints;

pub mod error;

mod logging;

mod setup;

#[cfg(test)]

mod tests;

use crate::common::*;

use error::*;

    };

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

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

    SocketAddrV4::new(Ipv4Addr::LOCALHOST, port).into()

}

fn file_logged_connector(connector_id: ConnectorId, dir_path: &Path) -> Connector {

    let _ = std::fs::create_dir(dir_path); // we will check failure soon

    let path = dir_path.join(format!("cid_{:?}.txt", connector_id));

    let file = File::create(path).unwrap();

    let file_logger = Box::new(FileLogger::new(connector_id, file));

    Connector::new(file_logger, MINIMAL_PROTO.clone(), connector_id, 8)

}

//////////////////////////////////////////

#[test]

fn basic_connector() {

    Connector::new(Box::new(DummyLogger), MINIMAL_PROTO.clone(), 0, 0);

}

#[test]

fn put_no_sync() {

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

    let mut c = file_logged_connector(0, test_log_path);

    let [o, _] = c.new_port_pair();

    c.connect(Some(Duration::from_secs(1))).unwrap();

}

#[test]

fn wrong_polarity_bad() {

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

    let mut c = file_logged_connector(0, test_log_path);

    let [_, i] = c.new_port_pair();

    c.connect(Some(Duration::from_secs(1))).unwrap();

}

#[test]

fn dup_put_bad() {

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

    let mut c = file_logged_connector(0, test_log_path);

    let [o, _] = c.new_port_pair();

    c.connect(Some(Duration::from_secs(1))).unwrap();

}

#[test]

fn trivial_sync() {

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

    let mut c = file_logged_connector(0, test_log_path);

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

    let mut c = file_logged_connector(0, test_log_path);

    let [o, i] = c.new_port_pair();

    c.connect(Some(Duration::from_secs(1))).unwrap();

    // fail...

    c.get(o).unwrap_err();

    // succeed..

    c.get(i).unwrap();

}

#[test]

fn native_multiple_gets() {

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

    let mut c = file_logged_connector(0, test_log_path);

fn native_self_msg() {

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

    let mut c = file_logged_connector(0, test_log_path);

    let [o, i] = c.new_port_pair();

    c.connect(Some(Duration::from_secs(1))).unwrap();

    c.get(i).unwrap();

    c.sync(Some(Duration::from_secs(1))).unwrap();

}

#[test]

fn two_natives_msg() {

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

            c.gotten(g).unwrap();

        });

        s.spawn(|_| {

            let mut c = file_logged_connector(1, test_log_path);

            let p = c.new_net_port(Putter, sock_addr, Passive).unwrap();

            c.connect(Some(Duration::from_secs(1))).unwrap();

            c.sync(Some(Duration::from_secs(1))).unwrap();

        });

    })

    .unwrap();

}

            c.gotten(g).unwrap();

        });

        s.spawn(|_| {

            let mut c = file_logged_connector(1, test_log_path);

            let p = c.new_net_port(Putter, sock_addr, Passive).unwrap();

            c.connect(Some(Duration::from_secs(1))).unwrap();

            c.sync(Some(Duration::from_secs(1))).unwrap();

        });

    })

    .unwrap();

}

    let [_, g] = c.new_port_pair();

    c.connect(Some(Duration::from_secs(1))).unwrap();

    c.get(g).unwrap();

    c.sync(Some(Duration::from_secs(30))).unwrap_err();

}

#[test]

fn cannot_use_moved_ports() {

    /*

    native p|-->|g sync

    */

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

    let mut c = file_logged_connector(0, test_log_path);

    let [p, g] = c.new_port_pair();

    c.add_component(b"sync", &[g, p]).unwrap();

    c.connect(Some(Duration::from_secs(1))).unwrap();

    c.get(g).unwrap_err();

}

#[test]

fn sync_sync() {

    /*

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

    let mut c = file_logged_connector(0, test_log_path);

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

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

    c.add_component(b"sync", &[g0, p1]).unwrap();

    c.connect(Some(Duration::from_secs(1))).unwrap();

    c.get(g1).unwrap();

    c.sync(Some(Duration::from_secs(1))).unwrap();

    c.gotten(g1).unwrap();

}

#[test]

            let mut c = file_logged_connector(1, test_log_path);

            let [g, p] = [

                c.new_net_port(Getter, sock_addrs[0], Passive).unwrap(),

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

            ];

            c.connect(Some(Duration::from_secs(1))).unwrap();

            c.get(g).unwrap();

            c.sync(Some(Duration::from_secs(1))).unwrap();

            c.gotten(g).unwrap();

        });

    })

    .unwrap();