src/test/test_routerset.c

   1 /* Copyright (c) 2014-2018, The Tor Project, Inc. */
   2 /* See LICENSE for licensing information */
   3
   4 #define ROUTERSET_PRIVATE
   5
   6 #include "core/or/or.h"
   7 #include "lib/geoip/geoip.h"
   8 #include "feature/nodelist/routerset.h"
   9 #include "feature/nodelist/routerparse.h"
  10 #include "core/or/policies.h"
  11 #include "feature/nodelist/nodelist.h"
  12
  13 #include "core/or/addr_policy_st.h"
  14 #include "core/or/extend_info_st.h"
  15 #include "feature/nodelist/node_st.h"
  16 #include "feature/nodelist/routerinfo_st.h"
  17 #include "feature/nodelist/routerstatus_st.h"
  18
  19 #include "test/test.h"
  20
  21 #define NS_MODULE routerset
  22
  23 #define NS_SUBMODULE routerset_new
  24
  25 /*
  26  * Functional (blackbox) test to determine that each member of the routerset
  27  * is non-NULL
  28  */
  29
  30 static void
  31 NS(test_main)(void *arg)
  32 {
  33   routerset_t *rs;
  34   (void)arg;
  35
  36   rs = routerset_new();
  37
  38   tt_ptr_op(rs, OP_NE, NULL);
  39   tt_ptr_op(rs->list, OP_NE, NULL);
  40   tt_ptr_op(rs->names, OP_NE, NULL);
  41   tt_ptr_op(rs->digests, OP_NE, NULL);
  42   tt_ptr_op(rs->policies, OP_NE, NULL);
  43   tt_ptr_op(rs->country_names, OP_NE, NULL);
  44
  45   done:
  46     routerset_free(rs);
  47 }
  48
  49 #undef NS_SUBMODULE
  50 #define NS_SUBMODULE routerset_get_countryname
  51
  52 /*
  53  * Functional test to strip the braces from a "{xx}" country code string.
  54  */
  55
  56 static void
  57 NS(test_main)(void *arg)
  58 {
  59   const char *input;
  60   char *name;
  61   (void)arg;
  62
  63   /* strlen(c) < 4 */
  64   input = "xxx";
  65   name = routerset_get_countryname(input);
  66   tt_ptr_op(name, OP_EQ, NULL);
  67   tor_free(name);
  68
  69   /* c[0] != '{' */
  70   input = "xxx}";
  71   name = routerset_get_countryname(input);
  72   tt_ptr_op(name, OP_EQ, NULL);
  73   tor_free(name);
  74
  75   /* c[3] != '}' */
  76   input = "{xxx";
  77   name = routerset_get_countryname(input);
  78   tt_ptr_op(name, OP_EQ, NULL);
  79   tor_free(name);
  80
  81   /* tor_strlower */
  82   input = "{XX}";
  83   name = routerset_get_countryname(input);
  84   tt_str_op(name, OP_EQ, "xx");
  85   tor_free(name);
  86
  87   input = "{xx}";
  88   name = routerset_get_countryname(input);
  89   tt_str_op(name, OP_EQ, "xx");
  90   done:
  91     tor_free(name);
  92 }
  93
  94 #undef NS_SUBMODULE
  95 #define NS_SUBMODULE ASPECT(routerset_refresh_counties, geoip_not_loaded)
  96
  97 /*
  98  * Structural (whitebox) test for routerset_refresh_counties, when the GeoIP DB
  99  * is not loaded.
 100  */
 101
 102 NS_DECL(int, geoip_is_loaded, (sa_family_t family));
 103 NS_DECL(int, geoip_get_n_countries, (void));
 104
 105 static void
 106 NS(test_main)(void *arg)
 107 {
 108   routerset_t *set = routerset_new();
 109   (void)arg;
 110
 111   NS_MOCK(geoip_is_loaded);
 112   NS_MOCK(geoip_get_n_countries);
 113
 114   routerset_refresh_countries(set);
 115
 116   tt_ptr_op(set->countries, OP_EQ, NULL);
 117   tt_int_op(set->n_countries, OP_EQ, 0);
 118   tt_int_op(CALLED(geoip_is_loaded), OP_EQ, 1);
 119   tt_int_op(CALLED(geoip_get_n_countries), OP_EQ, 0);
 120
 121   done:
 122     NS_UNMOCK(geoip_is_loaded);
 123     NS_UNMOCK(geoip_get_n_countries);
 124     routerset_free(set);
 125 }
 126
 127 static int
 128 NS(geoip_is_loaded)(sa_family_t family)
 129 {
 130   (void)family;
 131   CALLED(geoip_is_loaded)++;
 132
 133   return 0;
 134 }
 135
 136 static int
 137 NS(geoip_get_n_countries)(void)
 138 {
 139   CALLED(geoip_get_n_countries)++;
 140
 141   return 0;
 142 }
 143
 144 #undef NS_SUBMODULE
 145 #define NS_SUBMODULE ASPECT(routerset_refresh_counties, no_countries)
 146
 147 /*
 148  * Structural test for routerset_refresh_counties, when there are no countries.
 149  */
 150
 151 NS_DECL(int, geoip_is_loaded, (sa_family_t family));
 152 NS_DECL(int, geoip_get_n_countries, (void));
 153 NS_DECL(country_t, geoip_get_country, (const char *country));
 154
 155 static void
 156 NS(test_main)(void *arg)
 157 {
 158   routerset_t *set = routerset_new();
 159   (void)arg;
 160
 161   NS_MOCK(geoip_is_loaded);
 162   NS_MOCK(geoip_get_n_countries);
 163   NS_MOCK(geoip_get_country);
 164
 165   routerset_refresh_countries(set);
 166
 167   tt_ptr_op(set->countries, OP_NE, NULL);
 168   tt_int_op(set->n_countries, OP_EQ, 1);
 169   tt_int_op((unsigned int)(*set->countries), OP_EQ, 0);
 170   tt_int_op(CALLED(geoip_is_loaded), OP_EQ, 1);
 171   tt_int_op(CALLED(geoip_get_n_countries), OP_EQ, 1);
 172   tt_int_op(CALLED(geoip_get_country), OP_EQ, 0);
 173
 174   done:
 175     NS_UNMOCK(geoip_is_loaded);
 176     NS_UNMOCK(geoip_get_n_countries);
 177     NS_UNMOCK(geoip_get_country);
 178     routerset_free(set);
 179 }
 180
 181 static int
 182 NS(geoip_is_loaded)(sa_family_t family)
 183 {
 184   (void)family;
 185   CALLED(geoip_is_loaded)++;
 186
 187   return 1;
 188 }
 189
 190 static int
 191 NS(geoip_get_n_countries)(void)
 192 {
 193   CALLED(geoip_get_n_countries)++;
 194
 195   return 1;
 196 }
 197
 198 static country_t
 199 NS(geoip_get_country)(const char *countrycode)
 200 {
 201   (void)countrycode;
 202   CALLED(geoip_get_country)++;
 203
 204   return 1;
 205 }
 206
 207 #undef NS_SUBMODULE
 208 #define NS_SUBMODULE ASPECT(routerset_refresh_counties, one_valid_country)
 209
 210 /*
 211  * Structural test for routerset_refresh_counties, with one valid country.
 212  */
 213
 214 NS_DECL(int, geoip_is_loaded, (sa_family_t family));
 215 NS_DECL(int, geoip_get_n_countries, (void));
 216 NS_DECL(country_t, geoip_get_country, (const char *country));
 217
 218 static void
 219 NS(test_main)(void *arg)
 220 {
 221   routerset_t *set = routerset_new();
 222   (void)arg;
 223
 224   NS_MOCK(geoip_is_loaded);
 225   NS_MOCK(geoip_get_n_countries);
 226   NS_MOCK(geoip_get_country);
 227   smartlist_add(set->country_names, tor_strndup("foo", 3));
 228
 229   routerset_refresh_countries(set);
 230
 231   tt_ptr_op(set->countries, OP_NE, NULL);
 232   tt_int_op(set->n_countries, OP_EQ, 2);
 233   tt_int_op(CALLED(geoip_is_loaded), OP_EQ, 1);
 234   tt_int_op(CALLED(geoip_get_n_countries), OP_EQ, 1);
 235   tt_int_op(CALLED(geoip_get_country), OP_EQ, 1);
 236   tt_int_op((unsigned int)(*set->countries), OP_NE, 0);
 237
 238   done:
 239     NS_UNMOCK(geoip_is_loaded);
 240     NS_UNMOCK(geoip_get_n_countries);
 241     NS_UNMOCK(geoip_get_country);
 242     routerset_free(set);
 243 }
 244
 245 static int
 246 NS(geoip_is_loaded)(sa_family_t family)
 247 {
 248   (void)family;
 249   CALLED(geoip_is_loaded)++;
 250
 251   return 1;
 252 }
 253
 254 static int
 255 NS(geoip_get_n_countries)(void)
 256 {
 257   CALLED(geoip_get_n_countries)++;
 258
 259   return 2;
 260 }
 261
 262 static country_t
 263 NS(geoip_get_country)(const char *countrycode)
 264 {
 265   (void)countrycode;
 266   CALLED(geoip_get_country)++;
 267
 268   return 1;
 269 }
 270
 271 #undef NS_SUBMODULE
 272 #define NS_SUBMODULE ASPECT(routerset_refresh_counties, one_invalid_country)
 273
 274 /*
 275  * Structural test for routerset_refresh_counties, with one invalid
 276  * country code..
 277  */
 278
 279 NS_DECL(int, geoip_is_loaded, (sa_family_t family));
 280 NS_DECL(int, geoip_get_n_countries, (void));
 281 NS_DECL(country_t, geoip_get_country, (const char *country));
 282
 283 static void
 284 NS(test_main)(void *arg)
 285 {
 286   routerset_t *set = routerset_new();
 287   (void)arg;
 288
 289   NS_MOCK(geoip_is_loaded);
 290   NS_MOCK(geoip_get_n_countries);
 291   NS_MOCK(geoip_get_country);
 292   smartlist_add(set->country_names, tor_strndup("foo", 3));
 293
 294   routerset_refresh_countries(set);
 295
 296   tt_ptr_op(set->countries, OP_NE, NULL);
 297   tt_int_op(set->n_countries, OP_EQ, 2);
 298   tt_int_op(CALLED(geoip_is_loaded), OP_EQ, 1);
 299   tt_int_op(CALLED(geoip_get_n_countries), OP_EQ, 1);
 300   tt_int_op(CALLED(geoip_get_country), OP_EQ, 1);
 301   tt_int_op((unsigned int)(*set->countries), OP_EQ, 0);
 302
 303   done:
 304     NS_UNMOCK(geoip_is_loaded);
 305     NS_UNMOCK(geoip_get_n_countries);
 306     NS_UNMOCK(geoip_get_country);
 307     routerset_free(set);
 308 }
 309
 310 static int
 311 NS(geoip_is_loaded)(sa_family_t family)
 312 {
 313   (void)family;
 314   CALLED(geoip_is_loaded)++;
 315
 316   return 1;
 317 }
 318
 319 static int
 320 NS(geoip_get_n_countries)(void)
 321 {
 322   CALLED(geoip_get_n_countries)++;
 323
 324   return 2;
 325 }
 326
 327 static country_t
 328 NS(geoip_get_country)(const char *countrycode)
 329 {
 330   (void)countrycode;
 331   CALLED(geoip_get_country)++;
 332
 333   return -1;
 334 }
 335
 336 #undef NS_SUBMODULE
 337 #define NS_SUBMODULE ASPECT(routerset_parse, malformed)
 338
 339 /*
 340  * Functional test, with a malformed string to parse.
 341  */
 342
 343 static void
 344 NS(test_main)(void *arg)
 345 {
 346   routerset_t *set = routerset_new();
 347   const char *s = "_";
 348   int r;
 349   (void)arg;
 350
 351   r = routerset_parse(set, s, "");
 352
 353   tt_int_op(r, OP_EQ, -1);
 354
 355   done:
 356     routerset_free(set);
 357 }
 358
 359 #undef NS_SUBMODULE
 360 #define NS_SUBMODULE ASPECT(routerset_parse, valid_hexdigest)
 361
 362 /*
 363  * Functional test for routerset_parse, that routerset_parse returns 0
 364  * on a valid hexdigest entry.
 365  */
 366
 367 static void
 368 NS(test_main)(void *arg)
 369 {
 370   routerset_t *set;
 371   const char *s;
 372   int r;
 373   (void)arg;
 374
 375   set = routerset_new();
 376   s = "$0000000000000000000000000000000000000000";
 377   r = routerset_parse(set, s, "");
 378   tt_int_op(r, OP_EQ, 0);
 379   tt_int_op(digestmap_isempty(set->digests), OP_NE, 1);
 380
 381   done:
 382     routerset_free(set);
 383 }
 384
 385 #undef NS_SUBMODULE
 386 #define NS_SUBMODULE ASPECT(routerset_parse, valid_nickname)
 387
 388 /*
 389  * Functional test for routerset_parse, when given a valid nickname as input.
 390  */
 391
 392 static void
 393 NS(test_main)(void *arg)
 394 {
 395   routerset_t *set;
 396   const char *s;
 397   int r;
 398   (void)arg;
 399
 400   set = routerset_new();
 401   s = "fred";
 402   r = routerset_parse(set, s, "");
 403   tt_int_op(r, OP_EQ, 0);
 404   tt_int_op(strmap_isempty(set->names), OP_NE, 1);
 405
 406   done:
 407     routerset_free(set);
 408 }
 409
 410 #undef NS_SUBMODULE
 411 #define NS_SUBMODULE ASPECT(routerset_parse, get_countryname)
 412
 413 /*
 414  * Functional test for routerset_parse, when given a valid countryname.
 415  */
 416
 417 static void
 418 NS(test_main)(void *arg)
 419 {
 420   routerset_t *set;
 421   const char *s;
 422   int r;
 423   (void)arg;
 424
 425   set = routerset_new();
 426   s = "{cc}";
 427   r = routerset_parse(set, s, "");
 428   tt_int_op(r, OP_EQ, 0);
 429   tt_int_op(smartlist_len(set->country_names), OP_NE, 0);
 430
 431   done:
 432     routerset_free(set);
 433 }
 434
 435 #undef NS_SUBMODULE
 436 #define NS_SUBMODULE ASPECT(routerset_parse, policy_wildcard)
 437
 438 /*
 439  * Structural test for routerset_parse, when given a valid wildcard policy.
 440  */
 441
 442 NS_DECL(addr_policy_t *, router_parse_addr_policy_item_from_string,
 443     (const char *s, int assume_action, int *malformed_list));
 444
 445 static addr_policy_t *NS(mock_addr_policy);
 446
 447 static void
 448 NS(test_main)(void *arg)
 449 {
 450   routerset_t *set;
 451   const char *s;
 452   int r;
 453   (void)arg;
 454
 455   NS_MOCK(router_parse_addr_policy_item_from_string);
 456   NS(mock_addr_policy) = tor_malloc_zero(sizeof(addr_policy_t));
 457
 458   set = routerset_new();
 459   s = "*";
 460   r = routerset_parse(set, s, "");
 461   tt_int_op(r, OP_EQ, 0);
 462   tt_int_op(smartlist_len(set->policies), OP_NE, 0);
 463   tt_int_op(CALLED(router_parse_addr_policy_item_from_string), OP_EQ, 1);
 464
 465   done:
 466     routerset_free(set);
 467 }
 468
 469 addr_policy_t *
 470 NS(router_parse_addr_policy_item_from_string)(const char *s,
 471                                               int assume_action,
 472                                               int *malformed_list)
 473 {
 474   (void)s;
 475   (void)assume_action;
 476   (void)malformed_list;
 477   CALLED(router_parse_addr_policy_item_from_string)++;
 478
 479   return NS(mock_addr_policy);
 480 }
 481
 482 #undef NS_SUBMODULE
 483 #define NS_SUBMODULE ASPECT(routerset_parse, policy_ipv4)
 484
 485 /*
 486  * Structural test for routerset_parse, when given a valid IPv4 address
 487  * literal policy.
 488  */
 489
 490 NS_DECL(addr_policy_t *, router_parse_addr_policy_item_from_string,
 491         (const char *s, int assume_action, int *bogus));
 492
 493 static addr_policy_t *NS(mock_addr_policy);
 494
 495 static void
 496 NS(test_main)(void *arg)
 497 {
 498   routerset_t *set;
 499   const char *s;
 500   int r;
 501   (void)arg;
 502
 503   NS_MOCK(router_parse_addr_policy_item_from_string);
 504   NS(mock_addr_policy) = tor_malloc_zero(sizeof(addr_policy_t));
 505
 506   set = routerset_new();
 507   s = "127.0.0.1";
 508   r = routerset_parse(set, s, "");
 509   tt_int_op(r, OP_EQ, 0);
 510   tt_int_op(smartlist_len(set->policies), OP_NE, 0);
 511   tt_int_op(CALLED(router_parse_addr_policy_item_from_string), OP_EQ, 1);
 512
 513  done:
 514   routerset_free(set);
 515 }
 516
 517 addr_policy_t *
 518 NS(router_parse_addr_policy_item_from_string)(const char *s, int assume_action,
 519                                               int *bogus)
 520 {
 521   (void)s;
 522   (void)assume_action;
 523   CALLED(router_parse_addr_policy_item_from_string)++;
 524   *bogus = 0;
 525
 526   return NS(mock_addr_policy);
 527 }
 528
 529 #undef NS_SUBMODULE
 530 #define NS_SUBMODULE ASPECT(routerset_parse, policy_ipv6)
 531
 532 /*
 533  * Structural test for routerset_parse, when given a valid IPv6 address
 534  * literal policy.
 535  */
 536
 537 NS_DECL(addr_policy_t *, router_parse_addr_policy_item_from_string,
 538         (const char *s, int assume_action, int *bad));
 539
 540 static addr_policy_t *NS(mock_addr_policy);
 541
 542 static void
 543 NS(test_main)(void *arg)
 544 {
 545   routerset_t *set;
 546   const char *s;
 547   int r;
 548   (void)arg;
 549
 550   NS_MOCK(router_parse_addr_policy_item_from_string);
 551   NS(mock_addr_policy) = tor_malloc_zero(sizeof(addr_policy_t));
 552
 553   set = routerset_new();
 554   s = "::1";
 555   r = routerset_parse(set, s, "");
 556   tt_int_op(r, OP_EQ, 0);
 557   tt_int_op(smartlist_len(set->policies), OP_NE, 0);
 558   tt_int_op(CALLED(router_parse_addr_policy_item_from_string), OP_EQ, 1);
 559
 560  done:
 561   routerset_free(set);
 562 }
 563
 564 addr_policy_t *
 565 NS(router_parse_addr_policy_item_from_string)(const char *s,
 566                                               int assume_action, int *bad)
 567 {
 568   (void)s;
 569   (void)assume_action;
 570   CALLED(router_parse_addr_policy_item_from_string)++;
 571   *bad = 0;
 572
 573   return NS(mock_addr_policy);
 574 }
 575
 576 #undef NS_SUBMODULE
 577 #define NS_SUBMODULE ASPECT(routerset_union, source_bad)
 578
 579 /*
 580  * Structural test for routerset_union, when given a bad source argument.
 581  */
 582
 583 NS_DECL(smartlist_t *, smartlist_new, (void));
 584
 585 static void
 586 NS(test_main)(void *arg)
 587 {
 588   routerset_t *set, *bad_set;
 589   (void)arg;
 590
 591   set = routerset_new();
 592   bad_set = routerset_new();
 593   smartlist_free(bad_set->list);
 594   bad_set->list = NULL;
 595
 596   NS_MOCK(smartlist_new);
 597
 598   routerset_union(set, NULL);
 599   tt_int_op(CALLED(smartlist_new), OP_EQ, 0);
 600
 601   routerset_union(set, bad_set);
 602   tt_int_op(CALLED(smartlist_new), OP_EQ, 0);
 603
 604   done:
 605     NS_UNMOCK(smartlist_new);
 606     routerset_free(set);
 607
 608     /* Just recreate list, so we can simply use routerset_free. */
 609     bad_set->list = smartlist_new();
 610     routerset_free(bad_set);
 611 }
 612
 613 static smartlist_t *
 614 NS(smartlist_new)(void)
 615 {
 616   CALLED(smartlist_new)++;
 617
 618   return NULL;
 619 }
 620
 621 #undef NS_SUBMODULE
 622 #define NS_SUBMODULE ASPECT(routerset_union, one)
 623
 624 /*
 625  * Functional test for routerset_union.
 626  */
 627
 628 static void
 629 NS(test_main)(void *arg)
 630 {
 631   routerset_t *src = routerset_new();
 632   routerset_t *tgt;
 633   (void)arg;
 634
 635   tgt = routerset_new();
 636   smartlist_add_strdup(src->list, "{xx}");
 637   routerset_union(tgt, src);
 638
 639   tt_int_op(smartlist_len(tgt->list), OP_NE, 0);
 640
 641   done:
 642     routerset_free(src);
 643     routerset_free(tgt);
 644 }
 645
 646 #undef NS_SUBMODULE
 647 #define NS_SUBMODULE routerset_is_list
 648
 649 /*
 650  * Functional tests for routerset_is_list.
 651  */
 652
 653 static void
 654 NS(test_main)(void *arg)
 655 {
 656   routerset_t *set;
 657   addr_policy_t *policy;
 658   int is_list;
 659   (void)arg;
 660
 661   /* len(set->country_names) == 0, len(set->policies) == 0 */
 662   set = routerset_new();
 663   is_list = routerset_is_list(set);
 664   routerset_free(set);
 665   set = NULL;
 666   tt_int_op(is_list, OP_NE, 0);
 667
 668   /* len(set->country_names) != 0, len(set->policies) == 0 */
 669   set = routerset_new();
 670   smartlist_add(set->country_names, tor_strndup("foo", 3));
 671   is_list = routerset_is_list(set);
 672   routerset_free(set);
 673   set = NULL;
 674   tt_int_op(is_list, OP_EQ, 0);
 675
 676   /* len(set->country_names) == 0, len(set->policies) != 0 */
 677   set = routerset_new();
 678   policy = tor_malloc_zero(sizeof(addr_policy_t));
 679   smartlist_add(set->policies, (void *)policy);
 680   is_list = routerset_is_list(set);
 681   routerset_free(set);
 682   set = NULL;
 683   tt_int_op(is_list, OP_EQ, 0);
 684
 685   /* len(set->country_names) != 0, len(set->policies) != 0 */
 686   set = routerset_new();
 687   smartlist_add(set->country_names, tor_strndup("foo", 3));
 688   policy = tor_malloc_zero(sizeof(addr_policy_t));
 689   smartlist_add(set->policies, (void *)policy);
 690   is_list = routerset_is_list(set);
 691   routerset_free(set);
 692   set = NULL;
 693   tt_int_op(is_list, OP_EQ, 0);
 694
 695   done:
 696     ;
 697 }
 698
 699 #undef NS_SUBMODULE
 700 #define NS_SUBMODULE routerset_needs_geoip
 701
 702 /*
 703  * Functional tests for routerset_needs_geoip.
 704  */
 705
 706 static void
 707 NS(test_main)(void *arg)
 708 {
 709   routerset_t *set;
 710   int needs_geoip;
 711   (void)arg;
 712
 713   set = NULL;
 714   needs_geoip = routerset_needs_geoip(set);
 715   tt_int_op(needs_geoip, OP_EQ, 0);
 716
 717   set = routerset_new();
 718   needs_geoip = routerset_needs_geoip(set);
 719   routerset_free(set);
 720   tt_int_op(needs_geoip, OP_EQ, 0);
 721   set = NULL;
 722
 723   set = routerset_new();
 724   smartlist_add(set->country_names, tor_strndup("xx", 2));
 725   needs_geoip = routerset_needs_geoip(set);
 726   routerset_free(set);
 727   set = NULL;
 728   tt_int_op(needs_geoip, OP_NE, 0);
 729
 730   done:
 731     ;
 732 }
 733
 734 #undef NS_SUBMODULE
 735 #define NS_SUBMODULE routerset_is_empty
 736
 737 /*
 738  * Functional tests for routerset_is_empty.
 739  */
 740
 741 static void
 742 NS(test_main)(void *arg)
 743 {
 744   routerset_t *set = NULL;
 745   int is_empty;
 746   (void)arg;
 747
 748   is_empty = routerset_is_empty(set);
 749   tt_int_op(is_empty, OP_NE, 0);
 750
 751   set = routerset_new();
 752   is_empty = routerset_is_empty(set);
 753   routerset_free(set);
 754   set = NULL;
 755   tt_int_op(is_empty, OP_NE, 0);
 756
 757   set = routerset_new();
 758   smartlist_add_strdup(set->list, "{xx}");
 759   is_empty = routerset_is_empty(set);
 760   routerset_free(set);
 761   set = NULL;
 762   tt_int_op(is_empty, OP_EQ, 0);
 763
 764   done:
 765     ;
 766 }
 767
 768 #undef NS_SUBMODULE
 769 #define NS_SUBMODULE ASPECT(routerset_contains, null_set_or_null_set_list)
 770
 771 /*
 772  * Functional test for routerset_contains, when given a NULL set or the
 773  * set has a NULL list.
 774  */
 775
 776 static void
 777 NS(test_main)(void *arg)
 778 {
 779   routerset_t *set = NULL;
 780   int contains;
 781   (void)arg;
 782
 783   contains = routerset_contains(set, NULL, 0, NULL, NULL, 0);
 784
 785   tt_int_op(contains, OP_EQ, 0);
 786
 787   set = tor_malloc_zero(sizeof(routerset_t));
 788   set->list = NULL;
 789   contains = routerset_contains(set, NULL, 0, NULL, NULL, 0);
 790   tor_free(set);
 791   tt_int_op(contains, OP_EQ, 0);
 792
 793   done:
 794     ;
 795 }
 796
 797 #undef NS_SUBMODULE
 798 #define NS_SUBMODULE ASPECT(routerset_contains, set_and_null_nickname)
 799
 800 /*
 801  * Functional test for routerset_contains, when given a valid routerset but a
 802  * NULL nickname.
 803  */
 804
 805 static void
 806 NS(test_main)(void *arg)
 807 {
 808   routerset_t *set = routerset_new();
 809   char *nickname = NULL;
 810   int contains;
 811   (void)arg;
 812
 813   contains = routerset_contains(set, NULL, 0, nickname, NULL, 0);
 814   routerset_free(set);
 815
 816   tt_int_op(contains, OP_EQ, 0);
 817
 818   done:
 819     ;
 820 }
 821
 822 #undef NS_SUBMODULE
 823 #define NS_SUBMODULE ASPECT(routerset_contains, set_and_nickname)
 824
 825 /*
 826  * Functional test for routerset_contains, when given a valid routerset
 827  * and the nickname is in the routerset.
 828  */
 829
 830 static void
 831 NS(test_main)(void *arg)
 832 {
 833   routerset_t *set = routerset_new();
 834   const char *nickname;
 835   int contains;
 836   (void)arg;
 837
 838   nickname = "Foo";  /* This tests the lowercase comparison as well. */
 839   strmap_set_lc(set->names, nickname, (void *)1);
 840   contains = routerset_contains(set, NULL, 0, nickname, NULL, 0);
 841   routerset_free(set);
 842
 843   tt_int_op(contains, OP_EQ, 4);
 844   done:
 845     ;
 846 }
 847
 848 #undef NS_SUBMODULE
 849 #define NS_SUBMODULE ASPECT(routerset_contains, set_and_no_nickname)
 850
 851 /*
 852  * Functional test for routerset_contains, when given a valid routerset
 853  * and the nickname is not in the routerset.
 854  */
 855
 856 static void
 857 NS(test_main)(void *arg)
 858 {
 859   routerset_t *set = routerset_new();
 860   int contains;
 861   (void)arg;
 862
 863   strmap_set_lc(set->names, "bar", (void *)1);
 864   contains = routerset_contains(set, NULL, 0, "foo", NULL, 0);
 865   routerset_free(set);
 866
 867   tt_int_op(contains, OP_EQ, 0);
 868   done:
 869     ;
 870 }
 871
 872 #undef NS_SUBMODULE
 873 #define NS_SUBMODULE ASPECT(routerset_contains, set_and_digest)
 874
 875 /*
 876  * Functional test for routerset_contains, when given a valid routerset
 877  * and the digest is contained in the routerset.
 878  */
 879
 880 static void
 881 NS(test_main)(void *arg)
 882 {
 883   routerset_t *set = routerset_new();
 884   int contains;
 885   uint8_t foo[20] = { 2, 3, 4 };
 886   (void)arg;
 887
 888   digestmap_set(set->digests, (const char*)foo, (void *)1);
 889   contains = routerset_contains(set, NULL, 0, NULL, (const char*)foo, 0);
 890   routerset_free(set);
 891
 892   tt_int_op(contains, OP_EQ, 4);
 893   done:
 894     ;
 895 }
 896
 897 #undef NS_SUBMODULE
 898 #define NS_SUBMODULE ASPECT(routerset_contains, set_and_no_digest)
 899
 900 /*
 901  * Functional test for routerset_contains, when given a valid routerset
 902  * and the digest is not contained in the routerset.
 903  */
 904
 905 static void
 906 NS(test_main)(void *arg)
 907 {
 908   routerset_t *set = routerset_new();
 909   int contains;
 910   uint8_t bar[20] = { 9, 10, 11, 55 };
 911   uint8_t foo[20] = { 1, 2, 3, 4};
 912   (void)arg;
 913
 914   digestmap_set(set->digests, (const char*)bar, (void *)1);
 915   contains = routerset_contains(set, NULL, 0, NULL, (const char*)foo, 0);
 916   routerset_free(set);
 917
 918   tt_int_op(contains, OP_EQ, 0);
 919   done:
 920     ;
 921 }
 922
 923 #undef NS_SUBMODULE
 924 #define NS_SUBMODULE ASPECT(routerset_contains, set_and_null_digest)
 925
 926 /*
 927  * Functional test for routerset_contains, when given a valid routerset
 928  * and the digest is NULL.
 929  */
 930
 931 static void
 932 NS(test_main)(void *arg)
 933 {
 934   routerset_t *set = routerset_new();
 935   int contains;
 936   uint8_t bar[20] = { 9, 10, 11, 55 };
 937   (void)arg;
 938
 939   digestmap_set(set->digests, (const char*)bar, (void *)1);
 940   contains = routerset_contains(set, NULL, 0, NULL, NULL, 0);
 941   routerset_free(set);
 942
 943   tt_int_op(contains, OP_EQ, 0);
 944   done:
 945     ;
 946 }
 947
 948 #undef NS_SUBMODULE
 949 #define NS_SUBMODULE ASPECT(routerset_contains, set_and_addr)
 950
 951 /*
 952  * Structural test for routerset_contains, when given a valid routerset
 953  * and the address is rejected by policy.
 954  */
 955
 956 NS_DECL(addr_policy_result_t, compare_tor_addr_to_addr_policy,
 957     (const tor_addr_t *addr, uint16_t port, const smartlist_t *policy));
 958
 959 static tor_addr_t MOCK_TOR_ADDR;
 960 #define MOCK_TOR_ADDR_PTR (&MOCK_TOR_ADDR)
 961
 962 static void
 963 NS(test_main)(void *arg)
 964 {
 965   routerset_t *set = routerset_new();
 966   tor_addr_t *addr = MOCK_TOR_ADDR_PTR;
 967   int contains;
 968   (void)arg;
 969
 970   NS_MOCK(compare_tor_addr_to_addr_policy);
 971
 972   contains = routerset_contains(set, addr, 0, NULL, NULL, 0);
 973   routerset_free(set);
 974
 975   tt_int_op(CALLED(compare_tor_addr_to_addr_policy), OP_EQ, 1);
 976   tt_int_op(contains, OP_EQ, 3);
 977
 978   done:
 979     ;
 980 }
 981
 982 addr_policy_result_t
 983 NS(compare_tor_addr_to_addr_policy)(const tor_addr_t *addr, uint16_t port,
 984     const smartlist_t *policy)
 985 {
 986   (void)port;
 987   (void)policy;
 988   CALLED(compare_tor_addr_to_addr_policy)++;
 989   tt_ptr_op(addr, OP_EQ, MOCK_TOR_ADDR_PTR);
 990   return ADDR_POLICY_REJECTED;
 991
 992   done:
 993     return 0;
 994 }
 995
 996 #undef NS_SUBMODULE
 997 #define NS_SUBMODULE ASPECT(routerset_contains, set_and_no_addr)
 998
 999 /*
1000  * Structural test for routerset_contains, when given a valid routerset
1001  * and the address is not rejected by policy.
1002  */
1003
1004 NS_DECL(addr_policy_result_t, compare_tor_addr_to_addr_policy,
1005     (const tor_addr_t *addr, uint16_t port, const smartlist_t *policy));
1006
1007 static void
1008 NS(test_main)(void *arg)
1009 {
1010   routerset_t *set = routerset_new();
1011   tor_addr_t *addr = MOCK_TOR_ADDR_PTR;
1012   int contains;
1013   (void)arg;
1014
1015   NS_MOCK(compare_tor_addr_to_addr_policy);
1016
1017   contains = routerset_contains(set, addr, 0, NULL, NULL, 0);
1018   routerset_free(set);
1019
1020   tt_int_op(CALLED(compare_tor_addr_to_addr_policy), OP_EQ, 1);
1021   tt_int_op(contains, OP_EQ, 0);
1022
1023   done:
1024     ;
1025 }
1026
1027 addr_policy_result_t
1028 NS(compare_tor_addr_to_addr_policy)(const tor_addr_t *addr, uint16_t port,
1029     const smartlist_t *policy)
1030 {
1031   (void)port;
1032   (void)policy;
1033   CALLED(compare_tor_addr_to_addr_policy)++;
1034   tt_ptr_op(addr, OP_EQ, MOCK_TOR_ADDR_PTR);
1035
1036   return ADDR_POLICY_ACCEPTED;
1037
1038   done:
1039       return 0;
1040 }
1041
1042 #undef NS_SUBMODULE
1043 #define NS_SUBMODULE ASPECT(routerset_contains, set_and_null_addr)
1044
1045 /*
1046  * Structural test for routerset_contains, when given a valid routerset
1047  * and the address is NULL.
1048  */
1049
1050 NS_DECL(addr_policy_result_t, compare_tor_addr_to_addr_policy,
1051     (const tor_addr_t *addr, uint16_t port, const smartlist_t *policy));
1052
1053 static void
1054 NS(test_main)(void *arg)
1055 {
1056   routerset_t *set = routerset_new();
1057   int contains;
1058   (void)arg;
1059
1060   NS_MOCK(compare_tor_addr_to_addr_policy);
1061
1062   contains = routerset_contains(set, NULL, 0, NULL, NULL, 0);
1063   routerset_free(set);
1064
1065   tt_int_op(contains, OP_EQ, 0);
1066
1067   done:
1068     ;
1069 }
1070
1071 addr_policy_result_t
1072 NS(compare_tor_addr_to_addr_policy)(const tor_addr_t *addr, uint16_t port,
1073     const smartlist_t *policy)
1074 {
1075   (void)port;
1076   (void)policy;
1077   CALLED(compare_tor_addr_to_addr_policy)++;
1078   tt_ptr_op(addr, OP_EQ, MOCK_TOR_ADDR_PTR);
1079
1080   return ADDR_POLICY_ACCEPTED;
1081
1082   done:
1083     return 0;
1084 }
1085
1086 #undef NS_SUBMODULE
1087 #define NS_SUBMODULE ASPECT(routerset_contains, countries_no_geoip)
1088
1089 /*
1090  * Structural test for routerset_contains, when there is no matching country
1091  * for the address.
1092  */
1093
1094 NS_DECL(addr_policy_result_t, compare_tor_addr_to_addr_policy,
1095     (const tor_addr_t *addr, uint16_t port, const smartlist_t *policy));
1096 NS_DECL(int, geoip_get_country_by_addr, (const tor_addr_t *addr));
1097
1098 static void
1099 NS(test_main)(void *arg)
1100 {
1101   routerset_t *set = routerset_new();
1102   int contains = 1;
1103   (void)arg;
1104
1105   NS_MOCK(compare_tor_addr_to_addr_policy);
1106   NS_MOCK(geoip_get_country_by_addr);
1107
1108   set->countries = bitarray_init_zero(1);
1109   bitarray_set(set->countries, 1);
1110   contains = routerset_contains(set, MOCK_TOR_ADDR_PTR, 0, NULL, NULL, -1);
1111   routerset_free(set);
1112
1113   tt_int_op(contains, OP_EQ, 0);
1114   tt_int_op(CALLED(compare_tor_addr_to_addr_policy), OP_EQ, 1);
1115   tt_int_op(CALLED(geoip_get_country_by_addr), OP_EQ, 1);
1116
1117   done:
1118     ;
1119 }
1120
1121 addr_policy_result_t
1122 NS(compare_tor_addr_to_addr_policy)(const tor_addr_t *addr, uint16_t port,
1123     const smartlist_t *policy)
1124 {
1125   (void)port;
1126   (void)policy;
1127   CALLED(compare_tor_addr_to_addr_policy)++;
1128   tt_ptr_op(addr, OP_EQ, MOCK_TOR_ADDR_PTR);
1129
1130   done:
1131     return ADDR_POLICY_ACCEPTED;
1132 }
1133
1134 int
1135 NS(geoip_get_country_by_addr)(const tor_addr_t *addr)
1136 {
1137   CALLED(geoip_get_country_by_addr)++;
1138   tt_ptr_op(addr, OP_EQ, MOCK_TOR_ADDR_PTR);
1139
1140   done:
1141     return -1;
1142 }
1143
1144 #undef NS_SUBMODULE
1145 #define NS_SUBMODULE ASPECT(routerset_contains, countries_geoip)
1146
1147 /*
1148  * Structural test for routerset_contains, when there a matching country
1149  * for the address.
1150  */
1151
1152 NS_DECL(addr_policy_result_t, compare_tor_addr_to_addr_policy,
1153     (const tor_addr_t *addr, uint16_t port, const smartlist_t *policy));
1154 NS_DECL(int, geoip_get_country_by_addr, (const tor_addr_t *addr));
1155
1156 static void
1157 NS(test_main)(void *arg)
1158 {
1159   routerset_t *set = routerset_new();
1160   int contains = 1;
1161   (void)arg;
1162
1163   NS_MOCK(compare_tor_addr_to_addr_policy);
1164   NS_MOCK(geoip_get_country_by_addr);
1165
1166   set->n_countries = 2;
1167   set->countries = bitarray_init_zero(1);
1168   bitarray_set(set->countries, 1);
1169   contains = routerset_contains(set, MOCK_TOR_ADDR_PTR, 0, NULL, NULL, -1);
1170   routerset_free(set);
1171
1172   tt_int_op(contains, OP_EQ, 2);
1173   tt_int_op(CALLED(compare_tor_addr_to_addr_policy), OP_EQ, 1);
1174   tt_int_op(CALLED(geoip_get_country_by_addr), OP_EQ, 1);
1175
1176   done:
1177     ;
1178 }
1179
1180 addr_policy_result_t
1181 NS(compare_tor_addr_to_addr_policy)(const tor_addr_t *addr, uint16_t port,
1182     const smartlist_t *policy)
1183 {
1184   (void)port;
1185   (void)policy;
1186   CALLED(compare_tor_addr_to_addr_policy)++;
1187   tt_ptr_op(addr, OP_EQ, MOCK_TOR_ADDR_PTR);
1188
1189   done:
1190     return ADDR_POLICY_ACCEPTED;
1191 }
1192
1193 int
1194 NS(geoip_get_country_by_addr)(const tor_addr_t *addr)
1195 {
1196   CALLED(geoip_get_country_by_addr)++;
1197   tt_ptr_op(addr, OP_EQ, MOCK_TOR_ADDR_PTR);
1198
1199   done:
1200     return 1;
1201 }
1202
1203 #undef NS_SUBMODULE
1204 #define NS_SUBMODULE ASPECT(routerset_add_unknown_ccs, only_flag_and_no_ccs)
1205
1206 /*
1207  * Functional test for routerset_add_unknown_ccs, where only_if_some_cc_set
1208  * is set and there are no country names.
1209  */
1210
1211 static void
1212 NS(test_main)(void *arg)
1213 {
1214   routerset_t *set = routerset_new();
1215   routerset_t **setp = &set;
1216   int r;
1217   (void)arg;
1218
1219   r = routerset_add_unknown_ccs(setp, 1);
1220
1221   tt_int_op(r, OP_EQ, 0);
1222
1223   done:
1224     routerset_free(set);
1225 }
1226
1227 #undef NS_SUBMODULE
1228 #define NS_SUBMODULE ASPECT(routerset_add_unknown_ccs, creates_set)
1229
1230 /*
1231  * Functional test for routerset_add_unknown_ccs, where the set argument
1232  * is created if passed in as NULL.
1233  */
1234
1235 /* The mock is only used to stop the test from asserting erroneously. */
1236 NS_DECL(country_t, geoip_get_country, (const char *country));
1237
1238 static void
1239 NS(test_main)(void *arg)
1240 {
1241   routerset_t *set = NULL;
1242   routerset_t **setp = &set;
1243   int r;
1244   (void)arg;
1245
1246   NS_MOCK(geoip_get_country);
1247
1248   r = routerset_add_unknown_ccs(setp, 0);
1249
1250   tt_ptr_op(*setp, OP_NE, NULL);
1251   tt_int_op(r, OP_EQ, 0);
1252
1253   done:
1254     if (set != NULL)
1255       routerset_free(set);
1256 }
1257
1258 country_t
1259 NS(geoip_get_country)(const char *country)
1260 {
1261   (void)country;
1262   CALLED(geoip_get_country)++;
1263
1264   return -1;
1265 }
1266
1267 #undef NS_SUBMODULE
1268 #define NS_SUBMODULE ASPECT(routerset_add_unknown_ccs, add_unknown)
1269
1270 /*
1271  * Structural test for routerset_add_unknown_ccs, that the "{??}"
1272  * country code is added to the list.
1273  */
1274
1275 NS_DECL(country_t, geoip_get_country, (const char *country));
1276 NS_DECL(int, geoip_is_loaded, (sa_family_t family));
1277
1278 static void
1279 NS(test_main)(void *arg)
1280 {
1281   routerset_t *set = routerset_new();
1282   routerset_t **setp = &set;
1283   int r;
1284   (void)arg;
1285
1286   NS_MOCK(geoip_get_country);
1287   NS_MOCK(geoip_is_loaded);
1288
1289   r = routerset_add_unknown_ccs(setp, 0);
1290
1291   tt_int_op(r, OP_EQ, 1);
1292   tt_int_op(smartlist_contains_string(set->country_names, "??"), OP_EQ, 1);
1293   tt_int_op(smartlist_contains_string(set->list, "{??}"), OP_EQ, 1);
1294
1295   done:
1296     if (set != NULL)
1297       routerset_free(set);
1298 }
1299
1300 country_t
1301 NS(geoip_get_country)(const char *country)
1302 {
1303   int arg_is_qq, arg_is_a1;
1304
1305   CALLED(geoip_get_country)++;
1306
1307   arg_is_qq = !strcmp(country, "??");
1308   arg_is_a1 = !strcmp(country, "A1");
1309
1310   tt_int_op(arg_is_qq || arg_is_a1, OP_EQ, 1);
1311
1312   if (arg_is_qq)
1313     return 1;
1314
1315   done:
1316     return -1;
1317 }
1318
1319 int
1320 NS(geoip_is_loaded)(sa_family_t family)
1321 {
1322   CALLED(geoip_is_loaded)++;
1323
1324   tt_int_op(family, OP_EQ, AF_INET);
1325
1326   done:
1327     return 0;
1328 }
1329
1330 #undef NS_SUBMODULE
1331 #define NS_SUBMODULE ASPECT(routerset_add_unknown_ccs, add_a1)
1332
1333 /*
1334  * Structural test for routerset_add_unknown_ccs, that the "{a1}"
1335  * country code is added to the list.
1336  */
1337
1338 NS_DECL(country_t, geoip_get_country, (const char *country));
1339 NS_DECL(int, geoip_is_loaded, (sa_family_t family));
1340
1341 static void
1342 NS(test_main)(void *arg)
1343 {
1344   routerset_t *set = routerset_new();
1345   routerset_t **setp = &set;
1346   int r;
1347   (void)arg;
1348
1349   NS_MOCK(geoip_get_country);
1350   NS_MOCK(geoip_is_loaded);
1351
1352   r = routerset_add_unknown_ccs(setp, 0);
1353
1354   tt_int_op(r, OP_EQ, 1);
1355   tt_int_op(smartlist_contains_string(set->country_names, "a1"), OP_EQ, 1);
1356   tt_int_op(smartlist_contains_string(set->list, "{a1}"), OP_EQ, 1);
1357
1358   done:
1359     if (set != NULL)
1360       routerset_free(set);
1361 }
1362
1363 country_t
1364 NS(geoip_get_country)(const char *country)
1365 {
1366   int arg_is_qq, arg_is_a1;
1367
1368   CALLED(geoip_get_country)++;
1369
1370   arg_is_qq = !strcmp(country, "??");
1371   arg_is_a1 = !strcmp(country, "A1");
1372
1373   tt_int_op(arg_is_qq || arg_is_a1, OP_EQ, 1);
1374
1375   if (arg_is_a1)
1376     return 1;
1377
1378   done:
1379     return -1;
1380 }
1381
1382 int
1383 NS(geoip_is_loaded)(sa_family_t family)
1384 {
1385   CALLED(geoip_is_loaded)++;
1386
1387   tt_int_op(family, OP_EQ, AF_INET);
1388
1389   done:
1390     return 0;
1391 }
1392
1393 #undef NS_SUBMODULE
1394 #define NS_SUBMODULE routerset_contains_extendinfo
1395
1396 /*
1397  * Functional test for routerset_contains_extendinfo.
1398  */
1399
1400 static void
1401 NS(test_main)(void *arg)
1402 {
1403   routerset_t *set = routerset_new();
1404   extend_info_t ei;
1405   int r;
1406   const char *nickname = "foo";
1407   (void)arg;
1408
1409   memset(&ei, 0, sizeof(ei));
1410   strmap_set_lc(set->names, nickname, (void *)1);
1411   strncpy(ei.nickname, nickname, sizeof(ei.nickname) - 1);
1412   ei.nickname[sizeof(ei.nickname) - 1] = '\0';
1413
1414   r = routerset_contains_extendinfo(set, &ei);
1415
1416   tt_int_op(r, OP_EQ, 4);
1417   done:
1418     routerset_free(set);
1419 }
1420
1421 #undef NS_SUBMODULE
1422 #define NS_SUBMODULE routerset_contains_router
1423
1424 /*
1425  * Functional test for routerset_contains_router.
1426  */
1427
1428 static void
1429 NS(test_main)(void *arg)
1430 {
1431   routerset_t *set = routerset_new();
1432   routerinfo_t ri;
1433   country_t country = 1;
1434   int r;
1435   const char *nickname = "foo";
1436   (void)arg;
1437
1438   memset(&ri, 0, sizeof(ri));
1439   strmap_set_lc(set->names, nickname, (void *)1);
1440   ri.nickname = (char *)nickname;
1441
1442   r = routerset_contains_router(set, &ri, country);
1443
1444   tt_int_op(r, OP_EQ, 4);
1445   done:
1446     routerset_free(set);
1447 }
1448
1449 #undef NS_SUBMODULE
1450 #define NS_SUBMODULE routerset_contains_routerstatus
1451
1452 /*
1453  * Functional test for routerset_contains_routerstatus.
1454  */
1455
1456 // XXX: This is a bit brief. It only populates and tests the nickname fields
1457 // ie., enough to make the containment check succeed. Perhaps it should do
1458 // a bit more or test a bit more.
1459
1460 static void
1461 NS(test_main)(void *arg)
1462 {
1463   routerset_t *set = routerset_new();
1464   routerstatus_t rs;
1465   country_t country = 1;
1466   int r;
1467   const char *nickname = "foo";
1468   (void)arg;
1469
1470   memset(&rs, 0, sizeof(rs));
1471   strmap_set_lc(set->names, nickname, (void *)1);
1472   strncpy(rs.nickname, nickname, sizeof(rs.nickname) - 1);
1473   rs.nickname[sizeof(rs.nickname) - 1] = '\0';
1474
1475   r = routerset_contains_routerstatus(set, &rs, country);
1476
1477   tt_int_op(r, OP_EQ, 4);
1478   done:
1479     routerset_free(set);
1480 }
1481
1482 #undef NS_SUBMODULE
1483 #define NS_SUBMODULE ASPECT(routerset_contains_node, none)
1484
1485 /*
1486  * Functional test for routerset_contains_node, when the node has no
1487  * routerset or routerinfo.
1488  */
1489
1490 static node_t NS(mock_node);
1491
1492 static void
1493 NS(test_main)(void *arg)
1494 {
1495   routerset_t *set = routerset_new();
1496   int r;
1497   (void)arg;
1498
1499   NS(mock_node).ri = NULL;
1500   NS(mock_node).rs = NULL;
1501
1502   r = routerset_contains_node(set, &NS(mock_node));
1503   tt_int_op(r, OP_EQ, 0);
1504
1505   done:
1506     routerset_free(set);
1507 }
1508
1509 #undef NS_SUBMODULE
1510 #define NS_SUBMODULE ASPECT(routerset_contains_node, routerstatus)
1511
1512 /*
1513  * Functional test for routerset_contains_node, when the node has a
1514  * routerset and no routerinfo.
1515  */
1516
1517 static node_t NS(mock_node);
1518
1519 static void
1520 NS(test_main)(void *arg)
1521 {
1522   routerset_t *set = routerset_new();
1523   int r;
1524   const char *nickname = "foo";
1525   routerstatus_t rs;
1526   (void)arg;
1527
1528   strmap_set_lc(set->names, nickname, (void *)1);
1529
1530   strncpy(rs.nickname, nickname, sizeof(rs.nickname) - 1);
1531   rs.nickname[sizeof(rs.nickname) - 1] = '\0';
1532   NS(mock_node).ri = NULL;
1533   NS(mock_node).rs = &rs;
1534
1535   r = routerset_contains_node(set, &NS(mock_node));
1536
1537   tt_int_op(r, OP_EQ, 4);
1538   done:
1539     routerset_free(set);
1540 }
1541
1542 #undef NS_SUBMODULE
1543 #define NS_SUBMODULE ASPECT(routerset_contains_node, routerinfo)
1544
1545 /*
1546  * Functional test for routerset_contains_node, when the node has no
1547  * routerset and a routerinfo.
1548  */
1549
1550 static void
1551 NS(test_main)(void *arg)
1552 {
1553   routerset_t *set = routerset_new();
1554   int r;
1555   const char *nickname = "foo";
1556   routerinfo_t ri;
1557   node_t mock_node;
1558   (void)arg;
1559
1560   strmap_set_lc(set->names, nickname, (void *)1);
1561
1562   ri.nickname = (char *)nickname;
1563   mock_node.ri = &ri;
1564   mock_node.rs = NULL;
1565
1566   r = routerset_contains_node(set, &mock_node);
1567
1568   tt_int_op(r, OP_EQ, 4);
1569   done:
1570     routerset_free(set);
1571 }
1572
1573 #undef NS_SUBMODULE
1574 #define NS_SUBMODULE ASPECT(routerset_get_all_nodes, no_routerset)
1575
1576 /*
1577  * Functional test for routerset_get_all_nodes, when routerset is NULL or
1578  * the routerset list is NULL.
1579  */
1580
1581 static void
1582 NS(test_main)(void *arg)
1583 {
1584   smartlist_t *out = smartlist_new();
1585   routerset_t *set = NULL;
1586   (void)arg;
1587
1588   tt_int_op(smartlist_len(out), OP_EQ, 0);
1589   routerset_get_all_nodes(out, NULL, NULL, 0);
1590
1591   tt_int_op(smartlist_len(out), OP_EQ, 0);
1592
1593   set = routerset_new();
1594   smartlist_free(set->list);
1595   routerset_get_all_nodes(out, NULL, NULL, 0);
1596   tt_int_op(smartlist_len(out), OP_EQ, 0);
1597
1598   /* Just recreate list, so we can simply use routerset_free. */
1599   set->list = smartlist_new();
1600
1601  done:
1602   routerset_free(set);
1603   smartlist_free(out);
1604 }
1605
1606 #undef NS_SUBMODULE
1607 #define NS_SUBMODULE ASPECT(routerset_get_all_nodes, list_with_no_nodes)
1608
1609 /*
1610  * Structural test for routerset_get_all_nodes, when the routerset list
1611  * is empty.
1612  */
1613
1614 NS_DECL(const node_t *, node_get_by_nickname,
1615     (const char *nickname, unsigned flags));
1616 static const char *NS(mock_nickname);
1617
1618 static void
1619 NS(test_main)(void *arg)
1620 {
1621   smartlist_t *out = smartlist_new();
1622   routerset_t *set = routerset_new();
1623   int out_len;
1624   (void)arg;
1625
1626   NS_MOCK(node_get_by_nickname);
1627
1628   NS(mock_nickname) = "foo";
1629   smartlist_add_strdup(set->list, NS(mock_nickname));
1630
1631   routerset_get_all_nodes(out, set, NULL, 0);
1632   out_len = smartlist_len(out);
1633
1634   smartlist_free(out);
1635   routerset_free(set);
1636
1637   tt_int_op(out_len, OP_EQ, 0);
1638   tt_int_op(CALLED(node_get_by_nickname), OP_EQ, 1);
1639
1640   done:
1641     ;
1642 }
1643
1644 const node_t *
1645 NS(node_get_by_nickname)(const char *nickname, unsigned flags)
1646 {
1647   CALLED(node_get_by_nickname)++;
1648   tt_str_op(nickname, OP_EQ, NS(mock_nickname));
1649   tt_uint_op(flags, OP_EQ, 0);
1650
1651   done:
1652     return NULL;
1653 }
1654
1655 #undef NS_SUBMODULE
1656 #define NS_SUBMODULE ASPECT(routerset_get_all_nodes, list_flag_not_running)
1657
1658 /*
1659  * Structural test for routerset_get_all_nodes, with the running_only flag
1660  * is set but the nodes are not running.
1661  */
1662
1663 NS_DECL(const node_t *, node_get_by_nickname,
1664     (const char *nickname, unsigned flags));
1665 static const char *NS(mock_nickname);
1666 static node_t NS(mock_node);
1667
1668 static void
1669 NS(test_main)(void *arg)
1670 {
1671   smartlist_t *out = smartlist_new();
1672   routerset_t *set = routerset_new();
1673   int out_len;
1674   (void)arg;
1675
1676   NS_MOCK(node_get_by_nickname);
1677
1678   NS(mock_node).is_running = 0;
1679   NS(mock_nickname) = "foo";
1680   smartlist_add_strdup(set->list, NS(mock_nickname));
1681
1682   routerset_get_all_nodes(out, set, NULL, 1);
1683   out_len = smartlist_len(out);
1684
1685   smartlist_free(out);
1686   routerset_free(set);
1687
1688   tt_int_op(out_len, OP_EQ, 0);
1689   tt_int_op(CALLED(node_get_by_nickname), OP_EQ, 1);
1690
1691   done:
1692     ;
1693 }
1694
1695 const node_t *
1696 NS(node_get_by_nickname)(const char *nickname, unsigned flags)
1697 {
1698   CALLED(node_get_by_nickname)++;
1699   tt_str_op(nickname, OP_EQ, NS(mock_nickname));
1700   tt_int_op(flags, OP_EQ, 0);
1701
1702   done:
1703     return &NS(mock_node);
1704 }
1705
1706 #undef NS_SUBMODULE
1707 #define NS_SUBMODULE ASPECT(routerset_get_all_nodes, list)
1708
1709 /*
1710  * Structural test for routerset_get_all_nodes.
1711  */
1712
1713 NS_DECL(const node_t *, node_get_by_nickname,
1714     (const char *nickname, unsigned flags));
1715 static char *NS(mock_nickname);
1716 static node_t NS(mock_node);
1717
1718 static void
1719 NS(test_main)(void *arg)
1720 {
1721   smartlist_t *out = smartlist_new();
1722   routerset_t *set = routerset_new();
1723   int out_len;
1724   node_t *ent;
1725   (void)arg;
1726
1727   NS_MOCK(node_get_by_nickname);
1728
1729   NS(mock_nickname) = tor_strdup("foo");
1730   smartlist_add(set->list, NS(mock_nickname));
1731
1732   routerset_get_all_nodes(out, set, NULL, 0);
1733   out_len = smartlist_len(out);
1734   ent = (node_t *)smartlist_get(out, 0);
1735
1736   smartlist_free(out);
1737   routerset_free(set);
1738
1739   tt_int_op(out_len, OP_EQ, 1);
1740   tt_ptr_op(ent, OP_EQ, &NS(mock_node));
1741   tt_int_op(CALLED(node_get_by_nickname), OP_EQ, 1);
1742
1743   done:
1744     ;
1745 }
1746
1747 const node_t *
1748 NS(node_get_by_nickname)(const char *nickname, unsigned flags)
1749 {
1750   CALLED(node_get_by_nickname)++;
1751   tt_str_op(nickname, OP_EQ, NS(mock_nickname));
1752   tt_int_op(flags, OP_EQ, 0);
1753
1754   done:
1755     return &NS(mock_node);
1756 }
1757
1758 #undef NS_SUBMODULE
1759 #define NS_SUBMODULE ASPECT(routerset_get_all_nodes, nodelist_with_no_nodes)
1760
1761 /*
1762  * Structural test for routerset_get_all_nodes, when the nodelist has no nodes.
1763  */
1764
1765 NS_DECL(smartlist_t *, nodelist_get_list, (void));
1766
1767 static smartlist_t *NS(mock_smartlist);
1768
1769 static void
1770 NS(test_main)(void *arg)
1771 {
1772   routerset_t *set = routerset_new();
1773   smartlist_t *out = smartlist_new();
1774   int r;
1775   (void)arg;
1776
1777   NS_MOCK(nodelist_get_list);
1778
1779   smartlist_add_strdup(set->country_names, "{xx}");
1780   NS(mock_smartlist) = smartlist_new();
1781
1782   routerset_get_all_nodes(out, set, NULL, 1);
1783   r = smartlist_len(out);
1784   routerset_free(set);
1785   smartlist_free(out);
1786   smartlist_free(NS(mock_smartlist));
1787
1788   tt_int_op(r, OP_EQ, 0);
1789   tt_int_op(CALLED(nodelist_get_list), OP_EQ, 1);
1790
1791   done:
1792     ;
1793 }
1794
1795 smartlist_t *
1796 NS(nodelist_get_list)(void)
1797 {
1798   CALLED(nodelist_get_list)++;
1799
1800   return NS(mock_smartlist);
1801 }
1802
1803 #undef NS_SUBMODULE
1804 #define NS_SUBMODULE ASPECT(routerset_get_all_nodes, nodelist_flag_not_running)
1805
1806 /*
1807  * Structural test for routerset_get_all_nodes, with a non-list routerset
1808  * the running_only flag is set, but the nodes are not running.
1809  */
1810
1811 NS_DECL(smartlist_t *, nodelist_get_list, (void));
1812
1813 static smartlist_t *NS(mock_smartlist);
1814 static node_t NS(mock_node);
1815
1816 static void
1817 NS(test_main)(void *arg)
1818 {
1819   routerset_t *set = routerset_new();
1820   smartlist_t *out = smartlist_new();
1821   int r;
1822   (void)arg;
1823
1824   NS_MOCK(nodelist_get_list);
1825
1826   smartlist_add_strdup(set->country_names, "{xx}");
1827   NS(mock_smartlist) = smartlist_new();
1828   NS(mock_node).is_running = 0;
1829   smartlist_add(NS(mock_smartlist), (void *)&NS(mock_node));
1830
1831   routerset_get_all_nodes(out, set, NULL, 1);
1832   r = smartlist_len(out);
1833   routerset_free(set);
1834   smartlist_free(out);
1835   smartlist_free(NS(mock_smartlist));
1836
1837   tt_int_op(r, OP_EQ, 0);
1838   tt_int_op(CALLED(nodelist_get_list), OP_EQ, 1);
1839
1840   done:
1841     ;
1842 }
1843
1844 smartlist_t *
1845 NS(nodelist_get_list)(void)
1846 {
1847   CALLED(nodelist_get_list)++;
1848
1849   return NS(mock_smartlist);
1850 }
1851
1852 #undef NS_SUBMODULE
1853 #define NS_SUBMODULE routerset_subtract_nodes
1854
1855 /*
1856  * Functional test for routerset_subtract_nodes.
1857  */
1858
1859 static void
1860 NS(test_main)(void *arg)
1861 {
1862   routerset_t *set = routerset_new();
1863   smartlist_t *list = smartlist_new();
1864   const char *nickname = "foo";
1865   routerinfo_t ri;
1866   node_t mock_node;
1867   (void)arg;
1868
1869   strmap_set_lc(set->names, nickname, (void *)1);
1870
1871   ri.nickname = (char *)nickname;
1872   mock_node.rs = NULL;
1873   mock_node.ri = &ri;
1874   smartlist_add(list, (void *)&mock_node);
1875
1876   tt_int_op(smartlist_len(list), OP_NE, 0);
1877   routerset_subtract_nodes(list, set);
1878
1879   tt_int_op(smartlist_len(list), OP_EQ, 0);
1880   done:
1881     routerset_free(set);
1882     smartlist_free(list);
1883 }
1884
1885 #undef NS_SUBMODULE
1886 #define NS_SUBMODULE ASPECT(routerset_subtract_nodes, null_routerset)
1887
1888 /*
1889  * Functional test for routerset_subtract_nodes, with a NULL routerset.
1890  */
1891
1892 static void
1893 NS(test_main)(void *arg)
1894 {
1895   routerset_t *set = NULL;
1896   smartlist_t *list = smartlist_new();
1897   const char *nickname = "foo";
1898   routerinfo_t ri;
1899   node_t mock_node;
1900   (void)arg;
1901
1902   ri.nickname = (char *)nickname;
1903   mock_node.ri = &ri;
1904   smartlist_add(list, (void *)&mock_node);
1905
1906   tt_int_op(smartlist_len(list), OP_NE, 0);
1907   routerset_subtract_nodes(list, set);
1908
1909   tt_int_op(smartlist_len(list), OP_NE, 0);
1910   done:
1911     routerset_free(set);
1912     smartlist_free(list);
1913 }
1914
1915 #undef NS_SUBMODULE
1916 #define NS_SUBMODULE routerset_to_string
1917
1918 /*
1919  * Functional test for routerset_to_string.
1920  */
1921
1922 static void
1923 NS(test_main)(void *arg)
1924 {
1925   routerset_t *set = NULL;
1926   char *s = NULL;
1927   (void)arg;
1928
1929   set = NULL;
1930   s = routerset_to_string(set);
1931   tt_str_op(s, OP_EQ, "");
1932   tor_free(s);
1933
1934   set = routerset_new();
1935   s = routerset_to_string(set);
1936   tt_str_op(s, OP_EQ, "");
1937   tor_free(s);
1938   routerset_free(set); set = NULL;
1939
1940   set = routerset_new();
1941   smartlist_add(set->list, tor_strndup("a", 1));
1942   s = routerset_to_string(set);
1943   tt_str_op(s, OP_EQ, "a");
1944   tor_free(s);
1945   routerset_free(set); set = NULL;
1946
1947   set = routerset_new();
1948   smartlist_add(set->list, tor_strndup("a", 1));
1949   smartlist_add(set->list, tor_strndup("b", 1));
1950   s = routerset_to_string(set);
1951   tt_str_op(s, OP_EQ, "a,b");
1952   tor_free(s);
1953   routerset_free(set); set = NULL;
1954
1955  done:
1956   tor_free(s);
1957   routerset_free(set);
1958 }
1959
1960 #undef NS_SUBMODULE
1961 #define NS_SUBMODULE ASPECT(routerset_equal, empty_empty)
1962
1963 /*
1964  * Functional test for routerset_equal, with both routersets empty.
1965  */
1966
1967 static void
1968 NS(test_main)(void *arg)
1969 {
1970   routerset_t *a = routerset_new(), *b = routerset_new();
1971   int r;
1972   (void)arg;
1973
1974   r = routerset_equal(a, b);
1975   routerset_free(a);
1976   routerset_free(b);
1977
1978   tt_int_op(r, OP_EQ, 1);
1979
1980   done:
1981     ;
1982 }
1983
1984 #undef NS_SUBMODULE
1985 #define NS_SUBMODULE ASPECT(routerset_equal, empty_not_empty)
1986
1987 /*
1988  * Functional test for routerset_equal, with one routersets empty.
1989  */
1990
1991 static void
1992 NS(test_main)(void *arg)
1993 {
1994   routerset_t *a = routerset_new(), *b = routerset_new();
1995   int r;
1996   (void)arg;
1997
1998   smartlist_add_strdup(b->list, "{xx}");
1999   r = routerset_equal(a, b);
2000   routerset_free(a);
2001   routerset_free(b);
2002
2003   tt_int_op(r, OP_EQ, 0);
2004   done:
2005     ;
2006 }
2007
2008 #undef NS_SUBMODULE
2009 #define NS_SUBMODULE ASPECT(routerset_equal, differing_lengths)
2010
2011 /*
2012  * Functional test for routerset_equal, with the routersets having
2013  * differing lengths.
2014  */
2015
2016 static void
2017 NS(test_main)(void *arg)
2018 {
2019   routerset_t *a = routerset_new(), *b = routerset_new();
2020   int r;
2021   (void)arg;
2022
2023   smartlist_add_strdup(a->list, "{aa}");
2024   smartlist_add_strdup(b->list, "{b1}");
2025   smartlist_add_strdup(b->list, "{b2}");
2026   r = routerset_equal(a, b);
2027   routerset_free(a);
2028   routerset_free(b);
2029
2030   tt_int_op(r, OP_EQ, 0);
2031   done:
2032     ;
2033 }
2034
2035 #undef NS_SUBMODULE
2036 #define NS_SUBMODULE ASPECT(routerset_equal, unequal)
2037
2038 /*
2039  * Functional test for routerset_equal, with the routersets being
2040  * different.
2041  */
2042
2043 static void
2044 NS(test_main)(void *arg)
2045 {
2046   routerset_t *a = routerset_new(), *b = routerset_new();
2047   int r;
2048   (void)arg;
2049
2050   smartlist_add_strdup(a->list, "foo");
2051   smartlist_add_strdup(b->list, "bar");
2052   r = routerset_equal(a, b);
2053   routerset_free(a);
2054   routerset_free(b);
2055
2056   tt_int_op(r, OP_EQ, 0);
2057   done:
2058     ;
2059 }
2060
2061 #undef NS_SUBMODULE
2062 #define NS_SUBMODULE ASPECT(routerset_equal, equal)
2063
2064 /*
2065  * Functional test for routerset_equal, with the routersets being
2066  * equal.
2067  */
2068
2069 static void
2070 NS(test_main)(void *arg)
2071 {
2072   routerset_t *a = routerset_new(), *b = routerset_new();
2073   int r;
2074   (void)arg;
2075
2076   smartlist_add_strdup(a->list, "foo");
2077   smartlist_add_strdup(b->list, "foo");
2078   r = routerset_equal(a, b);
2079   routerset_free(a);
2080   routerset_free(b);
2081
2082   tt_int_op(r, OP_EQ, 1);
2083   done:
2084     ;
2085 }
2086
2087 #undef NS_SUBMODULE
2088 #define NS_SUBMODULE ASPECT(routerset_free, null_routerset)
2089
2090 /*
2091  * Structural test for routerset_free, where the routerset is NULL.
2092  */
2093
2094 NS_DECL(void, smartlist_free_, (smartlist_t *sl));
2095
2096 static void
2097 NS(test_main)(void *arg)
2098 {
2099   (void)arg;
2100
2101   NS_MOCK(smartlist_free_);
2102
2103   routerset_free_(NULL);
2104
2105   tt_int_op(CALLED(smartlist_free_), OP_EQ, 0);
2106
2107   done:
2108     ;
2109 }
2110
2111 void
2112 NS(smartlist_free_)(smartlist_t *s)
2113 {
2114   (void)s;
2115   CALLED(smartlist_free_)++;
2116 }
2117
2118 #undef NS_SUBMODULE
2119 #define NS_SUBMODULE routerset_free
2120
2121 /*
2122  * Structural test for routerset_free.
2123  */
2124
2125 NS_DECL(void, smartlist_free_, (smartlist_t *sl));
2126 NS_DECL(void, strmap_free_,(strmap_t *map, void (*free_val)(void*)));
2127 NS_DECL(void, digestmap_free_, (digestmap_t *map, void (*free_val)(void*)));
2128
2129 static void
2130 NS(test_main)(void *arg)
2131 {
2132   routerset_t *routerset = routerset_new();
2133   (void)arg;
2134
2135   NS_MOCK(smartlist_free_);
2136   NS_MOCK(strmap_free_);
2137   NS_MOCK(digestmap_free_);
2138
2139   routerset_free(routerset);
2140
2141   tt_int_op(CALLED(smartlist_free_), OP_NE, 0);
2142   tt_int_op(CALLED(strmap_free_), OP_NE, 0);
2143   tt_int_op(CALLED(digestmap_free_), OP_NE, 0);
2144
2145   done:
2146     ;
2147 }
2148
2149 void
2150 NS(smartlist_free_)(smartlist_t *s)
2151 {
2152   CALLED(smartlist_free_)++;
2153   smartlist_free___real(s);
2154 }
2155
2156 void
2157 NS(strmap_free_)(strmap_t *map, void (*free_val)(void*))
2158 {
2159   CALLED(strmap_free_)++;
2160   strmap_free___real(map, free_val);
2161 }
2162
2163 void
2164 NS(digestmap_free_)(digestmap_t *map, void (*free_val)(void*))
2165 {
2166   CALLED(digestmap_free_)++;
2167   digestmap_free___real(map, free_val);
2168 }
2169
2170 #undef NS_SUBMODULE
2171
2172 struct testcase_t routerset_tests[] = {
2173   TEST_CASE(routerset_new),
2174   TEST_CASE(routerset_get_countryname),
2175   TEST_CASE(routerset_is_list),
2176   TEST_CASE(routerset_needs_geoip),
2177   TEST_CASE(routerset_is_empty),
2178   TEST_CASE_ASPECT(routerset_contains, null_set_or_null_set_list),
2179   TEST_CASE_ASPECT(routerset_contains, set_and_nickname),
2180   TEST_CASE_ASPECT(routerset_contains, set_and_null_nickname),
2181   TEST_CASE_ASPECT(routerset_contains, set_and_no_nickname),
2182   TEST_CASE_ASPECT(routerset_contains, set_and_digest),
2183   TEST_CASE_ASPECT(routerset_contains, set_and_no_digest),
2184   TEST_CASE_ASPECT(routerset_contains, set_and_null_digest),
2185   TEST_CASE_ASPECT(routerset_contains, set_and_addr),
2186   TEST_CASE_ASPECT(routerset_contains, set_and_no_addr),
2187   TEST_CASE_ASPECT(routerset_contains, set_and_null_addr),
2188   TEST_CASE_ASPECT(routerset_contains, countries_no_geoip),
2189   TEST_CASE_ASPECT(routerset_contains, countries_geoip),
2190   TEST_CASE_ASPECT(routerset_add_unknown_ccs, only_flag_and_no_ccs),
2191   TEST_CASE_ASPECT(routerset_add_unknown_ccs, creates_set),
2192   TEST_CASE_ASPECT(routerset_add_unknown_ccs, add_unknown),
2193   TEST_CASE_ASPECT(routerset_add_unknown_ccs, add_a1),
2194   TEST_CASE(routerset_contains_extendinfo),
2195   TEST_CASE(routerset_contains_router),
2196   TEST_CASE(routerset_contains_routerstatus),
2197   TEST_CASE_ASPECT(routerset_contains_node, none),
2198   TEST_CASE_ASPECT(routerset_contains_node, routerinfo),
2199   TEST_CASE_ASPECT(routerset_contains_node, routerstatus),
2200   TEST_CASE_ASPECT(routerset_get_all_nodes, no_routerset),
2201   TEST_CASE_ASPECT(routerset_get_all_nodes, list_with_no_nodes),
2202   TEST_CASE_ASPECT(routerset_get_all_nodes, list_flag_not_running),
2203   TEST_CASE_ASPECT(routerset_get_all_nodes, list),
2204   TEST_CASE_ASPECT(routerset_get_all_nodes, nodelist_with_no_nodes),
2205   TEST_CASE_ASPECT(routerset_get_all_nodes, nodelist_flag_not_running),
2206   TEST_CASE_ASPECT(routerset_refresh_counties, geoip_not_loaded),
2207   TEST_CASE_ASPECT(routerset_refresh_counties, no_countries),
2208   TEST_CASE_ASPECT(routerset_refresh_counties, one_valid_country),
2209   TEST_CASE_ASPECT(routerset_refresh_counties, one_invalid_country),
2210   TEST_CASE_ASPECT(routerset_union, source_bad),
2211   TEST_CASE_ASPECT(routerset_union, one),
2212   TEST_CASE_ASPECT(routerset_parse, malformed),
2213   TEST_CASE_ASPECT(routerset_parse, valid_hexdigest),
2214   TEST_CASE_ASPECT(routerset_parse, valid_nickname),
2215   TEST_CASE_ASPECT(routerset_parse, get_countryname),
2216   TEST_CASE_ASPECT(routerset_parse, policy_wildcard),
2217   TEST_CASE_ASPECT(routerset_parse, policy_ipv4),
2218   TEST_CASE_ASPECT(routerset_parse, policy_ipv6),
2219   TEST_CASE(routerset_subtract_nodes),
2220   TEST_CASE_ASPECT(routerset_subtract_nodes, null_routerset),
2221   TEST_CASE(routerset_to_string),
2222   TEST_CASE_ASPECT(routerset_equal, empty_empty),
2223   TEST_CASE_ASPECT(routerset_equal, empty_not_empty),
2224   TEST_CASE_ASPECT(routerset_equal, differing_lengths),
2225   TEST_CASE_ASPECT(routerset_equal, unequal),
2226   TEST_CASE_ASPECT(routerset_equal, equal),
2227   TEST_CASE_ASPECT(routerset_free, null_routerset),
2228   TEST_CASE(routerset_free),
2229   END_OF_TESTCASES
2230 };