#include <criterion/criterion.h>
#include <stdint.h>
#include "internal/ping/tracker.h"

Test(ping_tracker, init)
{
	struct ping_tracker	t;

	ping_tracker_init(&t);
	cr_assert_eq(t.nb_sent, (size_t)0);
	cr_assert_eq(t.nb_recv, (size_t)0);
	cr_assert_eq(t.nb_dup, (size_t)0);
}

Test(ping_tracker, basic_send_recv)
{
	struct ping_tracker	t;
	int					accepted;

	ping_tracker_init(&t);
	ping_tracker_record_send(&t, 1);
	accepted = ping_tracker_record_recv(&t, 1);
	cr_assert_eq(accepted, 1);
	cr_assert_eq(t.nb_sent, (size_t)1);
	cr_assert_eq(t.nb_recv, (size_t)1);
	cr_assert_eq(t.nb_dup, (size_t)0);
}

Test(ping_tracker, double_recv_is_dup)
{
	struct ping_tracker	t;
	int					accepted;

	ping_tracker_init(&t);
	ping_tracker_record_send(&t, 5);
	accepted = ping_tracker_record_recv(&t, 5);
	cr_assert_eq(accepted, 1, "First recv should be accepted");
	accepted = ping_tracker_record_recv(&t, 5);
	cr_assert_eq(accepted, 0, "Duplicate recv should return 0");
	cr_assert_eq(t.nb_recv, (size_t)1);
	cr_assert_eq(t.nb_dup, (size_t)1);
}

Test(ping_tracker, unknown_seq_accepted)
{
	struct ping_tracker	t;
	int					accepted;

	ping_tracker_init(&t);
	accepted = ping_tracker_record_recv(&t, 42);
	cr_assert_eq(accepted, 1);
	cr_assert_eq(t.nb_recv, (size_t)1);
}

Test(ping_tracker, lost_count)
{
	struct ping_tracker	t;

	ping_tracker_init(&t);
	ping_tracker_record_send(&t, 1);
	ping_tracker_record_send(&t, 2);
	ping_tracker_record_send(&t, 3);
	ping_tracker_record_recv(&t, 2);
	cr_assert_eq(t.nb_sent, (size_t)3);
	cr_assert_eq(t.nb_recv, (size_t)1);
	cr_assert_eq(t.nb_sent - t.nb_recv, (size_t)2);
}

Test(ping_tracker, sent_count_increments)
{
	struct ping_tracker	t;

	ping_tracker_init(&t);
	ping_tracker_record_send(&t, 1);
	ping_tracker_record_send(&t, 2);
	ping_tracker_record_send(&t, 3);
	cr_assert_eq(t.nb_sent, (size_t)3);
}

Test(ping_tracker, no_slot_collision_at_256)
{
	struct ping_tracker	t;
	uint16_t			seq;

	ping_tracker_init(&t);
	for (seq = 0; seq < 256; seq++)
	{
		ping_tracker_record_send(&t, seq);
		cr_assert_eq(ping_tracker_record_recv(&t, seq), 1,
				"seq %u should be accepted", (unsigned)seq);
	}
	cr_assert_eq(t.nb_recv, (size_t)256);
}

Test(ping_tracker, full_seq_space)
{
	struct ping_tracker	t;
	uint32_t			seq;

	ping_tracker_init(&t);
	for (seq = 0; seq < 65536; seq++)
		ping_tracker_record_send(&t, (uint16_t)seq);
	cr_assert_eq(t.nb_sent, (size_t)65536);
}