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)
 427
 428 /*
 429  * Structural test for routerset_parse, when given a valid policy.
 430  */
 431
 432 NS_DECL(addr_policy_t *, router_parse_addr_policy_item_from_string,
 433     (const char *s, int assume_action));
 434
 435 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, int assume_action)
 461 {
 462   (void)s;
 463   (void)assume_action;
 464   CALLED(router_parse_addr_policy_item_from_string)++;
 465
 466   return NS(mock_addr_policy);
 467 }
 468
 469 #undef NS_SUBMODULE
 470 #define NS_SUBMODULE ASPECT(routerset_union, source_bad)
 471
 472 /*
 473  * Structural test for routerset_union, when given a bad source argument.
 474  */
 475
 476 NS_DECL(smartlist_t *, smartlist_new, (void));
 477
 478 static void
 479 NS(test_main)(void *arg)
 480 {
 481   routerset_t *set, *bad_set;
 482   (void)arg;
 483
 484   set = routerset_new();
 485   bad_set = routerset_new();
 486   smartlist_free(bad_set->list);
 487   bad_set->list = NULL;
 488
 489   NS_MOCK(smartlist_new);
 490
 491   routerset_union(set, NULL);
 492   tt_int_op(CALLED(smartlist_new), OP_EQ, 0);
 493
 494   routerset_union(set, bad_set);
 495   tt_int_op(CALLED(smartlist_new), OP_EQ, 0);
 496
 497   done:
 498     NS_UNMOCK(smartlist_new);
 499     routerset_free(set);
 500
 501     /* Just recreate list, so we can simply use routerset_free. */
 502     bad_set->list = smartlist_new();
 503     routerset_free(bad_set);
 504 }
 505
 506 static smartlist_t *
 507 NS(smartlist_new)(void)
 508 {
 509   CALLED(smartlist_new)++;
 510
 511   return NULL;
 512 }
 513
 514 #undef NS_SUBMODULE
 515 #define NS_SUBMODULE ASPECT(routerset_union, one)
 516
 517 /*
 518  * Functional test for routerset_union.
 519  */
 520
 521 static void
 522 NS(test_main)(void *arg)
 523 {
 524   routerset_t *src = routerset_new();
 525   routerset_t *tgt;
 526   (void)arg;
 527
 528   tgt = routerset_new();
 529   smartlist_add(src->list, tor_strdup("{xx}"));
 530   routerset_union(tgt, src);
 531
 532   tt_int_op(smartlist_len(tgt->list), OP_NE, 0);
 533
 534   done:
 535     routerset_free(src);
 536     routerset_free(tgt);
 537 }
 538
 539 #undef NS_SUBMODULE
 540 #define NS_SUBMODULE routerset_is_list
 541
 542 /*
 543  * Functional tests for routerset_is_list.
 544  */
 545
 546 static void
 547 NS(test_main)(void *arg)
 548 {
 549   routerset_t *set;
 550   addr_policy_t *policy;
 551   int is_list;
 552   (void)arg;
 553
 554   /* len(set->country_names) == 0, len(set->policies) == 0 */
 555   set = routerset_new();
 556   is_list = routerset_is_list(set);
 557   routerset_free(set);
 558   set = NULL;
 559   tt_int_op(is_list, OP_NE, 0);
 560
 561   /* len(set->country_names) != 0, len(set->policies) == 0 */
 562   set = routerset_new();
 563   smartlist_add(set->country_names, tor_strndup("foo", 3));
 564   is_list = routerset_is_list(set);
 565   routerset_free(set);
 566   set = NULL;
 567   tt_int_op(is_list, OP_EQ, 0);
 568
 569   /* len(set->country_names) == 0, len(set->policies) != 0 */
 570   set = routerset_new();
 571   policy = tor_malloc_zero(sizeof(addr_policy_t));
 572   smartlist_add(set->policies, (void *)policy);
 573   is_list = routerset_is_list(set);
 574   routerset_free(set);
 575   set = NULL;
 576   tt_int_op(is_list, OP_EQ, 0);
 577
 578   /* len(set->country_names) != 0, len(set->policies) != 0 */
 579   set = routerset_new();
 580   smartlist_add(set->country_names, tor_strndup("foo", 3));
 581   policy = tor_malloc_zero(sizeof(addr_policy_t));
 582   smartlist_add(set->policies, (void *)policy);
 583   is_list = routerset_is_list(set);
 584   routerset_free(set);
 585   set = NULL;
 586   tt_int_op(is_list, OP_EQ, 0);
 587
 588   done:
 589     ;
 590 }
 591
 592 #undef NS_SUBMODULE
 593 #define NS_SUBMODULE routerset_needs_geoip
 594
 595 /*
 596  * Functional tests for routerset_needs_geoip.
 597  */
 598
 599 static void
 600 NS(test_main)(void *arg)
 601 {
 602   const routerset_t *set;
 603   int needs_geoip;
 604   (void)arg;
 605
 606   set = NULL;
 607   needs_geoip = routerset_needs_geoip(set);
 608   tt_int_op(needs_geoip, OP_EQ, 0);
 609
 610   set = routerset_new();
 611   needs_geoip = routerset_needs_geoip(set);
 612   routerset_free((routerset_t *)set);
 613   tt_int_op(needs_geoip, OP_EQ, 0);
 614   set = NULL;
 615
 616   set = routerset_new();
 617   smartlist_add(set->country_names, tor_strndup("xx", 2));
 618   needs_geoip = routerset_needs_geoip(set);
 619   routerset_free((routerset_t *)set);
 620   set = NULL;
 621   tt_int_op(needs_geoip, OP_NE, 0);
 622
 623   done:
 624     ;
 625 }
 626
 627 #undef NS_SUBMODULE
 628 #define NS_SUBMODULE routerset_is_empty
 629
 630 /*
 631  * Functional tests for routerset_is_empty.
 632  */
 633
 634 static void
 635 NS(test_main)(void *arg)
 636 {
 637   routerset_t *set = NULL;
 638   int is_empty;
 639   (void)arg;
 640
 641   is_empty = routerset_is_empty(set);
 642   tt_int_op(is_empty, OP_NE, 0);
 643
 644   set = routerset_new();
 645   is_empty = routerset_is_empty(set);
 646   routerset_free(set);
 647   set = NULL;
 648   tt_int_op(is_empty, OP_NE, 0);
 649
 650   set = routerset_new();
 651   smartlist_add(set->list, tor_strdup("{xx}"));
 652   is_empty = routerset_is_empty(set);
 653   routerset_free(set);
 654   set = NULL;
 655   tt_int_op(is_empty, OP_EQ, 0);
 656
 657   done:
 658     ;
 659 }
 660
 661 #undef NS_SUBMODULE
 662 #define NS_SUBMODULE ASPECT(routerset_contains, null_set_or_null_set_list)
 663
 664 /*
 665  * Functional test for routerset_contains, when given a NULL set or the
 666  * set has a NULL list.
 667  */
 668
 669 static void
 670 NS(test_main)(void *arg)
 671 {
 672   routerset_t *set = NULL;
 673   int contains;
 674   (void)arg;
 675
 676   contains = routerset_contains(set, NULL, 0, NULL, NULL, 0);
 677
 678   tt_int_op(contains, OP_EQ, 0);
 679
 680   set = tor_malloc_zero(sizeof(routerset_t));
 681   set->list = NULL;
 682   contains = routerset_contains(set, NULL, 0, NULL, NULL, 0);
 683   tor_free(set);
 684   tt_int_op(contains, OP_EQ, 0);
 685
 686   done:
 687     ;
 688 }
 689
 690 #undef NS_SUBMODULE
 691 #define NS_SUBMODULE ASPECT(routerset_contains, set_and_null_nickname)
 692
 693 /*
 694  * Functional test for routerset_contains, when given a valid routerset but a
 695  * NULL nickname.
 696  */
 697
 698 static void
 699 NS(test_main)(void *arg)
 700 {
 701   routerset_t *set = routerset_new();
 702   char *nickname = NULL;
 703   int contains;
 704   (void)arg;
 705
 706   contains = routerset_contains(set, NULL, 0, nickname, NULL, 0);
 707   routerset_free(set);
 708
 709   tt_int_op(contains, OP_EQ, 0);
 710
 711   done:
 712     ;
 713 }
 714
 715 #undef NS_SUBMODULE
 716 #define NS_SUBMODULE ASPECT(routerset_contains, set_and_nickname)
 717
 718 /*
 719  * Functional test for routerset_contains, when given a valid routerset
 720  * and the nickname is in the routerset.
 721  */
 722
 723 static void
 724 NS(test_main)(void *arg)
 725 {
 726   routerset_t *set = routerset_new();
 727   const char *nickname;
 728   int contains;
 729   (void)arg;
 730
 731   nickname = "Foo";  /* This tests the lowercase comparison as well. */
 732   strmap_set_lc(set->names, nickname, (void *)1);
 733   contains = routerset_contains(set, NULL, 0, nickname, NULL, 0);
 734   routerset_free(set);
 735
 736   tt_int_op(contains, OP_EQ, 4);
 737   done:
 738     ;
 739 }
 740
 741 #undef NS_SUBMODULE
 742 #define NS_SUBMODULE ASPECT(routerset_contains, set_and_no_nickname)
 743
 744 /*
 745  * Functional test for routerset_contains, when given a valid routerset
 746  * and the nickname is not in the routerset.
 747  */
 748
 749 static void
 750 NS(test_main)(void *arg)
 751 {
 752   routerset_t *set = routerset_new();
 753   int contains;
 754   (void)arg;
 755
 756   strmap_set_lc(set->names, "bar", (void *)1);
 757   contains = routerset_contains(set, NULL, 0, "foo", NULL, 0);
 758   routerset_free(set);
 759
 760   tt_int_op(contains, OP_EQ, 0);
 761   done:
 762     ;
 763 }
 764
 765 #undef NS_SUBMODULE
 766 #define NS_SUBMODULE ASPECT(routerset_contains, set_and_digest)
 767
 768 /*
 769  * Functional test for routerset_contains, when given a valid routerset
 770  * and the digest is contained in the routerset.
 771  */
 772
 773 static void
 774 NS(test_main)(void *arg)
 775 {
 776   routerset_t *set = routerset_new();
 777   int contains;
 778   uint8_t foo[20] = { 2, 3, 4 };
 779   (void)arg;
 780
 781   digestmap_set(set->digests, (const char*)foo, (void *)1);
 782   contains = routerset_contains(set, NULL, 0, NULL, (const char*)foo, 0);
 783   routerset_free(set);
 784
 785   tt_int_op(contains, OP_EQ, 4);
 786   done:
 787     ;
 788 }
 789
 790 #undef NS_SUBMODULE
 791 #define NS_SUBMODULE ASPECT(routerset_contains, set_and_no_digest)
 792
 793 /*
 794  * Functional test for routerset_contains, when given a valid routerset
 795  * and the digest is not contained in the routerset.
 796  */
 797
 798 static void
 799 NS(test_main)(void *arg)
 800 {
 801   routerset_t *set = routerset_new();
 802   int contains;
 803   uint8_t bar[20] = { 9, 10, 11, 55 };
 804   uint8_t foo[20] = { 1, 2, 3, 4};
 805   (void)arg;
 806
 807   digestmap_set(set->digests, (const char*)bar, (void *)1);
 808   contains = routerset_contains(set, NULL, 0, NULL, (const char*)foo, 0);
 809   routerset_free(set);
 810
 811   tt_int_op(contains, OP_EQ, 0);
 812   done:
 813     ;
 814 }
 815
 816 #undef NS_SUBMODULE
 817 #define NS_SUBMODULE ASPECT(routerset_contains, set_and_null_digest)
 818
 819 /*
 820  * Functional test for routerset_contains, when given a valid routerset
 821  * and the digest is NULL.
 822  */
 823
 824 static void
 825 NS(test_main)(void *arg)
 826 {
 827   routerset_t *set = routerset_new();
 828   int contains;
 829   uint8_t bar[20] = { 9, 10, 11, 55 };
 830   (void)arg;
 831
 832   digestmap_set(set->digests, (const char*)bar, (void *)1);
 833   contains = routerset_contains(set, NULL, 0, NULL, NULL, 0);
 834   routerset_free(set);
 835
 836   tt_int_op(contains, OP_EQ, 0);
 837   done:
 838     ;
 839 }
 840
 841 #undef NS_SUBMODULE
 842 #define NS_SUBMODULE ASPECT(routerset_contains, set_and_addr)
 843
 844 /*
 845  * Structural test for routerset_contains, when given a valid routerset
 846  * and the address is rejected by policy.
 847  */
 848
 849 NS_DECL(addr_policy_result_t, compare_tor_addr_to_addr_policy,
 850     (const tor_addr_t *addr, uint16_t port, const smartlist_t *policy));
 851
 852 static tor_addr_t MOCK_TOR_ADDR;
 853 #define MOCK_TOR_ADDR_PTR (&MOCK_TOR_ADDR)
 854
 855 static void
 856 NS(test_main)(void *arg)
 857 {
 858   routerset_t *set = routerset_new();
 859   tor_addr_t *addr = MOCK_TOR_ADDR_PTR;
 860   int contains;
 861   (void)arg;
 862
 863   NS_MOCK(compare_tor_addr_to_addr_policy);
 864
 865   contains = routerset_contains(set, addr, 0, NULL, NULL, 0);
 866   routerset_free(set);
 867
 868   tt_int_op(CALLED(compare_tor_addr_to_addr_policy), OP_EQ, 1);
 869   tt_int_op(contains, OP_EQ, 3);
 870
 871   done:
 872     ;
 873 }
 874
 875 addr_policy_result_t
 876 NS(compare_tor_addr_to_addr_policy)(const tor_addr_t *addr, uint16_t port,
 877     const smartlist_t *policy)
 878 {
 879   (void)port;
 880   (void)policy;
 881   CALLED(compare_tor_addr_to_addr_policy)++;
 882   tt_ptr_op(addr, OP_EQ, MOCK_TOR_ADDR_PTR);
 883   return ADDR_POLICY_REJECTED;
 884
 885   done:
 886     return 0;
 887 }
 888
 889 #undef NS_SUBMODULE
 890 #define NS_SUBMODULE ASPECT(routerset_contains, set_and_no_addr)
 891
 892 /*
 893  * Structural test for routerset_contains, when given a valid routerset
 894  * and the address is not rejected by policy.
 895  */
 896
 897 NS_DECL(addr_policy_result_t, compare_tor_addr_to_addr_policy,
 898     (const tor_addr_t *addr, uint16_t port, const smartlist_t *policy));
 899
 900 static void
 901 NS(test_main)(void *arg)
 902 {
 903   routerset_t *set = routerset_new();
 904   tor_addr_t *addr = MOCK_TOR_ADDR_PTR;
 905   int contains;
 906   (void)arg;
 907
 908   NS_MOCK(compare_tor_addr_to_addr_policy);
 909
 910   contains = routerset_contains(set, addr, 0, NULL, NULL, 0);
 911   routerset_free(set);
 912
 913   tt_int_op(CALLED(compare_tor_addr_to_addr_policy), OP_EQ, 1);
 914   tt_int_op(contains, OP_EQ, 0);
 915
 916   done:
 917     ;
 918 }
 919
 920 addr_policy_result_t
 921 NS(compare_tor_addr_to_addr_policy)(const tor_addr_t *addr, uint16_t port,
 922     const smartlist_t *policy)
 923 {
 924   (void)port;
 925   (void)policy;
 926   CALLED(compare_tor_addr_to_addr_policy)++;
 927   tt_ptr_op(addr, OP_EQ, MOCK_TOR_ADDR_PTR);
 928
 929   return ADDR_POLICY_ACCEPTED;
 930
 931   done:
 932       return 0;
 933 }
 934
 935 #undef NS_SUBMODULE
 936 #define NS_SUBMODULE ASPECT(routerset_contains, set_and_null_addr)
 937
 938 /*
 939  * Structural test for routerset_contains, when given a valid routerset
 940  * and the address is NULL.
 941  */
 942
 943 NS_DECL(addr_policy_result_t, compare_tor_addr_to_addr_policy,
 944     (const tor_addr_t *addr, uint16_t port, const smartlist_t *policy));
 945
 946 static void
 947 NS(test_main)(void *arg)
 948 {
 949   routerset_t *set = routerset_new();
 950   int contains;
 951   (void)arg;
 952
 953   NS_MOCK(compare_tor_addr_to_addr_policy);
 954
 955   contains = routerset_contains(set, NULL, 0, NULL, NULL, 0);
 956   routerset_free(set);
 957
 958   tt_int_op(contains, OP_EQ, 0);
 959
 960   done:
 961     ;
 962 }
 963
 964 addr_policy_result_t
 965 NS(compare_tor_addr_to_addr_policy)(const tor_addr_t *addr, uint16_t port,
 966     const smartlist_t *policy)
 967 {
 968   (void)port;
 969   (void)policy;
 970   CALLED(compare_tor_addr_to_addr_policy)++;
 971   tt_ptr_op(addr, OP_EQ, MOCK_TOR_ADDR_PTR);
 972
 973   return ADDR_POLICY_ACCEPTED;
 974
 975   done:
 976     return 0;
 977 }
 978
 979 #undef NS_SUBMODULE
 980 #define NS_SUBMODULE ASPECT(routerset_contains, countries_no_geoip)
 981
 982 /*
 983  * Structural test for routerset_contains, when there is no matching country
 984  * for the address.
 985  */
 986
 987 NS_DECL(addr_policy_result_t, compare_tor_addr_to_addr_policy,
 988     (const tor_addr_t *addr, uint16_t port, const smartlist_t *policy));
 989 NS_DECL(int, geoip_get_country_by_addr, (const tor_addr_t *addr));
 990
 991 static void
 992 NS(test_main)(void *arg)
 993 {
 994   routerset_t *set = routerset_new();
 995   int contains = 1;
 996   (void)arg;
 997
 998   NS_MOCK(compare_tor_addr_to_addr_policy);
 999   NS_MOCK(geoip_get_country_by_addr);
1000
1001   set->countries = bitarray_init_zero(1);
1002   bitarray_set(set->countries, 1);
1003   contains = routerset_contains(set, MOCK_TOR_ADDR_PTR, 0, NULL, NULL, -1);
1004   routerset_free(set);
1005
1006   tt_int_op(contains, OP_EQ, 0);
1007   tt_int_op(CALLED(compare_tor_addr_to_addr_policy), OP_EQ, 1);
1008   tt_int_op(CALLED(geoip_get_country_by_addr), OP_EQ, 1);
1009
1010   done:
1011     ;
1012 }
1013
1014 addr_policy_result_t
1015 NS(compare_tor_addr_to_addr_policy)(const tor_addr_t *addr, uint16_t port,
1016     const smartlist_t *policy)
1017 {
1018   (void)port;
1019   (void)policy;
1020   CALLED(compare_tor_addr_to_addr_policy)++;
1021   tt_ptr_op(addr, OP_EQ, MOCK_TOR_ADDR_PTR);
1022
1023   done:
1024     return ADDR_POLICY_ACCEPTED;
1025 }
1026
1027 int
1028 NS(geoip_get_country_by_addr)(const tor_addr_t *addr)
1029 {
1030   CALLED(geoip_get_country_by_addr)++;
1031   tt_ptr_op(addr, OP_EQ, MOCK_TOR_ADDR_PTR);
1032
1033   done:
1034     return -1;
1035 }
1036
1037 #undef NS_SUBMODULE
1038 #define NS_SUBMODULE ASPECT(routerset_contains, countries_geoip)
1039
1040 /*
1041  * Structural test for routerset_contains, when there a matching country
1042  * for the address.
1043  */
1044
1045 NS_DECL(addr_policy_result_t, compare_tor_addr_to_addr_policy,
1046     (const tor_addr_t *addr, uint16_t port, const smartlist_t *policy));
1047 NS_DECL(int, geoip_get_country_by_addr, (const tor_addr_t *addr));
1048
1049 static void
1050 NS(test_main)(void *arg)
1051 {
1052   routerset_t *set = routerset_new();
1053   int contains = 1;
1054   (void)arg;
1055
1056   NS_MOCK(compare_tor_addr_to_addr_policy);
1057   NS_MOCK(geoip_get_country_by_addr);
1058
1059   set->n_countries = 2;
1060   set->countries = bitarray_init_zero(1);
1061   bitarray_set(set->countries, 1);
1062   contains = routerset_contains(set, MOCK_TOR_ADDR_PTR, 0, NULL, NULL, -1);
1063   routerset_free(set);
1064
1065   tt_int_op(contains, OP_EQ, 2);
1066   tt_int_op(CALLED(compare_tor_addr_to_addr_policy), OP_EQ, 1);
1067   tt_int_op(CALLED(geoip_get_country_by_addr), OP_EQ, 1);
1068
1069   done:
1070     ;
1071 }
1072
1073 addr_policy_result_t
1074 NS(compare_tor_addr_to_addr_policy)(const tor_addr_t *addr, uint16_t port,
1075     const smartlist_t *policy)
1076 {
1077   (void)port;
1078   (void)policy;
1079   CALLED(compare_tor_addr_to_addr_policy)++;
1080   tt_ptr_op(addr, OP_EQ, MOCK_TOR_ADDR_PTR);
1081
1082   done:
1083     return ADDR_POLICY_ACCEPTED;
1084 }
1085
1086 int
1087 NS(geoip_get_country_by_addr)(const tor_addr_t *addr)
1088 {
1089   CALLED(geoip_get_country_by_addr)++;
1090   tt_ptr_op(addr, OP_EQ, MOCK_TOR_ADDR_PTR);
1091
1092   done:
1093     return 1;
1094 }
1095
1096 #undef NS_SUBMODULE
1097 #define NS_SUBMODULE ASPECT(routerset_add_unknown_ccs, only_flag_and_no_ccs)
1098
1099 /*
1100  * Functional test for routerset_add_unknown_ccs, where only_if_some_cc_set
1101  * is set and there are no country names.
1102  */
1103
1104 static void
1105 NS(test_main)(void *arg)
1106 {
1107   routerset_t *set = routerset_new();
1108   routerset_t **setp = &set;
1109   int r;
1110   (void)arg;
1111
1112   r = routerset_add_unknown_ccs(setp, 1);
1113
1114   tt_int_op(r, OP_EQ, 0);
1115
1116   done:
1117     routerset_free(set);
1118 }
1119
1120 #undef NS_SUBMODULE
1121 #define NS_SUBMODULE ASPECT(routerset_add_unknown_ccs, creates_set)
1122
1123 /*
1124  * Functional test for routerset_add_unknown_ccs, where the set argument
1125  * is created if passed in as NULL.
1126  */
1127
1128 /* The mock is only used to stop the test from asserting erroneously. */
1129 NS_DECL(country_t, geoip_get_country, (const char *country));
1130
1131 static void
1132 NS(test_main)(void *arg)
1133 {
1134   routerset_t *set = NULL;
1135   routerset_t **setp = &set;
1136   int r;
1137   (void)arg;
1138
1139   NS_MOCK(geoip_get_country);
1140
1141   r = routerset_add_unknown_ccs(setp, 0);
1142
1143   tt_ptr_op(*setp, OP_NE, NULL);
1144   tt_int_op(r, OP_EQ, 0);
1145
1146   done:
1147     if (set != NULL)
1148       routerset_free(set);
1149 }
1150
1151 country_t
1152 NS(geoip_get_country)(const char *country)
1153 {
1154   (void)country;
1155   CALLED(geoip_get_country)++;
1156
1157   return -1;
1158 }
1159
1160 #undef NS_SUBMODULE
1161 #define NS_SUBMODULE ASPECT(routerset_add_unknown_ccs, add_unknown)
1162
1163 /*
1164  * Structural test for routerset_add_unknown_ccs, that the "{??}"
1165  * country code is added to the list.
1166  */
1167
1168 NS_DECL(country_t, geoip_get_country, (const char *country));
1169 NS_DECL(int, geoip_is_loaded, (sa_family_t family));
1170
1171 static void
1172 NS(test_main)(void *arg)
1173 {
1174   routerset_t *set = routerset_new();
1175   routerset_t **setp = &set;
1176   int r;
1177   (void)arg;
1178
1179   NS_MOCK(geoip_get_country);
1180   NS_MOCK(geoip_is_loaded);
1181
1182   r = routerset_add_unknown_ccs(setp, 0);
1183
1184   tt_int_op(r, OP_EQ, 1);
1185   tt_int_op(smartlist_contains_string(set->country_names, "??"), OP_EQ, 1);
1186   tt_int_op(smartlist_contains_string(set->list, "{??}"), OP_EQ, 1);
1187
1188   done:
1189     if (set != NULL)
1190       routerset_free(set);
1191 }
1192
1193 country_t
1194 NS(geoip_get_country)(const char *country)
1195 {
1196   int arg_is_qq, arg_is_a1;
1197
1198   CALLED(geoip_get_country)++;
1199
1200   arg_is_qq = !strcmp(country, "??");
1201   arg_is_a1 = !strcmp(country, "A1");
1202
1203   tt_int_op(arg_is_qq || arg_is_a1, OP_EQ, 1);
1204
1205   if (arg_is_qq)
1206     return 1;
1207
1208   done:
1209     return -1;
1210 }
1211
1212 int
1213 NS(geoip_is_loaded)(sa_family_t family)
1214 {
1215   CALLED(geoip_is_loaded)++;
1216
1217   tt_int_op(family, OP_EQ, AF_INET);
1218
1219   done:
1220     return 0;
1221 }
1222
1223 #undef NS_SUBMODULE
1224 #define NS_SUBMODULE ASPECT(routerset_add_unknown_ccs, add_a1)
1225
1226 /*
1227  * Structural test for routerset_add_unknown_ccs, that the "{a1}"
1228  * country code is added to the list.
1229  */
1230
1231 NS_DECL(country_t, geoip_get_country, (const char *country));
1232 NS_DECL(int, geoip_is_loaded, (sa_family_t family));
1233
1234 static void
1235 NS(test_main)(void *arg)
1236 {
1237   routerset_t *set = routerset_new();
1238   routerset_t **setp = &set;
1239   int r;
1240   (void)arg;
1241
1242   NS_MOCK(geoip_get_country);
1243   NS_MOCK(geoip_is_loaded);
1244
1245   r = routerset_add_unknown_ccs(setp, 0);
1246
1247   tt_int_op(r, OP_EQ, 1);
1248   tt_int_op(smartlist_contains_string(set->country_names, "a1"), OP_EQ, 1);
1249   tt_int_op(smartlist_contains_string(set->list, "{a1}"), OP_EQ, 1);
1250
1251   done:
1252     if (set != NULL)
1253       routerset_free(set);
1254 }
1255
1256 country_t
1257 NS(geoip_get_country)(const char *country)
1258 {
1259   int arg_is_qq, arg_is_a1;
1260
1261   CALLED(geoip_get_country)++;
1262
1263   arg_is_qq = !strcmp(country, "??");
1264   arg_is_a1 = !strcmp(country, "A1");
1265
1266   tt_int_op(arg_is_qq || arg_is_a1, OP_EQ, 1);
1267
1268   if (arg_is_a1)
1269     return 1;
1270
1271   done:
1272     return -1;
1273 }
1274
1275 int
1276 NS(geoip_is_loaded)(sa_family_t family)
1277 {
1278   CALLED(geoip_is_loaded)++;
1279
1280   tt_int_op(family, OP_EQ, AF_INET);
1281
1282   done:
1283     return 0;
1284 }
1285
1286 #undef NS_SUBMODULE
1287 #define NS_SUBMODULE routerset_contains_extendinfo
1288
1289 /*
1290  * Functional test for routerset_contains_extendinfo.
1291  */
1292
1293 static void
1294 NS(test_main)(void *arg)
1295 {
1296   routerset_t *set = routerset_new();
1297   extend_info_t ei;
1298   int r;
1299   const char *nickname = "foo";
1300   (void)arg;
1301
1302   memset(&ei, 0, sizeof(ei));
1303   strmap_set_lc(set->names, nickname, (void *)1);
1304   strncpy(ei.nickname, nickname, sizeof(ei.nickname) - 1);
1305   ei.nickname[sizeof(ei.nickname) - 1] = '\0';
1306
1307   r = routerset_contains_extendinfo(set, &ei);
1308
1309   tt_int_op(r, OP_EQ, 4);
1310   done:
1311     routerset_free(set);
1312 }
1313
1314 #undef NS_SUBMODULE
1315 #define NS_SUBMODULE routerset_contains_router
1316
1317 /*
1318  * Functional test for routerset_contains_router.
1319  */
1320
1321 static void
1322 NS(test_main)(void *arg)
1323 {
1324   routerset_t *set = routerset_new();
1325   routerinfo_t ri;
1326   country_t country = 1;
1327   int r;
1328   const char *nickname = "foo";
1329   (void)arg;
1330
1331   memset(&ri, 0, sizeof(ri));
1332   strmap_set_lc(set->names, nickname, (void *)1);
1333   ri.nickname = (char *)nickname;
1334
1335   r = routerset_contains_router(set, &ri, country);
1336
1337   tt_int_op(r, OP_EQ, 4);
1338   done:
1339     routerset_free(set);
1340 }
1341
1342 #undef NS_SUBMODULE
1343 #define NS_SUBMODULE routerset_contains_routerstatus
1344
1345 /*
1346  * Functional test for routerset_contains_routerstatus.
1347  */
1348
1349 // XXX: This is a bit brief. It only populates and tests the nickname fields
1350 // ie., enough to make the containment check succeed. Perhaps it should do
1351 // a bit more or test a bit more.
1352
1353 static void
1354 NS(test_main)(void *arg)
1355 {
1356   routerset_t *set = routerset_new();
1357   routerstatus_t rs;
1358   country_t country = 1;
1359   int r;
1360   const char *nickname = "foo";
1361   (void)arg;
1362
1363   memset(&rs, 0, sizeof(rs));
1364   strmap_set_lc(set->names, nickname, (void *)1);
1365   strncpy(rs.nickname, nickname, sizeof(rs.nickname) - 1);
1366   rs.nickname[sizeof(rs.nickname) - 1] = '\0';
1367
1368   r = routerset_contains_routerstatus(set, &rs, country);
1369
1370   tt_int_op(r, OP_EQ, 4);
1371   done:
1372     routerset_free(set);
1373 }
1374
1375 #undef NS_SUBMODULE
1376 #define NS_SUBMODULE ASPECT(routerset_contains_node, none)
1377
1378 /*
1379  * Functional test for routerset_contains_node, when the node has no
1380  * routerset or routerinfo.
1381  */
1382
1383 node_t NS(mock_node);
1384
1385 static void
1386 NS(test_main)(void *arg)
1387 {
1388   routerset_t *set = routerset_new();
1389   int r;
1390   (void)arg;
1391
1392   NS(mock_node).ri = NULL;
1393   NS(mock_node).rs = NULL;
1394
1395   r = routerset_contains_node(set, &NS(mock_node));
1396   tt_int_op(r, OP_EQ, 0);
1397
1398   done:
1399     routerset_free(set);
1400 }
1401
1402 #undef NS_SUBMODULE
1403 #define NS_SUBMODULE ASPECT(routerset_contains_node, routerstatus)
1404
1405 /*
1406  * Functional test for routerset_contains_node, when the node has a
1407  * routerset and no routerinfo.
1408  */
1409
1410 node_t NS(mock_node);
1411
1412 static void
1413 NS(test_main)(void *arg)
1414 {
1415   routerset_t *set = routerset_new();
1416   int r;
1417   const char *nickname = "foo";
1418   routerstatus_t rs;
1419   (void)arg;
1420
1421   strmap_set_lc(set->names, nickname, (void *)1);
1422
1423   strncpy(rs.nickname, nickname, sizeof(rs.nickname) - 1);
1424   rs.nickname[sizeof(rs.nickname) - 1] = '\0';
1425   NS(mock_node).ri = NULL;
1426   NS(mock_node).rs = &rs;
1427
1428   r = routerset_contains_node(set, &NS(mock_node));
1429
1430   tt_int_op(r, OP_EQ, 4);
1431   done:
1432     routerset_free(set);
1433 }
1434
1435 #undef NS_SUBMODULE
1436 #define NS_SUBMODULE ASPECT(routerset_contains_node, routerinfo)
1437
1438 /*
1439  * Functional test for routerset_contains_node, when the node has no
1440  * routerset and a routerinfo.
1441  */
1442
1443 static void
1444 NS(test_main)(void *arg)
1445 {
1446   routerset_t *set = routerset_new();
1447   int r;
1448   const char *nickname = "foo";
1449   routerinfo_t ri;
1450   node_t mock_node;
1451   (void)arg;
1452
1453   strmap_set_lc(set->names, nickname, (void *)1);
1454
1455   ri.nickname = (char *)nickname;
1456   mock_node.ri = &ri;
1457   mock_node.rs = NULL;
1458
1459   r = routerset_contains_node(set, &mock_node);
1460
1461   tt_int_op(r, OP_EQ, 4);
1462   done:
1463     routerset_free(set);
1464 }
1465
1466 #undef NS_SUBMODULE
1467 #define NS_SUBMODULE ASPECT(routerset_get_all_nodes, no_routerset)
1468
1469 /*
1470  * Functional test for routerset_get_all_nodes, when routerset is NULL or
1471  * the routerset list is NULL.
1472  */
1473
1474 static void
1475 NS(test_main)(void *arg)
1476 {
1477   smartlist_t *out = smartlist_new();
1478   routerset_t *set = NULL;
1479   (void)arg;
1480
1481   tt_int_op(smartlist_len(out), OP_EQ, 0);
1482   routerset_get_all_nodes(out, NULL, NULL, 0);
1483
1484   tt_int_op(smartlist_len(out), OP_EQ, 0);
1485
1486   set = routerset_new();
1487   smartlist_free(set->list);
1488   routerset_get_all_nodes(out, NULL, NULL, 0);
1489   tt_int_op(smartlist_len(out), OP_EQ, 0);
1490
1491   /* Just recreate list, so we can simply use routerset_free. */
1492   set->list = smartlist_new();
1493
1494  done:
1495   routerset_free(set);
1496   smartlist_free(out);
1497 }
1498
1499 #undef NS_SUBMODULE
1500 #define NS_SUBMODULE ASPECT(routerset_get_all_nodes, list_with_no_nodes)
1501
1502 /*
1503  * Structural test for routerset_get_all_nodes, when the routerset list
1504  * is empty.
1505  */
1506
1507 NS_DECL(const node_t *, node_get_by_nickname,
1508     (const char *nickname, int warn_if_unused));
1509 const char *NS(mock_nickname);
1510
1511 static void
1512 NS(test_main)(void *arg)
1513 {
1514   smartlist_t *out = smartlist_new();
1515   routerset_t *set = routerset_new();
1516   int out_len;
1517   (void)arg;
1518
1519   NS_MOCK(node_get_by_nickname);
1520
1521   NS(mock_nickname) = "foo";
1522   smartlist_add(set->list, tor_strdup(NS(mock_nickname)));
1523
1524   routerset_get_all_nodes(out, set, NULL, 0);
1525   out_len = smartlist_len(out);
1526
1527   smartlist_free(out);
1528   routerset_free(set);
1529
1530   tt_int_op(out_len, OP_EQ, 0);
1531   tt_int_op(CALLED(node_get_by_nickname), OP_EQ, 1);
1532
1533   done:
1534     ;
1535 }
1536
1537 const node_t *
1538 NS(node_get_by_nickname)(const char *nickname, int warn_if_unused)
1539 {
1540   CALLED(node_get_by_nickname)++;
1541   tt_str_op(nickname, OP_EQ, NS(mock_nickname));
1542   tt_int_op(warn_if_unused, OP_EQ, 1);
1543
1544   done:
1545     return NULL;
1546 }
1547
1548 #undef NS_SUBMODULE
1549 #define NS_SUBMODULE ASPECT(routerset_get_all_nodes, list_flag_not_running)
1550
1551 /*
1552  * Structural test for routerset_get_all_nodes, with the running_only flag
1553  * is set but the nodes are not running.
1554  */
1555
1556 NS_DECL(const node_t *, node_get_by_nickname,
1557     (const char *nickname, int warn_if_unused));
1558 const char *NS(mock_nickname);
1559 node_t NS(mock_node);
1560
1561 static void
1562 NS(test_main)(void *arg)
1563 {
1564   smartlist_t *out = smartlist_new();
1565   routerset_t *set = routerset_new();
1566   int out_len;
1567   (void)arg;
1568
1569   NS_MOCK(node_get_by_nickname);
1570
1571   NS(mock_node).is_running = 0;
1572   NS(mock_nickname) = "foo";
1573   smartlist_add(set->list, tor_strdup(NS(mock_nickname)));
1574
1575   routerset_get_all_nodes(out, set, NULL, 1);
1576   out_len = smartlist_len(out);
1577
1578   smartlist_free(out);
1579   routerset_free(set);
1580
1581   tt_int_op(out_len, OP_EQ, 0);
1582   tt_int_op(CALLED(node_get_by_nickname), OP_EQ, 1);
1583
1584   done:
1585     ;
1586 }
1587
1588 const node_t *
1589 NS(node_get_by_nickname)(const char *nickname, int warn_if_unused)
1590 {
1591   CALLED(node_get_by_nickname)++;
1592   tt_str_op(nickname, OP_EQ, NS(mock_nickname));
1593   tt_int_op(warn_if_unused, OP_EQ, 1);
1594
1595   done:
1596     return &NS(mock_node);
1597 }
1598
1599 #undef NS_SUBMODULE
1600 #define NS_SUBMODULE ASPECT(routerset_get_all_nodes, list)
1601
1602 /*
1603  * Structural test for routerset_get_all_nodes.
1604  */
1605
1606 NS_DECL(const node_t *, node_get_by_nickname,
1607     (const char *nickname, int warn_if_unused));
1608 char *NS(mock_nickname);
1609 node_t NS(mock_node);
1610
1611 static void
1612 NS(test_main)(void *arg)
1613 {
1614   smartlist_t *out = smartlist_new();
1615   routerset_t *set = routerset_new();
1616   int out_len;
1617   node_t *ent;
1618   (void)arg;
1619
1620   NS_MOCK(node_get_by_nickname);
1621
1622   NS(mock_nickname) = tor_strdup("foo");
1623   smartlist_add(set->list, NS(mock_nickname));
1624
1625   routerset_get_all_nodes(out, set, NULL, 0);
1626   out_len = smartlist_len(out);
1627   ent = (node_t *)smartlist_get(out, 0);
1628
1629   smartlist_free(out);
1630   routerset_free(set);
1631
1632   tt_int_op(out_len, OP_EQ, 1);
1633   tt_ptr_op(ent, OP_EQ, &NS(mock_node));
1634   tt_int_op(CALLED(node_get_by_nickname), OP_EQ, 1);
1635
1636   done:
1637     ;
1638 }
1639
1640 const node_t *
1641 NS(node_get_by_nickname)(const char *nickname, int warn_if_unused)
1642 {
1643   CALLED(node_get_by_nickname)++;
1644   tt_str_op(nickname, OP_EQ, NS(mock_nickname));
1645   tt_int_op(warn_if_unused, OP_EQ, 1);
1646
1647   done:
1648     return &NS(mock_node);
1649 }
1650
1651 #undef NS_SUBMODULE
1652 #define NS_SUBMODULE ASPECT(routerset_get_all_nodes, nodelist_with_no_nodes)
1653
1654 /*
1655  * Structural test for routerset_get_all_nodes, when the nodelist has no nodes.
1656  */
1657
1658 NS_DECL(smartlist_t *, nodelist_get_list, (void));
1659
1660 smartlist_t *NS(mock_smartlist);
1661
1662 static void
1663 NS(test_main)(void *arg)
1664 {
1665   routerset_t *set = routerset_new();
1666   smartlist_t *out = smartlist_new();
1667   int r;
1668   (void)arg;
1669
1670   NS_MOCK(nodelist_get_list);
1671
1672   smartlist_add(set->country_names, tor_strdup("{xx}"));
1673   NS(mock_smartlist) = smartlist_new();
1674
1675   routerset_get_all_nodes(out, set, NULL, 1);
1676   r = smartlist_len(out);
1677   routerset_free(set);
1678   smartlist_free(out);
1679   smartlist_free(NS(mock_smartlist));
1680
1681   tt_int_op(r, OP_EQ, 0);
1682   tt_int_op(CALLED(nodelist_get_list), OP_EQ, 1);
1683
1684   done:
1685     ;
1686 }
1687
1688 smartlist_t *
1689 NS(nodelist_get_list)(void)
1690 {
1691   CALLED(nodelist_get_list)++;
1692
1693   return NS(mock_smartlist);
1694 }
1695
1696 #undef NS_SUBMODULE
1697 #define NS_SUBMODULE ASPECT(routerset_get_all_nodes, nodelist_flag_not_running)
1698
1699 /*
1700  * Structural test for routerset_get_all_nodes, with a non-list routerset
1701  * the running_only flag is set, but the nodes are not running.
1702  */
1703
1704 NS_DECL(smartlist_t *, nodelist_get_list, (void));
1705
1706 smartlist_t *NS(mock_smartlist);
1707 node_t NS(mock_node);
1708
1709 static void
1710 NS(test_main)(void *arg)
1711 {
1712   routerset_t *set = routerset_new();
1713   smartlist_t *out = smartlist_new();
1714   int r;
1715   (void)arg;
1716
1717   NS_MOCK(nodelist_get_list);
1718
1719   smartlist_add(set->country_names, tor_strdup("{xx}"));
1720   NS(mock_smartlist) = smartlist_new();
1721   NS(mock_node).is_running = 0;
1722   smartlist_add(NS(mock_smartlist), (void *)&NS(mock_node));
1723
1724   routerset_get_all_nodes(out, set, NULL, 1);
1725   r = smartlist_len(out);
1726   routerset_free(set);
1727   smartlist_free(out);
1728   smartlist_free(NS(mock_smartlist));
1729
1730   tt_int_op(r, OP_EQ, 0);
1731   tt_int_op(CALLED(nodelist_get_list), OP_EQ, 1);
1732
1733   done:
1734     ;
1735 }
1736
1737 smartlist_t *
1738 NS(nodelist_get_list)(void)
1739 {
1740   CALLED(nodelist_get_list)++;
1741
1742   return NS(mock_smartlist);
1743 }
1744
1745 #undef NS_SUBMODULE
1746 #define NS_SUBMODULE routerset_subtract_nodes
1747
1748 /*
1749  * Functional test for routerset_subtract_nodes.
1750  */
1751
1752 static void
1753 NS(test_main)(void *arg)
1754 {
1755   routerset_t *set = routerset_new();
1756   smartlist_t *list = smartlist_new();
1757   const char *nickname = "foo";
1758   routerinfo_t ri;
1759   node_t mock_node;
1760   (void)arg;
1761
1762   strmap_set_lc(set->names, nickname, (void *)1);
1763
1764   ri.nickname = (char *)nickname;
1765   mock_node.rs = NULL;
1766   mock_node.ri = &ri;
1767   smartlist_add(list, (void *)&mock_node);
1768
1769   tt_int_op(smartlist_len(list), OP_NE, 0);
1770   routerset_subtract_nodes(list, set);
1771
1772   tt_int_op(smartlist_len(list), OP_EQ, 0);
1773   done:
1774     routerset_free(set);
1775     smartlist_free(list);
1776 }
1777
1778 #undef NS_SUBMODULE
1779 #define NS_SUBMODULE ASPECT(routerset_subtract_nodes, null_routerset)
1780
1781 /*
1782  * Functional test for routerset_subtract_nodes, with a NULL routerset.
1783  */
1784
1785 static void
1786 NS(test_main)(void *arg)
1787 {
1788   routerset_t *set = NULL;
1789   smartlist_t *list = smartlist_new();
1790   const char *nickname = "foo";
1791   routerinfo_t ri;
1792   node_t mock_node;
1793   (void)arg;
1794
1795   ri.nickname = (char *)nickname;
1796   mock_node.ri = &ri;
1797   smartlist_add(list, (void *)&mock_node);
1798
1799   tt_int_op(smartlist_len(list), OP_NE, 0);
1800   routerset_subtract_nodes(list, set);
1801
1802   tt_int_op(smartlist_len(list), OP_NE, 0);
1803   done:
1804     routerset_free(set);
1805     smartlist_free(list);
1806 }
1807
1808 #undef NS_SUBMODULE
1809 #define NS_SUBMODULE routerset_to_string
1810
1811 /*
1812  * Functional test for routerset_to_string.
1813  */
1814
1815 static void
1816 NS(test_main)(void *arg)
1817 {
1818   routerset_t *set = NULL;
1819   char *s = NULL;
1820   (void)arg;
1821
1822   set = NULL;
1823   s = routerset_to_string(set);
1824   tt_str_op(s, OP_EQ, "");
1825   tor_free(s);
1826
1827   set = routerset_new();
1828   s = routerset_to_string(set);
1829   tt_str_op(s, OP_EQ, "");
1830   tor_free(s);
1831   routerset_free(set); set = NULL;
1832
1833   set = routerset_new();
1834   smartlist_add(set->list, tor_strndup("a", 1));
1835   s = routerset_to_string(set);
1836   tt_str_op(s, OP_EQ, "a");
1837   tor_free(s);
1838   routerset_free(set); set = NULL;
1839
1840   set = routerset_new();
1841   smartlist_add(set->list, tor_strndup("a", 1));
1842   smartlist_add(set->list, tor_strndup("b", 1));
1843   s = routerset_to_string(set);
1844   tt_str_op(s, OP_EQ, "a,b");
1845   tor_free(s);
1846   routerset_free(set); set = NULL;
1847
1848  done:
1849   tor_free(s);
1850   routerset_free((routerset_t *)set);
1851 }
1852
1853 #undef NS_SUBMODULE
1854 #define NS_SUBMODULE ASPECT(routerset_equal, empty_empty)
1855
1856 /*
1857  * Functional test for routerset_equal, with both routersets empty.
1858  */
1859
1860 static void
1861 NS(test_main)(void *arg)
1862 {
1863   routerset_t *a = routerset_new(), *b = routerset_new();
1864   int r;
1865   (void)arg;
1866
1867   r = routerset_equal(a, b);
1868   routerset_free(a);
1869   routerset_free(b);
1870
1871   tt_int_op(r, OP_EQ, 1);
1872
1873   done:
1874     ;
1875 }
1876
1877 #undef NS_SUBMODULE
1878 #define NS_SUBMODULE ASPECT(routerset_equal, empty_not_empty)
1879
1880 /*
1881  * Functional test for routerset_equal, with one routersets empty.
1882  */
1883
1884 static void
1885 NS(test_main)(void *arg)
1886 {
1887   routerset_t *a = routerset_new(), *b = routerset_new();
1888   int r;
1889   (void)arg;
1890
1891   smartlist_add(b->list, tor_strdup("{xx}"));
1892   r = routerset_equal(a, b);
1893   routerset_free(a);
1894   routerset_free(b);
1895
1896   tt_int_op(r, OP_EQ, 0);
1897   done:
1898     ;
1899 }
1900
1901 #undef NS_SUBMODULE
1902 #define NS_SUBMODULE ASPECT(routerset_equal, differing_lengths)
1903
1904 /*
1905  * Functional test for routerset_equal, with the routersets having
1906  * differing lengths.
1907  */
1908
1909 static void
1910 NS(test_main)(void *arg)
1911 {
1912   routerset_t *a = routerset_new(), *b = routerset_new();
1913   int r;
1914   (void)arg;
1915
1916   smartlist_add(a->list, tor_strdup("{aa}"));
1917   smartlist_add(b->list, tor_strdup("{b1}"));
1918   smartlist_add(b->list, tor_strdup("{b2}"));
1919   r = routerset_equal(a, b);
1920   routerset_free(a);
1921   routerset_free(b);
1922
1923   tt_int_op(r, OP_EQ, 0);
1924   done:
1925     ;
1926 }
1927
1928 #undef NS_SUBMODULE
1929 #define NS_SUBMODULE ASPECT(routerset_equal, unequal)
1930
1931 /*
1932  * Functional test for routerset_equal, with the routersets being
1933  * different.
1934  */
1935
1936 static void
1937 NS(test_main)(void *arg)
1938 {
1939   routerset_t *a = routerset_new(), *b = routerset_new();
1940   int r;
1941   (void)arg;
1942
1943   smartlist_add(a->list, tor_strdup("foo"));
1944   smartlist_add(b->list, tor_strdup("bar"));
1945   r = routerset_equal(a, b);
1946   routerset_free(a);
1947   routerset_free(b);
1948
1949   tt_int_op(r, OP_EQ, 0);
1950   done:
1951     ;
1952 }
1953
1954 #undef NS_SUBMODULE
1955 #define NS_SUBMODULE ASPECT(routerset_equal, equal)
1956
1957 /*
1958  * Functional test for routerset_equal, with the routersets being
1959  * equal.
1960  */
1961
1962 static void
1963 NS(test_main)(void *arg)
1964 {
1965   routerset_t *a = routerset_new(), *b = routerset_new();
1966   int r;
1967   (void)arg;
1968
1969   smartlist_add(a->list, tor_strdup("foo"));
1970   smartlist_add(b->list, tor_strdup("foo"));
1971   r = routerset_equal(a, b);
1972   routerset_free(a);
1973   routerset_free(b);
1974
1975   tt_int_op(r, OP_EQ, 1);
1976   done:
1977     ;
1978 }
1979
1980 #undef NS_SUBMODULE
1981 #define NS_SUBMODULE ASPECT(routerset_free, null_routerset)
1982
1983 /*
1984  * Structural test for routerset_free, where the routerset is NULL.
1985  */
1986
1987 NS_DECL(void, smartlist_free, (smartlist_t *sl));
1988
1989 static void
1990 NS(test_main)(void *arg)
1991 {
1992   (void)arg;
1993
1994   NS_MOCK(smartlist_free);
1995
1996   routerset_free(NULL);
1997
1998   tt_int_op(CALLED(smartlist_free), OP_EQ, 0);
1999
2000   done:
2001     ;
2002 }
2003
2004 void
2005 NS(smartlist_free)(smartlist_t *s)
2006 {
2007   (void)s;
2008   CALLED(smartlist_free)++;
2009 }
2010
2011 #undef NS_SUBMODULE
2012 #define NS_SUBMODULE routerset_free
2013
2014 /*
2015  * Structural test for routerset_free.
2016  */
2017
2018 NS_DECL(void, smartlist_free, (smartlist_t *sl));
2019 NS_DECL(void, strmap_free,(strmap_t *map, void (*free_val)(void*)));
2020 NS_DECL(void, digestmap_free, (digestmap_t *map, void (*free_val)(void*)));
2021
2022 static void
2023 NS(test_main)(void *arg)
2024 {
2025   routerset_t *routerset = routerset_new();
2026   (void)arg;
2027
2028   NS_MOCK(smartlist_free);
2029   NS_MOCK(strmap_free);
2030   NS_MOCK(digestmap_free);
2031
2032   routerset_free(routerset);
2033
2034   tt_int_op(CALLED(smartlist_free), OP_NE, 0);
2035   tt_int_op(CALLED(strmap_free), OP_NE, 0);
2036   tt_int_op(CALLED(digestmap_free), OP_NE, 0);
2037
2038   done:
2039     ;
2040 }
2041
2042 void
2043 NS(smartlist_free)(smartlist_t *s)
2044 {
2045   CALLED(smartlist_free)++;
2046   smartlist_free__real(s);
2047 }
2048
2049 void
2050 NS(strmap_free)(strmap_t *map, void (*free_val)(void*))
2051 {
2052   CALLED(strmap_free)++;
2053   strmap_free__real(map, free_val);
2054 }
2055
2056 void
2057 NS(digestmap_free)(digestmap_t *map, void (*free_val)(void*))
2058 {
2059   CALLED(digestmap_free)++;
2060   digestmap_free__real(map, free_val);
2061 }
2062
2063 #undef NS_SUBMODULE
2064
2065 struct testcase_t routerset_tests[] = {
2066   TEST_CASE(routerset_new),
2067   TEST_CASE(routerset_get_countryname),
2068   TEST_CASE(routerset_is_list),
2069   TEST_CASE(routerset_needs_geoip),
2070   TEST_CASE(routerset_is_empty),
2071   TEST_CASE_ASPECT(routerset_contains, null_set_or_null_set_list),
2072   TEST_CASE_ASPECT(routerset_contains, set_and_nickname),
2073   TEST_CASE_ASPECT(routerset_contains, set_and_null_nickname),
2074   TEST_CASE_ASPECT(routerset_contains, set_and_no_nickname),
2075   TEST_CASE_ASPECT(routerset_contains, set_and_digest),
2076   TEST_CASE_ASPECT(routerset_contains, set_and_no_digest),
2077   TEST_CASE_ASPECT(routerset_contains, set_and_null_digest),
2078   TEST_CASE_ASPECT(routerset_contains, set_and_addr),
2079   TEST_CASE_ASPECT(routerset_contains, set_and_no_addr),
2080   TEST_CASE_ASPECT(routerset_contains, set_and_null_addr),
2081   TEST_CASE_ASPECT(routerset_contains, countries_no_geoip),
2082   TEST_CASE_ASPECT(routerset_contains, countries_geoip),
2083   TEST_CASE_ASPECT(routerset_add_unknown_ccs, only_flag_and_no_ccs),
2084   TEST_CASE_ASPECT(routerset_add_unknown_ccs, creates_set),
2085   TEST_CASE_ASPECT(routerset_add_unknown_ccs, add_unknown),
2086   TEST_CASE_ASPECT(routerset_add_unknown_ccs, add_a1),
2087   TEST_CASE(routerset_contains_extendinfo),
2088   TEST_CASE(routerset_contains_router),
2089   TEST_CASE(routerset_contains_routerstatus),
2090   TEST_CASE_ASPECT(routerset_contains_node, none),
2091   TEST_CASE_ASPECT(routerset_contains_node, routerinfo),
2092   TEST_CASE_ASPECT(routerset_contains_node, routerstatus),
2093   TEST_CASE_ASPECT(routerset_get_all_nodes, no_routerset),
2094   TEST_CASE_ASPECT(routerset_get_all_nodes, list_with_no_nodes),
2095   TEST_CASE_ASPECT(routerset_get_all_nodes, list_flag_not_running),
2096   TEST_CASE_ASPECT(routerset_get_all_nodes, list),
2097   TEST_CASE_ASPECT(routerset_get_all_nodes, nodelist_with_no_nodes),
2098   TEST_CASE_ASPECT(routerset_get_all_nodes, nodelist_flag_not_running),
2099   TEST_CASE_ASPECT(routerset_refresh_counties, geoip_not_loaded),
2100   TEST_CASE_ASPECT(routerset_refresh_counties, no_countries),
2101   TEST_CASE_ASPECT(routerset_refresh_counties, one_valid_country),
2102   TEST_CASE_ASPECT(routerset_refresh_counties, one_invalid_country),
2103   TEST_CASE_ASPECT(routerset_union, source_bad),
2104   TEST_CASE_ASPECT(routerset_union, one),
2105   TEST_CASE_ASPECT(routerset_parse, malformed),
2106   TEST_CASE_ASPECT(routerset_parse, valid_hexdigest),
2107   TEST_CASE_ASPECT(routerset_parse, valid_nickname),
2108   TEST_CASE_ASPECT(routerset_parse, get_countryname),
2109   TEST_CASE_ASPECT(routerset_parse, policy),
2110   TEST_CASE(routerset_subtract_nodes),
2111   TEST_CASE_ASPECT(routerset_subtract_nodes, null_routerset),
2112   TEST_CASE(routerset_to_string),
2113   TEST_CASE_ASPECT(routerset_equal, empty_empty),
2114   TEST_CASE_ASPECT(routerset_equal, empty_not_empty),
2115   TEST_CASE_ASPECT(routerset_equal, differing_lengths),
2116   TEST_CASE_ASPECT(routerset_equal, unequal),
2117   TEST_CASE_ASPECT(routerset_equal, equal),
2118   TEST_CASE_ASPECT(routerset_free, null_routerset),
2119   TEST_CASE(routerset_free),
2120   END_OF_TESTCASES
2121 };
2122