[thirdparty/pdns.git] / pdns / test-svc_records_cc.cc

#ifndef BOOST_TEST_DYN_LINK
#define BOOST_TEST_DYN_LINK
#endif

#define BOOST_TEST_NO_MAIN

#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include <boost/test/unit_test.hpp>
#include <bitset>
#include "svc-records.hh"
#include "base64.hh"

using namespace boost;

BOOST_AUTO_TEST_SUITE(test_svc_records_cc)
BOOST_AUTO_TEST_CASE(test_SvcParam_keyFromString) {
    SvcParam::SvcParamKey k;

    k = SvcParam::keyFromString("mandatory");
    BOOST_CHECK(k == 0);
    BOOST_CHECK(k == SvcParam::mandatory);

    k = SvcParam::keyFromString("alpn");
    BOOST_CHECK(k == 1);
    BOOST_CHECK(k == SvcParam::alpn);

    k = SvcParam::keyFromString("no-default-alpn");
    BOOST_CHECK(k == 2);
    BOOST_CHECK(k == SvcParam::no_default_alpn);

    k = SvcParam::keyFromString("port");
    BOOST_CHECK(k == 3);
    BOOST_CHECK(k == SvcParam::port);

    k = SvcParam::keyFromString("ipv4hint");
    BOOST_CHECK(k == 4);
    BOOST_CHECK(k == SvcParam::ipv4hint);

    k = SvcParam::keyFromString("ech");
    BOOST_CHECK(k == 5);
    BOOST_CHECK(k == SvcParam::ech);

    k = SvcParam::keyFromString("ipv6hint");
    BOOST_CHECK(k == 6);
    BOOST_CHECK(k == SvcParam::ipv6hint);

    k = SvcParam::keyFromString("key0");
    BOOST_CHECK(k == 0);
    BOOST_CHECK(k == SvcParam::mandatory);

    k = SvcParam::keyFromString("key666");
    BOOST_CHECK(k == 666);

    BOOST_CHECK_THROW(SvcParam::keyFromString("MANDATORY"), std::invalid_argument);
}

BOOST_AUTO_TEST_CASE(test_SvcParam_keyToString) {
    BOOST_CHECK_EQUAL(SvcParam::keyToString(SvcParam::mandatory), "mandatory");
    BOOST_CHECK_EQUAL(SvcParam::keyToString(SvcParam::alpn), "alpn");
    BOOST_CHECK_EQUAL(SvcParam::keyToString(SvcParam::no_default_alpn), "no-default-alpn");
    BOOST_CHECK_EQUAL(SvcParam::keyToString(SvcParam::port), "port");
    BOOST_CHECK_EQUAL(SvcParam::keyToString(SvcParam::ipv4hint), "ipv4hint");
    BOOST_CHECK_EQUAL(SvcParam::keyToString(SvcParam::ech), "ech");
    BOOST_CHECK_EQUAL(SvcParam::keyToString(SvcParam::ipv6hint), "ipv6hint");
    BOOST_CHECK_EQUAL(SvcParam::keyToString(SvcParam::SvcParamKey(7)), "key7");
    BOOST_CHECK_EQUAL(SvcParam::keyToString(SvcParam::SvcParamKey(666)), "key666");
}

BOOST_AUTO_TEST_CASE(test_SvcParam_ctor_no_value) {
    BOOST_CHECK_NO_THROW(SvcParam(SvcParam::keyFromString("no-default-alpn")));
    BOOST_CHECK_THROW(SvcParam(SvcParam::keyFromString("alpn")), std::invalid_argument);
    BOOST_CHECK_THROW(SvcParam(SvcParam::keyFromString("key666")), std::invalid_argument);
}

BOOST_AUTO_TEST_CASE(test_SvcParam_ctor_value) {
    string val = "foobar";
    auto base64val = Base64Encode(val);

    BOOST_CHECK_THROW(SvcParam(SvcParam::mandatory, val), std::invalid_argument);
    BOOST_CHECK_THROW(SvcParam(SvcParam::alpn, val), std::invalid_argument);
    BOOST_CHECK_THROW(SvcParam(SvcParam::no_default_alpn, val), std::invalid_argument);
    BOOST_CHECK_THROW(SvcParam(SvcParam::port, val), std::invalid_argument);
    BOOST_CHECK_THROW(SvcParam(SvcParam::ipv4hint, val), std::invalid_argument);
    BOOST_CHECK_THROW(SvcParam(SvcParam::ipv6hint, val), std::invalid_argument);

    SvcParam param(SvcParam::keyFromString("no-default-alpn"));
    BOOST_CHECK_NO_THROW(param = SvcParam(SvcParam::ech, base64val));
    BOOST_CHECK_EQUAL(param.getECH(), base64val);
    BOOST_CHECK_THROW(param.getValue(), std::invalid_argument);
    BOOST_CHECK_THROW(param.getALPN(), std::invalid_argument);
    BOOST_CHECK_THROW(param.getIPHints(), std::invalid_argument);
    BOOST_CHECK_THROW(param.getMandatory(), std::invalid_argument);
    BOOST_CHECK_THROW(param.getPort(), std::invalid_argument);

    // TODO test bad base64 value
    // BOOST_CHECK_THROW(SvcParam(SvcParam::ech, val), std::invalid_argument);

    // Any string is allowed.....
    BOOST_CHECK_NO_THROW(param = SvcParam(SvcParam::keyFromString("key666"), base64val));
    BOOST_CHECK_EQUAL(param.getValue(), base64val);
    BOOST_CHECK_NO_THROW(param = SvcParam(SvcParam::keyFromString("key666"), val));
    BOOST_CHECK_EQUAL(param.getValue(), val);

    BOOST_CHECK_THROW(param.getALPN(), std::invalid_argument);
    BOOST_CHECK_THROW(param.getECH(), std::invalid_argument);
    BOOST_CHECK_THROW(param.getIPHints(), std::invalid_argument);
    BOOST_CHECK_THROW(param.getMandatory(), std::invalid_argument);
    BOOST_CHECK_THROW(param.getPort(), std::invalid_argument);
}

BOOST_AUTO_TEST_CASE(test_SvcParam_ctor_set_string_value) {
    set<string> val({"foo", "bar", "baz"});

    BOOST_CHECK_THROW(SvcParam(SvcParam::alpn, std::move(val)), std::invalid_argument);
    BOOST_CHECK_THROW(SvcParam(SvcParam::no_default_alpn, std::move(val)), std::invalid_argument);
    BOOST_CHECK_THROW(SvcParam(SvcParam::port, std::move(val)), std::invalid_argument);
    BOOST_CHECK_THROW(SvcParam(SvcParam::ipv4hint, std::move(val)), std::invalid_argument);
    BOOST_CHECK_THROW(SvcParam(SvcParam::ech, std::move(val)), std::invalid_argument);
    BOOST_CHECK_THROW(SvcParam(SvcParam::ipv6hint, std::move(val)), std::invalid_argument);

    set<string> mandatoryVal = {"alpn", "key666"};
    set<SvcParam::SvcParamKey> mandatoryExpected = {SvcParam::alpn, (SvcParam::SvcParamKey)666};
    SvcParam param(SvcParam::keyFromString("no-default-alpn"));
    BOOST_CHECK_NO_THROW(param = SvcParam(SvcParam::keyFromString("mandatory"), std::move(mandatoryVal)));

    auto retval = param.getMandatory();
    BOOST_CHECK(retval == mandatoryExpected);
    BOOST_CHECK_THROW(param.getALPN(), std::invalid_argument);
    BOOST_CHECK_THROW(param.getECH(), std::invalid_argument);
    BOOST_CHECK_THROW(param.getIPHints(), std::invalid_argument);
    BOOST_CHECK_THROW(param.getPort(), std::invalid_argument);
    BOOST_CHECK_THROW(param.getValue(), std::invalid_argument);
}

BOOST_AUTO_TEST_CASE(test_SvcParam_ctor_vector_string_value) {
    auto val = vector<string>({"h3, h2"});
    auto checkVal = val;

    BOOST_CHECK_THROW(SvcParam(SvcParam::mandatory, std::move(val)), std::invalid_argument);
    BOOST_CHECK_THROW(SvcParam(SvcParam::no_default_alpn, std::move(val)), std::invalid_argument);
    BOOST_CHECK_THROW(SvcParam(SvcParam::port, std::move(val)), std::invalid_argument);
    BOOST_CHECK_THROW(SvcParam(SvcParam::ipv4hint, std::move(val)), std::invalid_argument);
    BOOST_CHECK_THROW(SvcParam(SvcParam::ech, std::move(val)), std::invalid_argument);
    BOOST_CHECK_THROW(SvcParam(SvcParam::ipv6hint, std::move(val)), std::invalid_argument);

    SvcParam param(SvcParam::keyFromString("no-default-alpn"));
    BOOST_CHECK_NO_THROW(param = SvcParam(SvcParam::keyFromString("alpn"), std::move(val)));
    auto alpns = param.getALPN();

    BOOST_CHECK_EQUAL_COLLECTIONS(alpns.begin(), alpns.end(), checkVal.begin(), checkVal.end());
    BOOST_CHECK_THROW(param.getMandatory(), std::invalid_argument);
    BOOST_CHECK_THROW(param.getECH(), std::invalid_argument);
    BOOST_CHECK_THROW(param.getIPHints(), std::invalid_argument);
    BOOST_CHECK_THROW(param.getPort(), std::invalid_argument);
    BOOST_CHECK_THROW(param.getValue(), std::invalid_argument);
}

BOOST_AUTO_TEST_CASE(test_SvcParam_ctor_set_comboaddress_value) {
    ComboAddress ca1("192.0.2.1");
    ComboAddress ca2("192.0.2.2");
    ComboAddress ca3("2001:db8::1");
    ComboAddress ca4("2001:db8::2");

    vector<ComboAddress> mixedVal({ca1, ca3});
    vector<ComboAddress> v4Val({ca1, ca2});
    auto v4CheckVal = v4Val;
    vector<ComboAddress> v6Val({ca3, ca4});
    auto v6CheckVal = v6Val;

    BOOST_CHECK_THROW(SvcParam(SvcParam::mandatory, std::move(v4Val)), std::invalid_argument);
    BOOST_CHECK_THROW(SvcParam(SvcParam::alpn, std::move(v4Val)), std::invalid_argument);
    BOOST_CHECK_THROW(SvcParam(SvcParam::no_default_alpn, std::move(v4Val)), std::invalid_argument);
    BOOST_CHECK_THROW(SvcParam(SvcParam::port, std::move(v4Val)), std::invalid_argument);
    BOOST_CHECK_THROW(SvcParam(SvcParam::ech, std::move(v4Val)), std::invalid_argument);

    BOOST_CHECK_THROW(SvcParam(SvcParam::ipv6hint, std::move(v4Val)), std::invalid_argument);
    BOOST_CHECK_THROW(SvcParam(SvcParam::ipv4hint, std::move(v6Val)), std::invalid_argument);
    BOOST_CHECK_THROW(SvcParam(SvcParam::ipv6hint, std::move(mixedVal)), std::invalid_argument);
    BOOST_CHECK_THROW(SvcParam(SvcParam::ipv4hint, std::move(mixedVal)), std::invalid_argument);

    SvcParam param(SvcParam::keyFromString("no-default-alpn"));
    BOOST_CHECK_NO_THROW(param = SvcParam(SvcParam::ipv4hint, std::move(v4Val)));

    auto retval = param.getIPHints();
    BOOST_CHECK(retval == v4CheckVal);
    BOOST_CHECK_THROW(param.getMandatory(), std::invalid_argument);
    BOOST_CHECK_THROW(param.getALPN(), std::invalid_argument);
    BOOST_CHECK_THROW(param.getECH(), std::invalid_argument);
    BOOST_CHECK_THROW(param.getPort(), std::invalid_argument);
    BOOST_CHECK_THROW(param.getValue(), std::invalid_argument);

    BOOST_CHECK_NO_THROW(param = SvcParam(SvcParam::ipv6hint, std::move(v6Val)));
    retval.clear();
    retval = param.getIPHints();
    BOOST_CHECK(retval == v6CheckVal);
    BOOST_CHECK_THROW(param.getMandatory(), std::invalid_argument);
    BOOST_CHECK_THROW(param.getALPN(), std::invalid_argument);
    BOOST_CHECK_THROW(param.getECH(), std::invalid_argument);
    BOOST_CHECK_THROW(param.getPort(), std::invalid_argument);
    BOOST_CHECK_THROW(param.getValue(), std::invalid_argument);
}

BOOST_AUTO_TEST_CASE(test_SvcParam_ctor_uint16_value) {
    uint16_t port(53);

    BOOST_CHECK_THROW(SvcParam(SvcParam::mandatory, port), std::invalid_argument);
    BOOST_CHECK_THROW(SvcParam(SvcParam::alpn, port), std::invalid_argument);
    BOOST_CHECK_THROW(SvcParam(SvcParam::no_default_alpn, port), std::invalid_argument);
    BOOST_CHECK_THROW(SvcParam(SvcParam::ipv4hint, port), std::invalid_argument);
    BOOST_CHECK_THROW(SvcParam(SvcParam::ech, port), std::invalid_argument);
    BOOST_CHECK_THROW(SvcParam(SvcParam::ipv6hint, port), std::invalid_argument);

    SvcParam param(SvcParam::keyFromString("no-default-alpn"));
    BOOST_CHECK_NO_THROW(param = SvcParam(SvcParam::port, port));
    BOOST_CHECK_EQUAL(param.getPort(), port);
    BOOST_CHECK_THROW(param.getMandatory(), std::invalid_argument);
    BOOST_CHECK_THROW(param.getALPN(), std::invalid_argument);
    BOOST_CHECK_THROW(param.getECH(), std::invalid_argument);
    BOOST_CHECK_THROW(param.getIPHints(), std::invalid_argument);
    BOOST_CHECK_THROW(param.getValue(), std::invalid_argument);
}

BOOST_AUTO_TEST_SUITE_END()
Commit	Line	Data
1c2d079d	1	#ifndef BOOST_TEST_DYN_LINK
77ea4f4c	2	#define BOOST_TEST_DYN_LINK
1c2d079d FM	3	#endif
1c2d079d FM	4
77ea4f4c	5	#define BOOST_TEST_NO_MAIN
1c2d079d	6
77ea4f4c PL	7	#ifdef HAVE_CONFIG_H
	8	#include "config.h"
	9	#endif
	10	#include <boost/test/unit_test.hpp>
	11	#include <bitset>
	12	#include "svc-records.hh"
	13	#include "base64.hh"
	14
	15	using namespace boost;
	16
	17	BOOST_AUTO_TEST_SUITE(test_svc_records_cc)
	18	BOOST_AUTO_TEST_CASE(test_SvcParam_keyFromString) {
	19	SvcParam::SvcParamKey k;
	20
	21	k = SvcParam::keyFromString("mandatory");
373914dc PL	22	BOOST_CHECK(k == 0);
373914dc PL	23	BOOST_CHECK(k == SvcParam::mandatory);
77ea4f4c PL	24
77ea4f4c PL	25	k = SvcParam::keyFromString("alpn");
373914dc PL	26	BOOST_CHECK(k == 1);
373914dc PL	27	BOOST_CHECK(k == SvcParam::alpn);
77ea4f4c PL	28
77ea4f4c PL	29	k = SvcParam::keyFromString("no-default-alpn");
373914dc PL	30	BOOST_CHECK(k == 2);
373914dc PL	31	BOOST_CHECK(k == SvcParam::no_default_alpn);
77ea4f4c PL	32
77ea4f4c PL	33	k = SvcParam::keyFromString("port");
373914dc PL	34	BOOST_CHECK(k == 3);
373914dc PL	35	BOOST_CHECK(k == SvcParam::port);
77ea4f4c PL	36
77ea4f4c PL	37	k = SvcParam::keyFromString("ipv4hint");
373914dc PL	38	BOOST_CHECK(k == 4);
373914dc PL	39	BOOST_CHECK(k == SvcParam::ipv4hint);
77ea4f4c	40
4f254e34	41	k = SvcParam::keyFromString("ech");
373914dc	42	BOOST_CHECK(k == 5);
4f254e34	43	BOOST_CHECK(k == SvcParam::ech);
77ea4f4c PL	44
77ea4f4c PL	45	k = SvcParam::keyFromString("ipv6hint");
373914dc PL	46	BOOST_CHECK(k == 6);
373914dc PL	47	BOOST_CHECK(k == SvcParam::ipv6hint);
77ea4f4c PL	48
77ea4f4c PL	49	k = SvcParam::keyFromString("key0");
373914dc PL	50	BOOST_CHECK(k == 0);
373914dc PL	51	BOOST_CHECK(k == SvcParam::mandatory);
77ea4f4c PL	52
77ea4f4c PL	53	k = SvcParam::keyFromString("key666");
373914dc	54	BOOST_CHECK(k == 666);
77ea4f4c PL	55
	56	BOOST_CHECK_THROW(SvcParam::keyFromString("MANDATORY"), std::invalid_argument);
	57	}
	58
	59	BOOST_AUTO_TEST_CASE(test_SvcParam_keyToString) {
	60	BOOST_CHECK_EQUAL(SvcParam::keyToString(SvcParam::mandatory), "mandatory");
	61	BOOST_CHECK_EQUAL(SvcParam::keyToString(SvcParam::alpn), "alpn");
	62	BOOST_CHECK_EQUAL(SvcParam::keyToString(SvcParam::no_default_alpn), "no-default-alpn");
	63	BOOST_CHECK_EQUAL(SvcParam::keyToString(SvcParam::port), "port");
	64	BOOST_CHECK_EQUAL(SvcParam::keyToString(SvcParam::ipv4hint), "ipv4hint");
4f254e34	65	BOOST_CHECK_EQUAL(SvcParam::keyToString(SvcParam::ech), "ech");
77ea4f4c PL	66	BOOST_CHECK_EQUAL(SvcParam::keyToString(SvcParam::ipv6hint), "ipv6hint");
	67	BOOST_CHECK_EQUAL(SvcParam::keyToString(SvcParam::SvcParamKey(7)), "key7");
	68	BOOST_CHECK_EQUAL(SvcParam::keyToString(SvcParam::SvcParamKey(666)), "key666");
	69	}
	70
	71	BOOST_AUTO_TEST_CASE(test_SvcParam_ctor_no_value) {
373914dc PL	72	BOOST_CHECK_NO_THROW(SvcParam(SvcParam::keyFromString("no-default-alpn")));
373914dc PL	73	BOOST_CHECK_THROW(SvcParam(SvcParam::keyFromString("alpn")), std::invalid_argument);
77ea4f4c PL	74	BOOST_CHECK_THROW(SvcParam(SvcParam::keyFromString("key666")), std::invalid_argument);
	75	}
	76
	77	BOOST_AUTO_TEST_CASE(test_SvcParam_ctor_value) {
	78	string val = "foobar";
	79	auto base64val = Base64Encode(val);
77ea4f4c PL	80
	81	BOOST_CHECK_THROW(SvcParam(SvcParam::mandatory, val), std::invalid_argument);
	82	BOOST_CHECK_THROW(SvcParam(SvcParam::alpn, val), std::invalid_argument);
	83	BOOST_CHECK_THROW(SvcParam(SvcParam::no_default_alpn, val), std::invalid_argument);
	84	BOOST_CHECK_THROW(SvcParam(SvcParam::port, val), std::invalid_argument);
	85	BOOST_CHECK_THROW(SvcParam(SvcParam::ipv4hint, val), std::invalid_argument);
	86	BOOST_CHECK_THROW(SvcParam(SvcParam::ipv6hint, val), std::invalid_argument);
	87
b9516294	88	SvcParam param(SvcParam::keyFromString("no-default-alpn"));
4f254e34 PL	89	BOOST_CHECK_NO_THROW(param = SvcParam(SvcParam::ech, base64val));
4f254e34 PL	90	BOOST_CHECK_EQUAL(param.getECH(), base64val);
77ea4f4c PL	91	BOOST_CHECK_THROW(param.getValue(), std::invalid_argument);
	92	BOOST_CHECK_THROW(param.getALPN(), std::invalid_argument);
	93	BOOST_CHECK_THROW(param.getIPHints(), std::invalid_argument);
	94	BOOST_CHECK_THROW(param.getMandatory(), std::invalid_argument);
	95	BOOST_CHECK_THROW(param.getPort(), std::invalid_argument);
	96
	97	// TODO test bad base64 value
4f254e34	98	// BOOST_CHECK_THROW(SvcParam(SvcParam::ech, val), std::invalid_argument);
77ea4f4c PL	99
	100	// Any string is allowed.....
	101	BOOST_CHECK_NO_THROW(param = SvcParam(SvcParam::keyFromString("key666"), base64val));
	102	BOOST_CHECK_EQUAL(param.getValue(), base64val);
	103	BOOST_CHECK_NO_THROW(param = SvcParam(SvcParam::keyFromString("key666"), val));
	104	BOOST_CHECK_EQUAL(param.getValue(), val);
	105
	106	BOOST_CHECK_THROW(param.getALPN(), std::invalid_argument);
4f254e34	107	BOOST_CHECK_THROW(param.getECH(), std::invalid_argument);
77ea4f4c PL	108	BOOST_CHECK_THROW(param.getIPHints(), std::invalid_argument);
	109	BOOST_CHECK_THROW(param.getMandatory(), std::invalid_argument);
	110	BOOST_CHECK_THROW(param.getPort(), std::invalid_argument);
	111	}
	112
	113	BOOST_AUTO_TEST_CASE(test_SvcParam_ctor_set_string_value) {
	114	set<string> val({"foo", "bar", "baz"});
	115
96fdac2a PL	116	BOOST_CHECK_THROW(SvcParam(SvcParam::alpn, std::move(val)), std::invalid_argument);
	117	BOOST_CHECK_THROW(SvcParam(SvcParam::no_default_alpn, std::move(val)), std::invalid_argument);
	118	BOOST_CHECK_THROW(SvcParam(SvcParam::port, std::move(val)), std::invalid_argument);
	119	BOOST_CHECK_THROW(SvcParam(SvcParam::ipv4hint, std::move(val)), std::invalid_argument);
4f254e34	120	BOOST_CHECK_THROW(SvcParam(SvcParam::ech, std::move(val)), std::invalid_argument);
96fdac2a	121	BOOST_CHECK_THROW(SvcParam(SvcParam::ipv6hint, std::move(val)), std::invalid_argument);
77ea4f4c	122
373914dc PL	123	set<string> mandatoryVal = {"alpn", "key666"};
373914dc PL	124	set<SvcParam::SvcParamKey> mandatoryExpected = {SvcParam::alpn, (SvcParam::SvcParamKey)666};
b9516294	125	SvcParam param(SvcParam::keyFromString("no-default-alpn"));
96fdac2a	126	BOOST_CHECK_NO_THROW(param = SvcParam(SvcParam::keyFromString("mandatory"), std::move(mandatoryVal)));
77ea4f4c PL	127
77ea4f4c PL	128	auto retval = param.getMandatory();
373914dc	129	BOOST_CHECK(retval == mandatoryExpected);
77ea4f4c	130	BOOST_CHECK_THROW(param.getALPN(), std::invalid_argument);
4f254e34	131	BOOST_CHECK_THROW(param.getECH(), std::invalid_argument);
77ea4f4c PL	132	BOOST_CHECK_THROW(param.getIPHints(), std::invalid_argument);
	133	BOOST_CHECK_THROW(param.getPort(), std::invalid_argument);
	134	BOOST_CHECK_THROW(param.getValue(), std::invalid_argument);
373914dc	135	}
77ea4f4c	136
373914dc PL	137	BOOST_AUTO_TEST_CASE(test_SvcParam_ctor_vector_string_value) {
373914dc PL	138	auto val = vector<string>({"h3, h2"});
96fdac2a	139	auto checkVal = val;
373914dc	140
96fdac2a PL	141	BOOST_CHECK_THROW(SvcParam(SvcParam::mandatory, std::move(val)), std::invalid_argument);
	142	BOOST_CHECK_THROW(SvcParam(SvcParam::no_default_alpn, std::move(val)), std::invalid_argument);
	143	BOOST_CHECK_THROW(SvcParam(SvcParam::port, std::move(val)), std::invalid_argument);
	144	BOOST_CHECK_THROW(SvcParam(SvcParam::ipv4hint, std::move(val)), std::invalid_argument);
4f254e34	145	BOOST_CHECK_THROW(SvcParam(SvcParam::ech, std::move(val)), std::invalid_argument);
96fdac2a	146	BOOST_CHECK_THROW(SvcParam(SvcParam::ipv6hint, std::move(val)), std::invalid_argument);
373914dc	147
b9516294	148	SvcParam param(SvcParam::keyFromString("no-default-alpn"));
96fdac2a	149	BOOST_CHECK_NO_THROW(param = SvcParam(SvcParam::keyFromString("alpn"), std::move(val)));
373914dc PL	150	auto alpns = param.getALPN();
373914dc PL	151
96fdac2a	152	BOOST_CHECK_EQUAL_COLLECTIONS(alpns.begin(), alpns.end(), checkVal.begin(), checkVal.end());
77ea4f4c	153	BOOST_CHECK_THROW(param.getMandatory(), std::invalid_argument);
4f254e34	154	BOOST_CHECK_THROW(param.getECH(), std::invalid_argument);
77ea4f4c PL	155	BOOST_CHECK_THROW(param.getIPHints(), std::invalid_argument);
	156	BOOST_CHECK_THROW(param.getPort(), std::invalid_argument);
	157	BOOST_CHECK_THROW(param.getValue(), std::invalid_argument);
	158	}
	159
	160	BOOST_AUTO_TEST_CASE(test_SvcParam_ctor_set_comboaddress_value) {
	161	ComboAddress ca1("192.0.2.1");
	162	ComboAddress ca2("192.0.2.2");
	163	ComboAddress ca3("2001:db8::1");
	164	ComboAddress ca4("2001:db8::2");
	165
373914dc PL	166	vector<ComboAddress> mixedVal({ca1, ca3});
373914dc PL	167	vector<ComboAddress> v4Val({ca1, ca2});
96fdac2a	168	auto v4CheckVal = v4Val;
373914dc	169	vector<ComboAddress> v6Val({ca3, ca4});
96fdac2a	170	auto v6CheckVal = v6Val;
77ea4f4c	171
96fdac2a PL	172	BOOST_CHECK_THROW(SvcParam(SvcParam::mandatory, std::move(v4Val)), std::invalid_argument);
	173	BOOST_CHECK_THROW(SvcParam(SvcParam::alpn, std::move(v4Val)), std::invalid_argument);
	174	BOOST_CHECK_THROW(SvcParam(SvcParam::no_default_alpn, std::move(v4Val)), std::invalid_argument);
	175	BOOST_CHECK_THROW(SvcParam(SvcParam::port, std::move(v4Val)), std::invalid_argument);
4f254e34	176	BOOST_CHECK_THROW(SvcParam(SvcParam::ech, std::move(v4Val)), std::invalid_argument);
77ea4f4c	177
96fdac2a PL	178	BOOST_CHECK_THROW(SvcParam(SvcParam::ipv6hint, std::move(v4Val)), std::invalid_argument);
	179	BOOST_CHECK_THROW(SvcParam(SvcParam::ipv4hint, std::move(v6Val)), std::invalid_argument);
	180	BOOST_CHECK_THROW(SvcParam(SvcParam::ipv6hint, std::move(mixedVal)), std::invalid_argument);
	181	BOOST_CHECK_THROW(SvcParam(SvcParam::ipv4hint, std::move(mixedVal)), std::invalid_argument);
77ea4f4c	182
b9516294	183	SvcParam param(SvcParam::keyFromString("no-default-alpn"));
96fdac2a	184	BOOST_CHECK_NO_THROW(param = SvcParam(SvcParam::ipv4hint, std::move(v4Val)));
77ea4f4c PL	185
77ea4f4c PL	186	auto retval = param.getIPHints();
96fdac2a	187	BOOST_CHECK(retval == v4CheckVal);
77ea4f4c PL	188	BOOST_CHECK_THROW(param.getMandatory(), std::invalid_argument);
77ea4f4c PL	189	BOOST_CHECK_THROW(param.getALPN(), std::invalid_argument);
4f254e34	190	BOOST_CHECK_THROW(param.getECH(), std::invalid_argument);
77ea4f4c PL	191	BOOST_CHECK_THROW(param.getPort(), std::invalid_argument);
	192	BOOST_CHECK_THROW(param.getValue(), std::invalid_argument);
	193
96fdac2a	194	BOOST_CHECK_NO_THROW(param = SvcParam(SvcParam::ipv6hint, std::move(v6Val)));
77ea4f4c PL	195	retval.clear();
77ea4f4c PL	196	retval = param.getIPHints();
96fdac2a	197	BOOST_CHECK(retval == v6CheckVal);
77ea4f4c PL	198	BOOST_CHECK_THROW(param.getMandatory(), std::invalid_argument);
77ea4f4c PL	199	BOOST_CHECK_THROW(param.getALPN(), std::invalid_argument);
4f254e34	200	BOOST_CHECK_THROW(param.getECH(), std::invalid_argument);
77ea4f4c PL	201	BOOST_CHECK_THROW(param.getPort(), std::invalid_argument);
	202	BOOST_CHECK_THROW(param.getValue(), std::invalid_argument);
	203	}
	204
	205	BOOST_AUTO_TEST_CASE(test_SvcParam_ctor_uint16_value) {
	206	uint16_t port(53);
	207
	208	BOOST_CHECK_THROW(SvcParam(SvcParam::mandatory, port), std::invalid_argument);
	209	BOOST_CHECK_THROW(SvcParam(SvcParam::alpn, port), std::invalid_argument);
	210	BOOST_CHECK_THROW(SvcParam(SvcParam::no_default_alpn, port), std::invalid_argument);
	211	BOOST_CHECK_THROW(SvcParam(SvcParam::ipv4hint, port), std::invalid_argument);
4f254e34	212	BOOST_CHECK_THROW(SvcParam(SvcParam::ech, port), std::invalid_argument);
77ea4f4c PL	213	BOOST_CHECK_THROW(SvcParam(SvcParam::ipv6hint, port), std::invalid_argument);
77ea4f4c PL	214
b9516294	215	SvcParam param(SvcParam::keyFromString("no-default-alpn"));
77ea4f4c PL	216	BOOST_CHECK_NO_THROW(param = SvcParam(SvcParam::port, port));
	217	BOOST_CHECK_EQUAL(param.getPort(), port);
	218	BOOST_CHECK_THROW(param.getMandatory(), std::invalid_argument);
	219	BOOST_CHECK_THROW(param.getALPN(), std::invalid_argument);
4f254e34	220	BOOST_CHECK_THROW(param.getECH(), std::invalid_argument);
77ea4f4c PL	221	BOOST_CHECK_THROW(param.getIPHints(), std::invalid_argument);
	222	BOOST_CHECK_THROW(param.getValue(), std::invalid_argument);
	223	}
	224
373914dc	225	BOOST_AUTO_TEST_SUITE_END()