loic/net-tools
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

test: add more tests

Browse source
This commit is contained in:
lohhiiccc 2026-03-16 22:19:34 +01:00
parent 743caab482
commit f0ecfa5ce9
7 changed files with 214 additions and 0 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
sources/ping.mk
View file

@ -55,8 +55,12 @@ PING_TESTS = $(PING_TESTS_DIR)/test_main.c \
$(PING_TESTS_DIR)/cli/handlers/test_handle_ttl.c \
$(PING_TESTS_DIR)/cli/handlers/test_handle_version.c \
$(PING_TESTS_DIR)/cli/handlers/test_handle_verbose.c \
$(PING_TESTS_DIR)/cli/handlers/test_handle_dont_fragment.c \
$(PING_TESTS_DIR)/cli/handlers/test_handle_deadline.c \
$(PING_TESTS_DIR)/cli/parse_utils/test_parse_int.c \
$(PING_TESTS_DIR)/cli/parse_utils/test_parse_float.c \
$(PING_TESTS_DIR)/cli/parse_utils/test_parse_inet_addr.c \
$(PING_TESTS_DIR)/cli/parse_utils/test_parse_destinations.c \
$(PING_TESTS_DIR)/ping/stats/test_stats.c \
$(PING_TESTS_DIR)/ping/tracker/test_tracker.c \

22
tests/cli/handlers/test_handle_deadline.c Normal file
View file

@ -0,0 +1,22 @@
#include <criterion/criterion.h>
#include "ping/cli.h"
#include "internal/ping/cli_handlers.h"
Test(cli_handle_deadline, valid_number)
{
struct ping_config config = {0};
const char *arg = "1.5";
int ret = cli_handle_deadline(arg, &config);
cr_assert_eq(ret, CLI_SUCCESS);
cr_assert_float_eq(config.deadline, 1.5, .001);
}
Test(cli_handle_deadline, invalid_number)
{
struct ping_config config = {0};
const char *arg = "-1";
int ret = cli_handle_deadline(arg, &config);
cr_assert_eq(ret, CLI_ERROR);
}

14
tests/cli/handlers/test_handle_dont_fragment.c Normal file
View file

@ -0,0 +1,14 @@
#include <criterion/criterion.h>
#include "ping/cli.h"
#include "ping/ft_ping_flags.h"
#include "internal/ping/cli_handlers.h"
Test(handle_dont_fragment, flag_test)
{
struct ping_config config = {0};
const char *arg = "";
const int ret = cli_handle_dont_fragment(arg, &config);
cr_assert(HAS_FLAG(config.flags, FLAG_DONT_FRAGMENT));
cr_assert_eq(ret, CLI_SUCCESS);
}

38
tests/cli/parse_utils/test_parse_destinations.c Normal file
View file

@ -0,0 +1,38 @@
#include <criterion/criterion.h>
#include <stdlib.h>
#include "ping/cli.h"
#include "internal/ping/parse_utils.h"
Test(cli_parse_destinations, no_destinations)
{
struct ping_config config = {0};
char *argv[] = {"ping"};
int argc = 1;
int ret = cli_parse_destinations(argc, argv, argc, &config);
cr_assert_eq(ret, CLI_ERROR);
}
Test(cli_parse_destinations, single_destination)
{
struct ping_config config = {0};
char *argv[] = {"ping", "127.0.0.1"};
int argc = 2;
int ret = cli_parse_destinations(argc, argv, 1, &config);
cr_assert_eq(ret, CLI_SUCCESS);
cr_assert_eq(config.nb_destinations, (size_t)1);
free(config.destinations);
}
Test(cli_parse_destinations, multiple_destinations)
{
struct ping_config config = {0};
char *argv[] = {"ping", "127.0.0.1", "127.0.0.2"};
int argc = 3;
int ret = cli_parse_destinations(argc, argv, 1, &config);
cr_assert_eq(ret, CLI_SUCCESS);
cr_assert_eq(config.nb_destinations, (size_t)2);
free(config.destinations);
}

21
tests/cli/parse_utils/test_parse_inet_addr.c Normal file
View file

@ -0,0 +1,21 @@
#include <criterion/criterion.h>
#include <string.h>
#include "ping/ping.h"
#include "internal/ping/parse_utils.h"
Test(cli_parse_inet_addr, valid_ip)
{
struct destinations out = {0};
int ret = cli_parse_inet_addr("127.0.0.1", &out);
cr_assert_eq(ret, 0);
cr_assert_str_eq(out.dom, "127.0.0.1");
}
Test(cli_parse_inet_addr, invalid_host)
{
struct destinations out = {0};
int ret = cli_parse_inet_addr("not.a.real.host.invalid", &out);
cr_assert_eq(ret, 1);
}

51
tests/ping/stats/test_stats.c
View file

@ -62,3 +62,54 @@ Test(ping_stats, identical_values_mdev_zero)
cr_assert_float_eq(avg_ms, 15.0, 1e-6);
cr_assert_float_eq(mdev_ms, 0.0, 1e-3);
}
Test(ping_stats, count_tracked)
{
struct ping_stats s;
ping_stats_init(&s);
ping_stats_update(&s, 10000000LL);
ping_stats_update(&s, 20000000LL);
ping_stats_update(&s, 30000000LL);
cr_assert_eq(s.count, (size_t)3);
}
Test(ping_stats, min_max_out_of_order)
{
struct ping_stats s;
double min_ms, max_ms, avg_ms, mdev_ms;
ping_stats_init(&s);
ping_stats_update(&s, 30000000LL); /* 30 ms */
ping_stats_update(&s, 10000000LL); /* 10 ms */
ping_stats_update(&s, 20000000LL); /* 20 ms */
ping_stats_get(&s, &min_ms, &max_ms, &avg_ms, &mdev_ms);
cr_assert_float_eq(min_ms, 10.0, 1e-6);
cr_assert_float_eq(max_ms, 30.0, 1e-6);
}
Test(ping_stats, large_rtt_no_overflow)
{
struct ping_stats s;
double min_ms, max_ms, avg_ms, mdev_ms;
ping_stats_init(&s);
ping_stats_update(&s, 10000000000LL); /* 10 s = 10000 ms */
ping_stats_get(&s, &min_ms, &max_ms, &avg_ms, &mdev_ms);
cr_assert(min_ms > 0.0, "min_ms should be > 0");
cr_assert(max_ms > 0.0, "max_ms should be > 0");
cr_assert(avg_ms > 0.0, "avg_ms should be > 0");
cr_assert_float_eq(avg_ms, 10000.0, 1e-3);
}
Test(ping_stats, two_values_avg)
{
struct ping_stats s;
double min_ms, max_ms, avg_ms, mdev_ms;
ping_stats_init(&s);
ping_stats_update(&s, 10000000LL); /* 10 ms */
ping_stats_update(&s, 30000000LL); /* 30 ms */
ping_stats_get(&s, &min_ms, &max_ms, &avg_ms, &mdev_ms);
cr_assert_float_eq(avg_ms, 20.0, 1e-6);
}

64
tests/ping/tracker/test_tracker.c
View file

@ -101,3 +101,67 @@ Test(ping_tracker, lost_count)
cr_assert_eq(ping_tracker_recv(&t), (size_t)1);
cr_assert_eq(ping_tracker_lost(&t), (size_t)2);
}
Test(ping_tracker, sent_count_increments)
{
struct ping_tracker t;
struct timespec ts;
ping_tracker_init(&t);
ts = make_ts(0, 0);
ping_tracker_record_send(&t, 1, &ts);
ping_tracker_record_send(&t, 2, &ts);
ping_tracker_record_send(&t, 3, &ts);
cr_assert_eq(ping_tracker_sent(&t), (size_t)3);
}
Test(ping_tracker, recv_rtt_positive)
{
struct ping_tracker t;
struct timespec ts_send;
struct timespec ts_recv;
int64_t rtt;
ping_tracker_init(&t);
ts_send = make_ts(1, 0);
ts_recv = make_ts(1, 10000000); /* 10 ms later */
ping_tracker_record_send(&t, 7, &ts_send);
rtt = ping_tracker_record_recv(&t, 7, &ts_recv);
cr_assert(rtt > 0, "RTT should be positive");
}
Test(ping_tracker, slot_reuse_after_wraparound)
{
struct ping_tracker t;
struct timespec ts_send;
struct timespec ts_recv;
int64_t rtt;
ping_tracker_init(&t);
ts_send = make_ts(0, 0);
ts_recv = make_ts(0, 1000000);
/* seq=1 -> slot 1 */
ping_tracker_record_send(&t, 1, &ts_send);
rtt = ping_tracker_record_recv(&t, 1, &ts_recv);
cr_assert(rtt >= 0, "First round RTT should be >= 0");
/* seq=129 -> slot 129 % 128 = 1, same slot */
ping_tracker_record_send(&t, 129, &ts_send);
rtt = ping_tracker_record_recv(&t, 129, &ts_recv);
cr_assert(rtt >= 0, "Second round RTT should be >= 0");
cr_assert_eq(ping_tracker_sent(&t), (size_t)2);
cr_assert_eq(ping_tracker_recv(&t), (size_t)2);
}
Test(ping_tracker, full_buffer)
{
struct ping_tracker t;
struct timespec ts;
uint16_t seq;
ping_tracker_init(&t);
ts = make_ts(0, 0);
for (seq = 1; seq <= 128; seq++)
ping_tracker_record_send(&t, seq, &ts);
cr_assert_eq(ping_tracker_sent(&t), (size_t)128);
cr_assert_eq(ping_tracker_recv(&t), (size_t)0);
}