feat: DDP frame sync over UDP broadcast, DDP acks, DDP enable setting
- Driver acks each completed DDP frame; the test waits for the acks before broadcasting the sync. - Sync listener on UDP 4049: a frame is held until the next sync, then shown. - DDP pixels are shown at full brightness, ignoring the device brightness settings. - "DDP and sync receive on" setting (NVS, network API, web UI); off ignores DDP and sync packets. - ddp_test.py: finds devices on the subnet, drives them in lockstep at a fixed rate, runs animations. - /api/ddp reports sync counters for diagnosis. - Includes in-progress WebSocket, multi-driver web UI and Wi-Fi work from the same tree. Co-Authored-By: Claude Haiku 5.5 <noreply@anthropic.com>
This commit is contained in:
1 parent
47f4eba0d6
commit
4cd3bc7973
294 files changed
+48954
-301
No files matched your search
@@ -0,0 +1,17 @@
|
||||
---
|
||||
:cmock:
|
||||
:mock_prefix: mock_
|
||||
:plugins:
|
||||
- :callback
|
||||
- :ignore
|
||||
- :expect_any_args
|
||||
- :array
|
||||
- :return_thru_ptr
|
||||
:strippables:
|
||||
- '(?:extern|static)\s+'
|
||||
:treat_as:
|
||||
uint8_t: HEX8
|
||||
uint16_t: HEX16
|
||||
uint32_t: UINT32
|
||||
int8_t: INT8
|
||||
bool: UINT8
|
||||
@@ -0,0 +1,160 @@
|
||||
/*
|
||||
* SPDX-FileCopyrightText: 2025 Espressif Systems (Shanghai) CO LTD
|
||||
*
|
||||
* SPDX-License-Identifier: Unlicense OR CC0-1.0
|
||||
*/
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <stdint.h>
|
||||
#include <unistd.h>
|
||||
#include "esp_err.h"
|
||||
#include "unity.h"
|
||||
#include "create_test_packet.h"
|
||||
|
||||
// Encode a domain name in DNS format (length byte + characters)
|
||||
size_t encode_dns_name(uint8_t* buffer, const char* name)
|
||||
{
|
||||
size_t pos = 0;
|
||||
const char* segment_start = name;
|
||||
|
||||
// Process each segment (separated by dots)
|
||||
for (const char* p = name; ; p++) {
|
||||
if (*p == '.' || *p == 0) {
|
||||
// Calculate segment length
|
||||
size_t segment_len = p - segment_start;
|
||||
|
||||
// Write length byte
|
||||
buffer[pos++] = segment_len;
|
||||
|
||||
// Write segment characters
|
||||
for (size_t i = 0; i < segment_len; i++) {
|
||||
buffer[pos++] = segment_start[i];
|
||||
}
|
||||
|
||||
// If at end of string, exit loop
|
||||
if (*p == 0) {
|
||||
break;
|
||||
}
|
||||
|
||||
// Move to next segment
|
||||
segment_start = p + 1;
|
||||
}
|
||||
}
|
||||
|
||||
// Add null terminator
|
||||
buffer[pos++] = 0;
|
||||
|
||||
return pos;
|
||||
}
|
||||
|
||||
// Create an mDNS test packet from arrays of queries and answers
|
||||
uint8_t* create_mdns_test_packet(
|
||||
mdns_test_query_t queries[], size_t query_count,
|
||||
mdns_test_answer_t answers[], size_t answer_count,
|
||||
mdns_test_answer_t additional[], size_t additional_count,
|
||||
size_t* packet_len)
|
||||
{
|
||||
// Allocate buffer for packet (max reasonable size for test)
|
||||
uint8_t* packet = malloc(1460);
|
||||
size_t pos = 0;
|
||||
|
||||
// DNS Header (12 bytes)
|
||||
// Transaction ID
|
||||
packet[pos++] = 0x00;
|
||||
packet[pos++] = 0x00;
|
||||
|
||||
// Flags (QR=1 for response if there are answers, AA=1)
|
||||
uint16_t flags = 0x0000;
|
||||
if (answer_count > 0) {
|
||||
flags |= 0x8400; // QR=1, AA=1
|
||||
}
|
||||
packet[pos++] = (flags >> 8) & 0xFF;
|
||||
packet[pos++] = flags & 0xFF;
|
||||
|
||||
// Counts
|
||||
packet[pos++] = 0x00;
|
||||
packet[pos++] = query_count & 0xFF; // QDCOUNT
|
||||
packet[pos++] = 0x00;
|
||||
packet[pos++] = answer_count & 0xFF; // ANCOUNT
|
||||
packet[pos++] = 0x00;
|
||||
packet[pos++] = 0x00; // NSCOUNT
|
||||
packet[pos++] = 0x00;
|
||||
packet[pos++] = additional_count & 0xFF; // ARCOUNT
|
||||
|
||||
// Add queries
|
||||
for (size_t i = 0; i < query_count; i++) {
|
||||
// Encode name
|
||||
pos += encode_dns_name(packet + pos, queries[i].name);
|
||||
|
||||
// Type
|
||||
packet[pos++] = (queries[i].type >> 8) & 0xFF;
|
||||
packet[pos++] = queries[i].type & 0xFF;
|
||||
|
||||
// Class
|
||||
packet[pos++] = (queries[i].class >> 8) & 0xFF;
|
||||
packet[pos++] = queries[i].class & 0xFF;
|
||||
}
|
||||
|
||||
// Add answers
|
||||
for (size_t i = 0; i < answer_count; i++) {
|
||||
// Encode name
|
||||
pos += encode_dns_name(packet + pos, answers[i].name);
|
||||
|
||||
// Type
|
||||
packet[pos++] = (answers[i].type >> 8) & 0xFF;
|
||||
packet[pos++] = answers[i].type & 0xFF;
|
||||
|
||||
// Class
|
||||
packet[pos++] = (answers[i].class >> 8) & 0xFF;
|
||||
packet[pos++] = answers[i].class & 0xFF;
|
||||
|
||||
// TTL (4 bytes)
|
||||
packet[pos++] = (answers[i].ttl >> 24) & 0xFF;
|
||||
packet[pos++] = (answers[i].ttl >> 16) & 0xFF;
|
||||
packet[pos++] = (answers[i].ttl >> 8) & 0xFF;
|
||||
packet[pos++] = answers[i].ttl & 0xFF;
|
||||
|
||||
// Data length
|
||||
packet[pos++] = (answers[i].data_len >> 8) & 0xFF;
|
||||
packet[pos++] = answers[i].data_len & 0xFF;
|
||||
|
||||
// Data
|
||||
if (answers[i].data && answers[i].data_len > 0) {
|
||||
memcpy(packet + pos, answers[i].data, answers[i].data_len);
|
||||
pos += answers[i].data_len;
|
||||
}
|
||||
}
|
||||
|
||||
// Add additional records
|
||||
for (size_t i = 0; i < additional_count; i++) {
|
||||
// Encode name
|
||||
pos += encode_dns_name(packet + pos, additional[i].name);
|
||||
|
||||
// Type
|
||||
packet[pos++] = (additional[i].type >> 8) & 0xFF;
|
||||
packet[pos++] = additional[i].type & 0xFF;
|
||||
|
||||
// Class
|
||||
packet[pos++] = (additional[i].class >> 8) & 0xFF;
|
||||
packet[pos++] = additional[i].class & 0xFF;
|
||||
|
||||
// TTL (4 bytes)
|
||||
packet[pos++] = (additional[i].ttl >> 24) & 0xFF;
|
||||
packet[pos++] = (additional[i].ttl >> 16) & 0xFF;
|
||||
packet[pos++] = (additional[i].ttl >> 8) & 0xFF;
|
||||
packet[pos++] = additional[i].ttl & 0xFF;
|
||||
|
||||
// Data length
|
||||
packet[pos++] = (additional[i].data_len >> 8) & 0xFF;
|
||||
packet[pos++] = additional[i].data_len & 0xFF;
|
||||
|
||||
// Data
|
||||
if (additional[i].data && additional[i].data_len > 0) {
|
||||
memcpy(packet + pos, additional[i].data, additional[i].data_len);
|
||||
pos += additional[i].data_len;
|
||||
}
|
||||
}
|
||||
|
||||
*packet_len = pos;
|
||||
return packet;
|
||||
}
|
||||
@@ -0,0 +1,31 @@
|
||||
/*
|
||||
* SPDX-FileCopyrightText: 2025 Espressif Systems (Shanghai) CO LTD
|
||||
*
|
||||
* SPDX-License-Identifier: Unlicense OR CC0-1.0
|
||||
*/
|
||||
#pragma once
|
||||
// Structure for a DNS query
|
||||
typedef struct {
|
||||
const char* name; // Name to query (e.g., "test.local")
|
||||
uint16_t type; // Query type (e.g., MDNS_TYPE_A)
|
||||
uint16_t class; // Query class (typically 1 for IN)
|
||||
} mdns_test_query_t;
|
||||
|
||||
// Structure for a DNS answer record
|
||||
typedef struct {
|
||||
const char* name; // Name this record refers to
|
||||
uint16_t type; // Record type
|
||||
uint16_t class; // Record class
|
||||
uint32_t ttl; // Time to live
|
||||
uint16_t data_len; // Length of data
|
||||
uint8_t* data; // Record data
|
||||
} mdns_test_answer_t;
|
||||
|
||||
|
||||
uint8_t* create_mdns_test_packet(
|
||||
mdns_test_query_t queries[], size_t query_count,
|
||||
mdns_test_answer_t answers[], size_t answer_count,
|
||||
mdns_test_answer_t additional[], size_t additional_count,
|
||||
size_t* packet_len);
|
||||
|
||||
size_t encode_dns_name(uint8_t* buffer, const char* name);
|
||||
@@ -0,0 +1,11 @@
|
||||
enable_testing()
|
||||
add_test(NAME ${PROJECT_NAME} COMMAND ${PROJECT_NAME} --test)
|
||||
|
||||
add_custom_target(generate_mocks
|
||||
DEPENDS ${MOCK_OUTPUTS}
|
||||
)
|
||||
add_dependencies(${PROJECT_NAME} generate_mocks)
|
||||
|
||||
# Add sanitizers: Please comment out when debugging
|
||||
target_link_options(${PROJECT_NAME} PRIVATE -fsanitize=address -fsanitize=undefined)
|
||||
target_compile_options(${PROJECT_NAME} PRIVATE -fsanitize=address -fsanitize=undefined)
|
||||
+311
@@ -0,0 +1,311 @@
|
||||
/*
|
||||
* SPDX-FileCopyrightText: 2026 Espressif Systems (Shanghai) CO LTD
|
||||
*
|
||||
* SPDX-License-Identifier: Unlicense OR CC0-1.0
|
||||
*/
|
||||
|
||||
#include <stdint.h>
|
||||
#include <string.h>
|
||||
|
||||
#include "mdns.h"
|
||||
#include "mdns_browser.h"
|
||||
#include "mdns_cache.h"
|
||||
#include "mdns_mem_caps.h"
|
||||
#include "mdns_private.h"
|
||||
#include "mock_mdns_pcb.h"
|
||||
#include "unity.h"
|
||||
|
||||
#define INSTANCE "cached-service"
|
||||
#define SERVICE "_cachetest"
|
||||
#define PROTO "_tcp"
|
||||
#define HOSTNAME "cache-host"
|
||||
#define PORT 8080
|
||||
#define TTL 120
|
||||
#define SUBTYPE "alpha"
|
||||
|
||||
#define TXT_VAL "value"
|
||||
#define TXT_VAL_LEN 5
|
||||
|
||||
static uint8_t s_netif_storage;
|
||||
static const mdns_txt_linked_item_t s_txt = {
|
||||
.key = "key",
|
||||
.value = TXT_VAL,
|
||||
.value_len = TXT_VAL_LEN,
|
||||
.next = NULL,
|
||||
};
|
||||
static const esp_ip_addr_t s_addr = ESP_IP4ADDR_INIT(192, 168, 1, 100);
|
||||
|
||||
static size_t s_notify_calls;
|
||||
static uint32_t s_last_ttl;
|
||||
static size_t s_subtype_calls;
|
||||
static uint32_t s_subtype_ttl;
|
||||
|
||||
static esp_netif_t *test_netif(void)
|
||||
{
|
||||
return (esp_netif_t *)&s_netif_storage;
|
||||
}
|
||||
|
||||
static void assert_browse_result(const mdns_result_t *result)
|
||||
{
|
||||
// Results belong to the browser and are only valid during this callback.
|
||||
TEST_ASSERT_NOT_NULL(result);
|
||||
TEST_ASSERT_NULL(result->next);
|
||||
TEST_ASSERT_EQUAL_PTR(test_netif(), result->esp_netif);
|
||||
TEST_ASSERT_EQUAL(MDNS_IP_PROTOCOL_V4, result->ip_protocol);
|
||||
TEST_ASSERT_EQUAL_STRING(INSTANCE, result->instance_name);
|
||||
TEST_ASSERT_EQUAL_STRING(SERVICE, result->service_type);
|
||||
TEST_ASSERT_EQUAL_STRING(PROTO, result->proto);
|
||||
TEST_ASSERT_EQUAL_STRING(HOSTNAME, result->hostname);
|
||||
TEST_ASSERT_EQUAL_UINT16(PORT, result->port);
|
||||
TEST_ASSERT_NOT_NULL(result->txt);
|
||||
TEST_ASSERT_EQUAL_UINT8(TXT_VAL_LEN, result->txt_value_len[0]);
|
||||
TEST_ASSERT_EQUAL_size_t(1, result->txt_count);
|
||||
TEST_ASSERT_NOT_NULL(result->addr);
|
||||
TEST_ASSERT_EQUAL(ESP_IPADDR_TYPE_V4, result->addr->addr.type);
|
||||
TEST_ASSERT_EQUAL_UINT32(s_addr.u_addr.ip4.addr, result->addr->addr.u_addr.ip4.addr);
|
||||
}
|
||||
|
||||
static void browse_callback(mdns_result_t *result)
|
||||
{
|
||||
assert_browse_result(result);
|
||||
TEST_ASSERT_NULL(result->subtype);
|
||||
s_notify_calls++;
|
||||
s_last_ttl = result->ttl;
|
||||
}
|
||||
|
||||
static void subtype_callback(mdns_result_t *result)
|
||||
{
|
||||
assert_browse_result(result);
|
||||
TEST_ASSERT_EQUAL_STRING(SUBTYPE, result->subtype);
|
||||
s_subtype_calls++;
|
||||
s_subtype_ttl = result->ttl;
|
||||
}
|
||||
|
||||
static void unexpected_callback(mdns_result_t *result)
|
||||
{
|
||||
(void)result;
|
||||
TEST_FAIL_MESSAGE("A non-matching browse received a notification");
|
||||
}
|
||||
|
||||
static mdns_txt_linked_item_t *clone_txt(const mdns_txt_linked_item_t *src_txt)
|
||||
{
|
||||
mdns_txt_linked_item_t *item = mdns_mem_calloc(1, sizeof(mdns_txt_linked_item_t));
|
||||
TEST_ASSERT_NOT_NULL(item);
|
||||
|
||||
item->key = mdns_mem_strdup(src_txt->key);
|
||||
TEST_ASSERT_NOT_NULL(item->key);
|
||||
|
||||
item->value_len = src_txt->value_len;
|
||||
|
||||
if (src_txt->value_len > 0) {
|
||||
item->value = mdns_mem_malloc(src_txt->value_len);
|
||||
TEST_ASSERT_NOT_NULL(item->value);
|
||||
memcpy(item->value, src_txt->value, src_txt->value_len);
|
||||
}
|
||||
|
||||
return item;
|
||||
}
|
||||
|
||||
static void cache_service_details(void)
|
||||
{
|
||||
TEST_ASSERT_NOT_EQUAL(MDNS_CACHE_ERROR, mdns_priv_cache_update_srv(test_netif(), MDNS_IP_PROTOCOL_V4,
|
||||
HOSTNAME, INSTANCE, SERVICE, PROTO,
|
||||
0, 0, PORT, TTL));
|
||||
TEST_ASSERT_NOT_EQUAL(MDNS_CACHE_ERROR, mdns_priv_cache_update_txt(test_netif(), MDNS_IP_PROTOCOL_V4,
|
||||
INSTANCE, SERVICE, PROTO, clone_txt(&s_txt), TTL));
|
||||
TEST_ASSERT_NOT_EQUAL(MDNS_CACHE_ERROR, mdns_priv_cache_update_addr(test_netif(), MDNS_IP_PROTOCOL_V4,
|
||||
HOSTNAME, &s_addr, TTL));
|
||||
}
|
||||
|
||||
static void cache_service(void)
|
||||
{
|
||||
TEST_ASSERT_NOT_EQUAL(MDNS_CACHE_ERROR, mdns_priv_cache_update_ptr(test_netif(), MDNS_IP_PROTOCOL_V4,
|
||||
INSTANCE, SERVICE, PROTO, NULL, TTL));
|
||||
cache_service_details();
|
||||
}
|
||||
|
||||
void mdns_test_set_up(void)
|
||||
{
|
||||
mdns_priv_browse_free();
|
||||
mdns_priv_cache_clear();
|
||||
s_notify_calls = 0;
|
||||
s_last_ttl = 0;
|
||||
s_subtype_calls = 0;
|
||||
s_subtype_ttl = 0;
|
||||
}
|
||||
|
||||
void mdns_test_tear_down(void)
|
||||
{
|
||||
mdns_priv_browse_free();
|
||||
mdns_priv_cache_clear();
|
||||
}
|
||||
|
||||
void setup_cmock(void)
|
||||
{
|
||||
mdns_priv_probe_all_pcbs_CMockIgnore();
|
||||
mdns_priv_pcb_announce_CMockIgnore();
|
||||
mdns_priv_pcb_send_bye_service_CMockIgnore();
|
||||
mdns_priv_pcb_check_probing_services_CMockIgnore();
|
||||
mdns_priv_pcb_is_after_probing_IgnoreAndReturn(true);
|
||||
mdsn_priv_pcb_is_inited_IgnoreAndReturn(false);
|
||||
}
|
||||
|
||||
static void test_browse_add_delete_sequence(void)
|
||||
{
|
||||
const char *other_service = "_other";
|
||||
|
||||
// Register A and reject an immediate duplicate.
|
||||
TEST_ASSERT_NOT_NULL(mdns_browse_new(SERVICE, PROTO, browse_callback));
|
||||
TEST_ASSERT_TRUE(mdns_priv_browse_has_service(SERVICE, PROTO));
|
||||
|
||||
TEST_ASSERT_NULL(mdns_browse_new(SERVICE, PROTO, browse_callback));
|
||||
TEST_ASSERT_TRUE(mdns_priv_browse_has_service(SERVICE, PROTO));
|
||||
|
||||
// Register B without affecting A.
|
||||
TEST_ASSERT_NOT_NULL(mdns_browse_new(other_service, PROTO, unexpected_callback));
|
||||
TEST_ASSERT_TRUE(mdns_priv_browse_has_service(SERVICE, PROTO));
|
||||
TEST_ASSERT_TRUE(mdns_priv_browse_has_service(other_service, PROTO));
|
||||
|
||||
// Delete A. B remains registered, and deleting A again must fail.
|
||||
TEST_ASSERT_EQUAL(ESP_OK, mdns_browse_delete(SERVICE, PROTO));
|
||||
TEST_ASSERT_FALSE(mdns_priv_browse_has_service(SERVICE, PROTO));
|
||||
TEST_ASSERT_TRUE(mdns_priv_browse_has_service(other_service, PROTO));
|
||||
|
||||
TEST_ASSERT_EQUAL(ESP_FAIL, mdns_browse_delete(SERVICE, PROTO));
|
||||
|
||||
// A can be registered again immediately after deletion.
|
||||
TEST_ASSERT_NOT_NULL(mdns_browse_new(SERVICE, PROTO, browse_callback));
|
||||
TEST_ASSERT_TRUE(mdns_priv_browse_has_service(SERVICE, PROTO));
|
||||
TEST_ASSERT_TRUE(mdns_priv_browse_has_service(other_service, PROTO));
|
||||
|
||||
TEST_ASSERT_EQUAL(ESP_OK, mdns_browse_delete(SERVICE, PROTO));
|
||||
TEST_ASSERT_EQUAL(ESP_OK, mdns_browse_delete(other_service, PROTO));
|
||||
TEST_ASSERT_FALSE(mdns_priv_browse_has_service(SERVICE, PROTO));
|
||||
TEST_ASSERT_FALSE(mdns_priv_browse_has_service(other_service, PROTO));
|
||||
}
|
||||
|
||||
static void test_browse_cached_result_and_delete(void)
|
||||
{
|
||||
// Consume pending updates before registering the browse.
|
||||
// The initial callback must come from replaying the cache on browse start.
|
||||
cache_service();
|
||||
mdns_priv_cache_process_sync();
|
||||
TEST_ASSERT_EQUAL_size_t(0, s_notify_calls);
|
||||
|
||||
TEST_ASSERT_NOT_NULL(mdns_browse_new(SERVICE, PROTO, browse_callback));
|
||||
TEST_ASSERT_EQUAL_size_t(1, s_notify_calls);
|
||||
TEST_ASSERT_EQUAL_UINT32(TTL, s_last_ttl);
|
||||
|
||||
TEST_ASSERT_EQUAL(ESP_OK, mdns_browse_delete(SERVICE, PROTO));
|
||||
TEST_ASSERT_FALSE(mdns_priv_browse_has_service(SERVICE, PROTO));
|
||||
|
||||
// Further cache changes must not call the deleted browse notifier.
|
||||
TEST_ASSERT_NOT_EQUAL(MDNS_CACHE_ERROR, mdns_priv_cache_update_srv(test_netif(), MDNS_IP_PROTOCOL_V4,
|
||||
HOSTNAME, INSTANCE, SERVICE, PROTO,
|
||||
0, 0, PORT + 1, TTL));
|
||||
mdns_priv_cache_process_sync();
|
||||
TEST_ASSERT_EQUAL_size_t(1, s_notify_calls);
|
||||
}
|
||||
|
||||
static void test_browse_matches_service_and_requires_ptr(void)
|
||||
{
|
||||
TEST_ASSERT_NOT_NULL(mdns_browse_new(SERVICE, PROTO, browse_callback));
|
||||
TEST_ASSERT_NOT_NULL(mdns_browse_new("_other", PROTO, unexpected_callback));
|
||||
TEST_ASSERT_NOT_NULL(mdns_browse_new(SERVICE, "_udp", unexpected_callback));
|
||||
|
||||
// SRV, TXT and addresses alone do not establish a browse result.
|
||||
cache_service_details();
|
||||
mdns_priv_cache_process_sync();
|
||||
TEST_ASSERT_EQUAL_size_t(0, s_notify_calls);
|
||||
|
||||
TEST_ASSERT_NOT_EQUAL(MDNS_CACHE_ERROR, mdns_priv_cache_update_ptr(test_netif(), MDNS_IP_PROTOCOL_V4,
|
||||
INSTANCE, SERVICE, PROTO, NULL, TTL));
|
||||
mdns_priv_cache_process_sync();
|
||||
TEST_ASSERT_EQUAL_size_t(1, s_notify_calls);
|
||||
TEST_ASSERT_EQUAL_UINT32(TTL, s_last_ttl);
|
||||
}
|
||||
|
||||
static void test_browse_goodbye_and_rediscovery(void)
|
||||
{
|
||||
TEST_ASSERT_NOT_NULL(mdns_browse_new(SERVICE, PROTO, browse_callback));
|
||||
|
||||
cache_service();
|
||||
mdns_priv_cache_process_sync();
|
||||
TEST_ASSERT_EQUAL_size_t(1, s_notify_calls);
|
||||
TEST_ASSERT_EQUAL_UINT32(TTL, s_last_ttl);
|
||||
|
||||
// Cache goodbye should notify the browse.
|
||||
TEST_ASSERT_NOT_EQUAL(MDNS_CACHE_ERROR, mdns_priv_cache_update_ptr(test_netif(), MDNS_IP_PROTOCOL_V4,
|
||||
INSTANCE, SERVICE, PROTO, NULL, 0));
|
||||
mdns_priv_cache_remove_expired_records(esp_timer_get_time());
|
||||
mdns_priv_cache_process_sync();
|
||||
TEST_ASSERT_EQUAL_size_t(2, s_notify_calls);
|
||||
TEST_ASSERT_EQUAL_UINT32(0, s_last_ttl);
|
||||
|
||||
// The same browse remains active and can discover the service again.
|
||||
cache_service();
|
||||
mdns_priv_cache_process_sync();
|
||||
TEST_ASSERT_EQUAL_size_t(3, s_notify_calls);
|
||||
TEST_ASSERT_EQUAL_UINT32(TTL, s_last_ttl);
|
||||
}
|
||||
|
||||
static void test_browse_subtype_update_filtering(void)
|
||||
{
|
||||
TEST_ASSERT_NOT_NULL(mdns_browse_new(SERVICE, PROTO, browse_callback));
|
||||
TEST_ASSERT_NOT_NULL(mdns_browse_new_with_subtype(SERVICE, PROTO, SUBTYPE, subtype_callback));
|
||||
cache_service();
|
||||
mdns_priv_cache_process_sync();
|
||||
TEST_ASSERT_EQUAL_size_t(1, s_notify_calls);
|
||||
TEST_ASSERT_EQUAL(MDNS_CACHE_UPDATED, mdns_priv_cache_update_ptr(test_netif(), MDNS_IP_PROTOCOL_V4,
|
||||
INSTANCE, SERVICE, PROTO, SUBTYPE, TTL));
|
||||
mdns_priv_cache_process_sync();
|
||||
TEST_ASSERT_EQUAL_size_t(1, s_subtype_calls);
|
||||
|
||||
// Changes to shared record (SRV/TXT/ADDR) TTLs reach both browsers.
|
||||
TEST_ASSERT_EQUAL(MDNS_CACHE_UPDATED, mdns_priv_cache_update_srv(test_netif(), MDNS_IP_PROTOCOL_V4,
|
||||
HOSTNAME, INSTANCE, SERVICE, PROTO,
|
||||
0, 0, PORT, TTL + 1));
|
||||
mdns_priv_cache_process_sync();
|
||||
TEST_ASSERT_EQUAL_size_t(2, s_notify_calls);
|
||||
TEST_ASSERT_EQUAL_size_t(2, s_subtype_calls);
|
||||
|
||||
TEST_ASSERT_EQUAL(MDNS_CACHE_UPDATED, mdns_priv_cache_update_txt(test_netif(), MDNS_IP_PROTOCOL_V4,
|
||||
INSTANCE, SERVICE, PROTO, clone_txt(&s_txt), TTL + 1));
|
||||
mdns_priv_cache_process_sync();
|
||||
TEST_ASSERT_EQUAL_size_t(3, s_notify_calls);
|
||||
TEST_ASSERT_EQUAL_size_t(3, s_subtype_calls);
|
||||
|
||||
TEST_ASSERT_EQUAL(MDNS_CACHE_UPDATED, mdns_priv_cache_update_addr(test_netif(), MDNS_IP_PROTOCOL_V4,
|
||||
HOSTNAME, &s_addr, TTL + 1));
|
||||
mdns_priv_cache_process_sync();
|
||||
TEST_ASSERT_EQUAL_size_t(4, s_notify_calls);
|
||||
TEST_ASSERT_EQUAL_size_t(4, s_subtype_calls);
|
||||
|
||||
// Base and subtype PTR updates notify only their matching browser.
|
||||
TEST_ASSERT_EQUAL(MDNS_CACHE_UPDATED, mdns_priv_cache_update_ptr(test_netif(), MDNS_IP_PROTOCOL_V4,
|
||||
INSTANCE, SERVICE, PROTO, NULL, TTL + 1));
|
||||
mdns_priv_cache_process_sync();
|
||||
TEST_ASSERT_EQUAL_size_t(5, s_notify_calls);
|
||||
TEST_ASSERT_EQUAL_size_t(4, s_subtype_calls);
|
||||
TEST_ASSERT_EQUAL_UINT32(TTL + 1, s_last_ttl);
|
||||
TEST_ASSERT_EQUAL_UINT32(TTL, s_subtype_ttl);
|
||||
|
||||
TEST_ASSERT_EQUAL(MDNS_CACHE_UPDATED, mdns_priv_cache_update_ptr(test_netif(), MDNS_IP_PROTOCOL_V4,
|
||||
INSTANCE, SERVICE, PROTO, SUBTYPE, TTL + 2));
|
||||
mdns_priv_cache_process_sync();
|
||||
TEST_ASSERT_EQUAL_size_t(5, s_notify_calls);
|
||||
TEST_ASSERT_EQUAL_size_t(5, s_subtype_calls);
|
||||
TEST_ASSERT_EQUAL_UINT32(TTL + 1, s_last_ttl);
|
||||
TEST_ASSERT_EQUAL_UINT32(TTL + 2, s_subtype_ttl);
|
||||
}
|
||||
|
||||
void run_unity_tests(void)
|
||||
{
|
||||
UNITY_BEGIN();
|
||||
RUN_TEST(test_browse_add_delete_sequence);
|
||||
RUN_TEST(test_browse_cached_result_and_delete);
|
||||
RUN_TEST(test_browse_matches_service_and_requires_ptr);
|
||||
RUN_TEST(test_browse_goodbye_and_rediscovery);
|
||||
RUN_TEST(test_browse_subtype_update_filtering);
|
||||
UNITY_END();
|
||||
}
|
||||
+6
@@ -0,0 +1,6 @@
|
||||
# Mock pcb to disable network queries. Use real browser and cache.
|
||||
set(MOCK_FILES
|
||||
"mdns_pcb"
|
||||
)
|
||||
|
||||
list(APPEND SOURCES unity/${UNIT_TESTS}/test_browse.c)
|
||||
+982
@@ -0,0 +1,982 @@
|
||||
/*
|
||||
* SPDX-FileCopyrightText: 2026 Espressif Systems (Shanghai) CO LTD
|
||||
*
|
||||
* SPDX-License-Identifier: Unlicense OR CC0-1.0
|
||||
*/
|
||||
|
||||
#include <stddef.h>
|
||||
#include <stdint.h>
|
||||
#include <string.h>
|
||||
#include <strings.h>
|
||||
|
||||
#include "esp_netif_ip_addr.h"
|
||||
#include "esp_netif_types.h"
|
||||
#include "mdns.h"
|
||||
#include "mdns_cache.h"
|
||||
#include "mdns_mem_caps.h"
|
||||
#include "mdns_mem_caps_test.h"
|
||||
#include "mdns_private.h"
|
||||
#include "mdns_test_clock.h"
|
||||
#include "mock_mdns_browser.h"
|
||||
#include "unity.h"
|
||||
#include "unity_internals.h"
|
||||
|
||||
#define INSTANCE "_instance"
|
||||
#define SERVICE "_http"
|
||||
#define PROTO "_tcp"
|
||||
#define HOSTNAME "device"
|
||||
#define SUBTYPE_A "alpha"
|
||||
#define SUBTYPE_B "beta"
|
||||
|
||||
#define PTR_TTL 120
|
||||
#define SRV_TTL 130
|
||||
#define TXT_TTL 140
|
||||
#define ADDR_TTL 150
|
||||
|
||||
#define SRV_PRIORITY 10
|
||||
#define SRV_WEIGHT 20
|
||||
#define SRV_PORT 8080
|
||||
|
||||
typedef struct {
|
||||
size_t update_calls;
|
||||
size_t goodbye_calls;
|
||||
|
||||
bool update_result;
|
||||
bool goodbye_result;
|
||||
|
||||
mdns_cache_record_mask_t records;
|
||||
mdns_ip_protocol_t ip_protocol;
|
||||
const esp_netif_t *esp_netif;
|
||||
|
||||
bool ptr_present;
|
||||
bool srv_present;
|
||||
bool txt_present;
|
||||
|
||||
uint32_t ptr_ttl;
|
||||
uint32_t srv_ttl;
|
||||
uint32_t txt_ttl;
|
||||
|
||||
uint16_t priority;
|
||||
uint16_t weight;
|
||||
uint16_t port;
|
||||
|
||||
size_t address_count;
|
||||
size_t txt_count;
|
||||
size_t subtype_count;
|
||||
|
||||
// These pointers are references to the pointers in service cache item during tests,
|
||||
// and should only be used after SUBTYPE/TXT/ADDR cache has been updated and before service cache is cleaned!
|
||||
// Do not manually free them, they should be maintained by mdns_cache.
|
||||
const mdns_txt_linked_item_t *txt;
|
||||
const mdns_cache_addr_t *addr;
|
||||
const mdns_cache_subtype_t *subtype;
|
||||
const mdns_cache_entry_t *entry;
|
||||
const mdns_service_cache_t *service_cache;
|
||||
|
||||
char hostname[MDNS_NAME_BUF_LEN];
|
||||
char instance[MDNS_NAME_BUF_LEN];
|
||||
char service[MDNS_NAME_BUF_LEN];
|
||||
char proto[MDNS_NAME_BUF_LEN];
|
||||
char goodbye_subtype[MDNS_NAME_BUF_LEN];
|
||||
} cache_observer_t;
|
||||
|
||||
static cache_observer_t s_observer;
|
||||
// Provide mock `esp_netif_t` pointers
|
||||
static uint8_t s_netif_storage_a;
|
||||
|
||||
// ----------------- Helper functions -----------------
|
||||
|
||||
static esp_netif_t *test_netif_a(void)
|
||||
{
|
||||
return (esp_netif_t *)&s_netif_storage_a;
|
||||
}
|
||||
|
||||
static void reset_observer(void)
|
||||
{
|
||||
memset(&s_observer, 0, sizeof(s_observer));
|
||||
s_observer.update_result = true;
|
||||
s_observer.goodbye_result = true;
|
||||
}
|
||||
|
||||
static void copy_optional_string(char *dst, size_t dst_size, const char *src)
|
||||
{
|
||||
if (!src) {
|
||||
dst[0] = '\0';
|
||||
return;
|
||||
}
|
||||
|
||||
strncpy(dst, src, dst_size - 1);
|
||||
dst[dst_size - 1] = '\0';
|
||||
}
|
||||
|
||||
static size_t count_addresses(const mdns_cache_addr_t *addr)
|
||||
{
|
||||
size_t count = 0;
|
||||
|
||||
while (addr) {
|
||||
count++;
|
||||
addr = addr->next;
|
||||
}
|
||||
|
||||
return count;
|
||||
}
|
||||
|
||||
static size_t count_txt(const mdns_txt_linked_item_t *txt)
|
||||
{
|
||||
size_t count = 0;
|
||||
|
||||
while (txt) {
|
||||
count++;
|
||||
txt = txt->next;
|
||||
}
|
||||
|
||||
return count;
|
||||
}
|
||||
|
||||
static size_t count_subtype(const mdns_cache_subtype_t *subtype)
|
||||
{
|
||||
size_t count = 0;
|
||||
|
||||
while (subtype) {
|
||||
count++;
|
||||
subtype = subtype->next;
|
||||
}
|
||||
|
||||
return count;
|
||||
}
|
||||
|
||||
static void capture_cache(const mdns_cache_entry_t *entry, const mdns_service_cache_t *service,
|
||||
mdns_cache_record_mask_t records)
|
||||
{
|
||||
TEST_ASSERT_NOT_NULL(entry);
|
||||
TEST_ASSERT_NOT_NULL(service);
|
||||
s_observer.records = records;
|
||||
s_observer.ip_protocol = entry->ip_protocol;
|
||||
s_observer.esp_netif = entry->esp_netif;
|
||||
|
||||
s_observer.ptr_present = service->ptr_present;
|
||||
s_observer.srv_present = service->srv_present;
|
||||
s_observer.txt_present = service->txt_present;
|
||||
|
||||
s_observer.ptr_ttl = service->ptr_ttl;
|
||||
s_observer.srv_ttl = service->srv_ttl;
|
||||
s_observer.txt_ttl = service->txt_ttl;
|
||||
|
||||
s_observer.priority = service->priority;
|
||||
s_observer.weight = service->weight;
|
||||
s_observer.port = service->port;
|
||||
|
||||
s_observer.address_count = count_addresses(entry->addr_list);
|
||||
s_observer.txt_count = count_txt(service->txt_list);
|
||||
s_observer.subtype_count = count_subtype(service->subtype_list);
|
||||
|
||||
s_observer.txt = service->txt_list;
|
||||
s_observer.addr = entry->addr_list;
|
||||
s_observer.subtype = service->subtype_list;
|
||||
s_observer.entry = entry;
|
||||
s_observer.service_cache = service;
|
||||
|
||||
copy_optional_string(s_observer.hostname, sizeof(s_observer.hostname), entry->hostname);
|
||||
copy_optional_string(s_observer.instance, sizeof(s_observer.instance), service->instance_name);
|
||||
copy_optional_string(s_observer.service, sizeof(s_observer.service), service->service);
|
||||
copy_optional_string(s_observer.proto, sizeof(s_observer.proto), service->proto);
|
||||
}
|
||||
|
||||
static bool browse_update_callback(const mdns_cache_entry_t *entry, const mdns_service_cache_t *service,
|
||||
mdns_cache_record_mask_t records, int cmock_num_calls)
|
||||
{
|
||||
(void)cmock_num_calls;
|
||||
s_observer.update_calls++;
|
||||
capture_cache(entry, service, records);
|
||||
return s_observer.update_result;
|
||||
}
|
||||
|
||||
static bool browse_goodbye_callback(const mdns_cache_entry_t *entry, const mdns_service_cache_t *service,
|
||||
const char *subtype, int cmock_num_calls)
|
||||
{
|
||||
(void)cmock_num_calls;
|
||||
s_observer.goodbye_calls++;
|
||||
capture_cache(entry, service, 0);
|
||||
copy_optional_string(s_observer.goodbye_subtype, sizeof(s_observer.goodbye_subtype), subtype);
|
||||
return s_observer.goodbye_result;
|
||||
}
|
||||
|
||||
static mdns_txt_linked_item_t *clone_txt(const mdns_txt_linked_item_t *src_txt)
|
||||
{
|
||||
mdns_txt_linked_item_t *item = mdns_mem_calloc(1, sizeof(mdns_txt_linked_item_t));
|
||||
TEST_ASSERT_NOT_NULL(item);
|
||||
|
||||
item->key = mdns_mem_strdup(src_txt->key);
|
||||
TEST_ASSERT_NOT_NULL(item->key);
|
||||
|
||||
item->value_len = src_txt->value_len;
|
||||
|
||||
if (src_txt->value_len > 0) {
|
||||
item->value = mdns_mem_malloc(src_txt->value_len);
|
||||
TEST_ASSERT_NOT_NULL(item->value);
|
||||
memcpy(item->value, src_txt->value, src_txt->value_len);
|
||||
}
|
||||
|
||||
return item;
|
||||
}
|
||||
|
||||
static bool find_txt_in_txt_list(const mdns_txt_linked_item_t *txt_list, const mdns_txt_linked_item_t *target)
|
||||
{
|
||||
if (!txt_list || !target) {
|
||||
return false;
|
||||
}
|
||||
|
||||
for (const mdns_txt_linked_item_t *it = txt_list; it; it = it->next) {
|
||||
if (strcasecmp(it->key, target->key) == 0) {
|
||||
if (it->value_len != target->value_len) {
|
||||
return false; // Do not allow duplicated keys
|
||||
}
|
||||
return it->value_len == 0 || memcmp(it->value, target->value, it->value_len) == 0;
|
||||
}
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
static bool assert_subtype_in_list(const mdns_cache_subtype_t *subtype_list, const char *subtype, uint32_t ttl)
|
||||
{
|
||||
if (!subtype_list || !subtype) {
|
||||
return false;
|
||||
}
|
||||
|
||||
for (const mdns_cache_subtype_t *it = subtype_list; it; it = it->next) {
|
||||
if (strcasecmp(it->subtype, subtype) == 0) {
|
||||
return it->ttl == ttl;
|
||||
}
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
static esp_ip_addr_t make_ipv4(uint32_t address)
|
||||
{
|
||||
esp_ip_addr_t addr = {0};
|
||||
|
||||
addr.type = ESP_IPADDR_TYPE_V4;
|
||||
addr.u_addr.ip4.addr = address;
|
||||
return addr;
|
||||
}
|
||||
|
||||
static esp_ip_addr_t make_ipv6(const uint32_t address[4])
|
||||
{
|
||||
esp_ip_addr_t addr = {0};
|
||||
|
||||
addr.type = ESP_IPADDR_TYPE_V6;
|
||||
for (int i = 0; i < 4; i++) {
|
||||
addr.u_addr.ip6.addr[i] = address[i];
|
||||
}
|
||||
return addr;
|
||||
}
|
||||
|
||||
static void assert_memory(size_t baseline)
|
||||
{
|
||||
TEST_ASSERT_EQUAL_size_t(baseline, mdns_mem_get_allocation_counts());
|
||||
}
|
||||
|
||||
static mdns_cache_update_result_t update_test_record(mdns_cache_record_type_t record_type, bool goodbye)
|
||||
{
|
||||
static const mdns_txt_linked_item_t txt = {
|
||||
.key = "key",
|
||||
.value = "value",
|
||||
.value_len = 5,
|
||||
.next = NULL,
|
||||
};
|
||||
const esp_ip_addr_t addr = make_ipv4(0x0101A8C0);
|
||||
|
||||
switch (record_type) {
|
||||
case MDNS_CACHE_RECORD_PTR:
|
||||
return mdns_priv_cache_update_ptr(test_netif_a(), MDNS_IP_PROTOCOL_V4,
|
||||
INSTANCE, SERVICE, PROTO, NULL, goodbye ? 0 : PTR_TTL);
|
||||
case MDNS_CACHE_RECORD_SRV:
|
||||
return mdns_priv_cache_update_srv(test_netif_a(), MDNS_IP_PROTOCOL_V4, HOSTNAME, INSTANCE,
|
||||
SERVICE, PROTO, SRV_PRIORITY, SRV_WEIGHT, SRV_PORT, goodbye ? 0 : SRV_TTL);
|
||||
case MDNS_CACHE_RECORD_TXT:
|
||||
return mdns_priv_cache_update_txt(test_netif_a(), MDNS_IP_PROTOCOL_V4, INSTANCE,
|
||||
SERVICE, PROTO, clone_txt(&txt), goodbye ? 0 : TXT_TTL);
|
||||
case MDNS_CACHE_RECORD_ADDR:
|
||||
return mdns_priv_cache_update_addr(test_netif_a(), MDNS_IP_PROTOCOL_V4, HOSTNAME,
|
||||
&addr, goodbye ? 0 : ADDR_TTL);
|
||||
default:
|
||||
TEST_FAIL_MESSAGE("Invalid record type");
|
||||
return MDNS_CACHE_ERROR;
|
||||
}
|
||||
}
|
||||
|
||||
static void insert_complete_service(void)
|
||||
{
|
||||
TEST_ASSERT_EQUAL(MDNS_CACHE_ADDED, update_test_record(MDNS_CACHE_RECORD_PTR, false));
|
||||
TEST_ASSERT_EQUAL(MDNS_CACHE_UPDATED, update_test_record(MDNS_CACHE_RECORD_SRV, false));
|
||||
TEST_ASSERT_EQUAL(MDNS_CACHE_UPDATED, update_test_record(MDNS_CACHE_RECORD_TXT, false));
|
||||
TEST_ASSERT_EQUAL(MDNS_CACHE_UPDATED, update_test_record(MDNS_CACHE_RECORD_ADDR, false));
|
||||
}
|
||||
|
||||
static void assert_observed_complete_service(void)
|
||||
{
|
||||
TEST_ASSERT_EQUAL_PTR(test_netif_a(), s_observer.esp_netif);
|
||||
TEST_ASSERT_EQUAL(MDNS_IP_PROTOCOL_V4, s_observer.ip_protocol);
|
||||
|
||||
TEST_ASSERT_TRUE(s_observer.ptr_present);
|
||||
TEST_ASSERT_TRUE(s_observer.srv_present);
|
||||
TEST_ASSERT_TRUE(s_observer.txt_present);
|
||||
|
||||
TEST_ASSERT_EQUAL_UINT32(PTR_TTL, s_observer.ptr_ttl);
|
||||
TEST_ASSERT_EQUAL_UINT32(SRV_TTL, s_observer.srv_ttl);
|
||||
TEST_ASSERT_EQUAL_UINT32(TXT_TTL, s_observer.txt_ttl);
|
||||
|
||||
TEST_ASSERT_EQUAL_UINT16(SRV_PRIORITY, s_observer.priority);
|
||||
TEST_ASSERT_EQUAL_UINT16(SRV_WEIGHT, s_observer.weight);
|
||||
TEST_ASSERT_EQUAL_UINT16(SRV_PORT, s_observer.port);
|
||||
|
||||
TEST_ASSERT_EQUAL_size_t(1, s_observer.txt_count);
|
||||
TEST_ASSERT_EQUAL_size_t(1, s_observer.address_count);
|
||||
|
||||
TEST_ASSERT_EQUAL_STRING(HOSTNAME, s_observer.hostname);
|
||||
TEST_ASSERT_EQUAL_STRING(INSTANCE, s_observer.instance);
|
||||
TEST_ASSERT_EQUAL_STRING(SERVICE, s_observer.service);
|
||||
TEST_ASSERT_EQUAL_STRING(PROTO, s_observer.proto);
|
||||
}
|
||||
|
||||
// Project only while the cache pointers captured by the callback are still valid.
|
||||
static mdns_result_t *project_observed_service(void)
|
||||
{
|
||||
mdns_result_t *result = NULL;
|
||||
TEST_ASSERT_EQUAL(ESP_OK, mdns_priv_service_cache_to_result(s_observer.entry, s_observer.service_cache, &result));
|
||||
TEST_ASSERT_NOT_NULL(result);
|
||||
return result;
|
||||
}
|
||||
|
||||
static void assert_complete_result(const mdns_result_t *result)
|
||||
{
|
||||
TEST_ASSERT_EQUAL_PTR(test_netif_a(), result->esp_netif);
|
||||
TEST_ASSERT_EQUAL(MDNS_IP_PROTOCOL_V4, result->ip_protocol);
|
||||
TEST_ASSERT_EQUAL_STRING(INSTANCE, result->instance_name);
|
||||
TEST_ASSERT_EQUAL_STRING(SERVICE, result->service_type);
|
||||
TEST_ASSERT_EQUAL_STRING(PROTO, result->proto);
|
||||
TEST_ASSERT_EQUAL_UINT32(PTR_TTL, result->ttl);
|
||||
TEST_ASSERT_EQUAL_STRING(HOSTNAME, result->hostname);
|
||||
TEST_ASSERT_EQUAL_UINT16(SRV_PORT, result->port);
|
||||
TEST_ASSERT_EQUAL_size_t(1, result->txt_count);
|
||||
TEST_ASSERT_NOT_NULL(result->txt);
|
||||
TEST_ASSERT_NOT_NULL(result->txt_value_len);
|
||||
TEST_ASSERT_EQUAL_STRING("key", result->txt[0].key);
|
||||
TEST_ASSERT_EQUAL_UINT8(5, result->txt_value_len[0]);
|
||||
TEST_ASSERT_EQUAL_MEMORY("value", result->txt[0].value, 5);
|
||||
TEST_ASSERT_NOT_NULL(result->addr);
|
||||
TEST_ASSERT_EQUAL(ESP_IPADDR_TYPE_V4, result->addr->addr.type);
|
||||
TEST_ASSERT_EQUAL_UINT32(0x0101A8C0, result->addr->addr.u_addr.ip4.addr);
|
||||
TEST_ASSERT_NULL(result->addr->next);
|
||||
TEST_ASSERT_NULL(result->next);
|
||||
}
|
||||
|
||||
// ----------------- Test functions -----------------
|
||||
|
||||
void mdns_test_set_up(void)
|
||||
{
|
||||
mdns_priv_cache_clear();
|
||||
mdns_test_clock_reset();
|
||||
reset_observer();
|
||||
}
|
||||
|
||||
void mdns_test_tear_down(void)
|
||||
{
|
||||
mdns_priv_cache_clear();
|
||||
}
|
||||
|
||||
void setup_cmock(void)
|
||||
{
|
||||
mdns_priv_browse_update_from_service_cache_Stub(browse_update_callback);
|
||||
mdns_priv_browse_notify_ptr_goodbye_from_service_cache_Stub(browse_goodbye_callback);
|
||||
|
||||
mdns_priv_browse_notify_from_service_cache_IgnoreAndReturn(true);
|
||||
}
|
||||
|
||||
static void test_cache_ptr_add_repeat_update_remove(void)
|
||||
{
|
||||
size_t baseline = mdns_mem_get_allocation_counts();
|
||||
|
||||
// Scenario 1: Add new PTR record
|
||||
TEST_ASSERT_EQUAL(MDNS_CACHE_ADDED, mdns_priv_cache_update_ptr(test_netif_a(), MDNS_IP_PROTOCOL_V4,
|
||||
INSTANCE, SERVICE, PROTO, NULL, PTR_TTL));
|
||||
mdns_priv_cache_process_sync();
|
||||
TEST_ASSERT_EQUAL_size_t(1, s_observer.update_calls);
|
||||
TEST_ASSERT_EQUAL_UINT8(MDNS_CACHE_RECORD_PTR, s_observer.records);
|
||||
TEST_ASSERT_TRUE(s_observer.ptr_present);
|
||||
TEST_ASSERT_EQUAL_UINT32(PTR_TTL, s_observer.ptr_ttl);
|
||||
TEST_ASSERT_EQUAL_STRING(INSTANCE, s_observer.instance);
|
||||
TEST_ASSERT_EQUAL_STRING(SERVICE, s_observer.service);
|
||||
TEST_ASSERT_EQUAL_STRING(PROTO, s_observer.proto);
|
||||
|
||||
// Scenario 2: Update the same service cache with identical PTR TTL
|
||||
TEST_ASSERT_EQUAL(MDNS_CACHE_NO_CHANGE, mdns_priv_cache_update_ptr(test_netif_a(), MDNS_IP_PROTOCOL_V4,
|
||||
INSTANCE, SERVICE, PROTO, NULL, PTR_TTL));
|
||||
mdns_priv_cache_process_sync();
|
||||
TEST_ASSERT_EQUAL_size_t(1, s_observer.update_calls);
|
||||
|
||||
// Scenario 3: Update the same service cache with different PTR TTL
|
||||
TEST_ASSERT_EQUAL(MDNS_CACHE_UPDATED, mdns_priv_cache_update_ptr(test_netif_a(), MDNS_IP_PROTOCOL_V4,
|
||||
INSTANCE, SERVICE, PROTO, NULL, 240));
|
||||
mdns_priv_cache_process_sync();
|
||||
TEST_ASSERT_EQUAL_size_t(2, s_observer.update_calls);
|
||||
TEST_ASSERT_EQUAL_UINT32(240, s_observer.ptr_ttl);
|
||||
|
||||
// Scenario 4: Remove cache with PTR TTL=0
|
||||
TEST_ASSERT_EQUAL(MDNS_CACHE_UPDATED, mdns_priv_cache_update_ptr(test_netif_a(), MDNS_IP_PROTOCOL_V4,
|
||||
INSTANCE, SERVICE, PROTO, NULL, 0));
|
||||
mdns_priv_cache_remove_expired_records(esp_timer_get_time());
|
||||
mdns_priv_cache_process_sync();
|
||||
TEST_ASSERT_EQUAL_size_t(1, s_observer.goodbye_calls);
|
||||
assert_memory(baseline);
|
||||
}
|
||||
|
||||
static void test_cache_srv_add_repeat_update_remove(void)
|
||||
{
|
||||
size_t baseline = mdns_mem_get_allocation_counts();
|
||||
|
||||
// Scenario 1: Add new SRV record
|
||||
TEST_ASSERT_EQUAL(MDNS_CACHE_ADDED, mdns_priv_cache_update_srv(test_netif_a(), MDNS_IP_PROTOCOL_V4, HOSTNAME, INSTANCE,
|
||||
SERVICE, PROTO, SRV_PRIORITY, SRV_WEIGHT, SRV_PORT, SRV_TTL));
|
||||
mdns_priv_cache_process_sync();
|
||||
TEST_ASSERT_EQUAL_size_t(1, s_observer.update_calls);
|
||||
TEST_ASSERT_EQUAL_UINT8(MDNS_CACHE_RECORD_SRV, s_observer.records);
|
||||
TEST_ASSERT_TRUE(s_observer.srv_present);
|
||||
TEST_ASSERT_EQUAL_UINT32(SRV_TTL, s_observer.srv_ttl);
|
||||
TEST_ASSERT_EQUAL_STRING(HOSTNAME, s_observer.hostname);
|
||||
TEST_ASSERT_EQUAL_STRING(INSTANCE, s_observer.instance);
|
||||
TEST_ASSERT_EQUAL_STRING(SERVICE, s_observer.service);
|
||||
TEST_ASSERT_EQUAL_STRING(PROTO, s_observer.proto);
|
||||
TEST_ASSERT_EQUAL_UINT16(SRV_PRIORITY, s_observer.priority);
|
||||
TEST_ASSERT_EQUAL_UINT16(SRV_WEIGHT, s_observer.weight);
|
||||
TEST_ASSERT_EQUAL_UINT16(SRV_PORT, s_observer.port);
|
||||
|
||||
// Scenario 2: Update the same service cache with identical priority, weight, port, and SRV TTL
|
||||
TEST_ASSERT_EQUAL(MDNS_CACHE_NO_CHANGE, mdns_priv_cache_update_srv(test_netif_a(), MDNS_IP_PROTOCOL_V4, HOSTNAME, INSTANCE,
|
||||
SERVICE, PROTO, SRV_PRIORITY, SRV_WEIGHT, SRV_PORT, SRV_TTL));
|
||||
mdns_priv_cache_process_sync();
|
||||
TEST_ASSERT_EQUAL_size_t(1, s_observer.update_calls);
|
||||
|
||||
// Scenario 3: Update the same service cache with different SRV record
|
||||
TEST_ASSERT_EQUAL(MDNS_CACHE_UPDATED, mdns_priv_cache_update_srv(test_netif_a(), MDNS_IP_PROTOCOL_V4, HOSTNAME, INSTANCE,
|
||||
SERVICE, PROTO, 30, 40, 8081, 240));
|
||||
mdns_priv_cache_process_sync();
|
||||
TEST_ASSERT_EQUAL_size_t(2, s_observer.update_calls);
|
||||
TEST_ASSERT_EQUAL_UINT32(240, s_observer.srv_ttl);
|
||||
TEST_ASSERT_EQUAL_UINT16(30, s_observer.priority);
|
||||
TEST_ASSERT_EQUAL_UINT16(40, s_observer.weight);
|
||||
TEST_ASSERT_EQUAL_UINT16(8081, s_observer.port);
|
||||
|
||||
// Scenario 4: Remove cache with SRV TTL=0
|
||||
TEST_ASSERT_EQUAL(MDNS_CACHE_UPDATED, mdns_priv_cache_update_srv(test_netif_a(), MDNS_IP_PROTOCOL_V4, HOSTNAME, INSTANCE,
|
||||
SERVICE, PROTO, SRV_PRIORITY, SRV_WEIGHT, SRV_PORT, 0));
|
||||
mdns_priv_cache_remove_expired_records(esp_timer_get_time());
|
||||
mdns_priv_cache_process_sync();
|
||||
assert_memory(baseline);
|
||||
}
|
||||
|
||||
static void test_cache_txt_add_repeat_update_remove(void)
|
||||
{
|
||||
static const uint8_t binary_arr[] = {0, 0, 0, 0, 255};
|
||||
// Normal TXT item
|
||||
static const mdns_txt_linked_item_t txt_1 = {
|
||||
.key = "key1",
|
||||
.value = "value",
|
||||
.value_len = 5,
|
||||
.next = NULL,
|
||||
};
|
||||
// Simulate TXT item with no value
|
||||
static const mdns_txt_linked_item_t txt_2 = {
|
||||
.key = "key2",
|
||||
.value = NULL,
|
||||
.value_len = 0,
|
||||
.next = NULL,
|
||||
};
|
||||
// Simulate TXT item with binary value
|
||||
static const mdns_txt_linked_item_t txt_3 = {
|
||||
.key = "key2",
|
||||
.value = (char *)binary_arr,
|
||||
.value_len = sizeof(binary_arr),
|
||||
.next = NULL,
|
||||
};
|
||||
|
||||
size_t baseline = mdns_mem_get_allocation_counts();
|
||||
|
||||
// Scenario 1: Add new TXT record
|
||||
mdns_txt_linked_item_t *test1_txt1 = clone_txt(&txt_1);
|
||||
TEST_ASSERT_EQUAL(MDNS_CACHE_ADDED, mdns_priv_cache_update_txt(test_netif_a(), MDNS_IP_PROTOCOL_V4, INSTANCE,
|
||||
SERVICE, PROTO, test1_txt1, TXT_TTL));
|
||||
mdns_priv_cache_process_sync();
|
||||
TEST_ASSERT_EQUAL_size_t(1, s_observer.update_calls);
|
||||
TEST_ASSERT_EQUAL_UINT8(MDNS_CACHE_RECORD_TXT, s_observer.records);
|
||||
TEST_ASSERT_TRUE(s_observer.txt_present);
|
||||
TEST_ASSERT_EQUAL_UINT32(TXT_TTL, s_observer.txt_ttl);
|
||||
TEST_ASSERT_EQUAL_STRING(INSTANCE, s_observer.instance);
|
||||
TEST_ASSERT_EQUAL_STRING(SERVICE, s_observer.service);
|
||||
TEST_ASSERT_EQUAL_STRING(PROTO, s_observer.proto);
|
||||
TEST_ASSERT_EQUAL_size_t(1, s_observer.txt_count);
|
||||
|
||||
// Scenario 2: Update the same service cache with identical TXT item and TTL
|
||||
mdns_txt_linked_item_t *test2_txt1 = clone_txt(&txt_1);
|
||||
TEST_ASSERT_EQUAL(MDNS_CACHE_NO_CHANGE, mdns_priv_cache_update_txt(test_netif_a(), MDNS_IP_PROTOCOL_V4, INSTANCE,
|
||||
SERVICE, PROTO, test2_txt1, TXT_TTL));
|
||||
mdns_priv_cache_process_sync();
|
||||
TEST_ASSERT_EQUAL_size_t(1, s_observer.update_calls);
|
||||
|
||||
// Scenario 3: Update the same service cache with different TXT item and TTL
|
||||
mdns_txt_linked_item_t *test3_txt1 = clone_txt(&txt_1);
|
||||
mdns_txt_linked_item_t *test3_txt2 = clone_txt(&txt_2);
|
||||
test3_txt1->next = test3_txt2;
|
||||
TEST_ASSERT_EQUAL(MDNS_CACHE_UPDATED, mdns_priv_cache_update_txt(test_netif_a(), MDNS_IP_PROTOCOL_V4, INSTANCE,
|
||||
SERVICE, PROTO, test3_txt1, 240));
|
||||
mdns_priv_cache_process_sync();
|
||||
TEST_ASSERT_EQUAL_size_t(2, s_observer.update_calls);
|
||||
TEST_ASSERT_EQUAL_UINT32(240, s_observer.txt_ttl);
|
||||
TEST_ASSERT_EQUAL_size_t(2, s_observer.txt_count);
|
||||
|
||||
// Scenario 4: Update the same service cache with a TXT item different in value
|
||||
mdns_txt_linked_item_t *test4_txt1 = clone_txt(&txt_1);
|
||||
mdns_txt_linked_item_t *test4_txt3 = clone_txt(&txt_3);
|
||||
test4_txt1->next = test4_txt3;
|
||||
TEST_ASSERT_EQUAL(MDNS_CACHE_UPDATED, mdns_priv_cache_update_txt(test_netif_a(), MDNS_IP_PROTOCOL_V4, INSTANCE,
|
||||
SERVICE, PROTO, test4_txt1, 240));
|
||||
mdns_priv_cache_process_sync();
|
||||
TEST_ASSERT_EQUAL_size_t(3, s_observer.update_calls);
|
||||
TEST_ASSERT_EQUAL_size_t(2, s_observer.txt_count);
|
||||
TEST_ASSERT_TRUE(find_txt_in_txt_list(s_observer.txt, &txt_3));
|
||||
|
||||
// Scenario 5: Remove cache with TXT TTL=0
|
||||
TEST_ASSERT_EQUAL(MDNS_CACHE_UPDATED, mdns_priv_cache_update_txt(test_netif_a(), MDNS_IP_PROTOCOL_V4, INSTANCE,
|
||||
SERVICE, PROTO, NULL, 0));
|
||||
mdns_priv_cache_remove_expired_records(esp_timer_get_time());
|
||||
mdns_priv_cache_process_sync();
|
||||
assert_memory(baseline);
|
||||
}
|
||||
|
||||
static void test_cache_addr_add_repeat_update_remove(void)
|
||||
{
|
||||
static const uint32_t ip6_addr[4] = {0x20010db8, 0, 0, 0x00000001};
|
||||
static const uint32_t ip4_addr_1 = 0x0101A8C0;
|
||||
static const uint32_t ip4_addr_2 = 0x0201A8C0;
|
||||
|
||||
const esp_ip_addr_t addr_1 = make_ipv4(ip4_addr_1);
|
||||
const esp_ip_addr_t addr_2 = make_ipv4(ip4_addr_2);
|
||||
const esp_ip_addr_t addr_3 = make_ipv6(ip6_addr);
|
||||
|
||||
// Because currently `mdns_priv_cache_process_sync()` only notifies browses, we need to setup an SRV record to establish a service cache.
|
||||
// So that `browse_update_callback()` stub can update `s_observer`.
|
||||
(void)mdns_priv_cache_update_srv(test_netif_a(), MDNS_IP_PROTOCOL_V6, HOSTNAME, INSTANCE,
|
||||
SERVICE, PROTO, SRV_PRIORITY, SRV_WEIGHT, SRV_PORT, SRV_TTL);
|
||||
size_t baseline = mdns_mem_get_allocation_counts();
|
||||
|
||||
// Scenario 1: Add new A record
|
||||
TEST_ASSERT_EQUAL(MDNS_CACHE_UPDATED, mdns_priv_cache_update_addr(test_netif_a(), MDNS_IP_PROTOCOL_V6, HOSTNAME,
|
||||
&addr_1, ADDR_TTL));
|
||||
mdns_priv_cache_process_sync();
|
||||
TEST_ASSERT_EQUAL_size_t(1, s_observer.update_calls);
|
||||
TEST_ASSERT_EQUAL_UINT8(MDNS_CACHE_RECORD_ADDR | MDNS_CACHE_RECORD_SRV, s_observer.records);
|
||||
TEST_ASSERT_NOT_NULL(s_observer.addr);
|
||||
TEST_ASSERT_EQUAL_UINT32(ADDR_TTL, s_observer.addr->ttl);
|
||||
TEST_ASSERT_EQUAL_UINT32(ip4_addr_1, s_observer.addr->addr.u_addr.ip4.addr);
|
||||
TEST_ASSERT_EQUAL_STRING(HOSTNAME, s_observer.hostname);
|
||||
TEST_ASSERT_EQUAL_size_t(1, s_observer.address_count);
|
||||
|
||||
// Scenario 2: Update the same service cache with identical A record
|
||||
TEST_ASSERT_EQUAL(MDNS_CACHE_NO_CHANGE, mdns_priv_cache_update_addr(test_netif_a(), MDNS_IP_PROTOCOL_V6, HOSTNAME,
|
||||
&addr_1, ADDR_TTL));
|
||||
mdns_priv_cache_process_sync();
|
||||
TEST_ASSERT_EQUAL_size_t(1, s_observer.update_calls);
|
||||
|
||||
// Scenario 3: Update the A record with new TTL
|
||||
TEST_ASSERT_EQUAL(MDNS_CACHE_UPDATED, mdns_priv_cache_update_addr(test_netif_a(), MDNS_IP_PROTOCOL_V6, HOSTNAME,
|
||||
&addr_1, 240));
|
||||
mdns_priv_cache_process_sync();
|
||||
TEST_ASSERT_EQUAL_size_t(2, s_observer.update_calls);
|
||||
TEST_ASSERT_EQUAL_UINT32(240, s_observer.addr->ttl);
|
||||
TEST_ASSERT_EQUAL_size_t(1, s_observer.address_count);
|
||||
|
||||
// Scenario 4: Add new A record
|
||||
TEST_ASSERT_EQUAL(MDNS_CACHE_UPDATED, mdns_priv_cache_update_addr(test_netif_a(), MDNS_IP_PROTOCOL_V6, HOSTNAME,
|
||||
&addr_2, ADDR_TTL));
|
||||
mdns_priv_cache_process_sync();
|
||||
TEST_ASSERT_EQUAL_size_t(3, s_observer.update_calls);
|
||||
TEST_ASSERT_EQUAL_size_t(2, s_observer.address_count);
|
||||
|
||||
// Scenario 5: Add new AAAA record
|
||||
TEST_ASSERT_EQUAL(MDNS_CACHE_UPDATED, mdns_priv_cache_update_addr(test_netif_a(), MDNS_IP_PROTOCOL_V6, HOSTNAME,
|
||||
&addr_3, ADDR_TTL));
|
||||
mdns_priv_cache_process_sync();
|
||||
TEST_ASSERT_EQUAL_size_t(4, s_observer.update_calls);
|
||||
TEST_ASSERT_EQUAL_size_t(3, s_observer.address_count);
|
||||
|
||||
// Scenario 6: Remove all addresses with TTL=0
|
||||
TEST_ASSERT_EQUAL(MDNS_CACHE_UPDATED, mdns_priv_cache_update_addr(test_netif_a(), MDNS_IP_PROTOCOL_V6, HOSTNAME,
|
||||
&addr_1, 0));
|
||||
mdns_priv_cache_remove_expired_records(esp_timer_get_time());
|
||||
mdns_priv_cache_process_sync();
|
||||
TEST_ASSERT_EQUAL_size_t(5, s_observer.update_calls);
|
||||
TEST_ASSERT_EQUAL_size_t(2, s_observer.address_count);
|
||||
TEST_ASSERT_EQUAL(MDNS_CACHE_UPDATED, mdns_priv_cache_update_addr(test_netif_a(), MDNS_IP_PROTOCOL_V6, HOSTNAME,
|
||||
&addr_2, 0));
|
||||
mdns_priv_cache_remove_expired_records(esp_timer_get_time());
|
||||
mdns_priv_cache_process_sync();
|
||||
TEST_ASSERT_EQUAL_size_t(6, s_observer.update_calls);
|
||||
TEST_ASSERT_EQUAL_size_t(1, s_observer.address_count);
|
||||
TEST_ASSERT_EQUAL(MDNS_CACHE_UPDATED, mdns_priv_cache_update_addr(test_netif_a(), MDNS_IP_PROTOCOL_V6, HOSTNAME,
|
||||
&addr_3, 0));
|
||||
mdns_priv_cache_remove_expired_records(esp_timer_get_time());
|
||||
mdns_priv_cache_process_sync();
|
||||
TEST_ASSERT_EQUAL_size_t(7, s_observer.update_calls);
|
||||
TEST_ASSERT_EQUAL_size_t(0, s_observer.address_count);
|
||||
assert_memory(baseline);
|
||||
|
||||
// Scenario 7: `mdns_priv_cache_update_existing_addr()` cannot create new entry
|
||||
size_t baseline_s7 = mdns_mem_get_allocation_counts();
|
||||
TEST_ASSERT_EQUAL(MDNS_CACHE_NO_CHANGE, mdns_priv_cache_update_existing_addr(test_netif_a(), MDNS_IP_PROTOCOL_V4,
|
||||
HOSTNAME, &addr_1, ADDR_TTL));
|
||||
assert_memory(baseline_s7);
|
||||
|
||||
(void)mdns_priv_cache_update_srv(test_netif_a(), MDNS_IP_PROTOCOL_V4, HOSTNAME, INSTANCE,
|
||||
SERVICE, PROTO, SRV_PRIORITY, SRV_WEIGHT, SRV_PORT, SRV_TTL);
|
||||
baseline_s7 = mdns_mem_get_allocation_counts();
|
||||
|
||||
// `mdns_priv_cache_update_existing_addr()` only updates if a consumer is subscribing to a service under the same entry
|
||||
mdns_priv_browse_has_service_IgnoreAndReturn(true);
|
||||
TEST_ASSERT_EQUAL(MDNS_CACHE_UPDATED, mdns_priv_cache_update_existing_addr(test_netif_a(), MDNS_IP_PROTOCOL_V4,
|
||||
HOSTNAME, &addr_1, 240));
|
||||
mdns_priv_cache_process_sync();
|
||||
TEST_ASSERT_EQUAL_size_t(8, s_observer.update_calls);
|
||||
mdns_priv_browse_has_service_IgnoreAndReturn(false);
|
||||
TEST_ASSERT_EQUAL(MDNS_CACHE_NO_CHANGE, mdns_priv_cache_update_existing_addr(test_netif_a(), MDNS_IP_PROTOCOL_V4,
|
||||
HOSTNAME, &addr_1, 300));
|
||||
mdns_priv_cache_process_sync();
|
||||
TEST_ASSERT_EQUAL_size_t(8, s_observer.update_calls);
|
||||
TEST_ASSERT_EQUAL_UINT32(240, s_observer.addr->ttl);
|
||||
mdns_priv_browse_has_service_IgnoreAndReturn(true);
|
||||
TEST_ASSERT_EQUAL(MDNS_CACHE_UPDATED, mdns_priv_cache_update_existing_addr(test_netif_a(), MDNS_IP_PROTOCOL_V4,
|
||||
HOSTNAME, &addr_1, 0));
|
||||
mdns_priv_cache_remove_expired_records(esp_timer_get_time());
|
||||
mdns_priv_cache_process_sync();
|
||||
TEST_ASSERT_EQUAL_size_t(9, s_observer.update_calls);
|
||||
TEST_ASSERT_EQUAL_size_t(0, s_observer.address_count);
|
||||
|
||||
assert_memory(baseline_s7);
|
||||
}
|
||||
|
||||
static void test_cache_record_order_and_result_projection(void)
|
||||
{
|
||||
const mdns_cache_record_type_t orders[][4] = {
|
||||
{ MDNS_CACHE_RECORD_PTR, MDNS_CACHE_RECORD_SRV, MDNS_CACHE_RECORD_TXT, MDNS_CACHE_RECORD_ADDR },
|
||||
{ MDNS_CACHE_RECORD_PTR, MDNS_CACHE_RECORD_ADDR, MDNS_CACHE_RECORD_TXT, MDNS_CACHE_RECORD_SRV },
|
||||
};
|
||||
|
||||
for (size_t i = 0; i < sizeof(orders) / sizeof(orders[0]); i++) {
|
||||
mdns_priv_cache_clear();
|
||||
reset_observer();
|
||||
for (size_t j = 0; j < sizeof(orders[i]) / sizeof(orders[i][0]); j++) {
|
||||
mdns_cache_update_result_t status = update_test_record(orders[i][j], false);
|
||||
TEST_ASSERT_TRUE(status == MDNS_CACHE_ADDED || status == MDNS_CACHE_UPDATED);
|
||||
}
|
||||
// All record updates are delivered in a single notification
|
||||
TEST_ASSERT_EQUAL_size_t(0, s_observer.update_calls);
|
||||
mdns_priv_cache_process_sync();
|
||||
TEST_ASSERT_EQUAL_size_t(1, s_observer.update_calls);
|
||||
assert_observed_complete_service();
|
||||
|
||||
mdns_result_t *result = project_observed_service();
|
||||
assert_complete_result(result);
|
||||
mdns_query_results_free(result);
|
||||
}
|
||||
}
|
||||
|
||||
static void test_cache_service_record_goodbyes(void)
|
||||
{
|
||||
insert_complete_service();
|
||||
mdns_priv_cache_process_sync();
|
||||
assert_observed_complete_service();
|
||||
reset_observer();
|
||||
|
||||
// Remove TXT while preserving SRV and addresses.
|
||||
TEST_ASSERT_EQUAL(MDNS_CACHE_UPDATED, update_test_record(MDNS_CACHE_RECORD_TXT, true));
|
||||
mdns_priv_cache_remove_expired_records(esp_timer_get_time());
|
||||
mdns_priv_cache_process_sync();
|
||||
TEST_ASSERT_EQUAL_size_t(1, s_observer.update_calls);
|
||||
TEST_ASSERT_EQUAL_UINT8(MDNS_CACHE_RECORD_TXT, s_observer.records);
|
||||
TEST_ASSERT_TRUE(s_observer.ptr_present);
|
||||
TEST_ASSERT_TRUE(s_observer.srv_present);
|
||||
TEST_ASSERT_FALSE(s_observer.txt_present);
|
||||
|
||||
mdns_result_t *result = project_observed_service();
|
||||
TEST_ASSERT_NULL(result->txt);
|
||||
TEST_ASSERT_NULL(result->txt_value_len);
|
||||
TEST_ASSERT_EQUAL_size_t(0, result->txt_count);
|
||||
TEST_ASSERT_EQUAL_STRING(HOSTNAME, result->hostname);
|
||||
TEST_ASSERT_EQUAL_UINT16(SRV_PORT, result->port);
|
||||
TEST_ASSERT_NOT_NULL(result->addr);
|
||||
mdns_query_results_free(result);
|
||||
|
||||
// Remove SRV. Cached addresses remain but must not appear in the result.
|
||||
TEST_ASSERT_EQUAL(MDNS_CACHE_UPDATED, update_test_record(MDNS_CACHE_RECORD_SRV, true));
|
||||
mdns_priv_cache_remove_expired_records(esp_timer_get_time());
|
||||
mdns_priv_cache_process_sync();
|
||||
TEST_ASSERT_EQUAL_size_t(2, s_observer.update_calls);
|
||||
TEST_ASSERT_EQUAL_UINT8(MDNS_CACHE_RECORD_SRV, s_observer.records);
|
||||
TEST_ASSERT_TRUE(s_observer.ptr_present);
|
||||
TEST_ASSERT_FALSE(s_observer.srv_present);
|
||||
TEST_ASSERT_NOT_NULL(s_observer.addr);
|
||||
|
||||
result = project_observed_service();
|
||||
TEST_ASSERT_NULL(result->hostname);
|
||||
TEST_ASSERT_EQUAL_UINT16(0, result->port);
|
||||
TEST_ASSERT_NULL(result->addr);
|
||||
mdns_query_results_free(result);
|
||||
|
||||
// Remove the remaining address without removing PTR.
|
||||
TEST_ASSERT_EQUAL(MDNS_CACHE_UPDATED, update_test_record(MDNS_CACHE_RECORD_ADDR, true));
|
||||
mdns_priv_cache_remove_expired_records(esp_timer_get_time());
|
||||
mdns_priv_cache_process_sync();
|
||||
TEST_ASSERT_EQUAL_size_t(3, s_observer.update_calls);
|
||||
TEST_ASSERT_EQUAL_UINT8(MDNS_CACHE_RECORD_ADDR, s_observer.records);
|
||||
TEST_ASSERT_NULL(s_observer.addr);
|
||||
TEST_ASSERT_TRUE(s_observer.ptr_present);
|
||||
TEST_ASSERT_EQUAL_UINT32(PTR_TTL, s_observer.ptr_ttl);
|
||||
TEST_ASSERT_EQUAL_size_t(0, s_observer.goodbye_calls);
|
||||
}
|
||||
|
||||
static void test_cache_expiry_extend_and_notify(void)
|
||||
{
|
||||
static const mdns_txt_linked_item_t txt = {
|
||||
.key = "key",
|
||||
.value = "value",
|
||||
.value_len = 5,
|
||||
.next = NULL,
|
||||
};
|
||||
const esp_ip_addr_t addr = make_ipv4(0x0101A8C0);
|
||||
size_t baseline = mdns_mem_get_allocation_counts();
|
||||
|
||||
// Scenario 1: Extend PTR TTL and test records expire one by one.
|
||||
// Initial state: t = 0s
|
||||
insert_complete_service();
|
||||
TEST_ASSERT_EQUAL(MDNS_CACHE_UPDATED, mdns_priv_cache_update_ptr(test_netif_a(), MDNS_IP_PROTOCOL_V4,
|
||||
INSTANCE, SERVICE, PROTO, SUBTYPE_A, 160));
|
||||
mdns_priv_cache_process_sync();
|
||||
assert_observed_complete_service();
|
||||
reset_observer();
|
||||
|
||||
// t = 60s
|
||||
TEST_ASSERT_TRUE(mdns_test_clock_advance_us(60 * MDNS_US_PER_SEC));
|
||||
TEST_ASSERT_EQUAL(MDNS_CACHE_NO_CHANGE, mdns_priv_cache_update_ptr(test_netif_a(), MDNS_IP_PROTOCOL_V4,
|
||||
INSTANCE, SERVICE, PROTO, NULL, PTR_TTL));
|
||||
mdns_priv_cache_process_sync();
|
||||
TEST_ASSERT_EQUAL_size_t(0, s_observer.update_calls);
|
||||
TEST_ASSERT_EQUAL_size_t(0, s_observer.goodbye_calls);
|
||||
|
||||
// PTR, SRV, TXT, ADDR will be expired at t = 180s, 130s, 140s, 150s respectively.
|
||||
// subtype A will expire at t = 160s.
|
||||
// t = 120s: Base PTR survives the original expiration time.
|
||||
TEST_ASSERT_TRUE(mdns_test_clock_advance_us(60 * MDNS_US_PER_SEC));
|
||||
mdns_priv_cache_remove_expired_records(esp_timer_get_time());
|
||||
mdns_priv_cache_process_sync();
|
||||
TEST_ASSERT_EQUAL_size_t(0, s_observer.update_calls);
|
||||
TEST_ASSERT_EQUAL_size_t(0, s_observer.goodbye_calls);
|
||||
// t = 129s
|
||||
TEST_ASSERT_TRUE(mdns_test_clock_advance_us(9 * MDNS_US_PER_SEC));
|
||||
mdns_priv_cache_remove_expired_records(esp_timer_get_time());
|
||||
mdns_priv_cache_process_sync();
|
||||
TEST_ASSERT_EQUAL_size_t(0, s_observer.update_calls);
|
||||
// t = 130s
|
||||
TEST_ASSERT_TRUE(mdns_test_clock_advance_us(1 * MDNS_US_PER_SEC));
|
||||
mdns_priv_cache_remove_expired_records(esp_timer_get_time());
|
||||
mdns_priv_cache_process_sync();
|
||||
TEST_ASSERT_EQUAL_size_t(1, s_observer.update_calls);
|
||||
TEST_ASSERT_EQUAL_UINT8(MDNS_CACHE_RECORD_SRV, s_observer.records);
|
||||
TEST_ASSERT_TRUE(s_observer.ptr_present);
|
||||
TEST_ASSERT_FALSE(s_observer.srv_present);
|
||||
TEST_ASSERT_TRUE(s_observer.txt_present);
|
||||
TEST_ASSERT_EQUAL_size_t(1, s_observer.address_count);
|
||||
// t = 139s
|
||||
TEST_ASSERT_TRUE(mdns_test_clock_advance_us(9 * MDNS_US_PER_SEC));
|
||||
mdns_priv_cache_remove_expired_records(esp_timer_get_time());
|
||||
mdns_priv_cache_process_sync();
|
||||
TEST_ASSERT_EQUAL_size_t(1, s_observer.update_calls);
|
||||
// t = 140s
|
||||
TEST_ASSERT_TRUE(mdns_test_clock_advance_us(1 * MDNS_US_PER_SEC));
|
||||
mdns_priv_cache_remove_expired_records(esp_timer_get_time());
|
||||
mdns_priv_cache_process_sync();
|
||||
TEST_ASSERT_EQUAL_size_t(2, s_observer.update_calls);
|
||||
TEST_ASSERT_EQUAL_UINT8(MDNS_CACHE_RECORD_TXT, s_observer.records);
|
||||
TEST_ASSERT_TRUE(s_observer.ptr_present);
|
||||
TEST_ASSERT_FALSE(s_observer.txt_present);
|
||||
TEST_ASSERT_EQUAL_size_t(0, s_observer.txt_count);
|
||||
TEST_ASSERT_EQUAL_size_t(1, s_observer.address_count);
|
||||
// t = 149s
|
||||
TEST_ASSERT_TRUE(mdns_test_clock_advance_us(9 * MDNS_US_PER_SEC));
|
||||
mdns_priv_cache_remove_expired_records(esp_timer_get_time());
|
||||
mdns_priv_cache_process_sync();
|
||||
TEST_ASSERT_EQUAL_size_t(2, s_observer.update_calls);
|
||||
// t = 150s
|
||||
TEST_ASSERT_TRUE(mdns_test_clock_advance_us(1 * MDNS_US_PER_SEC));
|
||||
mdns_priv_cache_remove_expired_records(esp_timer_get_time());
|
||||
mdns_priv_cache_process_sync();
|
||||
TEST_ASSERT_EQUAL_size_t(3, s_observer.update_calls);
|
||||
TEST_ASSERT_EQUAL_UINT8(MDNS_CACHE_RECORD_ADDR, s_observer.records);
|
||||
TEST_ASSERT_TRUE(s_observer.ptr_present);
|
||||
TEST_ASSERT_EQUAL_size_t(0, s_observer.address_count);
|
||||
// t = 159s
|
||||
TEST_ASSERT_TRUE(mdns_test_clock_advance_us(9 * MDNS_US_PER_SEC));
|
||||
mdns_priv_cache_remove_expired_records(esp_timer_get_time());
|
||||
mdns_priv_cache_process_sync();
|
||||
TEST_ASSERT_EQUAL_size_t(3, s_observer.update_calls);
|
||||
// t = 160s
|
||||
TEST_ASSERT_TRUE(mdns_test_clock_advance_us(1 * MDNS_US_PER_SEC));
|
||||
mdns_priv_cache_remove_expired_records(esp_timer_get_time());
|
||||
mdns_priv_cache_process_sync();
|
||||
TEST_ASSERT_EQUAL_size_t(1, s_observer.goodbye_calls);
|
||||
TEST_ASSERT_EQUAL_STRING(SUBTYPE_A, s_observer.goodbye_subtype);
|
||||
TEST_ASSERT_EQUAL_size_t(3, s_observer.update_calls);
|
||||
// t = 179s
|
||||
TEST_ASSERT_TRUE(mdns_test_clock_advance_us(19 * MDNS_US_PER_SEC));
|
||||
mdns_priv_cache_remove_expired_records(esp_timer_get_time());
|
||||
mdns_priv_cache_process_sync();
|
||||
TEST_ASSERT_EQUAL_size_t(1, s_observer.goodbye_calls);
|
||||
// t = 180s
|
||||
TEST_ASSERT_TRUE(mdns_test_clock_advance_us(1 * MDNS_US_PER_SEC));
|
||||
mdns_priv_cache_remove_expired_records(esp_timer_get_time());
|
||||
mdns_priv_cache_process_sync();
|
||||
TEST_ASSERT_EQUAL_size_t(2, s_observer.goodbye_calls);
|
||||
TEST_ASSERT_EQUAL_STRING("", s_observer.goodbye_subtype);
|
||||
TEST_ASSERT_EQUAL_size_t(3, s_observer.update_calls);
|
||||
assert_memory(baseline);
|
||||
|
||||
// Scenario 2: Records expire at the same time.
|
||||
// Initial state: t = 0s
|
||||
mdns_priv_cache_clear();
|
||||
mdns_test_clock_reset();
|
||||
reset_observer();
|
||||
baseline = mdns_mem_get_allocation_counts();
|
||||
|
||||
TEST_ASSERT_EQUAL(MDNS_CACHE_ADDED, update_test_record(MDNS_CACHE_RECORD_PTR, false));
|
||||
TEST_ASSERT_EQUAL(MDNS_CACHE_UPDATED, mdns_priv_cache_update_srv(test_netif_a(), MDNS_IP_PROTOCOL_V4, HOSTNAME, INSTANCE,
|
||||
SERVICE, PROTO, SRV_PRIORITY, SRV_WEIGHT, SRV_PORT, 60));
|
||||
TEST_ASSERT_EQUAL(MDNS_CACHE_UPDATED, mdns_priv_cache_update_txt(test_netif_a(), MDNS_IP_PROTOCOL_V4, INSTANCE,
|
||||
SERVICE, PROTO, clone_txt(&txt), 60));
|
||||
TEST_ASSERT_EQUAL(MDNS_CACHE_UPDATED, mdns_priv_cache_update_addr(test_netif_a(), MDNS_IP_PROTOCOL_V4, HOSTNAME,
|
||||
&addr, 60));
|
||||
mdns_priv_cache_process_sync();
|
||||
TEST_ASSERT_EQUAL_size_t(1, s_observer.update_calls);
|
||||
// t = 59s
|
||||
TEST_ASSERT_TRUE(mdns_test_clock_advance_us(59 * MDNS_US_PER_SEC));
|
||||
mdns_priv_cache_remove_expired_records(esp_timer_get_time());
|
||||
mdns_priv_cache_process_sync();
|
||||
TEST_ASSERT_EQUAL_size_t(1, s_observer.update_calls);
|
||||
// t = 60s, SRV, TXT, ADDR will be expired at the same time.
|
||||
TEST_ASSERT_TRUE(mdns_test_clock_advance_us(1 * MDNS_US_PER_SEC));
|
||||
mdns_priv_cache_remove_expired_records(esp_timer_get_time());
|
||||
mdns_priv_cache_process_sync();
|
||||
TEST_ASSERT_EQUAL_size_t(2, s_observer.update_calls);
|
||||
TEST_ASSERT_EQUAL_size_t(0, s_observer.goodbye_calls);
|
||||
TEST_ASSERT_EQUAL_UINT8(MDNS_CACHE_RECORD_SRV | MDNS_CACHE_RECORD_TXT | MDNS_CACHE_RECORD_ADDR, s_observer.records);
|
||||
TEST_ASSERT_TRUE(s_observer.ptr_present);
|
||||
TEST_ASSERT_FALSE(s_observer.srv_present);
|
||||
TEST_ASSERT_FALSE(s_observer.txt_present);
|
||||
TEST_ASSERT_EQUAL_size_t(0, s_observer.address_count);
|
||||
TEST_ASSERT_EQUAL_size_t(0, s_observer.txt_count);
|
||||
// t = 120s
|
||||
TEST_ASSERT_TRUE(mdns_test_clock_advance_us(60 * MDNS_US_PER_SEC));
|
||||
mdns_priv_cache_remove_expired_records(esp_timer_get_time());
|
||||
mdns_priv_cache_process_sync();
|
||||
TEST_ASSERT_EQUAL_size_t(2, s_observer.update_calls);
|
||||
TEST_ASSERT_EQUAL_size_t(1, s_observer.goodbye_calls);
|
||||
assert_memory(baseline);
|
||||
}
|
||||
|
||||
static void test_cache_subtype_add_repeat_update_remove(void)
|
||||
{
|
||||
size_t baseline = mdns_mem_get_allocation_counts();
|
||||
|
||||
// Scenario 1: Add a subtype without establishing a base PTR.
|
||||
TEST_ASSERT_EQUAL(MDNS_CACHE_ADDED, mdns_priv_cache_update_ptr(test_netif_a(), MDNS_IP_PROTOCOL_V4,
|
||||
INSTANCE, SERVICE, PROTO, SUBTYPE_A, PTR_TTL));
|
||||
mdns_priv_cache_process_sync();
|
||||
TEST_ASSERT_EQUAL_size_t(1, s_observer.update_calls);
|
||||
TEST_ASSERT_EQUAL_UINT8(MDNS_CACHE_RECORD_SUBTYPE, s_observer.records);
|
||||
TEST_ASSERT_FALSE(s_observer.ptr_present);
|
||||
TEST_ASSERT_NOT_NULL(s_observer.subtype);
|
||||
TEST_ASSERT_EQUAL_STRING(SUBTYPE_A, s_observer.subtype->subtype);
|
||||
TEST_ASSERT_EQUAL_UINT32(PTR_TTL, s_observer.subtype->ttl);
|
||||
TEST_ASSERT_EQUAL_size_t(1, s_observer.subtype_count);
|
||||
|
||||
// Scenario 2: Repeating the subtype does not add a duplicate or notify again.
|
||||
TEST_ASSERT_EQUAL(MDNS_CACHE_NO_CHANGE, mdns_priv_cache_update_ptr(test_netif_a(), MDNS_IP_PROTOCOL_V4,
|
||||
INSTANCE, SERVICE, PROTO, SUBTYPE_A, PTR_TTL));
|
||||
mdns_priv_cache_process_sync();
|
||||
TEST_ASSERT_EQUAL_size_t(1, s_observer.update_calls);
|
||||
|
||||
// Scenario 3: Changing the TTL notifies the browser.
|
||||
TEST_ASSERT_EQUAL(MDNS_CACHE_UPDATED, mdns_priv_cache_update_ptr(test_netif_a(), MDNS_IP_PROTOCOL_V4,
|
||||
INSTANCE, SERVICE, PROTO, SUBTYPE_A, 240));
|
||||
mdns_priv_cache_process_sync();
|
||||
TEST_ASSERT_EQUAL_size_t(2, s_observer.update_calls);
|
||||
TEST_ASSERT_EQUAL_UINT32(240, s_observer.subtype->ttl);
|
||||
|
||||
// Scenario 4: Base PTR/specific subtype update/removal will not notify others
|
||||
TEST_ASSERT_EQUAL(MDNS_CACHE_UPDATED, mdns_priv_cache_update_ptr(test_netif_a(), MDNS_IP_PROTOCOL_V4,
|
||||
INSTANCE, SERVICE, PROTO, NULL, PTR_TTL));
|
||||
TEST_ASSERT_EQUAL(MDNS_CACHE_UPDATED, mdns_priv_cache_update_ptr(test_netif_a(), MDNS_IP_PROTOCOL_V4,
|
||||
INSTANCE, SERVICE, PROTO, SUBTYPE_B, 180));
|
||||
mdns_priv_cache_process_sync();
|
||||
TEST_ASSERT_EQUAL_size_t(3, s_observer.update_calls);
|
||||
TEST_ASSERT_TRUE(s_observer.ptr_present);
|
||||
TEST_ASSERT_EQUAL_size_t(2, s_observer.subtype_count);
|
||||
TEST_ASSERT_EQUAL_UINT32(s_observer.ptr_ttl, PTR_TTL);
|
||||
TEST_ASSERT_TRUE(assert_subtype_in_list(s_observer.subtype, SUBTYPE_A, 240));
|
||||
TEST_ASSERT_TRUE(assert_subtype_in_list(s_observer.subtype, SUBTYPE_B, 180));
|
||||
|
||||
TEST_ASSERT_EQUAL(MDNS_CACHE_UPDATED, mdns_priv_cache_update_ptr(test_netif_a(), MDNS_IP_PROTOCOL_V4,
|
||||
INSTANCE, SERVICE, PROTO, NULL, 0));
|
||||
mdns_priv_cache_remove_expired_records(esp_timer_get_time());
|
||||
mdns_priv_cache_process_sync();
|
||||
TEST_ASSERT_EQUAL_size_t(1, s_observer.goodbye_calls);
|
||||
TEST_ASSERT_EQUAL_size_t(3, s_observer.update_calls);
|
||||
TEST_ASSERT_FALSE(s_observer.ptr_present);
|
||||
TEST_ASSERT_EQUAL_size_t(2, s_observer.subtype_count);
|
||||
TEST_ASSERT_EQUAL_STRING("", s_observer.goodbye_subtype);
|
||||
|
||||
TEST_ASSERT_EQUAL(MDNS_CACHE_UPDATED, mdns_priv_cache_update_ptr(test_netif_a(), MDNS_IP_PROTOCOL_V4,
|
||||
INSTANCE, SERVICE, PROTO, SUBTYPE_A, 0));
|
||||
mdns_priv_cache_remove_expired_records(esp_timer_get_time());
|
||||
mdns_priv_cache_process_sync();
|
||||
TEST_ASSERT_EQUAL_size_t(2, s_observer.goodbye_calls);
|
||||
TEST_ASSERT_EQUAL_size_t(3, s_observer.update_calls);
|
||||
// Goodbye captures the last subtype before removal; no update follows cache deletion.
|
||||
TEST_ASSERT_EQUAL_size_t(2, s_observer.subtype_count);
|
||||
TEST_ASSERT_EQUAL_STRING(SUBTYPE_A, s_observer.goodbye_subtype);
|
||||
TEST_ASSERT_TRUE(assert_subtype_in_list(s_observer.subtype, SUBTYPE_B, 180));
|
||||
|
||||
TEST_ASSERT_EQUAL(MDNS_CACHE_UPDATED, mdns_priv_cache_update_ptr(test_netif_a(), MDNS_IP_PROTOCOL_V4,
|
||||
INSTANCE, SERVICE, PROTO, SUBTYPE_B, 0));
|
||||
mdns_priv_cache_remove_expired_records(esp_timer_get_time());
|
||||
mdns_priv_cache_process_sync();
|
||||
TEST_ASSERT_EQUAL_size_t(3, s_observer.goodbye_calls);
|
||||
TEST_ASSERT_EQUAL_size_t(3, s_observer.update_calls);
|
||||
// Goodbye captures the last subtype before removal; no update follows cache deletion.
|
||||
TEST_ASSERT_EQUAL_size_t(1, s_observer.subtype_count);
|
||||
TEST_ASSERT_EQUAL_STRING(SUBTYPE_B, s_observer.goodbye_subtype);
|
||||
assert_memory(baseline);
|
||||
}
|
||||
|
||||
void run_unity_tests(void)
|
||||
{
|
||||
UNITY_BEGIN();
|
||||
RUN_TEST(test_cache_ptr_add_repeat_update_remove);
|
||||
RUN_TEST(test_cache_srv_add_repeat_update_remove);
|
||||
RUN_TEST(test_cache_txt_add_repeat_update_remove);
|
||||
RUN_TEST(test_cache_addr_add_repeat_update_remove);
|
||||
RUN_TEST(test_cache_record_order_and_result_projection);
|
||||
RUN_TEST(test_cache_service_record_goodbyes);
|
||||
RUN_TEST(test_cache_expiry_extend_and_notify);
|
||||
RUN_TEST(test_cache_subtype_add_repeat_update_remove);
|
||||
UNITY_END();
|
||||
}
|
||||
+6
@@ -0,0 +1,6 @@
|
||||
# Test mdns_cache in isolation. Browse-facing functions are mocked.
|
||||
set(MOCK_FILES
|
||||
"mdns_browser"
|
||||
)
|
||||
|
||||
list(APPEND SOURCES unity/${UNIT_TESTS}/test_cache.c)
|
||||
+244
@@ -0,0 +1,244 @@
|
||||
/*
|
||||
* SPDX-FileCopyrightText: 2025-2026 Espressif Systems (Shanghai) CO LTD
|
||||
*
|
||||
* SPDX-License-Identifier: Unlicense OR CC0-1.0
|
||||
*/
|
||||
|
||||
#include "unity.h"
|
||||
#include "create_test_packet.h"
|
||||
#include "unity_main.h"
|
||||
#include "mock_mdns_pcb.h"
|
||||
#include "mock_mdns_send.h"
|
||||
#include "mdns_private.h"
|
||||
#include "mdns_utils.h"
|
||||
#include "mdns_responder.h"
|
||||
|
||||
typedef struct {
|
||||
size_t count;
|
||||
char hostname[MDNS_NAME_BUF_LEN];
|
||||
} hostname_changed_callback_context_t;
|
||||
|
||||
static void hostname_changed_callback(const char *hostname, void *arg)
|
||||
{
|
||||
hostname_changed_callback_context_t *context = arg;
|
||||
|
||||
++context->count;
|
||||
strncpy(context->hostname, hostname, sizeof(context->hostname));
|
||||
context->hostname[sizeof(context->hostname) - 1] = '\0';
|
||||
}
|
||||
|
||||
static void test_hostname_changed_callback(void)
|
||||
{
|
||||
hostname_changed_callback_context_t context = { 0 };
|
||||
|
||||
TEST_ASSERT_EQUAL(ESP_OK, mdns_register_hostname_changed_callback(hostname_changed_callback, &context));
|
||||
|
||||
TEST_ASSERT_EQUAL(ESP_OK, mdns_hostname_set("renamed-hostname"));
|
||||
TEST_ASSERT_EQUAL_UINT(1, context.count);
|
||||
TEST_ASSERT_EQUAL_STRING("renamed-hostname", context.hostname);
|
||||
|
||||
TEST_ASSERT_EQUAL(ESP_OK, mdns_hostname_set("renamed-hostname"));
|
||||
TEST_ASSERT_EQUAL_UINT(1, context.count);
|
||||
|
||||
TEST_ASSERT_EQUAL(ESP_OK, mdns_hostname_set("renamed-hostname-again"));
|
||||
TEST_ASSERT_EQUAL_UINT(2, context.count);
|
||||
TEST_ASSERT_EQUAL_STRING("renamed-hostname-again", context.hostname);
|
||||
}
|
||||
|
||||
static void test_mdns_hostname_queries(void)
|
||||
{
|
||||
// Define the queries for test4.local and test.local
|
||||
mdns_test_query_t queries[] = {
|
||||
{ "test4.local", 1, 1 }, // A record for test4.local
|
||||
{ "test.local", 1, 1 } // A record for test.local
|
||||
};
|
||||
|
||||
// Create and send the packet
|
||||
size_t packet_len;
|
||||
uint8_t* packet = create_mdns_test_packet(
|
||||
queries, 2, // Queries
|
||||
NULL, 0, // No answers
|
||||
NULL, 0, // No additional records
|
||||
&packet_len
|
||||
);
|
||||
|
||||
send_test_packet_multiple(packet, packet_len);
|
||||
}
|
||||
|
||||
// Example of a more complex test with answers and additional records
|
||||
static void test_mdns_with_answers(void)
|
||||
{
|
||||
// Define a query for _http._tcp.local PTR record
|
||||
mdns_test_query_t queries[] = {
|
||||
{ "_http._tcp.local", 12, 1 } // PTR record
|
||||
};
|
||||
|
||||
// Example data for a PTR record (simplified)
|
||||
uint8_t ptr_data[200];
|
||||
size_t ptr_data_len = encode_dns_name(ptr_data, "test._http._tcp.local");
|
||||
|
||||
// Define an answer for the PTR record
|
||||
mdns_test_answer_t answers[] = {
|
||||
{ "_http._tcp.local", 12, 1, 120, ptr_data_len, ptr_data }
|
||||
};
|
||||
|
||||
// Create and send the packet
|
||||
size_t packet_len;
|
||||
uint8_t* packet = create_mdns_test_packet(
|
||||
queries, 1, // Single query
|
||||
answers, 1, // Single answer
|
||||
NULL, 0, // No additional records
|
||||
&packet_len
|
||||
);
|
||||
|
||||
send_test_packet_multiple(packet, packet_len);
|
||||
|
||||
}
|
||||
|
||||
/*
|
||||
* Regression test for fa84ee6: packets shorter than MDNS_HEAD_LEN (12) must
|
||||
* be rejected before reading the additional RR count at offset 10.
|
||||
* An 11-byte AFL input (id_000005) previously passed the old check and read
|
||||
* one byte past the RX buffer.
|
||||
*/
|
||||
static void test_mdns_reject_short_packet(void)
|
||||
{
|
||||
static const uint8_t eleven_byte_packet[] = {
|
||||
0x00, 0xc0, 0x32, 0x00, 0x01, 0x00, 0x14, 0x00, 0x00, 0x54, 0x01
|
||||
};
|
||||
|
||||
for (size_t len = 0; len < MDNS_HEAD_LEN; len++) {
|
||||
const uint8_t *data = eleven_byte_packet;
|
||||
send_packet(true, true, (uint8_t *)data, len);
|
||||
send_packet(true, false, (uint8_t *)data, len);
|
||||
send_packet(false, true, (uint8_t *)data, len);
|
||||
send_packet(false, false, (uint8_t *)data, len);
|
||||
}
|
||||
}
|
||||
|
||||
static void test_mdns_subtype_any_question_is_not_a_probe(void)
|
||||
{
|
||||
mdns_test_query_t queries[] = {
|
||||
{ "subtype._sub._http._tcp.local", MDNS_TYPE_ANY, 1 },
|
||||
};
|
||||
size_t packet_len;
|
||||
uint8_t *packet = create_mdns_test_packet(queries, 1, NULL, 0, NULL, 0, &packet_len);
|
||||
|
||||
send_test_packet_multiple(packet, packet_len);
|
||||
}
|
||||
|
||||
static void test_mdns_reject_misplaced_sub_label(void)
|
||||
{
|
||||
uint8_t fqdn[MDNS_NAME_BUF_LEN] = {};
|
||||
mdns_name_t name = {};
|
||||
size_t fqdn_len = encode_dns_name(fqdn, "instance._http._sub._tcp.local");
|
||||
|
||||
TEST_ASSERT_NOT_NULL(mdns_utils_parse_fqdn(fqdn, fqdn, &name, fqdn_len));
|
||||
TEST_ASSERT_TRUE(name.invalid);
|
||||
|
||||
fqdn_len = encode_dns_name(fqdn, "subtype._sub._http._tcp.local");
|
||||
TEST_ASSERT_NOT_NULL(mdns_utils_parse_fqdn(fqdn, fqdn, &name, fqdn_len));
|
||||
TEST_ASSERT_FALSE(name.invalid);
|
||||
TEST_ASSERT_TRUE(name.sub);
|
||||
}
|
||||
|
||||
static void mdns_priv_create_answer_from_parsed_packet_Callback(mdns_parsed_packet_t* parsed_packet, int cmock_num_calls)
|
||||
{
|
||||
printf("callback\n");
|
||||
if (parsed_packet->questions && parsed_packet->questions->sub && parsed_packet->questions->type == MDNS_TYPE_ANY) {
|
||||
TEST_ASSERT_FALSE(parsed_packet->probe);
|
||||
}
|
||||
}
|
||||
|
||||
static size_t count_registered_services(void)
|
||||
{
|
||||
size_t count = 0;
|
||||
for (mdns_srv_item_t *a = mdns_priv_get_services(); a; a = a->next) {
|
||||
count++;
|
||||
}
|
||||
return count;
|
||||
}
|
||||
|
||||
static size_t s_parsed_question_count;
|
||||
static size_t s_parsed_sdptr_count;
|
||||
|
||||
static void discovery_dedup_answer_callback(mdns_parsed_packet_t *parsed_packet, int cmock_num_calls)
|
||||
{
|
||||
(void)cmock_num_calls;
|
||||
s_parsed_question_count = 0;
|
||||
s_parsed_sdptr_count = 0;
|
||||
TEST_ASSERT_TRUE(parsed_packet->discovery);
|
||||
for (mdns_parsed_question_t *q = parsed_packet->questions; q; q = q->next) {
|
||||
s_parsed_question_count++;
|
||||
if (q->type == MDNS_TYPE_SDPTR) {
|
||||
s_parsed_sdptr_count++;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* Duplicate _services._dns-sd._udp.local PTR questions must expand the service
|
||||
* list only once. Without the guard, each copy allocates one SDPTR question per
|
||||
* registered service (heap amplification).
|
||||
*/
|
||||
static void test_mdns_discovery_questions_deduped(void)
|
||||
{
|
||||
size_t service_count = count_registered_services();
|
||||
TEST_ASSERT_GREATER_THAN(0, service_count);
|
||||
|
||||
mdns_test_query_t queries[] = {
|
||||
{ "_services._dns-sd._udp.local", MDNS_TYPE_PTR, 1 },
|
||||
{ "_services._dns-sd._udp.local", MDNS_TYPE_PTR, 1 },
|
||||
{ "_services._dns-sd._udp.local", MDNS_TYPE_PTR, 1 },
|
||||
{ "_services._dns-sd._udp.local", MDNS_TYPE_PTR, 1 },
|
||||
};
|
||||
|
||||
mdns_priv_create_answer_from_parsed_packet_Stub(discovery_dedup_answer_callback);
|
||||
|
||||
size_t packet_len;
|
||||
uint8_t *packet = create_mdns_test_packet(queries, 4, NULL, 0, NULL, 0, &packet_len);
|
||||
TEST_ASSERT_NOT_NULL(packet);
|
||||
send_packet(true, true, packet, packet_len);
|
||||
free(packet);
|
||||
|
||||
TEST_ASSERT_EQUAL(service_count, s_parsed_sdptr_count);
|
||||
TEST_ASSERT_EQUAL(service_count, s_parsed_question_count);
|
||||
|
||||
mdns_priv_create_answer_from_parsed_packet_Stub(mdns_priv_create_answer_from_parsed_packet_Callback);
|
||||
}
|
||||
|
||||
void setup_cmock(void)
|
||||
{
|
||||
mdns_priv_probe_all_pcbs_CMockIgnore();
|
||||
mdns_priv_pcb_announce_CMockIgnore();
|
||||
mdns_priv_pcb_send_bye_service_CMockIgnore();
|
||||
mdns_priv_pcb_check_probing_services_CMockIgnore();
|
||||
mdns_priv_pcb_is_after_probing_IgnoreAndReturn(true);
|
||||
|
||||
mdns_priv_clear_tx_queue_CMockIgnore();
|
||||
mdns_priv_remove_scheduled_service_packets_CMockIgnore();
|
||||
mdns_priv_create_answer_from_parsed_packet_Stub(mdns_priv_create_answer_from_parsed_packet_Callback);
|
||||
}
|
||||
|
||||
void run_unity_tests(void)
|
||||
{
|
||||
UNITY_BEGIN();
|
||||
|
||||
// Run hostname queries test
|
||||
RUN_TEST(test_mdns_hostname_queries);
|
||||
|
||||
RUN_TEST(test_hostname_changed_callback);
|
||||
|
||||
// Run test with answers
|
||||
RUN_TEST(test_mdns_with_answers);
|
||||
|
||||
RUN_TEST(test_mdns_reject_short_packet);
|
||||
|
||||
RUN_TEST(test_mdns_subtype_any_question_is_not_a_probe);
|
||||
|
||||
RUN_TEST(test_mdns_reject_misplaced_sub_label);
|
||||
|
||||
RUN_TEST(test_mdns_discovery_questions_deduped);
|
||||
|
||||
UNITY_END();
|
||||
}
|
||||
+7
@@ -0,0 +1,7 @@
|
||||
# Testing mDNS receiver, so mocking pbb and send
|
||||
set(MOCK_FILES
|
||||
"mdns_pcb"
|
||||
"mdns_send"
|
||||
)
|
||||
|
||||
list(APPEND SOURCES unity/${UNIT_TESTS}/test_receiver.c)
|
||||
+58
@@ -0,0 +1,58 @@
|
||||
/*
|
||||
* SPDX-FileCopyrightText: 2025 Espressif Systems (Shanghai) CO LTD
|
||||
*
|
||||
* SPDX-License-Identifier: Unlicense OR CC0-1.0
|
||||
*/
|
||||
|
||||
#include "unity.h"
|
||||
#include "unity_main.h"
|
||||
#include "mock_mdns_pcb.h"
|
||||
#include "mdns_send.h"
|
||||
#include "mdns_mem_caps_test.h"
|
||||
|
||||
void setup_cmock(void)
|
||||
{
|
||||
mdns_priv_probe_all_pcbs_CMockIgnore();
|
||||
mdns_priv_pcb_announce_CMockIgnore();
|
||||
mdns_priv_pcb_send_bye_service_CMockIgnore();
|
||||
mdns_priv_pcb_check_probing_services_CMockIgnore();
|
||||
mdns_priv_pcb_is_after_probing_IgnoreAndReturn(true);
|
||||
}
|
||||
|
||||
static void test_dispatch_tx_packet(void)
|
||||
{
|
||||
mdns_tx_packet_t p = {};
|
||||
mdns_priv_dispatch_tx_packet(&p);
|
||||
}
|
||||
|
||||
static void test_cleanup_tx_action_of_scheduled_packet(void)
|
||||
{
|
||||
size_t baseline = mdns_mem_get_allocation_counts();
|
||||
mdns_tx_packet_t *packet = mdns_priv_alloc_packet(0, MDNS_IP_PROTOCOL_V4);
|
||||
TEST_ASSERT_NOT_NULL(packet);
|
||||
mdns_priv_send_after(packet, 0);
|
||||
|
||||
// State left by mdns_priv_send_packets() for a due packet whose action has not run yet:
|
||||
// the packet is marked as queued and stays linked in the TX queue
|
||||
packet->queued = true;
|
||||
mdns_action_t action = { .type = ACTION_TX_HANDLE };
|
||||
action.data.tx_handle.packet = packet;
|
||||
|
||||
// mdns_free() cleans up the pending actions first, then clears the TX queue
|
||||
mdns_priv_send_action(&action, ACTION_CLEANUP);
|
||||
mdns_priv_clear_tx_queue();
|
||||
|
||||
TEST_ASSERT_EQUAL_size_t(baseline, mdns_mem_get_allocation_counts());
|
||||
}
|
||||
|
||||
void run_unity_tests(void)
|
||||
{
|
||||
UNITY_BEGIN();
|
||||
|
||||
// Run hostname queries test
|
||||
RUN_TEST(test_dispatch_tx_packet);
|
||||
RUN_TEST(test_cleanup_tx_action_of_scheduled_packet);
|
||||
|
||||
|
||||
UNITY_END();
|
||||
}
|
||||
+6
@@ -0,0 +1,6 @@
|
||||
# Testing mDNS sender, need to mock pbb
|
||||
set(MOCK_FILES
|
||||
"mdns_pcb"
|
||||
)
|
||||
|
||||
list(APPEND SOURCES unity/${UNIT_TESTS}/test_sender.c)
|
||||
@@ -0,0 +1,67 @@
|
||||
set(UNITY_DIR "$ENV{IDF_PATH}/components/unity")
|
||||
set(CMOCK_DIR "$ENV{IDF_PATH}/components/cmock")
|
||||
|
||||
include_directories(${UNITY_DIR}/unity/src)
|
||||
add_definitions(-DENABLE_UNIT_TESTS)
|
||||
|
||||
# Use ruby command directly instead of looking for ruby.exe
|
||||
find_program(RUBY_EXECUTABLE ruby)
|
||||
if(NOT RUBY_EXECUTABLE)
|
||||
message(FATAL_ERROR "Ruby is required for CMock but was not found!")
|
||||
endif()
|
||||
|
||||
include(unity/${UNIT_TESTS}/unit_test.cmake)
|
||||
|
||||
# Verify headers exist and create mock commands for each
|
||||
foreach(mock_file ${MOCK_FILES})
|
||||
set(header_path "${COMPONENT_DIR}/private_include/${mock_file}.h")
|
||||
if(NOT EXISTS ${header_path})
|
||||
message(FATAL_ERROR "Cannot find ${mock_file}.h at ${header_path}")
|
||||
endif()
|
||||
|
||||
list(APPEND MOCK_OUTPUTS
|
||||
${CMAKE_CURRENT_BINARY_DIR}/mocks/mock_${mock_file}.c
|
||||
${CMAKE_CURRENT_BINARY_DIR}/mocks/mock_${mock_file}.h
|
||||
)
|
||||
|
||||
add_custom_command(
|
||||
OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/mocks/mock_${mock_file}.c
|
||||
${CMAKE_CURRENT_BINARY_DIR}/mocks/mock_${mock_file}.h
|
||||
COMMAND ${RUBY_EXECUTABLE}
|
||||
${CMOCK_DIR}/CMock/lib/cmock.rb
|
||||
-o${CMAKE_CURRENT_SOURCE_DIR}/unity/cmock_config.yml
|
||||
${header_path}
|
||||
DEPENDS ${header_path}
|
||||
WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
|
||||
COMMENT "Generating mock for ${mock_file}.h"
|
||||
)
|
||||
endforeach()
|
||||
|
||||
# Include CMock headers
|
||||
include_directories(
|
||||
${CMOCK_DIR}/CMock/src
|
||||
${CMAKE_CURRENT_BINARY_DIR}/mocks
|
||||
${UNITY_DIR}/unity/src
|
||||
${UNITY_DIR}/include
|
||||
unity
|
||||
)
|
||||
|
||||
# Create directory for generated mocks
|
||||
file(MAKE_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/mocks)
|
||||
|
||||
foreach(mock_file ${MOCK_FILES})
|
||||
list(REMOVE_ITEM SOURCES ${MDNS_DIR}/${mock_file}.c)
|
||||
endforeach()
|
||||
|
||||
# Add test-related sources
|
||||
list(APPEND SOURCES
|
||||
${UNITY_DIR}/unity/src/unity.c
|
||||
${CMOCK_DIR}/CMock/src/cmock.c
|
||||
unity/unity_main.c
|
||||
unity/create_test_packet.c
|
||||
)
|
||||
|
||||
# Add all generated mock files
|
||||
foreach(mock_file ${MOCK_FILES})
|
||||
list(APPEND SOURCES ${CMAKE_CURRENT_BINARY_DIR}/mocks/mock_${mock_file}.c)
|
||||
endforeach()
|
||||
@@ -0,0 +1,162 @@
|
||||
/*
|
||||
* SPDX-FileCopyrightText: 2025-2026 Espressif Systems (Shanghai) CO LTD
|
||||
*
|
||||
* SPDX-License-Identifier: Unlicense OR CC0-1.0
|
||||
*/
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <stdint.h>
|
||||
#include <unistd.h>
|
||||
#include "esp_err.h"
|
||||
#include "unity.h"
|
||||
#include "mdns_receive.h"
|
||||
#include "mdns_responder.h"
|
||||
#include "mdns_mem_caps.h"
|
||||
#include "mdns_test_clock.h"
|
||||
|
||||
// Weak set-up and tear-down functions that can be overridden by unit tests
|
||||
void __attribute__((weak)) mdns_test_set_up(void)
|
||||
{
|
||||
}
|
||||
void __attribute__((weak)) mdns_test_tear_down(void)
|
||||
{
|
||||
}
|
||||
|
||||
void setUp(void)
|
||||
{
|
||||
mdns_test_set_up();
|
||||
}
|
||||
|
||||
void tearDown(void)
|
||||
{
|
||||
mdns_test_tear_down();
|
||||
}
|
||||
|
||||
// Sample test case - update based on the actual functionality in mdns_receive.c
|
||||
void test_init(void)
|
||||
{
|
||||
|
||||
|
||||
}
|
||||
|
||||
esp_err_t mdns_packet_push(esp_ip_addr_t *addr, int port, mdns_if_t tcpip_if, uint8_t*data, size_t len);
|
||||
|
||||
mdns_search_once_t *s_a, *s_aaaa, *s_ptr, *s_srv, *s_txt;
|
||||
|
||||
void init_responder(void)
|
||||
{
|
||||
mdns_ip_addr_t addr = { .addr = { .u_addr = ESP_IPADDR_TYPE_V4 } };
|
||||
addr.addr.u_addr.ip4.addr = 0x11111111;
|
||||
mdns_txt_item_t txt[4] = {
|
||||
{"board", "esp32"},
|
||||
{"tcp_check", "no"},
|
||||
{"ssh_upload", "no"},
|
||||
{"auth_upload", "no"}
|
||||
};
|
||||
mdns_priv_responder_init();
|
||||
mdns_hostname_set("test");
|
||||
mdns_instance_name_set("test2");
|
||||
mdns_delegate_hostname_add("test3", NULL);
|
||||
mdns_delegate_hostname_add("test4", &addr);
|
||||
mdns_service_add("inst1", "_http", "_tcp", 80, txt, 4);
|
||||
mdns_service_subtype_add_for_host("inst1", "_http", "_tcp", "test", "subtype");
|
||||
mdns_service_add("inst2", "_http", "_tcp", 80, txt, 1);
|
||||
mdns_service_subtype_add_for_host("inst2", "_http", "_tcp", "test", "subtype3");
|
||||
mdns_service_add("inst3", "_http", "_tcp", 80, NULL, 0);
|
||||
mdns_service_add_for_host("deleg1", "_http", "_tcp", "test3", 80, txt, 2);
|
||||
mdns_service_add_for_host(NULL, "_http", "_tcp", "test4", 80, txt, 2);
|
||||
mdns_service_add(NULL, "_scanner", "_tcp", 80, NULL, 0);
|
||||
mdns_service_add("inst5", "_scanner", "_tcp", 80, NULL, 0);
|
||||
mdns_service_add("inst6", "_http", "_tcp", 80, NULL, 0);
|
||||
mdns_service_add("inst7", "_sleep", "_udp", 80, NULL, 0);
|
||||
|
||||
s_a = mdns_query_async_new("host_name", NULL, NULL, MDNS_TYPE_A, 1000, 1, NULL);
|
||||
s_aaaa = mdns_query_async_new("host_name2", NULL, NULL, MDNS_TYPE_AAAA, 1000, 1, NULL);
|
||||
s_ptr = mdns_query_async_new("minifritz", "_http", "_tcp", MDNS_TYPE_PTR, 1000, 1, NULL);
|
||||
s_srv = mdns_query_async_new("fritz", "_http", "_tcp", MDNS_TYPE_SRV, 1000, 1, NULL);
|
||||
s_txt = mdns_query_async_new("fritz", "_http", "_tcp", MDNS_TYPE_TXT, 1000, 1, NULL);
|
||||
|
||||
}
|
||||
|
||||
void deinit_responder(void)
|
||||
{
|
||||
mdns_query_async_delete(s_a);
|
||||
mdns_query_async_delete(s_aaaa);
|
||||
mdns_query_async_delete(s_ptr);
|
||||
mdns_query_async_delete(s_srv);
|
||||
mdns_query_async_delete(s_txt);
|
||||
mdns_service_remove_all();
|
||||
mdns_priv_responder_free();
|
||||
}
|
||||
|
||||
void send_packet(bool ip4, bool mdns_port, uint8_t*data, size_t len)
|
||||
{
|
||||
esp_ip_addr_t addr4 = ESP_IP4ADDR_INIT(192, 168, 1, 1);
|
||||
esp_ip_addr_t addr6 = ESP_IP6ADDR_INIT(0x000002ff, 0, 0, 0xfe800000);
|
||||
esp_ip_addr_t *addr = ip4 ? &addr4 : &addr6;
|
||||
int port = mdns_port ? 53 : 5353;
|
||||
|
||||
if (mdns_packet_push(addr, port, 0, data, len) != ESP_OK) {
|
||||
printf("Failed to push packet\n");
|
||||
}
|
||||
}
|
||||
|
||||
// Helper function to send a test packet with different configurations and clean up
|
||||
void send_test_packet_multiple(uint8_t* packet, size_t packet_len)
|
||||
{
|
||||
if (packet) {
|
||||
// Test with different packet configurations
|
||||
send_packet(true, true, packet, packet_len);
|
||||
send_packet(true, false, packet, packet_len);
|
||||
send_packet(false, true, packet, packet_len);
|
||||
send_packet(false, false, packet, packet_len);
|
||||
|
||||
// Free the packet
|
||||
free(packet);
|
||||
} else {
|
||||
printf("Failed to create test packet\n");
|
||||
}
|
||||
}
|
||||
|
||||
void test_mdns_receive_from_file(const char* filename)
|
||||
{
|
||||
uint8_t buf[1460];
|
||||
FILE *file = fopen(filename, "r");
|
||||
TEST_ASSERT_NOT_NULL_MESSAGE(file, "Failed to open test packet file");
|
||||
|
||||
size_t len = fread(buf, 1, 1460, file);
|
||||
fclose(file);
|
||||
|
||||
// Test with different packet configurations
|
||||
send_packet(true, true, buf, len);
|
||||
send_packet(true, false, buf, len);
|
||||
send_packet(false, true, buf, len);
|
||||
send_packet(false, false, buf, len);
|
||||
|
||||
// Add assertions here based on expected behavior
|
||||
// For example:
|
||||
// TEST_ASSERT_EQUAL(expected_result, actual_result);
|
||||
}
|
||||
|
||||
|
||||
void run_unity_tests(void);
|
||||
void setup_cmock(void);
|
||||
|
||||
int main(int argc, char **argv)
|
||||
{
|
||||
if (argc >= 2 && strcmp(argv[1], "--test") == 0) {
|
||||
mdns_test_clock_reset();
|
||||
setup_cmock();
|
||||
|
||||
init_responder();
|
||||
run_unity_tests();
|
||||
|
||||
// Propagate Unity assertion failures to CTest through the process exit code.
|
||||
const int test_status = Unity.TestFailures == 0U ? 0 : 1;
|
||||
|
||||
deinit_responder();
|
||||
return test_status;
|
||||
}
|
||||
printf("Unit test configuration: run with --test argument\n");
|
||||
return 1;
|
||||
}
|
||||
@@ -0,0 +1,10 @@
|
||||
/*
|
||||
* SPDX-FileCopyrightText: 2025 Espressif Systems (Shanghai) CO LTD
|
||||
*
|
||||
* SPDX-License-Identifier: Unlicense OR CC0-1.0
|
||||
*/
|
||||
#pragma once
|
||||
#include <stdbool.h>
|
||||
|
||||
void send_packet(bool ip4, bool mdns_port, uint8_t*data, size_t len);
|
||||
void send_test_packet_multiple(uint8_t* packet, size_t packet_len);
|
||||
Reference in new issue
Block a user