Example #1
0
    static void stats_initialize()
    {
        Console.Write("initializing\n");

        reliable.init();

        global_context = new test_context_t();

        reliable.default_config(out var client_config);
        reliable.default_config(out var server_config);

        client_config.fragment_above = MAX_PACKET_BYTES;
        server_config.fragment_above = MAX_PACKET_BYTES;

        client_config.name    = "client";
        client_config.context = global_context;
        client_config.index   = 0;
        client_config.transmit_packet_function = test_transmit_packet_function;
        client_config.process_packet_function  = test_process_packet_function;

        server_config.name    = "server";
        server_config.context = global_context;
        server_config.index   = 1;
        server_config.transmit_packet_function = test_transmit_packet_function;
        server_config.process_packet_function  = test_process_packet_function;

        global_context.client = reliable.endpoint_create(client_config, global_time);
        global_context.server = reliable.endpoint_create(server_config, global_time);
    }
Example #2
0
        static void test_packets()
        {
            var time = 100.0;

            var context = new test_context_t();

            default_config(out var sender_config);
            default_config(out var receiver_config);

            sender_config.fragment_above   = 500;
            receiver_config.fragment_above = 500;

            sender_config.name    = "sender";
            sender_config.context = context;
            sender_config.index   = 0;
            sender_config.transmit_packet_function = test_transmit_packet_function;
            sender_config.process_packet_function  = test_process_packet_function_validate;

            receiver_config.name    = "receiver";
            receiver_config.context = context;
            receiver_config.index   = 1;
            receiver_config.transmit_packet_function = test_transmit_packet_function;
            receiver_config.process_packet_function  = test_process_packet_function_validate;

            context.sender   = endpoint_create(sender_config, time);
            context.receiver = endpoint_create(receiver_config, time);

            const double delta_time = 0.1;

            int i;

            for (i = 0; i < 16; ++i)
            {
                {
                    var packet_data  = new byte[TEST_MAX_PACKET_BYTES];
                    var sequence     = endpoint_next_packet_sequence(context.sender);
                    var packet_bytes = generate_packet_data(sequence, packet_data);
                    endpoint_send_packet(context.sender, packet_data, packet_bytes);
                }

                {
                    var packet_data  = new byte[TEST_MAX_PACKET_BYTES];
                    var sequence     = endpoint_next_packet_sequence(context.sender);
                    var packet_bytes = generate_packet_data(sequence, packet_data);
                    endpoint_send_packet(context.sender, packet_data, packet_bytes);
                }

                endpoint_update(context.sender, time);
                endpoint_update(context.receiver, time);

                endpoint_clear_acks(context.sender);
                endpoint_clear_acks(context.receiver);

                time += delta_time;
            }

            endpoint_destroy(ref context.sender);
            endpoint_destroy(ref context.receiver);
        }
Example #3
0
        static void test_sequence_buffer_rollover()
        {
            var time = 100.0;

            var context = new test_context_t();

            default_config(out var sender_config);
            default_config(out var receiver_config);

            sender_config.fragment_above   = 500;
            receiver_config.fragment_above = 500;

            sender_config.name    = "sender";
            sender_config.context = context;
            sender_config.index   = 0;
            sender_config.transmit_packet_function = test_transmit_packet_function;
            sender_config.process_packet_function  = test_process_packet_function;

            receiver_config.name    = "receiver";
            receiver_config.context = context;
            receiver_config.index   = 1;
            receiver_config.transmit_packet_function = test_transmit_packet_function;
            receiver_config.process_packet_function  = test_process_packet_function;

            context.sender   = endpoint_create(sender_config, time);
            context.receiver = endpoint_create(receiver_config, time);

            int num_packets_sent = 0;
            int i;

            for (i = 0; i <= 32767; ++i)
            {
                var packet_data  = new byte[16];
                var packet_bytes = 16;
                endpoint_next_packet_sequence(context.sender);
                endpoint_send_packet(context.sender, packet_data, packet_bytes);

                ++num_packets_sent;
            }

            {
                var packet_data  = new byte[TEST_MAX_PACKET_BYTES];
                var packet_bytes = TEST_MAX_PACKET_BYTES;
                endpoint_next_packet_sequence(context.sender);
                endpoint_send_packet(context.sender, packet_data, packet_bytes);
                ++num_packets_sent;
            }

            var receiver_counters = endpoint_counters(context.receiver);

            check(receiver_counters[ENDPOINT_COUNTER_NUM_PACKETS_RECEIVED] == (ushort)num_packets_sent);
            check(receiver_counters[ENDPOINT_COUNTER_NUM_FRAGMENTS_INVALID] == 0);

            endpoint_destroy(ref context.sender);
            endpoint_destroy(ref context.receiver);
        }
Example #4
0
        static void test_acks_packet_loss()
        {
            var time = 100.0;

            var context = new test_context_t();

            default_config(out var sender_config);
            default_config(out var receiver_config);

            sender_config.context = context;
            sender_config.index   = 0;
            sender_config.transmit_packet_function = test_transmit_packet_function;
            sender_config.process_packet_function  = test_process_packet_function;

            receiver_config.context = context;
            receiver_config.index   = 1;
            receiver_config.transmit_packet_function = test_transmit_packet_function;
            receiver_config.process_packet_function  = test_process_packet_function;

            context.sender   = endpoint_create(sender_config, time);
            context.receiver = endpoint_create(receiver_config, time);

            const double delta_time = 0.1;

            int i;

            for (i = 0; i < TEST_ACKS_NUM_ITERATIONS; ++i)
            {
                var dummy_packet = new byte[8];

                context.drop = (i % 2) != 0;

                endpoint_send_packet(context.sender, dummy_packet, dummy_packet.Length);
                endpoint_send_packet(context.receiver, dummy_packet, dummy_packet.Length);

                endpoint_update(context.sender, time);
                endpoint_update(context.receiver, time);

                time += delta_time;
            }

            var sender_acked_packet = new byte[TEST_ACKS_NUM_ITERATIONS];
            var sender_acks         = endpoint_get_acks(context.sender, out var sender_num_acks);

            for (i = 0; i < sender_num_acks; ++i)
            {
                if (sender_acks[i] < TEST_ACKS_NUM_ITERATIONS)
                {
                    sender_acked_packet[sender_acks[i]] = 1;
                }
            }
            for (i = 0; i < TEST_ACKS_NUM_ITERATIONS / 2; ++i)
            {
                check(sender_acked_packet[i] == (i + 1) % 2);
            }

            var receiver_acked_packet = new byte[TEST_ACKS_NUM_ITERATIONS];
            var receiver_acks         = endpoint_get_acks(context.sender, out var receiver_num_acks);

            for (i = 0; i < receiver_num_acks; ++i)
            {
                if (receiver_acks[i] < TEST_ACKS_NUM_ITERATIONS)
                {
                    receiver_acked_packet[receiver_acks[i]] = 1;
                }
            }
            for (i = 0; i < TEST_ACKS_NUM_ITERATIONS / 2; ++i)
            {
                check(receiver_acked_packet[i] == (i + 1) % 2);
            }

            endpoint_destroy(ref context.sender);
            endpoint_destroy(ref context.receiver);
        }