[thirdparty/pdns.git] / pdns / test-dnswriter_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 <fstream>

#include "dnswriter.hh"
#include "dnsparser.hh"

BOOST_AUTO_TEST_SUITE(test_dnswriter_cc)

BOOST_AUTO_TEST_CASE(test_compressionBool) {
  auto testCompressionBool = [](bool compress, size_t size1, size_t size2) {
    DNSName name("powerdns.com.");

    vector<uint8_t> packet;
    DNSPacketWriter pwR(packet, name, QType::A, QClass::IN, 0);
    pwR.getHeader()->qr = 1;

    pwR.startRecord(DNSName("mediumsizedlabel.example.net"), QType::A, 3600, QClass::IN, DNSResourceRecord::ANSWER, compress);
    pwR.xfrIP('P'<<24 |
              'Q'<<16 |
              'R'<<8  |
              'S');
    pwR.commit();
    BOOST_CHECK_EQUAL(pwR.size(), size1);

    pwR.startRecord(DNSName("adifferentlabel.example.net"), QType::NS, 3600, QClass::IN, DNSResourceRecord::ANSWER, compress);
    pwR.xfrName(DNSName("target.example.net"), true);
    pwR.commit();
    BOOST_CHECK_EQUAL(pwR.size(), size2);

    string spacket(packet.begin(), packet.end());

    BOOST_CHECK_NO_THROW(MOADNSParser mdp(false, spacket));
  };

  testCompressionBool(true, 74, 111);
  testCompressionBool(false, 74, 133);
}

BOOST_AUTO_TEST_CASE(test_compressionBoundary) {
  DNSName name("powerdns.com.");

  vector<uint8_t> packet;
  DNSPacketWriter pwR(packet, name, QType::A, QClass::IN, 0);
  pwR.getHeader()->qr = 1;

  /* record we want to see altered */
  pwR.startRecord(name, QType::TXT, 3600, QClass::IN, DNSResourceRecord::ANSWER);
  auto txt = string("\"")+string(16262, 'A')+string("\"");
  pwR.xfrText(txt);
  pwR.commit();
  BOOST_CHECK_EQUAL(pwR.size(), 16368U);

  pwR.startRecord(DNSName("mediumsizedlabel.example.net"), QType::A, 3600, QClass::IN, DNSResourceRecord::ANSWER);
  pwR.xfrIP('P'<<24 |
            'Q'<<16 |
            'R'<<8  |
            'S');
  pwR.commit();
  BOOST_CHECK_EQUAL(pwR.size(), 16412U); // 16412 (0x401c) puts '7example3net' at 0x4001

  pwR.startRecord(DNSName("adifferentlabel.example.net"), QType::A, 3600, QClass::IN, DNSResourceRecord::ANSWER);
  pwR.xfrIP('D'<<24 |
            'E'<<16 |
            'F'<<8  |
            'G');
  pwR.commit();
  BOOST_CHECK_EQUAL(pwR.size(), 16455U);

  string spacket(packet.begin(), packet.end());

  BOOST_CHECK_NO_THROW(MOADNSParser mdp(false, spacket));
}

BOOST_AUTO_TEST_CASE(test_xfrSvcParamKeyVals_mandatory) {
  DNSName name("powerdns.com.");
  vector<uint8_t> packet;
  DNSPacketWriter pwR(packet, name, QType::SVCB, QClass::IN, 0);
  pwR.getHeader()->qr = 1;

  set<string> keys({"alpn", "ipv6hint"});
  set<SvcParam> params({SvcParam(SvcParam::mandatory, std::move(keys))});

  pwR.startRecord(name, QType::SVCB);
  pwR.commit();
  auto start = pwR.getContent().size();

  pwR.xfrSvcParamKeyVals(params);
  pwR.commit();
  auto cit = pwR.getContent().begin();
  for (size_t i = 0; i<start; i++)
    cit++;

  vector<uint8_t> c(cit, pwR.getContent().end());
  BOOST_CHECK(c == vector<uint8_t>({0,0,0,4,0,1,0,6}));
}

BOOST_AUTO_TEST_CASE(test_xfrSvcParamKeyVals_alpn) {
  DNSName name("powerdns.com.");
  vector<uint8_t> packet;
  DNSPacketWriter pwR(packet, name, QType::SVCB, QClass::IN, 0);
  pwR.getHeader()->qr = 1;

  vector<string> alpns({"h2", "h2c", "h3"});
  set<SvcParam> params({SvcParam(SvcParam::alpn, std::move(alpns))});

  pwR.startRecord(name, QType::SVCB);
  pwR.commit();
  auto start = pwR.getContent().size();

  pwR.xfrSvcParamKeyVals(params);
  pwR.commit();
  auto cit = pwR.getContent().begin();
  for (size_t i = 0; i<start; i++)
    cit++;

  vector<uint8_t> c(cit, pwR.getContent().end());
  BOOST_CHECK(c == vector<uint8_t>({
    0,1,0,10,
    2,'h','2',
    3,'h','2','c',
    2,'h','3'}));
}

BOOST_AUTO_TEST_CASE(test_xfrSvcParamKeyVals_no_default_alpn) {
  DNSName name("powerdns.com.");
  vector<uint8_t> packet;
  DNSPacketWriter pwR(packet, name, QType::SVCB, QClass::IN, 0);
  pwR.getHeader()->qr = 1;

  set<SvcParam> params({SvcParam(SvcParam::no_default_alpn)});

  pwR.startRecord(name, QType::SVCB);
  pwR.commit();
  auto start = pwR.getContent().size();

  pwR.xfrSvcParamKeyVals(params);
  pwR.commit();
  auto cit = pwR.getContent().begin();
  for (size_t i = 0; i<start; i++)
    cit++;

  vector<uint8_t> c(cit, pwR.getContent().end());
  BOOST_CHECK(c == vector<uint8_t>({0,2,0,0}));
}

BOOST_AUTO_TEST_CASE(test_xfrSvcParamKeyVals_port) {
  DNSName name("powerdns.com.");
  vector<uint8_t> packet;
  DNSPacketWriter pwR(packet, name, QType::SVCB, QClass::IN, 0);
  pwR.getHeader()->qr = 1;

  set<SvcParam> params({SvcParam(SvcParam::port, 53)});

  pwR.startRecord(name, QType::SVCB);
  pwR.commit();
  auto start = pwR.getContent().size();

  pwR.xfrSvcParamKeyVals(params);
  pwR.commit();
  auto cit = pwR.getContent().begin();
  for (size_t i = 0; i<start; i++)
    cit++;

  vector<uint8_t> c(cit, pwR.getContent().end());
  BOOST_CHECK(c == vector<uint8_t>({0,3,0,2,0,53}));
}

BOOST_AUTO_TEST_CASE(test_xfrSvcParamKeyVals_ipv4hint) {
  DNSName name("powerdns.com.");
  vector<uint8_t> packet;
  DNSPacketWriter pwR(packet, name, QType::SVCB, QClass::IN, 0);
  pwR.getHeader()->qr = 1;

  vector<ComboAddress> addrs({ComboAddress("192.0.2.1"), ComboAddress("192.0.2.2")});
  set<SvcParam> params({SvcParam(SvcParam::ipv4hint, std::move(addrs))});

  pwR.startRecord(name, QType::SVCB);
  pwR.commit();
  auto start = pwR.getContent().size();

  pwR.xfrSvcParamKeyVals(params);
  pwR.commit();
  auto cit = pwR.getContent().begin();
  for (size_t i = 0; i<start; i++)
    cit++;

  vector<uint8_t> c(cit, pwR.getContent().end());
  BOOST_CHECK(c == vector<uint8_t>({0,4,0,8,192,0,2,1,192,0,2,2}));
}

BOOST_AUTO_TEST_CASE(test_xfrSvcParamKeyVals_ech) {
  DNSName name("powerdns.com.");
  vector<uint8_t> packet;
  DNSPacketWriter pwR(packet, name, QType::SVCB, QClass::IN, 0);
  pwR.getHeader()->qr = 1;

  set<SvcParam> params({SvcParam(SvcParam::ech, "a very bogus echconfig value")});

  pwR.startRecord(name, QType::SVCB);
  pwR.commit();
  auto start = pwR.getContent().size();

  pwR.xfrSvcParamKeyVals(params);
  pwR.commit();
  auto cit = pwR.getContent().begin();
  for (size_t i = 0; i<start; i++)
    cit++;

  vector<uint8_t> c(cit, pwR.getContent().end());
  BOOST_CHECK(c == vector<uint8_t>({0,5,0,28,
  'a',' ','v','e','r','y',' ','b','o','g','u','s',' ',
  'e','c','h','c','o','n','f','i','g',' ','v','a','l','u','e'
  }));
}

BOOST_AUTO_TEST_CASE(test_xfrSvcParamKeyVals_ipv6hint) {
  DNSName name("powerdns.com.");
  vector<uint8_t> packet;
  DNSPacketWriter pwR(packet, name, QType::SVCB, QClass::IN, 0);
  pwR.getHeader()->qr = 1;

  vector<ComboAddress> addrs({ComboAddress("2001:db8::1"), ComboAddress("2001:db8::2")});
  set<SvcParam> params({SvcParam(SvcParam::ipv6hint, std::move(addrs))});

  pwR.startRecord(name, QType::SVCB);
  pwR.commit();
  auto start = pwR.getContent().size();

  pwR.xfrSvcParamKeyVals(params);
  pwR.commit();
  auto cit = pwR.getContent().begin();
  for (size_t i = 0; i<start; i++)
    cit++;

  vector<uint8_t> c(cit, pwR.getContent().end());
  BOOST_CHECK(c == vector<uint8_t>({0,6,0,32,
  32,1,13,184,0,0,0,0,0,0,0,0,0,0,0,1,
  32,1,13,184,0,0,0,0,0,0,0,0,0,0,0,2}));
}

BOOST_AUTO_TEST_CASE(test_xfrSvcParamKeyVals_generic) {
  DNSName name("powerdns.com.");
  vector<uint8_t> packet;
  DNSPacketWriter pwR(packet, name, QType::SVCB, QClass::IN, 0);
  pwR.getHeader()->qr = 1;

  set<SvcParam> params({SvcParam(SvcParam::keyFromString("key666"), "mycoolvalue")});

  pwR.startRecord(name, QType::SVCB);
  pwR.commit();
  auto start = pwR.getContent().size();

  pwR.xfrSvcParamKeyVals(params);
  pwR.commit();
  auto cit = pwR.getContent().begin();
  for (size_t i = 0; i<start; i++)
    cit++;

  vector<uint8_t> c(cit, pwR.getContent().end());
  BOOST_CHECK(c == vector<uint8_t>({2,154,0,11,
  'm','y','c','o','o','l','v','a','l','u','e'
  }));
}

BOOST_AUTO_TEST_CASE(test_xfrSvcParamKeyVals_multiple) {
  DNSName name("powerdns.com.");
  vector<uint8_t> packet;
  DNSPacketWriter pwR(packet, name, QType::SVCB, QClass::IN, 0);
  pwR.getHeader()->qr = 1;

  vector<ComboAddress> addrs({ComboAddress("2001:db8::1"), ComboAddress("2001:db8::2")});
  vector<string> alpns({"h2", "h2c", "h3"});
  set<SvcParam> params({SvcParam(SvcParam::alpn, std::move(alpns)), SvcParam(SvcParam::ipv6hint, std::move(addrs)), SvcParam(SvcParam::port, 53)});

  pwR.startRecord(name, QType::SVCB);
  pwR.commit();
  auto start = pwR.getContent().size();

  pwR.xfrSvcParamKeyVals(params);
  pwR.commit();
  auto cit = pwR.getContent().begin();
  for (size_t i = 0; i<start; i++)
    cit++;

  vector<uint8_t> c(cit, pwR.getContent().end());
  BOOST_CHECK(c == vector<uint8_t>({
  0,1,0,10,2,'h','2',3,'h','2','c',2,'h','3',  // alpn
  0,3,0,2,0,53,                                // port    
  0,6,0,32,                                    // ipv6
  32,1,13,184,0,0,0,0,0,0,0,0,0,0,0,1,
  32,1,13,184,0,0,0,0,0,0,0,0,0,0,0,2}));
}

BOOST_AUTO_TEST_CASE(test_NodeOrLocatorID) {
  DNSName name("powerdns.com.");
  vector<uint8_t> packet;

  NodeOrLocatorID in = {0, 0, 0, 0, 0, 0, 0, 1};

  DNSPacketWriter writer(packet, name, QType::NID, QClass::IN, 0);
  writer.getHeader()->qr = 1;

  writer.startRecord(name, QType::NID);
  writer.commit();
  auto start = writer.getContent().size();

  writer.xfrNodeOrLocatorID(in);
  writer.commit();
  auto cit = writer.getContent().begin();
  for (size_t i = 0; i<start; i++)
    cit++;

  vector<uint8_t> c(cit, writer.getContent().end());
  BOOST_CHECK(c == vector<uint8_t>({
    0, 0, 0, 0,
    0, 0, 0, 1}));
}

BOOST_AUTO_TEST_SUITE_END()
Commit	Line	Data
1c2d079d	1	#ifndef BOOST_TEST_DYN_LINK
d26fa315	2	#define BOOST_TEST_DYN_LINK
1c2d079d FM	3	#endif
1c2d079d FM	4
d26fa315 PD	5	#define BOOST_TEST_NO_MAIN
	6
	7	#ifdef HAVE_CONFIG_H
	8	#include "config.h"
	9	#endif
	10
	11	#include <boost/test/unit_test.hpp>
	12	#include <fstream>
	13
	14	#include "dnswriter.hh"
	15	#include "dnsparser.hh"
	16
	17	BOOST_AUTO_TEST_SUITE(test_dnswriter_cc)
	18
02e7763f PD	19	BOOST_AUTO_TEST_CASE(test_compressionBool) {
	20	auto testCompressionBool = [](bool compress, size_t size1, size_t size2) {
	21	DNSName name("powerdns.com.");
	22
	23	vector<uint8_t> packet;
	24	DNSPacketWriter pwR(packet, name, QType::A, QClass::IN, 0);
	25	pwR.getHeader()->qr = 1;
	26
	27	pwR.startRecord(DNSName("mediumsizedlabel.example.net"), QType::A, 3600, QClass::IN, DNSResourceRecord::ANSWER, compress);
	28	pwR.xfrIP('P'<<24 \|
	29	'Q'<<16 \|
	30	'R'<<8 \|
	31	'S');
	32	pwR.commit();
	33	BOOST_CHECK_EQUAL(pwR.size(), size1);
	34
	35	pwR.startRecord(DNSName("adifferentlabel.example.net"), QType::NS, 3600, QClass::IN, DNSResourceRecord::ANSWER, compress);
	36	pwR.xfrName(DNSName("target.example.net"), true);
	37	pwR.commit();
	38	BOOST_CHECK_EQUAL(pwR.size(), size2);
	39
	40	string spacket(packet.begin(), packet.end());
	41
	42	BOOST_CHECK_NO_THROW(MOADNSParser mdp(false, spacket));
	43	};
	44
	45	testCompressionBool(true, 74, 111);
	46	testCompressionBool(false, 74, 133);
	47	}
	48
d26fa315 PD	49	BOOST_AUTO_TEST_CASE(test_compressionBoundary) {
	50	DNSName name("powerdns.com.");
	51
	52	vector<uint8_t> packet;
	53	DNSPacketWriter pwR(packet, name, QType::A, QClass::IN, 0);
	54	pwR.getHeader()->qr = 1;
	55
	56	/* record we want to see altered */
	57	pwR.startRecord(name, QType::TXT, 3600, QClass::IN, DNSResourceRecord::ANSWER);
	58	auto txt = string("\"")+string(16262, 'A')+string("\"");
	59	pwR.xfrText(txt);
	60	pwR.commit();
690b86b7	61	BOOST_CHECK_EQUAL(pwR.size(), 16368U);
d26fa315 PD	62
	63	pwR.startRecord(DNSName("mediumsizedlabel.example.net"), QType::A, 3600, QClass::IN, DNSResourceRecord::ANSWER);
	64	pwR.xfrIP('P'<<24 \|
	65	'Q'<<16 \|
	66	'R'<<8 \|
	67	'S');
	68	pwR.commit();
690b86b7	69	BOOST_CHECK_EQUAL(pwR.size(), 16412U); // 16412 (0x401c) puts '7example3net' at 0x4001
d26fa315 PD	70
	71	pwR.startRecord(DNSName("adifferentlabel.example.net"), QType::A, 3600, QClass::IN, DNSResourceRecord::ANSWER);
	72	pwR.xfrIP('D'<<24 \|
	73	'E'<<16 \|
	74	'F'<<8 \|
	75	'G');
	76	pwR.commit();
690b86b7	77	BOOST_CHECK_EQUAL(pwR.size(), 16455U);
d26fa315 PD	78
	79	string spacket(packet.begin(), packet.end());
	80
	81	BOOST_CHECK_NO_THROW(MOADNSParser mdp(false, spacket));
	82	}
	83
373914dc PL	84	BOOST_AUTO_TEST_CASE(test_xfrSvcParamKeyVals_mandatory) {
	85	DNSName name("powerdns.com.");
	86	vector<uint8_t> packet;
	87	DNSPacketWriter pwR(packet, name, QType::SVCB, QClass::IN, 0);
	88	pwR.getHeader()->qr = 1;
	89
	90	set<string> keys({"alpn", "ipv6hint"});
96fdac2a	91	set<SvcParam> params({SvcParam(SvcParam::mandatory, std::move(keys))});
373914dc PL	92
	93	pwR.startRecord(name, QType::SVCB);
	94	pwR.commit();
	95	auto start = pwR.getContent().size();
	96
	97	pwR.xfrSvcParamKeyVals(params);
	98	pwR.commit();
	99	auto cit = pwR.getContent().begin();
	100	for (size_t i = 0; i<start; i++)
	101	cit++;
	102
	103	vector<uint8_t> c(cit, pwR.getContent().end());
	104	BOOST_CHECK(c == vector<uint8_t>({0,0,0,4,0,1,0,6}));
	105	}
	106
	107	BOOST_AUTO_TEST_CASE(test_xfrSvcParamKeyVals_alpn) {
	108	DNSName name("powerdns.com.");
	109	vector<uint8_t> packet;
	110	DNSPacketWriter pwR(packet, name, QType::SVCB, QClass::IN, 0);
	111	pwR.getHeader()->qr = 1;
	112
	113	vector<string> alpns({"h2", "h2c", "h3"});
96fdac2a	114	set<SvcParam> params({SvcParam(SvcParam::alpn, std::move(alpns))});
373914dc PL	115
	116	pwR.startRecord(name, QType::SVCB);
	117	pwR.commit();
	118	auto start = pwR.getContent().size();
	119
	120	pwR.xfrSvcParamKeyVals(params);
	121	pwR.commit();
	122	auto cit = pwR.getContent().begin();
	123	for (size_t i = 0; i<start; i++)
	124	cit++;
	125
	126	vector<uint8_t> c(cit, pwR.getContent().end());
	127	BOOST_CHECK(c == vector<uint8_t>({
	128	0,1,0,10,
	129	2,'h','2',
	130	3,'h','2','c',
	131	2,'h','3'}));
	132	}
	133
	134	BOOST_AUTO_TEST_CASE(test_xfrSvcParamKeyVals_no_default_alpn) {
	135	DNSName name("powerdns.com.");
	136	vector<uint8_t> packet;
	137	DNSPacketWriter pwR(packet, name, QType::SVCB, QClass::IN, 0);
	138	pwR.getHeader()->qr = 1;
	139
	140	set<SvcParam> params({SvcParam(SvcParam::no_default_alpn)});
	141
	142	pwR.startRecord(name, QType::SVCB);
	143	pwR.commit();
	144	auto start = pwR.getContent().size();
	145
	146	pwR.xfrSvcParamKeyVals(params);
	147	pwR.commit();
	148	auto cit = pwR.getContent().begin();
	149	for (size_t i = 0; i<start; i++)
	150	cit++;
	151
	152	vector<uint8_t> c(cit, pwR.getContent().end());
	153	BOOST_CHECK(c == vector<uint8_t>({0,2,0,0}));
	154	}
	155
	156	BOOST_AUTO_TEST_CASE(test_xfrSvcParamKeyVals_port) {
	157	DNSName name("powerdns.com.");
	158	vector<uint8_t> packet;
	159	DNSPacketWriter pwR(packet, name, QType::SVCB, QClass::IN, 0);
	160	pwR.getHeader()->qr = 1;
	161
	162	set<SvcParam> params({SvcParam(SvcParam::port, 53)});
	163
	164	pwR.startRecord(name, QType::SVCB);
	165	pwR.commit();
	166	auto start = pwR.getContent().size();
	167
	168	pwR.xfrSvcParamKeyVals(params);
	169	pwR.commit();
	170	auto cit = pwR.getContent().begin();
	171	for (size_t i = 0; i<start; i++)
	172	cit++;
	173
	174	vector<uint8_t> c(cit, pwR.getContent().end());
	175	BOOST_CHECK(c == vector<uint8_t>({0,3,0,2,0,53}));
	176	}
	177
	178	BOOST_AUTO_TEST_CASE(test_xfrSvcParamKeyVals_ipv4hint) {
179	DNSName name("powerdns.com.");
180	vector<uint8_t> packet;
181	DNSPacketWriter pwR(packet, name, QType::SVCB, QClass::IN, 0);
182	pwR.getHeader()->qr = 1;
183
184	vector<ComboAddress> addrs({ComboAddress("192.0.2.1"), ComboAddress("192.0.2.2")});
96fdac2a	185	set<SvcParam> params({SvcParam(SvcParam::ipv4hint, std::move(addrs))});
373914dc PL	186
	187	pwR.startRecord(name, QType::SVCB);
	188	pwR.commit();
	189	auto start = pwR.getContent().size();
	190
	191	pwR.xfrSvcParamKeyVals(params);
	192	pwR.commit();
	193	auto cit = pwR.getContent().begin();
	194	for (size_t i = 0; i<start; i++)
	195	cit++;
	196
	197	vector<uint8_t> c(cit, pwR.getContent().end());
	198	BOOST_CHECK(c == vector<uint8_t>({0,4,0,8,192,0,2,1,192,0,2,2}));
	199	}
	200
4f254e34	201	BOOST_AUTO_TEST_CASE(test_xfrSvcParamKeyVals_ech) {
373914dc PL	202	DNSName name("powerdns.com.");
	203	vector<uint8_t> packet;
	204	DNSPacketWriter pwR(packet, name, QType::SVCB, QClass::IN, 0);
	205	pwR.getHeader()->qr = 1;
	206
4f254e34	207	set<SvcParam> params({SvcParam(SvcParam::ech, "a very bogus echconfig value")});
373914dc PL	208
	209	pwR.startRecord(name, QType::SVCB);
	210	pwR.commit();
	211	auto start = pwR.getContent().size();
	212
	213	pwR.xfrSvcParamKeyVals(params);
	214	pwR.commit();
	215	auto cit = pwR.getContent().begin();
	216	for (size_t i = 0; i<start; i++)
	217	cit++;
	218
	219	vector<uint8_t> c(cit, pwR.getContent().end());
	220	BOOST_CHECK(c == vector<uint8_t>({0,5,0,28,
	221	'a',' ','v','e','r','y',' ','b','o','g','u','s',' ',
	222	'e','c','h','c','o','n','f','i','g',' ','v','a','l','u','e'
	223	}));
	224	}
	225
	226	BOOST_AUTO_TEST_CASE(test_xfrSvcParamKeyVals_ipv6hint) {
	227	DNSName name("powerdns.com.");
	228	vector<uint8_t> packet;
	229	DNSPacketWriter pwR(packet, name, QType::SVCB, QClass::IN, 0);
	230	pwR.getHeader()->qr = 1;
	231
	232	vector<ComboAddress> addrs({ComboAddress("2001:db8::1"), ComboAddress("2001:db8::2")});
96fdac2a	233	set<SvcParam> params({SvcParam(SvcParam::ipv6hint, std::move(addrs))});
373914dc PL	234
	235	pwR.startRecord(name, QType::SVCB);
	236	pwR.commit();
	237	auto start = pwR.getContent().size();
	238
	239	pwR.xfrSvcParamKeyVals(params);
	240	pwR.commit();
	241	auto cit = pwR.getContent().begin();
	242	for (size_t i = 0; i<start; i++)
	243	cit++;
	244
	245	vector<uint8_t> c(cit, pwR.getContent().end());
	246	BOOST_CHECK(c == vector<uint8_t>({0,6,0,32,
	247	32,1,13,184,0,0,0,0,0,0,0,0,0,0,0,1,
	248	32,1,13,184,0,0,0,0,0,0,0,0,0,0,0,2}));
	249	}
	250
	251	BOOST_AUTO_TEST_CASE(test_xfrSvcParamKeyVals_generic) {
	252	DNSName name("powerdns.com.");
	253	vector<uint8_t> packet;
	254	DNSPacketWriter pwR(packet, name, QType::SVCB, QClass::IN, 0);
	255	pwR.getHeader()->qr = 1;
	256
	257	set<SvcParam> params({SvcParam(SvcParam::keyFromString("key666"), "mycoolvalue")});
	258
	259	pwR.startRecord(name, QType::SVCB);
	260	pwR.commit();
	261	auto start = pwR.getContent().size();
	262
	263	pwR.xfrSvcParamKeyVals(params);
	264	pwR.commit();
	265	auto cit = pwR.getContent().begin();
	266	for (size_t i = 0; i<start; i++)
	267	cit++;
	268
	269	vector<uint8_t> c(cit, pwR.getContent().end());
	270	BOOST_CHECK(c == vector<uint8_t>({2,154,0,11,
	271	'm','y','c','o','o','l','v','a','l','u','e'
	272	}));
	273	}
	274
	275	BOOST_AUTO_TEST_CASE(test_xfrSvcParamKeyVals_multiple) {
	276	DNSName name("powerdns.com.");
	277	vector<uint8_t> packet;
	278	DNSPacketWriter pwR(packet, name, QType::SVCB, QClass::IN, 0);
	279	pwR.getHeader()->qr = 1;
	280
	281	vector<ComboAddress> addrs({ComboAddress("2001:db8::1"), ComboAddress("2001:db8::2")});
	282	vector<string> alpns({"h2", "h2c", "h3"});
96fdac2a	283	set<SvcParam> params({SvcParam(SvcParam::alpn, std::move(alpns)), SvcParam(SvcParam::ipv6hint, std::move(addrs)), SvcParam(SvcParam::port, 53)});
373914dc PL	284
	285	pwR.startRecord(name, QType::SVCB);
	286	pwR.commit();
	287	auto start = pwR.getContent().size();
	288
	289	pwR.xfrSvcParamKeyVals(params);
	290	pwR.commit();
	291	auto cit = pwR.getContent().begin();
	292	for (size_t i = 0; i<start; i++)
	293	cit++;
	294
	295	vector<uint8_t> c(cit, pwR.getContent().end());
	296	BOOST_CHECK(c == vector<uint8_t>({
	297	0,1,0,10,2,'h','2',3,'h','2','c',2,'h','3', // alpn
	298	0,3,0,2,0,53, // port
	299	0,6,0,32, // ipv6
	300	32,1,13,184,0,0,0,0,0,0,0,0,0,0,0,1,
	301	32,1,13,184,0,0,0,0,0,0,0,0,0,0,0,2}));
	302	}
	303
786ed0ff PL	304	BOOST_AUTO_TEST_CASE(test_NodeOrLocatorID) {
	305	DNSName name("powerdns.com.");
	306	vector<uint8_t> packet;
	307
	308	NodeOrLocatorID in = {0, 0, 0, 0, 0, 0, 0, 1};
	309
	310	DNSPacketWriter writer(packet, name, QType::NID, QClass::IN, 0);
	311	writer.getHeader()->qr = 1;
	312
	313	writer.startRecord(name, QType::NID);
	314	writer.commit();
	315	auto start = writer.getContent().size();
	316
	317	writer.xfrNodeOrLocatorID(in);
	318	writer.commit();
	319	auto cit = writer.getContent().begin();
	320	for (size_t i = 0; i<start; i++)
	321	cit++;
	322
	323	vector<uint8_t> c(cit, writer.getContent().end());
	324	BOOST_CHECK(c == vector<uint8_t>({
	325	0, 0, 0, 0,
	326	0, 0, 0, 1}));
	327	}
	328
d26fa315	329	BOOST_AUTO_TEST_SUITE_END()