// name memory location

    let (created_key, created_runtime_component) = sched_ctx.runtime.finish_create_component(

        reservation, component_instance, created_ctx, false

    );

    let created_ctx = &mut created_runtime_component.ctx;

    let created_component = &mut created_runtime_component.component;

    created_component.on_creation(created_key.downgrade(), sched_ctx);

    // Transfer messages and link instantiator to created component

    for pair in port_pairs.iter() {

        instantiator_ctx.change_port_peer(sched_ctx, pair.instantiator_handle, None);

        transfer_messages(inbox_main, inbox_backup, pair, instantiator_ctx, created_ctx, created_component.as_mut());

        let created_port_info = created_ctx.get_port(pair.created_handle);

        if pair.is_open && created_port_info.peer_comp_id == instantiator_ctx.id {

            // Set up channel between instantiator component port, and its peer,

            // which is owned by the new component

            let instantiator_port_handle = instantiator_ctx.get_port_handle(created_port_info.peer_port_id);

            let instantiator_port_info = instantiator_ctx.get_port_mut(instantiator_port_handle);

            instantiator_port_info.peer_port_id = created_port_info.self_id;

            instantiator_ctx.change_port_peer(sched_ctx, instantiator_port_handle, Some(created_ctx.id));

        }

    }

    );

    let created_ctx = &mut created_runtime_component.ctx;

    let created_component = &mut created_runtime_component.component;

    created_component.on_creation(created_key.downgrade(), sched_ctx);

    // We now pass along the messages that the instantiator component still has

    // that belong to the new component. At the same time we'll take care of

    // setting the correct peer of the instantiator component

    for pair in port_pairs.iter() {

        // Transferring the messages and removing the port from the

        // instantiator component

        instantiator_ctx.change_port_peer(sched_ctx, pair.instantiator_handle, None);

        transfer_messages(inbox_main, inbox_backup, pair, instantiator_ctx, created_ctx, created_component.as_mut());

        // Here we take care of the case where the instantiator previously owned

        // both ends of the channel, but has transferred one port to the new

        // component (hence creating a channel between the instantiator

        // component and the new component).

        let created_port_info = created_ctx.get_port(pair.created_handle);

        if pair.is_open && created_port_info.peer_comp_id == instantiator_ctx.id {

            // Note: the port we're receiving here belongs to the instantiator

            // and is NOT in the "port_pairs" array.

            let instantiator_port_handle = instantiator_ctx.get_port_handle(created_port_info.peer_port_id);

            let instantiator_port_info = instantiator_ctx.get_port_mut(instantiator_port_handle);

            instantiator_port_info.peer_port_id = created_port_info.self_id;

    import std.internet as inet;

    comp fake_listener_once(out<inet::TcpConnection> tx) {

        channel cmd_tx -> cmd_rx;

        channel data_tx -> data_rx;

        new fake_socket(cmd_rx, data_tx);

        sync put(tx, inet::TcpConnection{

            tx: cmd_tx,

            rx: data_rx,

        });

    }

        auto to_send = {};

        auto shutdown = false;

        while (!shutdown) {

            auto keep_going = true;

            sync {

                while (keep_going) {

                    auto cmd = get(cmds);

                        to_send = data;

                        keep_going = false;

                        put(tx, to_send);

                        keep_going = false;

                        keep_going = false;

                        shutdown = true;

                    }

                }

            }

        }

    }

    comp fake_client(inet::TcpConnection conn) {

        sync {

            auto val = get(conn.rx);

            while (val[0] != 1 || val[1] != 3 || val[2] != 3 || val[3] != 7) {

                print(\"this is going very wrong\");

            }

        }

    }

    comp constructor() {

        channel conn_tx -> conn_rx;

        new fake_listener_once(conn_tx);

        // Same crap as before:

        channel cmd_tx -> unused_cmd_rx;

        channel unused_data_tx -> data_rx;

        auto connection = inet::TcpConnection{ tx: cmd_tx, rx: data_rx };

        sync {

        new random_taker(rx, num_values);

    }

    ").expect("compilation");

    let rt = Runtime::new(1, LOG_LEVEL, pd).unwrap();

    create_component(&rt, "", "constructor", no_args());

}

#[test]

fn test_tcp_socket_http_request() {

    let _pd = ProtocolDescription::parse(b"

    import std.internet::*;

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

        sync {

        }

        print(\"*** TCPSocket: Receiving response\");

        auto buffer = {};

        auto done_receiving = false;

        sync while (!done_receiving) {

            auto data = get(data_rx);

            buffer @= data;

            // Completely crap detection of end-of-document. But here we go, we

            // try to detect the trailing </html>. Proper way would be to parse

            // for 'content-length' or 'content-encoding'

            s32 index = 0;

            s32 partial_length = cast(length(data) - 7);

            while (index < partial_length) {

                // No string conversion yet, so check byte buffer one byte at

                // a time.

                auto c1 = data[index];

                if (c1 == cast('<')) {

                    auto c2 = data[index + 1];

                    auto c3 = data[index + 2];

                    auto c4 = data[index + 3];

                    auto c5 = data[index + 4];

                    auto c6 = data[index + 5];

                    auto c7 = data[index + 6];

                    if ( // i.e. if (data[index..] == '</html>'

                        c2 == cast('/') && c3 == cast('h') && c4 == cast('t') &&

                        c5 == cast('m') && c6 == cast('l') && c7 == cast('>')

                    ) {

                        print(\"*** TCPSocket: Detected </html>\");

                        done_receiving = true;

                    }

                }

                index += 1;

            }

        }

        print(\"*** TCPSocket: Requesting shutdown\");

        sync {

        }

    }

    comp main() {

        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

        new requester(cmd_tx, data_rx);

    }

    ").expect("compilation");

    // This test is disabled because it performs a HTTP request to google.

    // create_component(&rt, "", "main", no_args());

}

#[test]

fn test_sending_receiving_union() {

    let pd = ProtocolDescription::parse(b"

    union Cmd {

        Set(u8[]),

        Get,

        Shutdown,

    }

#module std.internet

union ClientCmd {

    Send(u8[]),

    Receive,

    Finish,

    Shutdown,

}

    #builtin

}

union ListenerCmd {

    Accept,

    Shutdown,

}

struct TcpConnection {

    in<u8[]> rx,

}

/* comp tcp_listener(u8[] ip, u16 port, in<ListenerCmd> cmds, out<TcpConnection> rx) {

    #builtin

} */