src/test/test_routerset.c

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