pdns/test-rcpgenerator_cc.cc

   1 #ifndef BOOST_TEST_DYN_LINK
   2 #define BOOST_TEST_DYN_LINK
   3 #endif
   4
   5 #define BOOST_TEST_NO_MAIN
   6
   7 #ifdef HAVE_CONFIG_H
   8 #include "config.h"
   9 #endif
  10 #include <boost/test/unit_test.hpp>
  11 #include "rcpgenerator.hh"
  12 #include "misc.hh"
  13 #include <utility>
  14
  15 using std::string;
  16
  17 BOOST_AUTO_TEST_SUITE(test_rcpgenerator_cc)
  18
  19 BOOST_AUTO_TEST_CASE(test_xfrIP6) {
  20         RecordTextReader rtr("::1");
  21         string rawIPv6;
  22         rtr.xfrIP6(rawIPv6);
  23         string loopback6;
  24         loopback6.append(15, 0);
  25         loopback6.append(1,1);
  26         BOOST_CHECK_EQUAL(makeHexDump(rawIPv6), makeHexDump(loopback6));
  27
  28         RecordTextReader rtr2("2a01:4f8:d12:1880::5");
  29         rtr2.xfrIP6(rawIPv6);
  30         string ip6("\x2a\x01\x04\xf8\x0d\x12\x18\x80\x00\x00\x00\x00\x00\x00\x00\x05", 16);
  31         BOOST_CHECK_EQUAL(makeHexDump(rawIPv6), makeHexDump(ip6));
  32
  33         RecordTextReader rtr3("::FFFF:192.0.2.0");
  34         rtr3.xfrIP6(rawIPv6);
  35         string ip62("\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xc0\x00\x02\x00", 16);
  36         BOOST_CHECK_EQUAL(makeHexDump(rawIPv6), makeHexDump(ip62));
  37 }
  38
  39 BOOST_AUTO_TEST_CASE(test_xfrSvcParamKeyVals_alpn) {
  40         string source("alpn=h2");
  41         RecordTextReader rtr(source);
  42         set<SvcParam> v;
  43         rtr.xfrSvcParamKeyVals(v);
  44         BOOST_CHECK_EQUAL(v.size(), 1U);
  45         auto alpn = v.begin()->getALPN();
  46         BOOST_CHECK_EQUAL(alpn.size(), 1U);
  47         auto val = alpn.begin();
  48         BOOST_CHECK_EQUAL(*val, "h2");
  49
  50         // Check the writer
  51         string target;
  52         RecordTextWriter rtw(target);
  53         rtw.xfrSvcParamKeyVals(v);
  54         BOOST_CHECK_EQUAL(target, source);
  55
  56         v.clear();
  57         source = "alpn=h2,h3";
  58         RecordTextReader rtr2(source);
  59         rtr2.xfrSvcParamKeyVals(v);
  60         BOOST_CHECK_EQUAL(v.size(), 1U);
  61         alpn = v.begin()->getALPN();
  62         BOOST_CHECK_EQUAL(alpn.size(), 2U);
  63         val = alpn.begin();
  64         BOOST_CHECK_EQUAL(*val, "h2");
  65         val++;
  66         BOOST_CHECK_EQUAL(*val, "h3");
  67
  68         // Check the writer
  69         target.clear();
  70         RecordTextWriter rtw2(target);
  71         rtw2.xfrSvcParamKeyVals(v);
  72         BOOST_CHECK_EQUAL(target, source);
  73
  74         // Check generic
  75         v.clear();
  76         source="key1=\\002h2\\002h3";
  77         RecordTextReader rtr3(source);
  78         rtr3.xfrSvcParamKeyVals(v);
  79         BOOST_CHECK_EQUAL(v.size(), 1U);
  80         alpn = v.begin()->getALPN();
  81         BOOST_CHECK_EQUAL(alpn.size(), 2U);
  82         val = alpn.begin();
  83         BOOST_CHECK_EQUAL(*val, "h2");
  84         val++;
  85         BOOST_CHECK_EQUAL(*val, "h3");
  86
  87         // Error conditions
  88         source="key1=\\002h2\\003h3"; // Wrong length for 2nd argument
  89         RecordTextReader rtr4(source);
  90         BOOST_CHECK_THROW(rtr4.xfrSvcParamKeyVals(v), RecordTextException);
  91
  92         source="key1=\\002h2\\002h3foobar"; // extra data
  93         RecordTextReader rtr5(source);
  94         BOOST_CHECK_THROW(rtr5.xfrSvcParamKeyVals(v), RecordTextException);
  95 }
  96
  97 BOOST_AUTO_TEST_CASE(test_xfrSvcParamKeyVals_mandatory) {
  98         string source("mandatory=alpn");
  99         RecordTextReader rtr(source);
 100         set<SvcParam> v;
 101         rtr.xfrSvcParamKeyVals(v);
 102         BOOST_CHECK_EQUAL(v.size(), 1U);
 103         auto m = v.begin()->getMandatory();
 104         BOOST_CHECK_EQUAL(m.size(), 1U);
 105         auto val = m.begin();
 106         BOOST_CHECK(*val == SvcParam::alpn);
 107
 108         // Check the writer
 109         string target;
 110         RecordTextWriter rtw(target);
 111         rtw.xfrSvcParamKeyVals(v);
 112         BOOST_CHECK_EQUAL(target, source);
 113
 114         v.clear();
 115         source = "mandatory=alpn,ipv4hint";
 116         RecordTextReader rtr2("mandatory=alpn,ipv4hint");
 117         rtr2.xfrSvcParamKeyVals(v);
 118         BOOST_CHECK_EQUAL(v.size(), 1U);
 119         m = v.begin()->getMandatory();
 120         BOOST_CHECK_EQUAL(m.size(), 2U);
 121         val = m.begin();
 122         BOOST_CHECK(*val == SvcParam::alpn);
 123         val++;
 124         BOOST_CHECK(*val ==  SvcParam::ipv4hint);
 125
 126         // Check the writer
 127         target.clear();
 128         RecordTextWriter rtw2(target);
 129         rtw2.xfrSvcParamKeyVals(v);
 130         BOOST_CHECK_EQUAL(target, source);
 131
 132         // Generic parsing
 133         v.clear();
 134         source = "key0=\\000\\001\\000\\004";
 135         RecordTextReader rtr3(source);
 136         rtr3.xfrSvcParamKeyVals(v);
 137         BOOST_CHECK_EQUAL(v.size(), 1U);
 138         m = v.begin()->getMandatory();
 139         BOOST_CHECK_EQUAL(m.size(), 2U);
 140         val = m.begin();
 141         BOOST_CHECK(*val == SvcParam::alpn);
 142         val++;
 143         BOOST_CHECK(*val ==  SvcParam::ipv4hint);
 144
 145         // Broken
 146         v.clear();
 147         source = "key0=\\000\\001\\000";
 148         RecordTextReader rtr4(source);
 149         BOOST_CHECK_THROW(rtr4.xfrSvcParamKeyVals(v), RecordTextException);
 150
 151         v.clear();
 152         source = "key0=";
 153         RecordTextReader rtr5(source);
 154         BOOST_CHECK_THROW(rtr5.xfrSvcParamKeyVals(v), RecordTextException);
 155
 156         v.clear();
 157         source = "key0";
 158         RecordTextReader rtr6(source);
 159         BOOST_CHECK_THROW(rtr6.xfrSvcParamKeyVals(v), RecordTextException);
 160 }
 161
 162 BOOST_AUTO_TEST_CASE(test_xfrSvcParamKeyVals_no_default_alpn) {
 163         string source("no-default-alpn");
 164         RecordTextReader rtr(source);
 165         set<SvcParam> v;
 166         rtr.xfrSvcParamKeyVals(v);
 167         BOOST_CHECK_EQUAL(v.size(), 1U);
 168         auto k = v.begin()->getKey();
 169         BOOST_CHECK(k == SvcParam::no_default_alpn);
 170
 171         // Check the writer
 172         string target;
 173         RecordTextWriter rtw(target);
 174         rtw.xfrSvcParamKeyVals(v);
 175         BOOST_CHECK_EQUAL(target, source);
 176
 177         RecordTextReader rtr2("no-default-alpn=");
 178         v.clear();
 179         BOOST_CHECK_THROW(rtr2.xfrSvcParamKeyVals(v), RecordTextException);
 180
 181         // Generic
 182         v.clear();
 183         source = "key2";
 184         RecordTextReader rtr3(source);
 185         rtr3.xfrSvcParamKeyVals(v);
 186         BOOST_CHECK_EQUAL(v.size(), 1U);
 187         k = v.begin()->getKey();
 188         BOOST_CHECK(k == SvcParam::no_default_alpn);
 189 }
 190
 191 BOOST_AUTO_TEST_CASE(test_xfrSvcParamKeyVals_ipv4hint) {
 192         string source("ipv4hint=192.0.2.1");
 193         RecordTextReader rtr(source);
 194         set<SvcParam> v;
 195         rtr.xfrSvcParamKeyVals(v);
 196         BOOST_CHECK_EQUAL(v.size(), 1U);
 197         auto k = v.begin()->getKey();
 198         BOOST_CHECK(k == SvcParam::ipv4hint);
 199         auto val = v.begin()->getIPHints();
 200         BOOST_CHECK_EQUAL(val.size(), 1U);
 201         BOOST_CHECK_EQUAL(val.begin()->toString(), "192.0.2.1");
 202
 203         // Check the writer
 204         string target;
 205         RecordTextWriter rtw(target);
 206         rtw.xfrSvcParamKeyVals(v);
 207         BOOST_CHECK_EQUAL(target, source);
 208
 209         v.clear();
 210         source = "ipv4hint=192.0.2.1,192.0.2.2,192.0.2.3";
 211         RecordTextReader rtr2(source);
 212         rtr2.xfrSvcParamKeyVals(v);
 213         BOOST_CHECK_EQUAL(v.size(), 1U);
 214         k = v.begin()->getKey();
 215         BOOST_CHECK(k == SvcParam::ipv4hint);
 216
 217         val = v.begin()->getIPHints();
 218         BOOST_CHECK_EQUAL(val.size(), 3U);
 219         auto valit = val.begin();
 220         BOOST_CHECK_EQUAL(valit->toString(), "192.0.2.1");
 221         valit++;
 222         BOOST_CHECK_EQUAL(valit->toString(), "192.0.2.2");
 223         valit++;
 224         BOOST_CHECK_EQUAL(valit->toString(), "192.0.2.3");
 225
 226         // Check the writer
 227         target.clear();
 228         RecordTextWriter rtw2(target);
 229         rtw2.xfrSvcParamKeyVals(v);
 230         BOOST_CHECK_EQUAL(target, source);
 231
 232         v.clear();
 233         RecordTextReader rtr3("ipv4hint=2001:db8::1");
 234         BOOST_CHECK_THROW(rtr3.xfrSvcParamKeyVals(v), RecordTextException);
 235
 236         v.clear();
 237         RecordTextReader rtr4("ipv4hint=192.0.2.1,2001:db8::1");
 238         BOOST_CHECK_THROW(rtr4.xfrSvcParamKeyVals(v), RecordTextException);
 239
 240         // Check if we can parse the generic format
 241         v.clear();
 242         source = "key4=\\192\\000\\002\\015";
 243         RecordTextReader rtr5(source);
 244         rtr5.xfrSvcParamKeyVals(v);
 245         BOOST_CHECK_EQUAL(v.size(), 1U);
 246         BOOST_CHECK_EQUAL(v.begin()->getIPHints().size(), 1U);
 247         k = v.begin()->getKey();
 248         BOOST_CHECK(k == SvcParam::ipv4hint);
 249         BOOST_CHECK_EQUAL(v.begin()->getIPHints().begin()->toString(), "192.0.2.15");
 250
 251         v.clear();
 252         source = "key4=\\192\\000\\002\\015\\192\\000\\002\\222";
 253         RecordTextReader rtr6(source);
 254         rtr6.xfrSvcParamKeyVals(v);
 255         BOOST_CHECK_EQUAL(v.size(), 1U);
 256         BOOST_CHECK_EQUAL(v.begin()->getIPHints().size(), 2U);
 257         k = v.begin()->getKey();
 258         BOOST_CHECK(k == SvcParam::ipv4hint);
 259         BOOST_CHECK_EQUAL(v.begin()->getIPHints().begin()->toString(), "192.0.2.15");
 260         BOOST_CHECK_EQUAL(v.begin()->getIPHints().at(1).toString(), "192.0.2.222");
 261
 262         v.clear();
 263         source = "key4=\\192\\000\\222"; // Wrong number of octets
 264         RecordTextReader rtr7(source);
 265         BOOST_CHECK_THROW(rtr7.xfrSvcParamKeyVals(v), RecordTextException);
 266 }
 267
 268 BOOST_AUTO_TEST_CASE(test_xfrSvcParamKeyVals_ipv6hint) {
 269         string source("ipv6hint=2001:db8::1");
 270         RecordTextReader rtr(source);
 271         set<SvcParam> v;
 272         rtr.xfrSvcParamKeyVals(v);
 273         BOOST_CHECK_EQUAL(v.size(), 1U);
 274         auto k = v.begin()->getKey();
 275         BOOST_CHECK(k == SvcParam::ipv6hint);
 276         auto val = v.begin()->getIPHints();
 277         BOOST_CHECK_EQUAL(val.size(), 1U);
 278         BOOST_CHECK_EQUAL(val.begin()->toString(), "2001:db8::1");
 279
 280         // Check the writer
 281         string target;
 282         RecordTextWriter rtw(target);
 283         rtw.xfrSvcParamKeyVals(v);
 284         BOOST_CHECK_EQUAL(target, source);
 285
 286         v.clear();
 287         source = "ipv6hint=2001:db8::1,2001:db8::2,2001:db8::3";
 288         RecordTextReader rtr2(source);
 289         rtr2.xfrSvcParamKeyVals(v);
 290         BOOST_CHECK_EQUAL(v.size(), 1U);
 291         k = v.begin()->getKey();
 292         BOOST_CHECK(k == SvcParam::ipv6hint);
 293
 294         val = v.begin()->getIPHints();
 295         BOOST_CHECK_EQUAL(val.size(), 3U);
 296         auto valit = val.begin();
 297         BOOST_CHECK_EQUAL(valit->toString(), "2001:db8::1");
 298         valit++;
 299         BOOST_CHECK_EQUAL(valit->toString(), "2001:db8::2");
 300         valit++;
 301         BOOST_CHECK_EQUAL(valit->toString(), "2001:db8::3");
 302
 303         // Check the writer
 304         target.clear();
 305         RecordTextWriter rtw2(target);
 306         rtw2.xfrSvcParamKeyVals(v);
 307         BOOST_CHECK_EQUAL(target, source);
 308
 309         v.clear();
 310         RecordTextReader rtr3("ipv6hint=192.0.2.1");
 311         BOOST_CHECK_THROW(rtr3.xfrSvcParamKeyVals(v), RecordTextException);
 312
 313         v.clear();
 314         RecordTextReader rtr4("ipv6hint=192.0.2.1,2001:db8::1");
 315         BOOST_CHECK_THROW(rtr4.xfrSvcParamKeyVals(v), RecordTextException);
 316
 317         // Check if we can parse the generic format
 318         v.clear();
 319         RecordTextReader rtr5("key6=\\032\\001\\013\\184\\000\\083\\000\\000\\000\\000\\000\\000\\000\\000\\000\\021");
 320         rtr5.xfrSvcParamKeyVals(v);
 321         BOOST_CHECK_EQUAL(v.size(), 1U);
 322         BOOST_CHECK_EQUAL(v.begin()->getIPHints().size(), 1U);
 323         k = v.begin()->getKey();
 324         BOOST_CHECK(k == SvcParam::ipv6hint);
 325         BOOST_CHECK_EQUAL(v.begin()->getIPHints().begin()->toString(), "2001:db8:53::15");
 326
 327         v.clear();
 328         source = "key6=\\032\\001\\013\\184\\000\\083\\000\\000\\000\\000\\000\\000\\000\\000\\000\\021\\032\\001\\013\\184\\000\\083\\000\\000\\000\\000\\000\\000\\000\\000\\000\\022";
 329         RecordTextReader rtr6(source);
 330         rtr6.xfrSvcParamKeyVals(v);
 331         BOOST_CHECK_EQUAL(v.size(), 1U);
 332         BOOST_CHECK_EQUAL(v.begin()->getIPHints().size(), 2U);
 333         k = v.begin()->getKey();
 334         BOOST_CHECK(k == SvcParam::ipv6hint);
 335         BOOST_CHECK_EQUAL(v.begin()->getIPHints().begin()->toString(), "2001:db8:53::15");
 336         BOOST_CHECK_EQUAL(v.begin()->getIPHints().at(1).toString(), "2001:db8:53::16");
 337
 338         v.clear();
 339         source = "key6=\\040\\001\\015\\270\\000\\123\\000\\000\\000\\000\\000\\000\\000\\000\\000"; // wrong number of octets
 340         RecordTextReader rtr7(source);
 341         BOOST_CHECK_THROW(rtr7.xfrSvcParamKeyVals(v), RecordTextException);
 342 }
 343
 344 BOOST_AUTO_TEST_CASE(test_xfrSvcParamKeyVals_port) {
 345         string source("port=53");
 346         RecordTextReader rtr(source);
 347         set<SvcParam> v;
 348         rtr.xfrSvcParamKeyVals(v);
 349         BOOST_CHECK_EQUAL(v.size(), 1U);
 350         auto k = v.begin()->getKey();
 351         BOOST_CHECK(k == SvcParam::port);
 352         auto val = v.begin()->getPort();
 353         BOOST_CHECK_EQUAL(val, 53);
 354
 355         // Check the writer
 356         string target;
 357         RecordTextWriter rtw(target);
 358         rtw.xfrSvcParamKeyVals(v);
 359         BOOST_CHECK_EQUAL(target, source);
 360
 361         v.clear();
 362         RecordTextReader rtr2("port=100000");
 363         BOOST_CHECK_THROW(rtr2.xfrSvcParamKeyVals(v), RecordTextException);
 364
 365         v.clear();
 366         RecordTextReader rtr3("port=foo");
 367         BOOST_CHECK_THROW(rtr3.xfrSvcParamKeyVals(v), RecordTextException);
 368
 369         v.clear();
 370         RecordTextReader rtr4("port=");
 371         BOOST_CHECK_THROW(rtr4.xfrSvcParamKeyVals(v), RecordTextException);
 372
 373         v.clear();
 374         RecordTextReader rtr5("port");
 375         BOOST_CHECK_THROW(rtr5.xfrSvcParamKeyVals(v), RecordTextException);
 376
 377         // Generic
 378         v.clear();
 379         RecordTextReader rtr6("key3");
 380         BOOST_CHECK_THROW(rtr6.xfrSvcParamKeyVals(v), RecordTextException);
 381
 382         v.clear();
 383         RecordTextReader rtr7("key3=\\000\\053");
 384         rtr7.xfrSvcParamKeyVals(v);
 385         BOOST_CHECK_EQUAL(v.size(), 1U);
 386         k = v.begin()->getKey();
 387         BOOST_CHECK(k == SvcParam::port);
 388         val = v.begin()->getPort();
 389         BOOST_CHECK_EQUAL(val, 53);
 390 }
 391
 392 BOOST_AUTO_TEST_CASE(test_xfrSvcParamKeyVals_generic) {
 393         string source("key666=foobar");
 394         RecordTextReader rtr(source);
 395         set<SvcParam> v;
 396         rtr.xfrSvcParamKeyVals(v);
 397         BOOST_CHECK_EQUAL(v.size(), 1U);
 398         auto k = v.begin()->getKey();
 399         BOOST_CHECK(k == 666);
 400         auto val = v.begin()->getValue();
 401         BOOST_CHECK_EQUAL(val, "foobar");
 402
 403         // Check the writer
 404         string target;
 405         RecordTextWriter rtw(target);
 406         rtw.xfrSvcParamKeyVals(v);
 407         BOOST_CHECK_EQUAL(target, "key666=\"foobar\"");
 408
 409         v.clear();
 410         RecordTextReader rtr2("key666=");
 411         BOOST_CHECK_THROW(rtr2.xfrSvcParamKeyVals(v), RecordTextException);
 412
 413         v.clear();
 414         RecordTextReader rtr3("key666");
 415         BOOST_CHECK_THROW(rtr3.xfrSvcParamKeyVals(v), RecordTextException);
 416
 417         v.clear();
 418         source = "key666=\"blablabla\"";
 419         RecordTextReader rtr4(source);
 420         rtr4.xfrSvcParamKeyVals(v);
 421         BOOST_CHECK_EQUAL(v.size(), 1U);
 422         k = v.begin()->getKey();
 423         BOOST_CHECK(k == SvcParam::keyFromString("key666"));
 424         val = v.begin()->getValue();
 425         BOOST_CHECK_EQUAL(val, "blablabla");
 426
 427         // Check the writer
 428         target.clear();
 429         RecordTextWriter rtw2(target);
 430         rtw2.xfrSvcParamKeyVals(v);
 431         BOOST_CHECK_EQUAL(target, source);
 432
 433         v.clear();
 434         source = "key666=\"foo\\123 bar\"";
 435         RecordTextReader rtr5(source);
 436         rtr5.xfrSvcParamKeyVals(v);
 437         BOOST_CHECK_EQUAL(v.size(), 1U);
 438         k = v.begin()->getKey();
 439         BOOST_CHECK(k == SvcParam::keyFromString("key666"));
 440         val = v.begin()->getValue();
 441         BOOST_CHECK_EQUAL(val, "foo{ bar");
 442
 443         // Check the writer
 444         target.clear();
 445         RecordTextWriter rtw3(target);
 446         rtw3.xfrSvcParamKeyVals(v);
 447         BOOST_CHECK_EQUAL("key666=\"foo{ bar\"", target);
 448
 449         v.clear();
 450         RecordTextReader rtr6("key665= blabla");
 451         BOOST_CHECK_THROW(rtr6.xfrSvcParamKeyVals(v), RecordTextException);
 452
 453         v.clear();
 454         RecordTextReader rtr7("key665=bla bla");
 455         BOOST_CHECK_THROW(rtr7.xfrSvcParamKeyVals(v), RecordTextException);
 456 }
 457
 458 BOOST_AUTO_TEST_CASE(test_xfrSvcParamKeyVals_multiple) {
 459         RecordTextReader rtr("key666=foobar ech=\"dG90YWxseSBib2d1cyBlY2hjb25maWcgdmFsdWU=\" ipv6hint=2001:db8::1 alpn=h2,h3 mandatory=alpn ipv4hint=192.0.2.1,192.0.2.2"); // out of order, resulting set should be in-order
 460         set<SvcParam> v;
 461         rtr.xfrSvcParamKeyVals(v);
 462         BOOST_CHECK_EQUAL(v.size(), 6U);
 463         auto vit = v.begin();
 464
 465         // Check ordering
 466         for (size_t i = 0; i < v.size(); i++) {
 467                 if (i == 0) {
 468                         BOOST_CHECK(vit->getKey() == SvcParam::mandatory);
 469                 }
 470                 if (i == 1) {
 471                         BOOST_CHECK(vit->getKey() == SvcParam::alpn);
 472                 }
 473                 if (i == 2) {
 474                         BOOST_CHECK(vit->getKey() == SvcParam::ipv4hint);
 475                 }
 476                 if (i == 3) {
 477                         BOOST_CHECK(vit->getKey() == SvcParam::ech);
 478                 }
 479                 if (i == 4) {
 480                         BOOST_CHECK(vit->getKey() == SvcParam::ipv6hint);
 481                 }
 482                 if (i == 5) {
 483                         BOOST_CHECK(vit->getKey() == SvcParam::keyFromString("key666"));
 484                 }
 485                 vit++;
 486         }
 487
 488         // Check the writer
 489         string target;
 490         RecordTextWriter rtw(target);
 491         rtw.xfrSvcParamKeyVals(v);
 492         BOOST_CHECK_EQUAL(target, "mandatory=alpn alpn=h2,h3 ipv4hint=192.0.2.1,192.0.2.2 ech=\"dG90YWxseSBib2d1cyBlY2hjb25maWcgdmFsdWU=\" ipv6hint=2001:db8::1 key666=\"foobar\"");
 493 }
 494
 495 BOOST_AUTO_TEST_CASE(test_xfrSvcParamKeyVals_ech) {
 496         string source("ech=\"dG90YWxseSBib2d1cyBlY2hjb25maWcgdmFsdWU=\"");
 497         RecordTextReader rtr(source);
 498         set<SvcParam> v;
 499         rtr.xfrSvcParamKeyVals(v);
 500         BOOST_CHECK_EQUAL(v.size(), 1U);
 501         auto k = v.begin()->getKey();
 502         BOOST_CHECK(k == SvcParam::ech);
 503         auto val = v.begin()->getECH();
 504         BOOST_CHECK_EQUAL(val, "totally bogus echconfig value"); // decoded!
 505
 506         // Check the writer
 507         string target;
 508         RecordTextWriter rtw(target);
 509         rtw.xfrSvcParamKeyVals(v);
 510         BOOST_CHECK_EQUAL(source, target);
 511
 512         // Generic
 513         v.clear();
 514         source = "key5=echconfig";
 515         RecordTextReader rtr2(source);
 516         rtr2.xfrSvcParamKeyVals(v);
 517         BOOST_CHECK_EQUAL(v.size(), 1U);
 518         k = v.begin()->getKey();
 519         BOOST_CHECK(k == SvcParam::ech);
 520         val = v.begin()->getECH();
 521         BOOST_CHECK_EQUAL(val, "echconfig");
 522 }
 523
 524 BOOST_AUTO_TEST_CASE(test_xfrNodeOrLocatorID) {
 525   string source("0000:0000:0000:0001");
 526   RecordTextReader rtr(source);
 527   NodeOrLocatorID v;
 528   rtr.xfrNodeOrLocatorID(v);
 529   BOOST_CHECK_EQUAL(v.content[0], 0);
 530   BOOST_CHECK_EQUAL(v.content[1], 0);
 531   BOOST_CHECK_EQUAL(v.content[2], 0);
 532   BOOST_CHECK_EQUAL(v.content[3], 0);
 533   BOOST_CHECK_EQUAL(v.content[4], 0);
 534   BOOST_CHECK_EQUAL(v.content[5], 0);
 535   BOOST_CHECK_EQUAL(v.content[6], 0);
 536   BOOST_CHECK_EQUAL(v.content[7], 1);
 537
 538   string target;
 539   RecordTextWriter rtw(target);
 540   rtw.xfrNodeOrLocatorID(v);
 541   BOOST_CHECK_EQUAL(source, target);
 542 }
 543
 544 BOOST_AUTO_TEST_SUITE_END()