// SPDX-License-Identifier: BSD-3-Clause OR Apache-2.0
#include "ud3tn/common.h"
#include "ud3tn/eid.h"

#include "testud3tn_unity.h"
#include "testud3tn_eid_helpers.h"

#include <stdlib.h>
#include <string.h>

// NOTE on test data: The Null Endpoint (both ipn and dtn) receives special treatment below.

static const char *const EID_STRINGS_DTN_OK_EQUAL[] = {
	"dtn://ud3tn.dtn/",
	"dtn://ud3tn.dtn/agent1",
	"dtn://ud3tn.dtn/agent1/",
	"dtn://ud3tn.dtn/agent1/x",
	"dtn://U/",
	"dtn://U-D.3_T-N/!\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~",
};

static const char *const EID_STRINGS_IPN_OK_EQUAL[] = {
	"ipn:1.0",
	"ipn:1.1",
	"ipn:1.2.3",
	"ipn:!.0",
	"ipn:!.18446744073709551615",
	"ipn:4294967295.4294967295.18446744073709551615",
	"ipn:1.4294967295.18446744073709551615",
};

static const char *const EID_STRINGS_INVALID[] = {
	// dtn
	// invalid format
	"dtn:non",
	"dtn:NONE",
	"dtn:abcd",
	"dtn:",
	"DTN:",
	"DTN:none",
	"dtn",
	"dtn:/",
	// empty node number
	"dtn://",
	"dtn:///",
	"dtn:///A",
	"dtn:///agent1",
	// invalid characters
	"dtn://ud3tn+dtn",
	"dtn://=/__",
	"dtn://ud3tn/abc\td",

	// ipn
	// invalid format
	"ipn:1",
	"ipn:1.",
	"ipn:1..",
	"ipn:1..0",
	"ipn:1.1.",
	"ipn:1.0ABC",
	"ipn:1.0.0ABC",
	"ipn:1ABC.0",
	"ipn:-1.0",
	"ipn:1.-1",
	"ipn:1.0.-1",
	"ipn:",
	"ipn:.",
	"ipn:..",
	"ipn",
	"IPN:1.0",
	"IPN:1.0.0",
	"ipn:1:33",
	"ipn:1.1:33",
	"ipn:!",
	"ipn:!.",
	"ipn:!.1.",
	"ipn:!.1.0",
	"ipn:!.1.1",
	"ipn:!.!",
	"ipn:!.!.",
	"ipn:!.!.0",
	"ipn:1.!",
	"ipn:1.!.0",

	// overflow
	"ipn:18446744073709551616.18446744073709551616",
	"ipn:18446744073709551615.18446744073709551616",
	"ipn:18446744073709551616.18446744073709551615",
	"ipn:4294967295.4294967295.18446744073709551616",
	"ipn:4294967296.4294967295.18446744073709551615",
	"ipn:4294967295.4294967296.18446744073709551615",
	"ipn:4294967296.4294967295.0",
	"ipn:4294967295.4294967296.0",
	"ipn:0.4294967296.0",
	"ipn:4294967295.0.18446744073709551616",
	"ipn:0.18446744073709551616",
	"ipn:0.0.18446744073709551616",
	"ipn:18446744073709551616.0",

	// generic - invalid formats
	":",
	"",
	"/",
	"invalid:scheme",
	"https://d3tn.com/",
	NULL,
};

static const char *const INVALID_IPN_ULL_STRINGS[] = {
	NULL,

	// invalid chars
	" ",
	" 5",
	"-",
	"-.",

	// empty
	"",
	".",
	".0",

	// signs are not allowed
	"-7",
	"+0",

	// exclamation mark (LocalNode) is not parsed by this function
	"!",

	// overflow
	"18446744073709551616",
};

TEST_GROUP(eid);

TEST_SETUP(eid)
{
}

TEST_TEAR_DOWN(eid)
{
}

TEST(eid, eid_is_error)
{
	TEST_ASSERT(eid_is_error(EID_INVALID));
	TEST_ASSERT_FALSE(eid_is_error(EID_NULL_DTN));
	TEST_ASSERT_FALSE(eid_is_error(EID_NULL_IPN));
	TEST_ASSERT_FALSE(eid_is_error(EID_DTN("dtn:none")));
	TEST_ASSERT_FALSE(eid_is_error(EID_DTN("dtn://ud3tn.dtn/")));
	TEST_ASSERT_FALSE(eid_is_error(EID_IPN(1, 0)));
	TEST_ASSERT_FALSE(eid_is_error(EID_IPN(0, 0)));
	TEST_ASSERT_FALSE(eid_is_error(EID_IPN(0, 1)));
	TEST_ASSERT_FALSE(eid_is_error(EID_IPN_3(0, 0, 0)));
	TEST_ASSERT_FALSE(eid_is_error(EID_IPN_3(0, 1, 0)));
	TEST_ASSERT_FALSE(eid_is_error(EID_IPN_3(0, 0, 1)));
	TEST_ASSERT_FALSE(eid_is_error(EID_IPN_3(1, 0, 1)));
}

TEST(eid, eid_get_invalid)
{
	TEST_ASSERT_EQUAL_EID(eid_get_invalid(), eid_get_invalid());
	TEST_ASSERT_EQUAL(EID_SCHEME_UNKNOWN, eid_get_invalid().scheme);
	TEST_ASSERT_NULL(eid_get_invalid().dtn_eid);
}

TEST(eid, eid_get_null)
{
	TEST_ASSERT_EQUAL_EID(eid_get_null(), eid_get_null());
	TEST_ASSERT_EQUAL(EID_SCHEME_DTN, eid_get_null().scheme);
	TEST_ASSERT_NULL(eid_get_invalid().dtn_eid);
}

TEST(eid, eid_is_null)
{
	TEST_ASSERT(eid_is_null(EID_NULL_DTN));
	TEST_ASSERT(eid_is_null(EID_NULL_IPN));
	TEST_ASSERT(eid_is_null(EID_DTN(NULL)));
	TEST_ASSERT(eid_is_null(EID_IPN(0, 0)));
	TEST_ASSERT(eid_is_null(EID_IPN_3(0, 0, 0)));
	TEST_ASSERT_FALSE(eid_is_null(EID_DTN("dtn:none"))); // not normalized -> not checked
	TEST_ASSERT_FALSE(eid_is_null(EID_INVALID));
	TEST_ASSERT_FALSE(eid_is_null(EID_IPN(1, 0)));
	TEST_ASSERT_FALSE(eid_is_null(EID_IPN_3(1, 0, 0)));
	TEST_ASSERT_FALSE(eid_is_null(EID_IPN_3(1, 1, 0)));
	TEST_ASSERT_FALSE(eid_is_null(EID_IPN(4294967295UL, 0)));
}

TEST(eid, eid_is_localnode)
{
	TEST_ASSERT(eid_is_localnode(EID_IPN(4294967295UL, 0)));
	TEST_ASSERT(eid_is_localnode(EID_IPN(4294967295UL, 18446744073709551615ULL)));
	TEST_ASSERT(eid_is_localnode(EID_IPN(4294967295UL, 4294967295UL)));
	TEST_ASSERT(eid_is_localnode(EID_IPN_3(0, 4294967295UL, 1)));
	TEST_ASSERT_FALSE(eid_is_localnode(EID_INVALID));
	TEST_ASSERT_FALSE(eid_is_localnode(EID_NULL_DTN));
	TEST_ASSERT_FALSE(eid_is_localnode(EID_NULL_IPN));
	TEST_ASSERT_FALSE(eid_is_localnode(EID_IPN(1, 0)));
	TEST_ASSERT_FALSE(eid_is_localnode(EID_IPN(0, 1)));
	TEST_ASSERT_FALSE(eid_is_localnode(EID_IPN_3(1, 0, 0)));
	TEST_ASSERT_FALSE(eid_is_localnode(EID_IPN_3(1, 1, 0)));
	TEST_ASSERT_FALSE(eid_is_localnode(EID_IPN_3(1, 4294967295UL, 1)));
	TEST_ASSERT_FALSE(eid_is_localnode(EID_DTN_UD3TN));
	TEST_ASSERT_FALSE(eid_is_localnode(EID_DTN_UD3TN_AGENT));
	TEST_ASSERT_FALSE(eid_is_localnode(EID_DTN("dtn://a.dtn/~a")));
}

TEST(eid, eid_is_private_use)
{
	TEST_ASSERT(eid_is_private_use(EID_IPN_3(0, 1, 0)));
	TEST_ASSERT(eid_is_private_use(EID_IPN_3(0, 1, 1)));
	TEST_ASSERT(eid_is_private_use(EID_IPN_3(0, 0x3FFF, 0)));
	TEST_ASSERT(eid_is_private_use(EID_IPN_3(0, 0x3FFF, 18446744073709551615ULL)));
	TEST_ASSERT_FALSE(eid_is_private_use(EID_IPN_3(0, 0x4000, 1)));
	TEST_ASSERT_FALSE(eid_is_private_use(EID_IPN_3(1, 0x3FFF, 1)));
	TEST_ASSERT_FALSE(eid_is_private_use(EID_IPN_3(1, 1, 1)));
	TEST_ASSERT_FALSE(eid_is_private_use(EID_INVALID));
	TEST_ASSERT_FALSE(eid_is_private_use(EID_NULL_DTN));
	TEST_ASSERT_FALSE(eid_is_private_use(EID_NULL_IPN));
	TEST_ASSERT_FALSE(eid_is_private_use(EID_IPN(0, 1)));
	TEST_ASSERT_FALSE(eid_is_private_use(EID_IPN_3(1, 0, 0)));
	TEST_ASSERT_FALSE(eid_is_private_use(EID_IPN_3(1, 1, 0)));
	TEST_ASSERT_FALSE(eid_is_private_use(EID_IPN_3(1, 4294967295UL, 1)));
	TEST_ASSERT_FALSE(eid_is_private_use(EID_IPN(4294967295UL, 0)));
	TEST_ASSERT_FALSE(eid_is_private_use(EID_IPN(4294967295UL, 18446744073709551615ULL)));
	TEST_ASSERT_FALSE(eid_is_private_use(EID_DTN_UD3TN));
	TEST_ASSERT_FALSE(eid_is_private_use(EID_DTN_UD3TN_AGENT));
	TEST_ASSERT_FALSE(eid_is_private_use(EID_DTN("dtn://a.dtn/~a")));
}

TEST(eid, eid_from_string)
{
	TEST_ASSERT_EQUAL_AEID(EID_NULL_DTN, eid_from_string("dtn:none"));
	TEST_ASSERT_EQUAL_AEID(EID_NULL_IPN, eid_from_string("ipn:0.0"));

	for (size_t i = 0; i < ARRAY_LENGTH(EID_STRINGS_DTN_OK_EQUAL); i++)
		TEST_ASSERT_EQUAL_AEID_MESSAGE(
			EID_DTN(EID_STRINGS_DTN_OK_EQUAL[i]),
			eid_from_string(EID_STRINGS_DTN_OK_EQUAL[i]),
			EID_STRINGS_DTN_OK_EQUAL[i]
		);

	for (size_t i = 0; i < ARRAY_LENGTH(EID_STRINGS_IPN_OK_EQUAL); i++)
		TEST_ASSERT_EQUAL_AEID_MESSAGE(
			EID_IPN_S(EID_STRINGS_IPN_OK_EQUAL[i]),
			eid_from_string(EID_STRINGS_IPN_OK_EQUAL[i]),
			EID_STRINGS_IPN_OK_EQUAL[i]
		);

	for (size_t i = 0; i < ARRAY_LENGTH(EID_STRINGS_INVALID); i++)
		TEST_ASSERT_MESSAGE(
			eid_is_error(eid_from_string(EID_STRINGS_INVALID[i])),
			EID_STRINGS_INVALID[i]
		);

	// Test DTN normalization
	TEST_ASSERT_EQUAL_AEID(EID_DTN("dtn://ud3tn.dtn/"), eid_from_string("dtn://ud3tn.dtn"));
	TEST_ASSERT_EQUAL_AEID(EID_DTN("dtn://U/"), eid_from_string("dtn://U"));

	// Test DTN multicast EIDs
	TEST_ASSERT_EQUAL_AEID(
		EID_DTN("dtn://ud3tn.dtn/~mc1"),
		eid_from_string("dtn://ud3tn.dtn/~mc1")
	);
	// An empty "multicast demux" is not forbidden!
	TEST_ASSERT_EQUAL_AEID(
		EID_DTN("dtn://ud3tn.dtn/~"),
		eid_from_string("dtn://ud3tn.dtn/~")
	);

	// Test IPN Null Node
	TEST_ASSERT_EQUAL_AEID(
		EID_NULL_IPN,
		eid_from_string("ipn:0.1")
	);
	TEST_ASSERT_EQUAL_AEID(
		EID_NULL_IPN,
		eid_from_string("ipn:0.0.0")
	);
	// Non-null service numbers
	// NOTE that we assert a normalization here and consider the input valid as per RFC9758
	// 3.4.1: "[...] processors of such ipn URIs MUST consider them as the Null ipn URI."
	TEST_ASSERT_EQUAL_AEID(
		EID_NULL_IPN,
		eid_from_string("ipn:0.18446744073709551615")
	);
	TEST_ASSERT_EQUAL_AEID(
		EID_NULL_IPN,
		eid_from_string("ipn:0.0.18446744073709551615")
	);

	// Test IPN LocalNode EIDs
	TEST_ASSERT_EQUAL_AEID(
		EID_IPN(4294967295UL, 0),
		eid_from_string("ipn:!.0")
	);
	TEST_ASSERT_EQUAL_AEID(
		EID_IPN(4294967295UL, 18446744073709551615ULL),
		eid_from_string("ipn:!.18446744073709551615")
	);

	// Test IPN 3-element format
	TEST_ASSERT_EQUAL_AEID(
		EID_IPN(18446744073709551615ULL, 18446744073709551615ULL),
		eid_from_string("ipn:18446744073709551615.18446744073709551615")
	);
	TEST_ASSERT_EQUAL_AEID(
		EID_IPN_3(4294967295UL, 4294967295UL, 18446744073709551615ULL),
		eid_from_string("ipn:18446744073709551615.18446744073709551615")
	);
	TEST_ASSERT_EQUAL_AEID(
		EID_IPN_3(4294967295UL, 4294967295UL, 18446744073709551615ULL),
		eid_from_string("ipn:4294967295.4294967295.18446744073709551615")
	);
	TEST_ASSERT_EQUAL_AEID(
		EID_IPN_3(4294967295UL, 0, 18446744073709551615ULL),
		eid_from_string("ipn:4294967295.0.18446744073709551615")
	);
	TEST_ASSERT_EQUAL_AEID(
		EID_IPN_3(1, 0, 18446744073709551615ULL),
		eid_from_string("ipn:4294967296.18446744073709551615")
	);
	TEST_ASSERT_EQUAL_AEID(
		EID_IPN_3(0, 4294967295UL, 18446744073709551615ULL),
		eid_from_string("ipn:0.4294967295.18446744073709551615")
	);
	TEST_ASSERT_EQUAL_AEID(
		EID_IPN(4294967295UL, 18446744073709551615ULL),
		eid_from_string("ipn:0.4294967295.18446744073709551615")
	);

	char *const too_long_eid = malloc(EID_MAX_LEN + 2);
	int i;

	snprintf(too_long_eid, EID_MAX_LEN + 2, "dtn://");
	for (i = 6; i < EID_MAX_LEN; i++)
		too_long_eid[i] = 'd';
	too_long_eid[EID_MAX_LEN] = '/';
	too_long_eid[EID_MAX_LEN + 1] = '\0';
	TEST_ASSERT(eid_is_error(eid_from_string(too_long_eid)));
	too_long_eid[EID_MAX_LEN - 1] = '/';
	too_long_eid[EID_MAX_LEN] = '\0';
	TEST_ASSERT_EQUAL_AEID(EID_DTN(too_long_eid), eid_from_string(too_long_eid));
	free(too_long_eid);
}

TEST(eid, eid_to_string)
{
	TEST_ASSERT_EQUAL_ASTRING(NULL, eid_to_string(EID_INVALID));
	TEST_ASSERT_EQUAL_ASTRING("dtn:none", eid_to_string(EID_NULL_DTN));
	TEST_ASSERT_EQUAL_ASTRING("ipn:0.0", eid_to_string(EID_NULL_IPN));

	for (size_t i = 0; i < ARRAY_LENGTH(EID_STRINGS_DTN_OK_EQUAL); i++) {
		const char *const str = EID_STRINGS_DTN_OK_EQUAL[i];
		const struct eid eid = EID_DTN(str);
		char *result = eid_to_string(eid);

		TEST_ASSERT_NOT_NULL_MESSAGE(result, str);
		TEST_ASSERT_EQUAL_ASTRING(str, result);
	}

	for (size_t i = 0; i < ARRAY_LENGTH(EID_STRINGS_IPN_OK_EQUAL); i++) {
		const char *const str = EID_STRINGS_IPN_OK_EQUAL[i];
		const struct eid eid = EID_IPN_S(str);
		char *result = eid_to_string(eid);

		TEST_ASSERT_NOT_NULL_MESSAGE(result, str);
		TEST_ASSERT_EQUAL_ASTRING(str, result);
	}

	// No normalization on conversion *to* string
	TEST_ASSERT_EQUAL_ASTRING("dtn://ud3tn.dtn/", eid_to_string(EID_DTN("dtn://ud3tn.dtn/")));
	TEST_ASSERT_EQUAL_ASTRING("dtn://ud3tn.dtn", eid_to_string(EID_DTN("dtn://ud3tn.dtn")));

	// Test DTN multicast EIDs
	TEST_ASSERT_EQUAL_ASTRING(
		"dtn://ud3tn.dtn/~mc1",
		eid_to_string(EID_DTN("dtn://ud3tn.dtn/~mc1"))
	);
	// An empty "multicast demux" is not forbidden!
	TEST_ASSERT_EQUAL_ASTRING(
		"dtn://ud3tn.dtn/~",
		eid_to_string(EID_DTN("dtn://ud3tn.dtn/~"))
	);

	// Test IPN Null Node
	TEST_ASSERT_EQUAL_ASTRING(
		"ipn:0.18446744073709551615",
		eid_to_string(EID_IPN(0, 18446744073709551615ULL))
	);

	// Test IPN LocalNode conversion
	TEST_ASSERT_EQUAL_ASTRING(
		"ipn:!.0",
		eid_to_string(EID_IPN(4294967295UL, 0))
	);
	TEST_ASSERT_EQUAL_ASTRING(
		"ipn:!.18446744073709551615",
		eid_to_string(EID_IPN(4294967295UL, 18446744073709551615ULL))
	);

	// Test IPN 3-element format
	TEST_ASSERT_EQUAL_ASTRING(
		"ipn:4294967295.4294967295.18446744073709551615",
		eid_to_string(EID_IPN_3(4294967295UL, 4294967295UL, 18446744073709551615ULL))
	);
	TEST_ASSERT_EQUAL_ASTRING(
		"ipn:1.0.18446744073709551615",
		eid_to_string(EID_IPN_3(1, 0, 18446744073709551615ULL))
	);
	TEST_ASSERT_EQUAL_ASTRING(
		"ipn:1.18446744073709551615",
		eid_to_string(EID_IPN_3(0, 1, 18446744073709551615ULL))
	);
	TEST_ASSERT_EQUAL_ASTRING(
		"ipn:4294967294.18446744073709551615",
		eid_to_string(EID_IPN_3(0, 4294967294UL, 18446744073709551615ULL))
	);

	// Test IPN 3-element with 2-element enforcement
	TEST_ASSERT_EQUAL_ASTRING(
		"ipn:4294967296.0",
		eid_to_string2(EID_IPN_3(1, 0, 0), true)
	);
	TEST_ASSERT_EQUAL_ASTRING(
		"ipn:18446744073709551615.18446744073709551615",
		eid_to_string2(EID_IPN_3(4294967295UL, 4294967295UL, 18446744073709551615ULL), true)
	);
	TEST_ASSERT_EQUAL_ASTRING(
		"ipn:4294967296.18446744073709551615",
		eid_to_string2(EID_IPN_3(1, 0, 18446744073709551615ULL), true)
	);
}

TEST(eid, eid_free)
{
	eid_free(EID_INVALID);
	eid_free(EID_NULL_IPN);
	eid_free(EID_NULL_DTN);
	eid_free(eid_from_string("dtn://ud3tn.dtn/"));
}

TEST(eid, eid_dup)
{
	TEST_ASSERT_EQUAL_EID(eid_get_invalid(), eid_dup(EID_INVALID));
	TEST_ASSERT_EQUAL_EID(eid_get_null(), eid_dup(eid_get_null()));
	TEST_ASSERT_EQUAL_EID(EID_IPN(0, 0), eid_dup(EID_IPN(0, 0)));

	for (size_t i = 0; i < ARRAY_LENGTH(EID_STRINGS_DTN_OK_EQUAL); i++) {
		const char *const str = EID_STRINGS_DTN_OK_EQUAL[i];
		const struct eid eid = EID_DTN(str);
		struct eid dup = eid_dup(eid);

		TEST_ASSERT_NOT_NULL_MESSAGE(dup.dtn_eid, str);
		TEST_ASSERT_NOT_EQUAL_MESSAGE(eid.dtn_eid, dup.dtn_eid, str);
		TEST_ASSERT_EQUAL_AEID_MESSAGE(eid, dup, str); // frees dup
	}

	for (size_t i = 0; i < ARRAY_LENGTH(EID_STRINGS_IPN_OK_EQUAL); i++) {
		const char *const str = EID_STRINGS_IPN_OK_EQUAL[i];
		const struct eid eid = EID_IPN_S(str);
		struct eid dup = eid_dup(eid);

		TEST_ASSERT_EQUAL_AEID_MESSAGE(eid, dup, str); // frees dup
	}

	// No normalization on duplication
	TEST_ASSERT_EQUAL_AEID(EID_DTN("dtn://ud3tn.dtn"), eid_dup(EID_DTN("dtn://ud3tn.dtn")));
	TEST_ASSERT_EQUAL_AEID(EID_DTN("dtn://U"), eid_dup(EID_DTN("dtn://U")));

	// Test DTN multicast EIDs
	TEST_ASSERT_EQUAL_AEID(
		EID_DTN("dtn://ud3tn.dtn/~mc1"),
		eid_dup(EID_DTN("dtn://ud3tn.dtn/~mc1"))
	);
	// An empty "multicast demux" is not forbidden!
	TEST_ASSERT_EQUAL_AEID(
		EID_DTN("dtn://ud3tn.dtn/~"),
		eid_dup(EID_DTN("dtn://ud3tn.dtn/~"))
	);

	// Test IPN Null Node
	TEST_ASSERT_EQUAL_AEID(
		EID_IPN(0, 18446744073709551615ULL),
		eid_dup(EID_IPN(0, 18446744073709551615ULL))
	);
}

TEST(eid, eid_eq)
{
	TEST_ASSERT(eid_eq(EID_NULL_DTN, EID_NULL_DTN));
	TEST_ASSERT(eid_eq(EID_NULL_IPN, EID_NULL_IPN));
	TEST_ASSERT(eid_eq(EID_NULL_DTN, EID_NULL_IPN));
	TEST_ASSERT(eid_eq(EID_NULL_IPN, EID_NULL_DTN));
	TEST_ASSERT_FALSE(eid_eq(EID_INVALID, EID_INVALID));
	TEST_ASSERT_FALSE(eid_eq(EID_NULL_IPN, EID_INVALID));
	TEST_ASSERT_FALSE(eid_eq(EID_INVALID, EID_NULL_IPN));
	TEST_ASSERT_FALSE(eid_eq(EID_NULL_DTN, EID_INVALID));
	TEST_ASSERT_FALSE(eid_eq(EID_INVALID, EID_NULL_DTN));

	for (size_t i = 0; i < ARRAY_LENGTH(EID_STRINGS_DTN_OK_EQUAL); i++) {
		const char *const str = EID_STRINGS_DTN_OK_EQUAL[i];
		const struct eid eid = EID_DTN(str);

		TEST_ASSERT_MESSAGE(eid_eq(eid, eid), str);
		TEST_ASSERT_FALSE_MESSAGE(eid_eq(EID_INVALID, eid), str);
		TEST_ASSERT_FALSE_MESSAGE(eid_eq(eid, EID_INVALID), str);

		const struct eid eid2 = eid_from_string(str);

		TEST_ASSERT_MESSAGE(eid_eq(eid, eid2), str);
		TEST_ASSERT_MESSAGE(eid_eq(eid2, eid), str);

		eid_free(eid2);
	}

	for (size_t i = 0; i < ARRAY_LENGTH(EID_STRINGS_IPN_OK_EQUAL); i++) {
		const char *const str = EID_STRINGS_IPN_OK_EQUAL[i];
		const struct eid eid = EID_IPN_S(str);

		TEST_ASSERT_MESSAGE(eid_eq(eid, eid), str);
		TEST_ASSERT_FALSE_MESSAGE(eid_eq(EID_INVALID, eid), str);
		TEST_ASSERT_FALSE_MESSAGE(eid_eq(eid, EID_INVALID), str);

		const struct eid eid2 = eid_from_string(str);

		TEST_ASSERT_MESSAGE(eid_eq(eid, eid2), str);
		TEST_ASSERT_MESSAGE(eid_eq(eid2, eid), str);

		eid_free(eid2);
	}

	// Non-normalized DTN EIDs are not equal (-> ensure norm. on creation!)
	TEST_ASSERT_FALSE(eid_eq(EID_DTN("dtn://ud3tn.dtn/"), EID_DTN("dtn://ud3tn.dtn")));
	TEST_ASSERT_FALSE(eid_eq(EID_DTN("dtn://ud3tn.dtn"), EID_DTN("dtn://ud3tn.dtn/")));
	TEST_ASSERT_FALSE(eid_eq(EID_DTN("dtn://U/"), EID_DTN("dtn://U")));
	TEST_ASSERT_FALSE(eid_eq(EID_DTN("dtn://U"), EID_DTN("dtn://U/")));

	// Test DTN multicast EIDs (note that we use eid_from_string in one instance to prevent the
	// "pointer equals" check to trigger (equal static string literals == equal pointer)
	struct eid tmp_eid;

	tmp_eid = eid_from_string("dtn://ud3tn.dtn/~mc1");
	TEST_ASSERT(eid_eq(EID_DTN("dtn://ud3tn.dtn/~mc1"), tmp_eid));
	eid_free(tmp_eid);
	tmp_eid = eid_from_string("dtn://ud3tn.dtn/~");
	TEST_ASSERT(eid_eq(EID_DTN("dtn://ud3tn.dtn/~"), tmp_eid));
	eid_free(tmp_eid);

	// Test IPN Null Node
	TEST_ASSERT(eid_eq(
		EID_IPN(0, 18446744073709551615ULL),
		EID_IPN(0, 18446744073709551615ULL)
	));

	// Test IPN LocalNode
	TEST_ASSERT(eid_eq(
		EID_IPN(4294967295ULL, 0),
		EID_IPN_S("ipn:!.0")
	));
}

TEST(eid, eid_node_eq)
{
	// 1. Test that all EIDs for which eid_eq(a, b) applies also pass eid_eq_node(a, b)
	// 2. Pass valid EIDs through eid_get_admin_endpoint and check that node is still the same
	// 3. Apply an agent ID using eid_get_agent_eid, check again

	TEST_ASSERT(eid_node_eq(EID_NULL_DTN, EID_NULL_DTN));
	TEST_ASSERT(eid_node_eq(EID_NULL_IPN, EID_NULL_IPN));
	TEST_ASSERT(eid_node_eq(EID_NULL_DTN, EID_NULL_IPN));
	TEST_ASSERT(eid_node_eq(EID_NULL_IPN, EID_NULL_DTN));
	TEST_ASSERT_FALSE(eid_node_eq(EID_INVALID, EID_INVALID));
	TEST_ASSERT_FALSE(eid_node_eq(EID_NULL_IPN, EID_INVALID));
	TEST_ASSERT_FALSE(eid_node_eq(EID_INVALID, EID_NULL_IPN));
	TEST_ASSERT_FALSE(eid_node_eq(EID_NULL_DTN, EID_INVALID));
	TEST_ASSERT_FALSE(eid_node_eq(EID_INVALID, EID_NULL_DTN));

	for (size_t i = 0; i < ARRAY_LENGTH(EID_STRINGS_DTN_OK_EQUAL); i++) {
		const char *const str = EID_STRINGS_DTN_OK_EQUAL[i];
		const struct eid eid = EID_DTN(str);

		TEST_ASSERT_MESSAGE(eid_node_eq(eid, eid), str);
		TEST_ASSERT_FALSE_MESSAGE(eid_node_eq(EID_INVALID, eid), str);
		TEST_ASSERT_FALSE_MESSAGE(eid_node_eq(eid, EID_INVALID), str);

		const struct eid eid2 = eid_from_string(str);

		TEST_ASSERT_MESSAGE(eid_node_eq(eid, eid2), str);
		TEST_ASSERT_MESSAGE(eid_node_eq(eid2, eid), str);
		eid_free(eid2);

		const struct eid eid_adm_ep = eid_get_admin_endpoint(eid);

		TEST_ASSERT_MESSAGE(eid_node_eq(eid, eid_adm_ep), str);
		TEST_ASSERT_MESSAGE(eid_node_eq(eid_adm_ep, eid), str);

		const struct eid eid_agent_a = eid_get_agent_eid(eid_adm_ep, "agent");

		TEST_ASSERT_MESSAGE(eid_node_eq(eid, eid_agent_a), str);
		TEST_ASSERT_MESSAGE(eid_node_eq(eid_agent_a, eid), str);

		eid_free(eid_adm_ep);
		eid_free(eid_agent_a);
	}

	for (size_t i = 0; i < ARRAY_LENGTH(EID_STRINGS_IPN_OK_EQUAL); i++) {
		const char *const str = EID_STRINGS_IPN_OK_EQUAL[i];
		const struct eid eid = EID_IPN_S(str);

		TEST_ASSERT_MESSAGE(eid_node_eq(eid, eid), str);
		TEST_ASSERT_FALSE_MESSAGE(eid_node_eq(EID_INVALID, eid), str);
		TEST_ASSERT_FALSE_MESSAGE(eid_node_eq(eid, EID_INVALID), str);

		const struct eid eid2 = eid_from_string(str);

		TEST_ASSERT_MESSAGE(eid_node_eq(eid, eid2), str);
		TEST_ASSERT_MESSAGE(eid_node_eq(eid2, eid), str);
		eid_free(eid2);

		const struct eid eid_adm_ep = eid_get_admin_endpoint(eid);

		TEST_ASSERT_MESSAGE(eid_node_eq(eid, eid_adm_ep), str);
		TEST_ASSERT_MESSAGE(eid_node_eq(eid_adm_ep, eid), str);

		const struct eid eid_agent_a = eid_get_agent_eid(eid_adm_ep, "9000");

		TEST_ASSERT_MESSAGE(eid_node_eq(eid, eid_agent_a), str);
		TEST_ASSERT_MESSAGE(eid_node_eq(eid_agent_a, eid), str);

		eid_free(eid_adm_ep);
		eid_free(eid_agent_a);
	}

	// Non-normalized DTN EIDs that have the same node name
	TEST_ASSERT(eid_node_eq(EID_DTN("dtn://ud3tn.dtn/"), EID_DTN("dtn://ud3tn.dtn")));
	TEST_ASSERT(eid_node_eq(EID_DTN("dtn://ud3tn.dtn"), EID_DTN("dtn://ud3tn.dtn/")));
	TEST_ASSERT(eid_node_eq(EID_DTN("dtn://U/abc"), EID_DTN("dtn://U")));
	TEST_ASSERT(eid_node_eq(EID_DTN("dtn://U"), EID_DTN("dtn://U/abc")));

	// Test DTN multicast EIDs (note that we use eid_from_string in one instance to prevent the
	// "pointer equals" check to trigger (equal static string literals == equal pointer)
	struct eid tmp_eid;

	tmp_eid = eid_from_string("dtn://ud3tn.dtn/~mc1");
	TEST_ASSERT(eid_node_eq(EID_DTN("dtn://ud3tn.dtn/~mc1"), tmp_eid));
	eid_free(tmp_eid);
	tmp_eid = eid_from_string("dtn://ud3tn.dtn/~");
	TEST_ASSERT(eid_node_eq(EID_DTN("dtn://ud3tn.dtn/~"), tmp_eid));
	eid_free(tmp_eid);

	// Test IPN Null Node
	TEST_ASSERT(eid_node_eq(
		EID_IPN(0, 18446744073709551615ULL),
		EID_IPN(0, 18446744073709551615ULL)
	));
}

TEST(eid, eid_get_admin_endpoint)
{
	// Null Endpoint
	TEST_ASSERT_EQUAL_AEID(
		EID_NULL_DTN,
		eid_get_admin_endpoint(EID_NULL_DTN)
	);
	TEST_ASSERT_EQUAL_AEID(
		EID_NULL_IPN,
		eid_get_admin_endpoint(EID_NULL_IPN)
	);

	// Invalid must stay invalid
	TEST_ASSERT(eid_is_error(eid_get_admin_endpoint(EID_INVALID)));

	// dtn
	// NOTE that the inputs to eid_get_admin_endpoint must be valid(ated) EID structs
	TEST_ASSERT_EQUAL_AEID(
		EID_DTN("dtn://ud3tn/"),
		eid_get_admin_endpoint(EID_DTN("dtn://ud3tn/a"))
	);
	TEST_ASSERT_EQUAL_AEID(
		EID_DTN("dtn://ud3tn/"),
		eid_get_admin_endpoint(EID_DTN("dtn://ud3tn/a/"))
	);
	TEST_ASSERT_EQUAL_AEID(
		EID_DTN("dtn://ud3tn/"),
		eid_get_admin_endpoint(EID_DTN("dtn://ud3tn/a/b"))
	);
	TEST_ASSERT_EQUAL_AEID(
		EID_DTN("dtn://ud3tn/"),
		eid_get_admin_endpoint(EID_DTN("dtn://ud3tn/"))
	);
	TEST_ASSERT_EQUAL_AEID(
		EID_DTN("dtn://ud3tn/"),
		eid_get_admin_endpoint(EID_DTN("dtn://ud3tn"))
	);

	// DTN Multicast EIDs
	TEST_ASSERT_EQUAL_AEID(
		EID_DTN("dtn://ud3tn/"),
		eid_get_admin_endpoint(EID_DTN("dtn://ud3tn/~mc1"))
	);
	TEST_ASSERT_EQUAL_AEID(
		EID_DTN("dtn://ud3tn/"),
		eid_get_admin_endpoint(EID_DTN("dtn://ud3tn/~"))
	);

	// ipn
	TEST_ASSERT_EQUAL_AEID(EID_IPN(1, 0), eid_get_admin_endpoint(EID_IPN(1, 0)));
	TEST_ASSERT_EQUAL_AEID(EID_IPN(1, 0), eid_get_admin_endpoint(EID_IPN(1, 0)));
	TEST_ASSERT_EQUAL_AEID(EID_IPN(1, 0), eid_get_admin_endpoint(EID_IPN(1, 12345)));
	TEST_ASSERT_EQUAL_AEID(
		EID_IPN(18446744073709551615ULL, 0),
		eid_get_admin_endpoint(EID_IPN(18446744073709551615ULL, 12345))
	);

	// ipn Null Node
	TEST_ASSERT_EQUAL_AEID(
		EID_NULL_IPN,
		eid_get_admin_endpoint(EID_IPN(0, 18446744073709551615ULL))
	);
}

TEST(eid, eid_get_agent_eid_and_eid_get_agent_id_str)
{
	// -- eid_get_agent_eid --

	// Invalid inputs
	TEST_ASSERT_EQUAL_AEID(EID_INVALID, eid_get_agent_eid(EID_NULL_DTN, "a"));
	TEST_ASSERT_EQUAL_AEID(EID_INVALID, eid_get_agent_eid(EID_NULL_IPN, "5"));
	TEST_ASSERT_EQUAL_AEID(EID_INVALID, eid_get_agent_eid(EID_DTN("dtn://a/"), NULL));
	TEST_ASSERT(eid_is_error(eid_get_agent_eid(EID_INVALID, "a")));
	TEST_ASSERT(eid_is_error(eid_get_agent_eid(EID_INVALID, NULL)));
	TEST_ASSERT(eid_is_error(eid_get_agent_eid(EID_INVALID, "")));

	for (size_t i = 0; i < ARRAY_LENGTH(INVALID_IPN_ULL_STRINGS); i++) {
		TEST_ASSERT_EQUAL_AEID_MESSAGE(
			EID_INVALID,
			eid_get_agent_eid(EID_IPN(1, 0), INVALID_IPN_ULL_STRINGS[i]),
			INVALID_IPN_ULL_STRINGS[i]
		);
	}
	// We additionally disallow any trailing decimals.
	TEST_ASSERT(eid_is_error(eid_get_agent_eid(EID_IPN(1, 2), "18446744073709551615.")));
	TEST_ASSERT(eid_is_error(eid_get_agent_eid(EID_IPN(1, 2), "1.05")));

	TEST_ASSERT_EQUAL_AEID(
		EID_DTN("dtn://ud3tn.dtn/agent"),
		eid_get_agent_eid(EID_DTN("dtn://ud3tn.dtn"), "agent")
	);
	TEST_ASSERT_EQUAL_AEID(
		EID_DTN("dtn://ud3tn.dtn/agent"),
		eid_get_agent_eid(EID_DTN("dtn://ud3tn.dtn/"), "agent")
	);
	TEST_ASSERT_EQUAL_AEID(
		EID_DTN("dtn://ud3tn.dtn/agent"),
		eid_get_agent_eid(EID_DTN("dtn://ud3tn.dtn/~"), "agent")
	);
	TEST_ASSERT_EQUAL_AEID(
		EID_DTN("dtn://ud3tn.dtn/"),
		eid_get_agent_eid(EID_DTN("dtn://ud3tn.dtn/~mc1"), "")
	);
	// We allow multicast "agents" here
	TEST_ASSERT_EQUAL_AEID(
		EID_DTN("dtn://ud3tn.dtn/~mc"),
		eid_get_agent_eid(EID_DTN("dtn://ud3tn.dtn/"), "~mc")
	);

	TEST_ASSERT_EQUAL_AEID(
		EID_IPN(1, 1),
		eid_get_agent_eid(EID_IPN(1, 0), "1")
	);
	TEST_ASSERT_EQUAL_AEID(
		EID_IPN(1, 1),
		eid_get_agent_eid(EID_IPN(1, 1), "1")
	);
	TEST_ASSERT_EQUAL_AEID(
		EID_IPN(1, 0),
		eid_get_agent_eid(EID_IPN(1, 2), "0")
	);
	TEST_ASSERT_EQUAL_AEID(
		EID_IPN(1, 18446744073709551615ULL),
		eid_get_agent_eid(EID_IPN(1, 2), "18446744073709551615")
	);

	TEST_ASSERT_EQUAL_AEID(
		EID_IPN_3(1, 1, 1),
		eid_get_agent_eid(EID_IPN_3(1, 1, 0), "1")
	);
	TEST_ASSERT_EQUAL_AEID(
		EID_IPN_3(1, 1, 1),
		eid_get_agent_eid(EID_IPN_3(1, 1, 1), "1")
	);
	TEST_ASSERT_EQUAL_AEID(
		EID_IPN_3(4294967295UL, 4294967295UL, 18446744073709551615ULL),
		eid_get_agent_eid(
			EID_IPN_3(4294967295UL, 4294967295UL, 0),
			"18446744073709551615"
		)
	);

	// -- eid_get_agent_id_str --

	TEST_ASSERT_NULL(eid_get_agent_id_str(EID_NULL_DTN));
	TEST_ASSERT_NULL(eid_get_agent_id_str(EID_NULL_IPN));
	TEST_ASSERT_NULL(eid_get_agent_id_str(EID_INVALID));
	TEST_ASSERT_NULL(eid_get_agent_id_str(EID_DTN("dtn://ud3tn.dtn/")));
	TEST_ASSERT_NULL(eid_get_agent_id_str(EID_DTN("dtn://ud3tn.dtn")));
	TEST_ASSERT_NULL(eid_get_agent_id_str(EID_IPN(1, 0)));
	TEST_ASSERT_NULL(eid_get_agent_id_str(EID_IPN(18446744073709551615ULL, 0)));

	TEST_ASSERT_EQUAL_ASTRING("1", eid_get_agent_id_str(EID_DTN("dtn://ud3tn.dtn/1")));
	TEST_ASSERT_EQUAL_ASTRING("~", eid_get_agent_id_str(EID_DTN("dtn://ud3tn.dtn/~")));
	TEST_ASSERT_EQUAL_ASTRING("~a", eid_get_agent_id_str(EID_DTN("dtn://ud3tn.dtn/~a")));
	TEST_ASSERT_EQUAL_ASTRING(
		"1",
		eid_get_agent_id_str(EID_IPN(18446744073709551615ULL, 1)
	));
	TEST_ASSERT_EQUAL_ASTRING(
		"1",
		eid_get_agent_id_str(EID_IPN(4294967295UL, 1)
	));
	TEST_ASSERT_EQUAL_ASTRING(
		"1",
		eid_get_agent_id_str(EID_IPN_3(1, 4294967295UL, 1)
	));
	TEST_ASSERT_EQUAL_ASTRING(
		"18446744073709551615",
		eid_get_agent_id_str(EID_IPN(18446744073709551615ULL, 18446744073709551615ULL)
	));
	TEST_ASSERT_EQUAL_ASTRING(
		"18446744073709551615",
		eid_get_agent_id_str(EID_IPN_3(4294967295UL, 0, 18446744073709551615ULL)
	));

	// -- Combined test: eid_get_agent_eid -> eid_get_agent_id_str --

	for (size_t i = 0; i < ARRAY_LENGTH(EID_STRINGS_DTN_OK_EQUAL); i++) {
		const char *const str = EID_STRINGS_DTN_OK_EQUAL[i];
		const struct eid eid = EID_DTN(str);
		const struct eid eid_w_agent = eid_get_agent_eid(eid, "agent");

		TEST_ASSERT_FALSE_MESSAGE(eid_is_error(eid), str);
		TEST_ASSERT_FALSE_MESSAGE(eid_is_error(eid_w_agent), str);

		char *const agent_id_str = eid_get_agent_id_str(eid_w_agent);

		TEST_ASSERT_EQUAL_STRING_MESSAGE("agent", agent_id_str, str);

		eid_free(eid_w_agent);
		free(agent_id_str);
	}

	for (size_t i = 0; i < ARRAY_LENGTH(EID_STRINGS_IPN_OK_EQUAL); i++) {
		const char *const str = EID_STRINGS_IPN_OK_EQUAL[i];
		const struct eid eid = EID_IPN_S(str);
		const struct eid eid_w_agent = eid_get_agent_eid(eid, "9000");

		TEST_ASSERT_FALSE_MESSAGE(eid_is_error(eid), str);
		TEST_ASSERT_FALSE_MESSAGE(eid_is_error(eid_w_agent), str);

		char *const agent_id_str = eid_get_agent_id_str(eid_w_agent);

		TEST_ASSERT_EQUAL_STRING_MESSAGE("9000", agent_id_str, str);

		eid_free(eid_w_agent);
		free(agent_id_str);
	}
}

TEST(eid, eidstr_is_valid)
{
	TEST_ASSERT_TRUE(eidstr_is_valid("dtn:none"));

	for (size_t i = 0; i < ARRAY_LENGTH(EID_STRINGS_DTN_OK_EQUAL); i++)
		TEST_ASSERT_TRUE_MESSAGE(
			eidstr_is_valid(EID_STRINGS_DTN_OK_EQUAL[i]),
			EID_STRINGS_DTN_OK_EQUAL[i]
		);

	for (size_t i = 0; i < ARRAY_LENGTH(EID_STRINGS_IPN_OK_EQUAL); i++)
		TEST_ASSERT_TRUE_MESSAGE(
			eidstr_is_valid(EID_STRINGS_IPN_OK_EQUAL[i]),
			EID_STRINGS_IPN_OK_EQUAL[i]
		);

	for (size_t i = 0; i < ARRAY_LENGTH(EID_STRINGS_INVALID); i++)
		TEST_ASSERT_FALSE_MESSAGE(
			eidstr_is_valid(EID_STRINGS_INVALID[i]),
			EID_STRINGS_INVALID[i]
		);

	TEST_ASSERT_TRUE(eidstr_is_valid("dtn://ud3tn.dtn/~mc1"));
	TEST_ASSERT_TRUE(eidstr_is_valid("dtn://ud3tn.dtn/~"));

	char *const too_long_eid = malloc(EID_MAX_LEN + 2);
	int i;

	snprintf(too_long_eid, EID_MAX_LEN + 2, "dtn://");
	for (i = 6; i < EID_MAX_LEN; i++)
		too_long_eid[i] = 'd';
	too_long_eid[EID_MAX_LEN] = '/';
	too_long_eid[EID_MAX_LEN + 1] = '\0';
	TEST_ASSERT_FALSE(eidstr_is_valid(too_long_eid));
	too_long_eid[EID_MAX_LEN] = '\0';
	TEST_ASSERT_TRUE(eidstr_is_valid(too_long_eid));
	free(too_long_eid);
}

TEST(eid, eidstr_get_eid_scheme)
{
	for (size_t i = 0; i < ARRAY_LENGTH(EID_STRINGS_DTN_OK_EQUAL); i++)
		TEST_ASSERT_EQUAL_MESSAGE(
			EID_SCHEME_DTN,
			eidstr_get_eid_scheme(EID_STRINGS_DTN_OK_EQUAL[i]),
			EID_STRINGS_DTN_OK_EQUAL[i]
		);

	for (size_t i = 0; i < ARRAY_LENGTH(EID_STRINGS_IPN_OK_EQUAL); i++)
		TEST_ASSERT_EQUAL_MESSAGE(
			EID_SCHEME_IPN,
			eidstr_get_eid_scheme(EID_STRINGS_IPN_OK_EQUAL[i]),
			EID_STRINGS_IPN_OK_EQUAL[i]
		);

	// NOTE: We do not iterate over EID_STRINGS_INVALID as get_eid_scheme does not validate
	TEST_ASSERT_EQUAL(EID_SCHEME_UNKNOWN, eidstr_get_eid_scheme(""));
	TEST_ASSERT_EQUAL(EID_SCHEME_UNKNOWN, eidstr_get_eid_scheme(":"));
	TEST_ASSERT_EQUAL(EID_SCHEME_UNKNOWN, eidstr_get_eid_scheme("dtn"));
	TEST_ASSERT_EQUAL(EID_SCHEME_UNKNOWN, eidstr_get_eid_scheme("dt"));
	TEST_ASSERT_EQUAL(EID_SCHEME_UNKNOWN, eidstr_get_eid_scheme("d tn"));
	TEST_ASSERT_EQUAL(EID_SCHEME_UNKNOWN, eidstr_get_eid_scheme("ipn"));
	TEST_ASSERT_EQUAL(EID_SCHEME_UNKNOWN, eidstr_get_eid_scheme("ip"));
	TEST_ASSERT_EQUAL(EID_SCHEME_UNKNOWN, eidstr_get_eid_scheme("i pn"));
	TEST_ASSERT_EQUAL(EID_SCHEME_UNKNOWN, eidstr_get_eid_scheme("invalid"));
	TEST_ASSERT_EQUAL(EID_SCHEME_UNKNOWN, eidstr_get_eid_scheme("DTN:"));
	TEST_ASSERT_EQUAL(EID_SCHEME_UNKNOWN, eidstr_get_eid_scheme("IPN:"));
	TEST_ASSERT_EQUAL(EID_SCHEME_UNKNOWN, eidstr_get_eid_scheme("http://123"));
}

TEST(eid, eidstr_ipn_is_valid)
{
	uint64_t node, service;

	node = service = 5555;
	TEST_ASSERT_TRUE(eidstr_ipn_is_valid(
		"ipn:1.0", &node, &service
	));
	TEST_ASSERT_EQUAL_UINT64(1, node);
	TEST_ASSERT_EQUAL_UINT64(0, service);
	node = service = 5555;
	TEST_ASSERT_TRUE(eidstr_ipn_is_valid(
		"ipn:0.1.0", &node, &service
	));
	TEST_ASSERT_EQUAL_UINT64(1, node);
	TEST_ASSERT_EQUAL_UINT64(0, service);
	node = service = 5555;
	TEST_ASSERT_TRUE(eidstr_ipn_is_valid(
		"ipn:1.0.18446744073709551615",
		&node, &service
	));
	TEST_ASSERT_EQUAL_UINT64(4294967296ULL, node);
	TEST_ASSERT_EQUAL_UINT64(18446744073709551615ULL, service);
	node = service = 5555;
	TEST_ASSERT_TRUE(eidstr_ipn_is_valid(
		"ipn:18446744073709551615.18446744073709551615",
		&node, &service
	));
	TEST_ASSERT_EQUAL_UINT64(18446744073709551615ULL, node);
	TEST_ASSERT_EQUAL_UINT64(18446744073709551615ULL, service);
	node = service = 5555;
	TEST_ASSERT_TRUE(eidstr_ipn_is_valid(
		"ipn:4294967295.4294967295.18446744073709551615",
		&node, &service
	));
	TEST_ASSERT_EQUAL_UINT64(18446744073709551615ULL, node);
	TEST_ASSERT_EQUAL_UINT64(18446744073709551615ULL, service);
	node = service = 5555;
	TEST_ASSERT_TRUE(eidstr_ipn_is_valid(
		"ipn:!.18446744073709551615",
		&node, &service
	));
	TEST_ASSERT_EQUAL_UINT64(4294967295ULL, node);
	TEST_ASSERT_EQUAL_UINT64(18446744073709551615ULL, service);

	// Invalid cases
	node = service = 5555;
	TEST_ASSERT_FALSE(eidstr_ipn_is_valid(
		"ipn:18446744073709551616.18446744073709551616",
		&node, &service
	));
	TEST_ASSERT_EQUAL_UINT64(5555, node);
	TEST_ASSERT_EQUAL_UINT64(5555, service);
	TEST_ASSERT_FALSE(eidstr_ipn_is_valid(
		"ipn:18446744073709551615.18446744073709551616",
		&node, &service
	));
	TEST_ASSERT_EQUAL_UINT64(5555, node);
	TEST_ASSERT_EQUAL_UINT64(5555, service);
	TEST_ASSERT_FALSE(eidstr_ipn_is_valid(
		"ipn:18446744073709551616.18446744073709551615",
		&node, &service
	));
	TEST_ASSERT_EQUAL_UINT64(5555, node);
	TEST_ASSERT_EQUAL_UINT64(5555, service);
	TEST_ASSERT_FALSE(eidstr_ipn_is_valid(
		"ipn:4294967296.4294967295.0",
		&node, &service
	));
	TEST_ASSERT_EQUAL_UINT64(5555, node);
	TEST_ASSERT_EQUAL_UINT64(5555, service);
	TEST_ASSERT_FALSE(eidstr_ipn_is_valid(
		"ipn:4294967295.4294967296.0",
		&node, &service
	));
	TEST_ASSERT_EQUAL_UINT64(5555, node);
	TEST_ASSERT_EQUAL_UINT64(5555, service);
	TEST_ASSERT_FALSE(eidstr_ipn_is_valid(
		"ipn:4294967296.0.18446744073709551615",
		&node, &service
	));
	TEST_ASSERT_EQUAL_UINT64(5555, node);
	TEST_ASSERT_EQUAL_UINT64(5555, service);
	TEST_ASSERT_FALSE(eidstr_ipn_is_valid(
		"ipn:0.4294967296.18446744073709551615",
		&node, &service
	));
	TEST_ASSERT_EQUAL_UINT64(5555, node);
	TEST_ASSERT_EQUAL_UINT64(5555, service);
	TEST_ASSERT_FALSE(eidstr_ipn_is_valid(
		"ipn:1.",
		&node, &service
	));
	TEST_ASSERT_EQUAL_UINT64(5555, node);
	TEST_ASSERT_EQUAL_UINT64(5555, service);
	TEST_ASSERT_FALSE(eidstr_ipn_is_valid(
		"ipn:1",
		&node, &service
	));
	TEST_ASSERT_EQUAL_UINT64(5555, node);
	TEST_ASSERT_EQUAL_UINT64(5555, service);
	TEST_ASSERT_FALSE(eidstr_ipn_is_valid(
		"dtn:none",
		&node, &service
	));
	TEST_ASSERT_EQUAL_UINT64(5555, node);
	TEST_ASSERT_EQUAL_UINT64(5555, service);
	TEST_ASSERT_FALSE(eidstr_ipn_is_valid(
		"ipn:!.18446744073709551616",
		&node, &service
	));
	TEST_ASSERT_EQUAL_UINT64(5555, node);
	TEST_ASSERT_EQUAL_UINT64(5555, service);
	TEST_ASSERT_FALSE(eidstr_ipn_is_valid(
		"ipn:!.0.1",
		&node, &service
	));
	TEST_ASSERT_EQUAL_UINT64(5555, node);
	TEST_ASSERT_EQUAL_UINT64(5555, service);
	TEST_ASSERT_FALSE(eidstr_ipn_is_valid(
		"ipn:!.!",
		&node, &service
	));
	TEST_ASSERT_EQUAL_UINT64(5555, node);
	TEST_ASSERT_EQUAL_UINT64(5555, service);
	TEST_ASSERT_FALSE(eidstr_ipn_is_valid(
		"ipn:!.!.0",
		&node, &service
	));
	TEST_ASSERT_EQUAL_UINT64(5555, node);
	TEST_ASSERT_EQUAL_UINT64(5555, service);
	TEST_ASSERT_FALSE(eidstr_ipn_is_valid(
		"ipn:1.!.0",
		&node, &service
	));
	TEST_ASSERT_EQUAL_UINT64(5555, node);
	TEST_ASSERT_EQUAL_UINT64(5555, service);
	TEST_ASSERT_FALSE(eidstr_ipn_is_valid(
		"ipn:1.!",
		&node, &service
	));
	TEST_ASSERT_EQUAL_UINT64(5555, node);
	TEST_ASSERT_EQUAL_UINT64(5555, service);

	// Null Node -> Null Endpoint
	// NOTE that we assert a normalization here and consider the input valid as per RFC9758
	// 3.4.1: "[...] processors of such ipn URIs MUST consider them as the Null ipn URI."
	TEST_ASSERT_TRUE(eidstr_ipn_is_valid(
		"ipn:0.18446744073709551615",
		&node, &service
	));
	TEST_ASSERT_EQUAL_UINT64(0, node);
	TEST_ASSERT_EQUAL_UINT64(0, service);
	node = service = 5555;
	TEST_ASSERT_TRUE(eidstr_ipn_is_valid(
		"ipn:0.0.1",
		&node, &service
	));
	TEST_ASSERT_EQUAL_UINT64(0, node);
	TEST_ASSERT_EQUAL_UINT64(0, service);
	node = service = 5555;
	TEST_ASSERT_TRUE(eidstr_ipn_is_valid(
		"ipn:0.0",
		&node, &service
	));
	TEST_ASSERT_EQUAL_UINT64(0, node);
	TEST_ASSERT_EQUAL_UINT64(0, service);
	node = service = 5555;
	TEST_ASSERT_TRUE(eidstr_ipn_is_valid(
		"ipn:0.0.0",
		&node, &service
	));
	TEST_ASSERT_EQUAL_UINT64(0, node);
	TEST_ASSERT_EQUAL_UINT64(0, service);
}

TEST(eid, eidstr_parse_ipn_ull)
{
	uint64_t out = 55555;

	for (size_t i = 0; i < ARRAY_LENGTH(INVALID_IPN_ULL_STRINGS); i++) {
		TEST_ASSERT_NULL_MESSAGE(
			eidstr_parse_ipn_ull(INVALID_IPN_ULL_STRINGS[i], &out),
			INVALID_IPN_ULL_STRINGS[i]
		);
		TEST_ASSERT_EQUAL_MESSAGE(55555, out, INVALID_IPN_ULL_STRINGS[i]);
	}

	TEST_ASSERT_EQUAL_STRING("", eidstr_parse_ipn_ull("0", &out));
	TEST_ASSERT_EQUAL_UINT64(0, out);
	TEST_ASSERT_EQUAL_STRING("", eidstr_parse_ipn_ull("18446744073709551615", &out));
	TEST_ASSERT_EQUAL_UINT64(18446744073709551615ULL, out);
	TEST_ASSERT_EQUAL_STRING(".0", eidstr_parse_ipn_ull("0.0", &out));
	TEST_ASSERT_EQUAL_UINT64(0, out);
	TEST_ASSERT_EQUAL_STRING(".", eidstr_parse_ipn_ull("18446744073709551615.", &out));
	TEST_ASSERT_EQUAL_UINT64(18446744073709551615ULL, out);
}

TEST_GROUP_RUNNER(eid)
{
	RUN_TEST_CASE(eid, eid_is_error);
	RUN_TEST_CASE(eid, eid_get_invalid);
	RUN_TEST_CASE(eid, eid_get_null);
	RUN_TEST_CASE(eid, eid_is_null);
	RUN_TEST_CASE(eid, eid_is_localnode);
	RUN_TEST_CASE(eid, eid_is_private_use);
	RUN_TEST_CASE(eid, eid_from_string);
	RUN_TEST_CASE(eid, eid_to_string);
	RUN_TEST_CASE(eid, eid_free);
	RUN_TEST_CASE(eid, eid_dup);
	RUN_TEST_CASE(eid, eid_eq);
	RUN_TEST_CASE(eid, eid_node_eq);
	RUN_TEST_CASE(eid, eid_get_admin_endpoint);
	RUN_TEST_CASE(eid, eid_get_agent_eid_and_eid_get_agent_id_str);
	RUN_TEST_CASE(eid, eidstr_is_valid);
	RUN_TEST_CASE(eid, eidstr_get_eid_scheme);
	RUN_TEST_CASE(eid, eidstr_ipn_is_valid);
	RUN_TEST_CASE(eid, eidstr_parse_ipn_ull);
}