}

// Note that we will have function definitions for builtin functions as well. In

// that case the span, the identifier span and the body are all invalid.

#[derive(Debug)]

                                // TODO: Once we start generating bytecode this is unnecessary

                                let procedure_id = proc_def.this;

                                let method = match proc_def.source {

                                    ProcedureSource::FuncGet => Method::Get,

                                    ProcedureSource::FuncPut => Method::Put,

                                    ProcedureSource::FuncFires => Method::Fires,

    Tester::new_single_source_expect_ok(

        "guard variable decl",

        "

            channel<u32> unused -> input;

            u32 outer_value = 0;

    Tester::new_single_source_expect_ok(

        "empty select",

    );

    Tester::new_single_source_expect_ok(

        "mixed uses", "

            channel unused_output -> input;

            u32 outer_value = 0;

            sync select {

fn test_incorrect_select_statement() {

    Tester::new_single_source_expect_err(

        "outside sync",

    ).error(|e| { e

        .assert_num(1)

        .assert_occurs_at(0, "select")

    Tester::new_single_source_expect_err(

        "variable in previous block",

            channel<u32> tx -> rx;

            u32 a = 0; // this one will be shadowed

            sync select { auto a = get(rx) -> {} }

    Tester::new_single_source_expect_err(

        "put inside arm",

            channel<u32> a -> b;

            sync select { put(a) -> {} }

        }"

    Tester::new_single_source_expect_err(

        "goto jumping outside sync",

            sync { goto exit; }

            exit: u32 v = 0;

        }"

    Tester::new_single_source_expect_err(

        "goto jumping to select case",

            sync select {

                hello: auto a = get(i) -> i += 1

            }

    Tester::new_single_source_expect_err(

        "goto jumping into select case skipping variable",

            goto waza;

            sync select {

                auto a = get(i) -> {

    Tester::new_single_source_expect_err(

        "break outside of sync",

            outer: while (true) { //mark

                sync while(true) { break outer; }

            }

#[test]

fn test_put_and_get() {

    const CODE: &'static str = "

        u32 index = 0;

        while (index < loops) {

            sync {

#[test]

fn test_getting_from_component() {

    const CODE: &'static str ="

        while (cur < last) {

            sync {

                put(numbers, cur);

#[test]

fn test_putting_to_component() {

    const CODE: &'static str = "

        while (cur < last) {

            sync {

                auto number = get(numbers);

#[test]

fn test_doing_nothing() {

    const CODE: &'static str = "

        u32 index = 0;

        while (index < num_loops) {

            sync {}

    // If this thing does not get into an infinite loop, (hence: the runtime

    // exits), then the test works

    const CODE: &'static str ="

        u32 index = 0;

        while (index < loops) {

            sync { index += 1; }

#[test]

fn test_single_put_and_get() {

    const CODE: &'static str = "

        u32 index = 0;

        while (index < loops) {

            sync {

        }

    }

        u32 index = 0;

        while (index < loops) {

            sync {

#[test]

fn test_combined_put_and_get() {

    const CODE: &'static str = "

        u32 index = 0;

        while (index < num_loops) {

            sync {

        }

    }

        channel output_a -> input_a;

        channel output_b -> input_b;

        new put_then_get(output_a, input_b, num_loops);

#[test]

fn test_multi_put_and_get() {

    const CODE: &'static str = "

        u32 index = 0;

        while (index < num_loops) {

            sync {

        }

    }

        u32 loop_index = 0;

        while (loop_index < num_loops) {

            sync {

#[test]

fn test_star_shaped_request() {

    const CODE: &'static str = "

        u32 index = 0;

        while (index < loops) {

            sync {

        }

    }

        u32 loop_index = 0;

        auto num_edges = length(requests);

        }

    }

        auto requests = {};

        auto responses = {};

#[test]

fn test_conga_line_request() {

    const CODE: &'static str = "

        u32 loop_index = 0;

        u32 initial_value = 1337;

        while (loop_index < num_loops) {

        }

    }

        in<u32> req_in, out<u32> req_forward,

        in<u32> resp_in, out<u32> resp_forward,

        u32 num_loops

        }

    }

        u32 loop_index = 0;

        while (loop_index < num_loops) {

            sync {

        }

    }

        channel initial_req -> req_in;

        channel resp_out -> final_resp;

        new start(initial_req, final_resp, num_nodes, num_loops);

    // somehow not allowed. Note that we "check" by seeing if the test finishes.

    // Only the branches in which ports fire increment the loop index

    const CODE: &'static str = "

        u32 index = 0;

        while (index < num_loops) {

            sync { put(output, true); }

        }

    }

        u32 index = 0;

        while (index < num_loops) {

            sync {

        }

    }

        u32 index = 0;

        while (index < num_loops) {

            sync { auto res = get(input); assert(res); }

        }

    }

        u32 index = 0;

        while (index < num_loops) {

            sync fork { auto res = get(input); assert(res); index += 1; } or {}

    // If the component exits cleanly, then the runtime exits cleanly, and the

    // test will finish

    const CODE: &'static str = "

        u32[] only_allows_index_0 = { 1 };

        while (true) sync { // note the infinite loop

            auto value = only_allows_index_0[1];

        }

    }

        u32[] only_allows_index_0 = { 1 };

        auto never_gonna_get = only_allows_index_0[1];

        while (true) sync {}

const SHARED_SYNC_CODE: &'static str = "

enum Location { BeforeSync, AfterPut, AfterGet, AfterSync, Never }

    u32[] failure_array = {};

    while (true) {

        if (loc == Location::BeforeSync) failure_array[0];

    }

}

    channel output_a -> input_a;

    channel output_b -> input_b;

    new failing_at_location(input_b, output_a, loc);

    new failing_at_location(input_a, output_b, Location::Never);

}

    channel output_a -> input_a;

    channel output_b -> input_b;

    new failing_at_location(input_b, output_a, Location::Never);

    new failing_at_location(input_a, output_b, loc);

}

    channel output_first -> input_old;

    channel output_cur -> input_new;

    // Iterating over ports by index to work around borrowing rules

    for port_index in 0..comp_ctx.num_ports() {

        let port = comp_ctx.get_port_by_index_mut(port_index);

        if port.state.is_closed() || port.state.is_set(PortStateFlag::Transmitted) || port.close_at_sync_end {

            // Already closed, or in the process of being closed

            continue;

#[test]

fn test_unconnected_component_error() {

    compile_and_create_component("

        u8[] array = { 5 };

        auto value = array[1];

    }", "interact_with_noone", no_args());

#[test]

fn test_connected_uncommunicating_component_error() {

    compile_and_create_component("

        u8[] array = { 1337 };

        auto value = array[1337];

    }

        sync auto a = get(never_providing);

    }

        // Test one way

        // channel a -> b;

        // new sitting_idly_waiting(b);

#[test]

fn test_connected_communicating_component_error() {

    compile_and_create_component("

        u8[] array = {};

        sync {

            put(tx, 0);

            array[0] = 5;

        }

    }

        sync auto a = get(rx);

    }

        channel a -> b;

        new send_and_fail(a);

        new receive_once(b);

#[test]

fn test_failing_after_successful_sync() {

    compile_and_create_component("

        {

            channel a -> b;

            new put_and_fail(a);

    compile_and_create_component("

    import std.internet as inet;

        channel cmd_tx -> cmd_rx;

        channel data_tx -> data_rx;

        sync put(tx, inet::TcpConnection{

            tx: cmd_tx,

            rx: data_rx,

        });

    }

        auto to_send = {};

        auto shutdown = false;

            auto keep_going = true;

            sync {

                while (keep_going) {

                    if (let inet::Cmd::Send(data) = cmd) {

                        to_send = data;

                        put(tx, to_send);

                    } else if (let inet::Cmd::Finish = cmd) {

                        keep_going = false;

        }

    }

        sync put(conn.tx, inet::Cmd::Send({1, 3, 3, 7}));

        sync {

            put(conn.tx, inet::Cmd::Receive);

        sync put(conn.tx, inet::Cmd::Shutdown);

    }

        channel conn_tx -> conn_rx;

        new fake_listener_once(conn_tx);

#[test]

fn test_component_communication() {

    let pd = ProtocolDescription::parse(b"

        u32 outside_index = 0;

        while (outside_index < outside_loops) {

            u32 inside_index = 0;

        }

    }

        u32 outside_index = 0;

        while (outside_index < outside_loops) {

            u32 inside_index = 0;

        }

    }

        channel o_orom -> i_orom;

        channel o_mrom -> i_mrom;

        channel o_ormm -> i_ormm;

#[test]

fn test_send_to_self() {

    compile_and_create_component("

        channel a -> b;

        sync {

            put(a, 1);

#[test]

fn test_intermediate_messenger() {

    let pd = ProtocolDescription::parse(b"

        auto index = 0;

        while (index < num) {

            sync { auto v = get(rx); }

        }

    }

        auto index = 0;

        while (index < num) {

            sync { put(tx, get(rx)); }

        }

    }

        auto index = 0;

        while (index < num) {

            sync put(tx, 1337);

        }

    }

        auto num = 0;

        channel<T> tx_a -> rx_a;

        channel tx_b -> rx_b;

        new receiver(rx_b, 3);

    }

        new constructor_template<u16>();

        new constructor_template<u32>();

        new constructor_template<u64>();

#[test]

fn test_component_creation() {

    let pd = ProtocolDescription::parse(b"

        s32 a = 5;

        auto b = 5 + a;

    }

        return ();

    }

        auto num_from_a = 0;

        auto num_from_b = 0;

        while (num_from_a + num_from_b < 2 * num_sends) {

        }

    }

        auto index = 0;

        while (index < num_sends) {

            sync {

        }

    }

        auto num_sends = 1;

        channel tx_a -> rx_a;

        channel tx_b -> rx_b;

#[test]

fn test_unguarded_select() {

    let pd = ProtocolDescription::parse(b"

        u32 index = 0;

        while (index < 5) {

            sync select { auto v = () -> print(\"hello\"); }

        }

    }

        u32 index = 0;

        while (index < 5) {

            sync select { auto v = () -> index += 1; }

#[test]

fn test_empty_select() {

    let pd = ProtocolDescription::parse(b"

        u32 index = 0;

        while (index < 5) {

            sync select {}

    let pd = ProtocolDescription::parse(b"

    import std.random::random_u32;

        auto i = 0;

        while (i < num_values) {

            sync {

        }

    }

        channel tx -> rx;

        auto num_values = 25;

        new random_u32(tx, 1, 100, num_values);

    let _pd = ProtocolDescription::parse(b"

    import std.internet::*;

        print(\"*** TCPSocket: Sending request\");

        sync {

            put(cmd_tx, Cmd::Send(b\"GET / HTTP/1.1\\r\\n\\r\\n\"));

        }

    }

        channel cmd_tx -> cmd_rx;

        channel data_tx -> data_rx;

        new tcp_client({142, 250, 179, 163}, 80, cmd_rx, data_tx); // port 80 of google

        Shutdown,

    }

        auto stored = {};

        auto done = false;

        while (!done) {

        }

    }

        auto round = 0;

        while (round < num_rounds) {

            auto set_value = b\"hello there\";

        sync put(tx, Cmd::Shutdown);

    }

        auto num_rounds = 5;

        channel cmd_tx -> cmd_rx;

        channel data_tx -> data_rx;

#[test]

fn test_transfer_precreated_port_with_owned_peer() {

    compile_and_create_component("

        channel a -> b;

        sync put(tx, b);

    }

        sync auto a = get(rx);

    }

        channel a -> b;

        new port_sender(a);

        new port_receiver(b);

    ", "constructor", no_args());

}

#[test]

fn test_transfer_precreated_port_with_foreign_peer() {

    compile_and_create_component("

        sync put(tx, to_send);

    }

        sync auto a = get(rx);

    }

        channel tx -> rx;

        channel forgotten -> to_send;

        new port_sender(tx, to_send);

#[test]

fn test_transfer_synccreated_port() {

    compile_and_create_component("

        sync {

            channel a -> b;

            put(tx, b);

        }

    }

        sync auto a = get(rx);

    }

        channel a -> b;

        new port_sender(a);

        new port_receiver(b);

#[test]

fn test_transfer_precreated_port_with_owned_peer_and_communication() {

    compile_and_create_component("

        channel a -> b;

        sync put(tx, b);

        sync put(a, 1337);

    }

        channel a -> b; // this is stupid, but we need to have a variable to use

        sync b = get(rx);

        u32 value = 0;

        sync value = get(b);

        while (value != 1337) {}

    }

        channel a -> b;

        new port_sender(a);

        new port_receiver(b);

#[test]

fn test_transfer_precreated_port_with_foreign_peer_and_communication() {

    compile_and_create_component("