jeka
/
utun2
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
345 Commits
4 Branches
0 Tags
60 MiB
 
 
 
 
 
 
Tree: 473190281a
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '473190281a'
${ noResults }
utun2/tests/test_route_lib.c

633 lines
22 KiB
Raw Blame History

/**
* Unit-тесты для route_lib - библиотеки маршрутизации
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include <time.h>
#include <sys/time.h>
#include "route_lib.h"
#include "../lib/debug_config.h"
#include "../lib/mem.h"
#ifndef DEBUG_CATEGORY_ROUTING
#define DEBUG_CATEGORY_ROUTING 1
#endif
static struct {
int run, passed, failed;
long ops;
double time_ms;
} stats = {0};
#define TEST(name) do { \
printf("TEST: %-40s ", name); fflush(stdout); \
stats.run++; \
} while(0)
#define PASS() do { puts("PASS"); stats.passed++; } while(0)
#define FAIL(msg) do { printf("FAIL: %s\n", msg); stats.failed++; } while(0)
#define ASSERT(c, m) do { if (!(c)) { FAIL(m); return; } } while(0)
#define ASSERT_EQ(a,b,m) ASSERT((a)==(b),m)
#define ASSERT_NE(a,b,m) ASSERT((a)!=(b),m)
/* ------------------------------------------------------------------ */
static double now_ms(void) {
struct timeval tv; gettimeofday(&tv, NULL);
return tv.tv_sec * 1000.0 + tv.tv_usec / 1000.0;
}
/* Создание тестового маршрута */
static void create_test_route(struct ROUTE_ENTRY *entry, uint32_t network,
uint8_t prefix_len, route_type_t type,
struct ETCP_CONN *next_hop) {
memset(entry, 0, sizeof(*entry));
entry->network = network;
entry->prefix_length = prefix_len;
entry->type = type;
entry->next_hop = next_hop;
entry->flags = ROUTE_FLAG_ACTIVE;
entry->metrics.latency_ms = 10 + (rand() % 100);
entry->metrics.packet_loss_rate = rand() % 50;
entry->hop_count = 1 + (rand() % 5);
entry->metrics.bandwidth_kbps = 1000 + (rand() % 9000);
route_update_quality(entry);
}
/* ------------------------------------------------------------------ */
static void test_table_create_destroy(void) {
TEST("table create/destroy");
struct ROUTE_TABLE *table = route_table_create();
ASSERT(table != NULL, "failed to create table");
ASSERT_EQ(table->count, 0, "new table should be empty");
ASSERT(table->capacity > 0, "table should have capacity");
ASSERT(table->entries != NULL, "table should have entries array");
route_table_destroy(table);
PASS();
}
static void test_route_insert(void) {
TEST("route insert");
struct ROUTE_TABLE *table = route_table_create();
ASSERT(table != NULL, "failed to create table");
struct ROUTE_ENTRY entry;
create_test_route(&entry, 0xC0A80100, 24, ROUTE_TYPE_STATIC, NULL);
ASSERT(route_table_insert(table, &entry), "failed to insert static route");
ASSERT_EQ(table->count, 1, "table should have 1 route");
create_test_route(&entry, 0xC0A80200, 24, ROUTE_TYPE_STATIC, NULL);
ASSERT(route_table_insert(table, &entry), "failed to insert second route");
ASSERT_EQ(table->count, 2, "table should have 2 routes");
route_table_destroy(table);
PASS();
}
static void test_route_update_existing(void) {
TEST("route update existing");
struct ROUTE_TABLE *table = route_table_create();
struct ROUTE_ENTRY entry;
create_test_route(&entry, 0xC0A80100, 24, ROUTE_TYPE_STATIC, NULL);
entry.metrics.latency_ms = 50;
ASSERT(route_table_insert(table, &entry), "failed to insert route");
create_test_route(&entry, 0xC0A80100, 24, ROUTE_TYPE_STATIC, NULL);
entry.metrics.latency_ms = 100;
ASSERT(route_table_insert(table, &entry), "failed to update route");
ASSERT_EQ(table->count, 1, "should still have 1 route after update");
route_table_destroy(table);
PASS();
}
static void test_route_lookup_basic(void) {
TEST("route lookup basic");
struct ROUTE_TABLE *table = route_table_create();
struct ROUTE_ENTRY entry;
create_test_route(&entry, 0xC0A80100, 24, ROUTE_TYPE_STATIC, NULL);
route_table_insert(table, &entry);
struct ROUTE_ARRAY *result = route_table_lookup(table, 0xC0A80164);
ASSERT(result != NULL, "should find route for 192.168.1.100");
ASSERT_EQ(result->routes, 1, "should find exactly 1 route");
ASSERT_EQ(result->entries[0]->network, 0xC0A80100, "wrong network");
route_cache_clear();
route_table_destroy(table);
PASS();
}
static void test_route_lookup_miss(void) {
TEST("route lookup miss");
struct ROUTE_TABLE *table = route_table_create();
struct ROUTE_ENTRY entry;
create_test_route(&entry, 0xC0A80100, 24, ROUTE_TYPE_STATIC, NULL);
route_table_insert(table, &entry);
struct ROUTE_ARRAY *result = route_table_lookup(table, 0x0A000001);
ASSERT(result == NULL, "should not find route for 10.0.0.1");
route_table_destroy(table);
PASS();
}
static void test_longest_prefix_match(void) {
TEST("longest prefix match");
struct ROUTE_TABLE *table = route_table_create();
struct ROUTE_ENTRY entry;
// Используем фиктивные указатели для next_hop
struct ETCP_CONN *dummy_conn1 = (struct ETCP_CONN *)0x1000;
struct ETCP_CONN *dummy_conn2 = (struct ETCP_CONN *)0x2000;
create_test_route(&entry, 0xC0A80000, 16, ROUTE_TYPE_STATIC, dummy_conn1);
route_table_insert(table, &entry);
create_test_route(&entry, 0xC0A80100, 24, ROUTE_TYPE_STATIC, dummy_conn2);
route_table_insert(table, &entry);
// Используем IP 192.168.1.200 (0xC0A801C8) - отличается от предыдущего теста
// чтобы избежать попадания в кеш с предыдущего теста
struct ROUTE_ARRAY *result = route_table_lookup(table, 0xC0A801C8);
ASSERT(result != NULL, "should find routes");
ASSERT_EQ(result->routes, 2, "should find 2 routes");
int found_16 = 0, found_24 = 0;
for (uint32_t i = 0; i < result->routes; i++) {
if (result->entries[i]->prefix_length == 16) found_16 = 1;
if (result->entries[i]->prefix_length == 24) found_24 = 1;
}
ASSERT(found_16 && found_24, "should find both prefix lengths");
route_cache_clear();
route_table_destroy(table);
PASS();
}
static void test_route_delete_by_conn(void) {
TEST("route delete by connection");
struct ROUTE_TABLE *table = route_table_create();
struct ROUTE_ENTRY entry;
struct ETCP_CONN *conn1 = (struct ETCP_CONN *)0x1000;
struct ETCP_CONN *conn2 = (struct ETCP_CONN *)0x2000;
create_test_route(&entry, 0xC0A80100, 24, ROUTE_TYPE_STATIC, conn1);
route_table_insert(table, &entry);
create_test_route(&entry, 0xC0A80200, 24, ROUTE_TYPE_STATIC, conn1);
route_table_insert(table, &entry);
create_test_route(&entry, 0xC0A80300, 24, ROUTE_TYPE_STATIC, conn2);
route_table_insert(table, &entry);
ASSERT_EQ(table->count, 3, "should have 3 routes");
route_table_delete(table, conn1);
ASSERT_EQ(table->count, 1, "should have 1 route after deletion");
struct ROUTE_ARRAY *result = route_table_lookup(table, 0xC0A80301);
ASSERT(result != NULL, "should still find route via conn2");
ASSERT_EQ(result->entries[0]->next_hop, conn2, "wrong next_hop");
route_cache_clear();
route_table_destroy(table);
PASS();
}
static void test_parse_subnet(void) {
TEST("parse subnet");
uint32_t network;
uint8_t prefix_len;
ASSERT_EQ(parse_subnet("192.168.1.0/24", &network, &prefix_len), 0,
"failed to parse 192.168.1.0/24");
ASSERT_EQ(network, 0xC0A80100, "wrong network for 192.168.1.0/24");
ASSERT_EQ(prefix_len, 24, "wrong prefix length");
ASSERT_EQ(parse_subnet("10.0.0.0/8", &network, &prefix_len), 0,
"failed to parse 10.0.0.0/8");
ASSERT_EQ(network, 0x0A000000, "wrong network for 10.0.0.0/8");
ASSERT_EQ(prefix_len, 8, "wrong prefix length");
ASSERT_EQ(parse_subnet("0.0.0.0/0", &network, &prefix_len), 0,
"failed to parse 0.0.0.0/0");
ASSERT_EQ(network, 0, "wrong network for 0.0.0.0/0");
ASSERT_EQ(prefix_len, 0, "wrong prefix length");
ASSERT_EQ(parse_subnet("invalid", &network, &prefix_len), -1,
"should fail on invalid string");
ASSERT_EQ(parse_subnet("192.168.1.0/33", &network, &prefix_len), -1,
"should fail on prefix > 32");
ASSERT_EQ(parse_subnet("192.168.1.0", &network, &prefix_len), -1,
"should fail without prefix");
ASSERT_EQ(parse_subnet("256.0.0.0/8", &network, &prefix_len), -1,
"should fail on invalid IP");
ASSERT_EQ(parse_subnet(NULL, &network, &prefix_len), -1,
"should fail on NULL string");
PASS();
}
static void test_update_quality(void) {
TEST("update quality calculation");
struct ROUTE_ENTRY entry;
memset(&entry, 0, sizeof(entry));
entry.latency = 100; // x0.1 ms units (= 10 ms)
entry.metrics.packet_loss_rate = 0;
entry.hop_count = 1;
ASSERT(route_update_quality(&entry), "failed to update quality");
ASSERT_EQ(entry.metrics.metric, 70, "wrong quality calculation");
struct ROUTE_ENTRY entry2;
memset(&entry2, 0, sizeof(entry2));
entry2.latency = 50; // x0.1 ms units (= 5 ms)
entry2.metrics.packet_loss_rate = 0;
entry2.hop_count = 1;
route_update_quality(&entry2);
ASSERT(entry2.metrics.metric < entry.metrics.metric,
"better route should have lower quality metric");
PASS();
}
static void test_dynamic_subnet_validation(void) {
TEST("dynamic subnet validation");
struct ROUTE_TABLE *table = route_table_create();
ASSERT(table != NULL, "failed to create table");
ASSERT(route_add_dynamic_subnet(table, 0x0A000000, 8),
"failed to add dynamic subnet");
struct ROUTE_ENTRY entry;
create_test_route(&entry, 0x0A000100, 24, ROUTE_TYPE_DYNAMIC, NULL);
ASSERT(route_table_insert(table, &entry),
"should insert route in allowed subnet");
create_test_route(&entry, 0xC0A80100, 24, ROUTE_TYPE_DYNAMIC, NULL);
ASSERT(!route_table_insert(table, &entry),
"should reject route outside allowed subnet");
create_test_route(&entry, 0xC0A80100, 24, ROUTE_TYPE_STATIC, NULL);
ASSERT(route_table_insert(table, &entry),
"should accept static route regardless of validation");
route_table_destroy(table);
PASS();
}
static void test_local_subnet_validation(void) {
TEST("local subnet validation");
struct ROUTE_TABLE *table = route_table_create();
ASSERT(route_add_local_subnet(table, 0xAC100000, 12),
"failed to add local subnet");
struct ROUTE_ENTRY entry;
create_test_route(&entry, 0xAC100100, 24, ROUTE_TYPE_LOCAL, NULL);
ASSERT(route_table_insert(table, &entry),
"should insert local route in allowed subnet");
create_test_route(&entry, 0xC0A80100, 24, ROUTE_TYPE_LOCAL, NULL);
ASSERT(!route_table_insert(table, &entry),
"should reject local route outside allowed subnet");
ASSERT_EQ(table->stats.local_routes, 1, "should have 1 local route");
route_table_destroy(table);
PASS();
}
static void test_get_all_routes(void) {
TEST("get all routes for subnet");
struct ROUTE_TABLE *table = route_table_create();
struct ROUTE_ENTRY entry;
struct ETCP_CONN *conn1 = (struct ETCP_CONN *)0x1000;
struct ETCP_CONN *conn2 = (struct ETCP_CONN *)0x2000;
create_test_route(&entry, 0xC0A80100, 24, ROUTE_TYPE_STATIC, conn1);
route_table_insert(table, &entry);
create_test_route(&entry, 0xC0A80100, 24, ROUTE_TYPE_STATIC, conn2);
route_table_insert(table, &entry);
create_test_route(&entry, 0xC0A80200, 24, ROUTE_TYPE_STATIC, conn1);
route_table_insert(table, &entry);
struct ROUTE_ENTRY *routes = NULL;
size_t count = 0;
ASSERT(route_get_all_routes(table, 0xC0A80100, 24, &routes, &count),
"failed to get routes");
ASSERT_EQ(count, 2, "should find 2 routes for 192.168.1.0/24");
ASSERT(routes != NULL, "routes should not be NULL");
u_free(routes);
route_table_destroy(table);
PASS();
}
static void test_inactive_route(void) {
TEST("inactive route not returned");
struct ROUTE_TABLE *table = route_table_create();
struct ROUTE_ENTRY entry;
struct ETCP_CONN *active_hop = (struct ETCP_CONN *)0x1000;
struct ETCP_CONN *inactive_hop = (struct ETCP_CONN *)0x2000;
// Активный маршрут через active_hop
create_test_route(&entry, 0xC0A80100, 24, ROUTE_TYPE_STATIC, active_hop);
route_table_insert(table, &entry);
// Неактивный маршрут через inactive_hop (разный next_hop = разный маршрут)
create_test_route(&entry, 0xC0A80100, 24, ROUTE_TYPE_STATIC, inactive_hop);
entry.flags = 0; // Убираем флаг ACTIVE
route_table_insert(table, &entry);
ASSERT_EQ(table->count, 2, "should have 2 routes in table");
struct ROUTE_ARRAY *result = route_table_lookup(table, 0xC0A80101);
ASSERT(result != NULL, "should find route");
ASSERT_EQ(result->routes, 1, "should find only 1 active route");
ASSERT(result->entries[0]->flags & ROUTE_FLAG_ACTIVE,
"returned route should be active");
route_cache_clear();
route_table_destroy(table);
PASS();
}
static void test_table_expansion(void) {
TEST("table expansion");
struct ROUTE_TABLE *table = route_table_create();
ASSERT(table != NULL, "failed to create table");
size_t initial_capacity = table->capacity;
struct ROUTE_ENTRY entry;
for (int i = 0; i < (int)initial_capacity + 10; i++) {
create_test_route(&entry, 0xC0A80000 + (i << 8), 24,
ROUTE_TYPE_STATIC, NULL);
ASSERT(route_table_insert(table, &entry), "failed to insert route");
}
ASSERT(table->capacity > initial_capacity, "table should have expanded");
ASSERT_EQ(table->count, (size_t)(initial_capacity + 10),
"should have all routes");
route_table_destroy(table);
PASS();
}
static void test_cache_functionality(void) {
TEST("route cache functionality");
struct ROUTE_TABLE *table = route_table_create();
struct ROUTE_ENTRY entry;
create_test_route(&entry, 0xC0A80100, 24, ROUTE_TYPE_STATIC, NULL);
route_table_insert(table, &entry);
uint64_t hits_before = table->stats.routes_lookup_hits;
struct ROUTE_ARRAY *result1 = route_table_lookup(table, 0xC0A80101);
ASSERT(result1 != NULL, "first lookup should succeed");
struct ROUTE_ARRAY *result2 = route_table_lookup(table, 0xC0A80101);
ASSERT(result2 != NULL, "second lookup should succeed");
ASSERT(table->stats.routes_lookup_hits > hits_before,
"should increment lookup hits");
route_cache_clear();
route_table_destroy(table);
PASS();
}
static void test_route_types(void) {
TEST("all route types");
struct ROUTE_TABLE *table = route_table_create();
struct ROUTE_ENTRY entry;
create_test_route(&entry, 0xC0A80100, 24, ROUTE_TYPE_STATIC, NULL);
ASSERT(route_table_insert(table, &entry),
"failed to insert static route");
route_add_dynamic_subnet(table, 0x0A000000, 8);
create_test_route(&entry, 0x0A000100, 24, ROUTE_TYPE_DYNAMIC, NULL);
ASSERT(route_table_insert(table, &entry),
"failed to insert dynamic route");
route_add_local_subnet(table, 0xAC100000, 12);
create_test_route(&entry, 0xAC100100, 24, ROUTE_TYPE_LOCAL, NULL);
ASSERT(route_table_insert(table, &entry),
"failed to insert local route");
create_test_route(&entry, 0xC0A80200, 24, ROUTE_TYPE_LEARNED, NULL);
ASSERT(route_table_insert(table, &entry),
"failed to insert learned route");
ASSERT_EQ(table->count, 4, "should have 4 routes of different types");
ASSERT_EQ(table->stats.local_routes, 1, "should have 1 local route");
ASSERT_EQ(table->stats.learned_routes, 1, "should have 1 learned route");
route_table_destroy(table);
PASS();
}
static void test_route_delete_entry(void) {
TEST("route delete entry");
struct ROUTE_TABLE *table = route_table_create();
struct ROUTE_ENTRY entry;
struct ETCP_CONN *conn1 = (struct ETCP_CONN *)0x1000;
// Вставляем несколько маршрутов
create_test_route(&entry, 0xC0A80100, 24, ROUTE_TYPE_STATIC, conn1);
route_table_insert(table, &entry);
create_test_route(&entry, 0xC0A80200, 24, ROUTE_TYPE_STATIC, conn1);
route_table_insert(table, &entry);
create_test_route(&entry, 0xC0A80300, 24, ROUTE_TYPE_STATIC, conn1);
route_table_insert(table, &entry);
ASSERT_EQ(table->count, 3, "should have 3 routes");
// Удаляем маршрут по network/prefix (next_hop = NULL - любой)
ASSERT(route_table_delete_entry(table, 0xC0A80200, 24, NULL),
"should delete route 192.168.2.0/24");
ASSERT_EQ(table->count, 2, "should have 2 routes after deletion");
// Проверяем что правильный маршрут удалён
struct ROUTE_ARRAY *result = route_table_lookup(table, 0xC0A80201);
ASSERT(result == NULL, "should not find deleted route");
result = route_table_lookup(table, 0xC0A80101);
ASSERT(result != NULL, "should still find 192.168.1.x route");
route_cache_clear();
// Пытаемся удалить несуществующий маршрут
ASSERT(!route_table_delete_entry(table, 0xC0A80500, 24, NULL),
"should fail to delete non-existent route");
ASSERT_EQ(table->count, 2, "should still have 2 routes");
route_table_destroy(table);
PASS();
}
static void test_route_delete_entry_by_nexthop(void) {
TEST("route delete entry by next_hop");
struct ROUTE_TABLE *table = route_table_create();
struct ROUTE_ENTRY entry;
struct ETCP_CONN *conn1 = (struct ETCP_CONN *)0x1000;
struct ETCP_CONN *conn2 = (struct ETCP_CONN *)0x2000;
// Одинаковый network/prefix, разные next_hop
create_test_route(&entry, 0xC0A80100, 24, ROUTE_TYPE_STATIC, conn1);
route_table_insert(table, &entry);
create_test_route(&entry, 0xC0A80100, 24, ROUTE_TYPE_STATIC, conn2);
route_table_insert(table, &entry);
ASSERT_EQ(table->count, 2, "should have 2 routes");
// Удаляем только маршрут через conn1
ASSERT(route_table_delete_entry(table, 0xC0A80100, 24, conn1),
"should delete route via conn1");
ASSERT_EQ(table->count, 1, "should have 1 route after deletion");
// Проверяем что остался маршрут через conn2
struct ROUTE_ARRAY *result = route_table_lookup(table, 0xC0A80101);
ASSERT(result != NULL, "should still find route via conn2");
ASSERT_EQ(result->entries[0]->next_hop, conn2, "wrong next_hop remaining");
route_cache_clear();
route_table_destroy(table);
PASS();
}
static void test_route_withdraw_scenario(void) {
TEST("BGP withdraw scenario");
struct ROUTE_TABLE *table = route_table_create();
struct ROUTE_ENTRY entry;
struct ETCP_CONN *peer = (struct ETCP_CONN *)0x1000;
// Имитируем получение маршрута от пира (learned route)
memset(&entry, 0, sizeof(entry));
entry.network = 0x0A000000; // 10.0.0.0
entry.prefix_length = 8;
entry.next_hop = peer;
entry.type = ROUTE_TYPE_LEARNED;
entry.flags = ROUTE_FLAG_ACTIVE | ROUTE_FLAG_LEARNED;
entry.node_id = 0x1234567890ABCDEFULL;
ASSERT(route_table_insert(table, &entry), "failed to insert learned route");
ASSERT_EQ(table->stats.learned_routes, 1, "should have 1 learned route");
// Имитируем получение withdraw
ASSERT(route_table_delete_entry(table, 0x0A000000, 8, peer),
"should withdraw route from peer");
ASSERT_EQ(table->count, 0, "should have 0 routes after withdraw");
ASSERT_EQ(table->stats.learned_routes, 0, "should have 0 learned routes");
route_table_destroy(table);
PASS();
}
static void test_stress(void) {
TEST("stress 1000 routes");
double start = now_ms();
struct ROUTE_TABLE *table = route_table_create();
struct ROUTE_ENTRY entry;
for (int i = 0; i < 1000; i++) {
uint32_t network = 0xC0000000 | ((i & 0xFF) << 8) | ((i >> 8) & 0xFF);
create_test_route(&entry, network, 24, ROUTE_TYPE_STATIC, NULL);
ASSERT(route_table_insert(table, &entry),
"failed to insert route in stress test");
stats.ops++;
}
for (int i = 0; i < 1000; i++) {
uint32_t ip = 0xC0000000 | ((i & 0xFF) << 8) | ((i >> 8) & 0xFF) | 1;
struct ROUTE_ARRAY *result = route_table_lookup(table, ip);
// result находится в кеше, не освобождаем явно
(void)result;
stats.ops++;
}
stats.time_ms += now_ms() - start;
ASSERT_EQ(table->count, 1000, "should have 1000 routes");
route_cache_clear();
route_table_destroy(table);
PASS();
}
/* ------------------------------------------------------------------ */
int main(void) {
debug_config_init();
debug_set_level(DEBUG_LEVEL_INFO);
debug_set_categories(DEBUG_CATEGORY_ROUTING);
srand(time(NULL));
double t0 = now_ms();
test_table_create_destroy();
test_route_insert();
test_route_update_existing();
test_route_lookup_basic();
test_route_lookup_miss();
test_longest_prefix_match();
test_route_delete_by_conn();
test_parse_subnet();
test_update_quality();
test_dynamic_subnet_validation();
test_local_subnet_validation();
test_get_all_routes();
test_inactive_route();
test_table_expansion();
test_cache_functionality();
test_route_types();
test_route_delete_entry();
test_route_delete_entry_by_nexthop();
test_route_withdraw_scenario();
test_stress();
printf("\n=== SUMMARY ===\n"
"run=%d passed=%d failed=%d\n"
"ops=%ld time=%.2f ms\n",
stats.run, stats.passed, stats.failed,
stats.ops, now_ms() - t0);
return stats.failed ? 1 : 0;
}