自学教程：C++ tt_str_op函数代码示例

static voidtest_procmon_tor_process_monitor_new(void *ignored){  (void)ignored;  tor_process_monitor_t *res;  const char *msg;  res = tor_process_monitor_new(NULL, "probably invalid", 0, NULL, NULL, &msg);  tt_assert(!res);  tt_str_op(msg, OP_EQ, "invalid PID");  res = tor_process_monitor_new(NULL, "243443535345454", 0, NULL, NULL, &msg);  tt_assert(!res);  tt_str_op(msg, OP_EQ, "invalid PID");  res = tor_process_monitor_new(tor_libevent_get_base(), "43", 0, NULL, NULL, &msg);  tt_assert(res);  tt_assert(!msg);  res = tor_process_monitor_new(tor_libevent_get_base(), "44 hello", 0, NULL, NULL, &msg);  tt_assert(res);  tt_assert(!msg);  res = tor_process_monitor_new(tor_libevent_get_base(), "45:hello", 0, NULL, NULL, &msg);  tt_assert(res);  tt_assert(!msg); done:  (void)0;}

static voidtest_md_generate(void *arg){  routerinfo_t *ri;  microdesc_t *md = NULL;  (void)arg;  ri = router_parse_entry_from_string(test_ri, NULL, 0, 0, NULL, NULL);  tt_assert(ri);  md = dirvote_create_microdescriptor(ri, 8);  tt_str_op(md->body, OP_EQ, test_md_8);  /* XXXX test family lines. */  /* XXXX test method 14 for A lines. */  /* XXXX test method 15 for P6 lines. */  microdesc_free(md);  md = NULL;  md = dirvote_create_microdescriptor(ri, 16);  tt_str_op(md->body, OP_EQ, test_md_16);  microdesc_free(md);  md = NULL;  md = dirvote_create_microdescriptor(ri, 18);  tt_str_op(md->body, OP_EQ, test_md_18); done:  microdesc_free(md);  routerinfo_free(ri);}

static voidtest_md_generate(void *arg){  routerinfo_t *ri;  microdesc_t *md = NULL;  (void)arg;  ri = router_parse_entry_from_string(test_ri, NULL, 0, 0, NULL, NULL);  tt_assert(ri);  microdesc_free(md);  md = NULL;  md = dirvote_create_microdescriptor(ri, 18);  tt_str_op(md->body, OP_EQ, test_md_18);  microdesc_free(md);  md = NULL;  md = dirvote_create_microdescriptor(ri, 21);  tt_str_op(md->body, OP_EQ, test_md_18);  routerinfo_free(ri);  ri = router_parse_entry_from_string(test_ri2, NULL, 0, 0, NULL, NULL);  microdesc_free(md);  md = NULL;  md = dirvote_create_microdescriptor(ri, 21);  tt_str_op(md->body, OP_EQ, test_md2_21);  tt_assert(ed25519_pubkey_eq(md->ed25519_identity_pkey,                              &ri->cache_info.signing_key_cert->signing_key)); done:  microdesc_free(md);  routerinfo_free(ri);}

static voidtest_addr_basic(void *arg){  (void) arg;  tt_int_op(0,OP_EQ, addr_mask_get_bits(0x0u));  tt_int_op(32,OP_EQ, addr_mask_get_bits(0xFFFFFFFFu));  tt_int_op(16,OP_EQ, addr_mask_get_bits(0xFFFF0000u));  tt_int_op(31,OP_EQ, addr_mask_get_bits(0xFFFFFFFEu));  tt_int_op(1,OP_EQ, addr_mask_get_bits(0x80000000u));  /* Test inet_ntop */  {    char tmpbuf[TOR_ADDR_BUF_LEN];    const char *ip = "176.192.208.224";    struct in_addr in;    /* good round trip */    tt_int_op(tor_inet_pton(AF_INET, ip, &in), OP_EQ, 1);    tt_ptr_op(tor_inet_ntop(AF_INET, &in, tmpbuf, sizeof(tmpbuf)),              OP_EQ, &tmpbuf);    tt_str_op(tmpbuf,OP_EQ, ip);    /* just enough buffer length */    tt_str_op(tor_inet_ntop(AF_INET, &in, tmpbuf, strlen(ip) + 1), OP_EQ, ip);    /* too short buffer */    tt_ptr_op(tor_inet_ntop(AF_INET, &in, tmpbuf, strlen(ip)),OP_EQ, NULL);  } done:  ;}

static voidtest_addr_make_null(void *data){  tor_addr_t *addr = tor_malloc(sizeof(*addr));  tor_addr_t *zeros = tor_malloc_zero(sizeof(*addr));  char buf[TOR_ADDR_BUF_LEN];  (void) data;  /* Ensure that before tor_addr_make_null, addr != 0's */  memset(addr, 1, sizeof(*addr));  tt_int_op(fast_memcmp(addr, zeros, sizeof(*addr)), OP_NE, 0);  /* Test with AF == AF_INET */  zeros->family = AF_INET;  tor_addr_make_null(addr, AF_INET);  tt_int_op(fast_memcmp(addr, zeros, sizeof(*addr)), OP_EQ, 0);  tt_str_op(tor_addr_to_str(buf, addr, sizeof(buf), 0), OP_EQ, "0.0.0.0");  /* Test with AF == AF_INET6 */  memset(addr, 1, sizeof(*addr));  zeros->family = AF_INET6;  tor_addr_make_null(addr, AF_INET6);  tt_int_op(fast_memcmp(addr, zeros, sizeof(*addr)), OP_EQ, 0);  tt_str_op(tor_addr_to_str(buf, addr, sizeof(buf), 0), OP_EQ, "::"); done:  tor_free(addr);  tor_free(zeros);}

/* Test encoding and decoding service authorization cookies */static voidtest_hs_auth_cookies(void *arg){#define TEST_COOKIE_RAW ((const uint8_t *) "abcdefghijklmnop")#define TEST_COOKIE_ENCODED "YWJjZGVmZ2hpamtsbW5vcA"#define TEST_COOKIE_ENCODED_STEALTH "YWJjZGVmZ2hpamtsbW5vcB"#define TEST_COOKIE_ENCODED_INVALID "YWJjZGVmZ2hpamtsbW5vcD"  char *encoded_cookie;  uint8_t raw_cookie[REND_DESC_COOKIE_LEN];  rend_auth_type_t auth_type;  char *err_msg;  int re;  (void)arg;  /* Test that encoding gives the expected result */  encoded_cookie = rend_auth_encode_cookie(TEST_COOKIE_RAW, REND_BASIC_AUTH);  tt_str_op(encoded_cookie, OP_EQ, TEST_COOKIE_ENCODED);  tor_free(encoded_cookie);  encoded_cookie = rend_auth_encode_cookie(TEST_COOKIE_RAW, REND_STEALTH_AUTH);  tt_str_op(encoded_cookie, OP_EQ, TEST_COOKIE_ENCODED_STEALTH);  tor_free(encoded_cookie);  /* Decoding should give the original value */  re = rend_auth_decode_cookie(TEST_COOKIE_ENCODED, raw_cookie, &auth_type,                               &err_msg);  tt_assert(!re);  tt_ptr_op(err_msg, OP_EQ, NULL);  tt_mem_op(raw_cookie, OP_EQ, TEST_COOKIE_RAW, REND_DESC_COOKIE_LEN);  tt_int_op(auth_type, OP_EQ, REND_BASIC_AUTH);  memset(raw_cookie, 0, sizeof(raw_cookie));  re = rend_auth_decode_cookie(TEST_COOKIE_ENCODED_STEALTH, raw_cookie,                               &auth_type, &err_msg);  tt_assert(!re);  tt_ptr_op(err_msg, OP_EQ, NULL);  tt_mem_op(raw_cookie, OP_EQ, TEST_COOKIE_RAW, REND_DESC_COOKIE_LEN);  tt_int_op(auth_type, OP_EQ, REND_STEALTH_AUTH);  memset(raw_cookie, 0, sizeof(raw_cookie));  /* Decoding with padding characters should also work */  re = rend_auth_decode_cookie(TEST_COOKIE_ENCODED "==", raw_cookie, NULL,                               &err_msg);  tt_assert(!re);  tt_ptr_op(err_msg, OP_EQ, NULL);  tt_mem_op(raw_cookie, OP_EQ, TEST_COOKIE_RAW, REND_DESC_COOKIE_LEN);  /* Decoding with an unknown type should fail */  re = rend_auth_decode_cookie(TEST_COOKIE_ENCODED_INVALID, raw_cookie,                               &auth_type, &err_msg);  tt_int_op(re, OP_LT, 0);  tt_assert(err_msg);  tor_free(err_msg); done:  return;}

static voidtest_ext_or_init_auth(void *arg){  or_options_t *options = get_options_mutable();  const char *fn;  char *cp = NULL;  struct stat st;  char cookie0[32];  (void)arg;  /* Check default filename location */  tor_free(options->DataDirectory);  options->DataDirectory = tor_strdup("foo");  cp = get_ext_or_auth_cookie_file_name();  tt_str_op(cp, OP_EQ, "foo"PATH_SEPARATOR"extended_orport_auth_cookie");  tor_free(cp);  /* Shouldn't be initialized already, or our tests will be a bit   * meaningless */  ext_or_auth_cookie = tor_malloc_zero(32);  tt_assert(tor_mem_is_zero((char*)ext_or_auth_cookie, 32));  /* Now make sure we use a temporary file */  fn = get_fname("ext_cookie_file");  options->ExtORPortCookieAuthFile = tor_strdup(fn);  cp = get_ext_or_auth_cookie_file_name();  tt_str_op(cp, OP_EQ, fn);  tor_free(cp);  /* Test the initialization function with a broken     write_bytes_to_file(). See if the problem is handled properly. */  MOCK(write_bytes_to_file, write_bytes_to_file_fail);  tt_int_op(-1, OP_EQ, init_ext_or_cookie_authentication(1));  tt_int_op(ext_or_auth_cookie_is_set, OP_EQ, 0);  UNMOCK(write_bytes_to_file);  /* Now do the actual initialization. */  tt_int_op(0, OP_EQ, init_ext_or_cookie_authentication(1));  tt_int_op(ext_or_auth_cookie_is_set, OP_EQ, 1);  cp = read_file_to_str(fn, RFTS_BIN, &st);  tt_ptr_op(cp, OP_NE, NULL);  tt_u64_op((uint64_t)st.st_size, OP_EQ, 64);  tt_mem_op(cp,OP_EQ, "! Extended ORPort Auth Cookie !/x0a", 32);  tt_mem_op(cp+32,OP_EQ, ext_or_auth_cookie, 32);  memcpy(cookie0, ext_or_auth_cookie, 32);  tt_assert(!tor_mem_is_zero((char*)ext_or_auth_cookie, 32));  /* Operation should be idempotent. */  tt_int_op(0, OP_EQ, init_ext_or_cookie_authentication(1));  tt_mem_op(cookie0,OP_EQ, ext_or_auth_cookie, 32); done:  tor_free(cp);  ext_orport_free_all();}

/** Perform supported SOCKS 4 commands */static voidtest_socks_4_supported_commands(void *ptr){  SOCKS_TEST_INIT();  tt_int_op(0,OP_EQ, buf_datalen(buf));  /* SOCKS 4 Send CONNECT [01] to IP address 2.2.2.2:4370 */  ADD_DATA(buf, "/x04/x01/x11/x12/x02/x02/x02/x03/x00");  tt_assert(fetch_from_buf_socks(buf, socks, get_options()->TestSocks,                                   get_options()->SafeSocks) == 1);  tt_int_op(4,OP_EQ, socks->socks_version);  tt_int_op(0,OP_EQ, socks->replylen); /* XXX: shouldn't tor reply? */  tt_int_op(SOCKS_COMMAND_CONNECT,OP_EQ, socks->command);  tt_str_op("2.2.2.3",OP_EQ, socks->address);  tt_int_op(4370,OP_EQ, socks->port);  tt_assert(socks->got_auth == 0);  tt_assert(! socks->username);  tt_int_op(0,OP_EQ, buf_datalen(buf));  socks_request_clear(socks);  /* SOCKS 4 Send CONNECT [01] to IP address 2.2.2.2:4369 with userid*/  ADD_DATA(buf, "/x04/x01/x11/x12/x02/x02/x02/x04me/x00");  tt_assert(fetch_from_buf_socks(buf, socks, get_options()->TestSocks,                                   get_options()->SafeSocks) == 1);  tt_int_op(4,OP_EQ, socks->socks_version);  tt_int_op(0,OP_EQ, socks->replylen); /* XXX: shouldn't tor reply? */  tt_int_op(SOCKS_COMMAND_CONNECT,OP_EQ, socks->command);  tt_str_op("2.2.2.4",OP_EQ, socks->address);  tt_int_op(4370,OP_EQ, socks->port);  tt_assert(socks->got_auth == 1);  tt_assert(socks->username);  tt_int_op(2,OP_EQ, socks->usernamelen);  tt_mem_op("me",OP_EQ, socks->username, 2);  tt_int_op(0,OP_EQ, buf_datalen(buf));  socks_request_clear(socks);  /* SOCKS 4a Send RESOLVE [F0] request for torproject.org */  ADD_DATA(buf, "/x04/xF0/x01/x01/x00/x00/x00/x02me/x00torproject.org/x00");  tt_assert(fetch_from_buf_socks(buf, socks, get_options()->TestSocks,                                   get_options()->SafeSocks) == 1);  tt_int_op(4,OP_EQ, socks->socks_version);  tt_int_op(0,OP_EQ, socks->replylen); /* XXX: shouldn't tor reply? */  tt_str_op("torproject.org",OP_EQ, socks->address);  tt_int_op(0,OP_EQ, buf_datalen(buf)); done:  ;}

static voidtest_cntev_append_cell_stats(void *arg){  smartlist_t *event_parts;  char *cp = NULL;  const char *key = "Z";  uint64_t include_if_non_zero[CELL_COMMAND_MAX_ + 1],           number_to_include[CELL_COMMAND_MAX_ + 1];  (void)arg;  event_parts = smartlist_new();  memset(include_if_non_zero, 0,         (CELL_COMMAND_MAX_ + 1) * sizeof(uint64_t));  memset(number_to_include, 0,         (CELL_COMMAND_MAX_ + 1) * sizeof(uint64_t));  /* All array entries empty. */  append_cell_stats_by_command(event_parts, key,                               include_if_non_zero,                               number_to_include);  tt_int_op(0, OP_EQ, smartlist_len(event_parts));  /* There's a RELAY cell to include, but the corresponding field in   * include_if_non_zero is still zero. */  number_to_include[CELL_RELAY] = 1;  append_cell_stats_by_command(event_parts, key,                               include_if_non_zero,                               number_to_include);  tt_int_op(0, OP_EQ, smartlist_len(event_parts));  /* Now include single RELAY cell. */  include_if_non_zero[CELL_RELAY] = 2;  append_cell_stats_by_command(event_parts, key,                               include_if_non_zero,                               number_to_include);  cp = smartlist_pop_last(event_parts);  tt_str_op("Z=relay:1", OP_EQ, cp);  tor_free(cp);  /* Add four CREATE cells. */  include_if_non_zero[CELL_CREATE] = 3;  number_to_include[CELL_CREATE] = 4;  append_cell_stats_by_command(event_parts, key,                               include_if_non_zero,                               number_to_include);  cp = smartlist_pop_last(event_parts);  tt_str_op("Z=create:4,relay:1", OP_EQ, cp); done:  tor_free(cp);  smartlist_free(event_parts);}

static voidNS(logv)(int severity, log_domain_mask_t domain,  const char *funcname, const char *suffix, const char *format, va_list ap){  switch (CALLED(logv))  {    case 0:      tt_int_op(severity, OP_EQ, LOG_NOTICE);      tt_int_op(domain, OP_EQ, LD_HEARTBEAT);      tt_ptr_op(strstr(funcname, "log_heartbeat"), OP_NE, NULL);      tt_ptr_op(suffix, OP_EQ, NULL);      tt_str_op(format, OP_EQ,          "Heartbeat: It seems like we are not in the cached consensus.");      break;    case 1:      tt_int_op(severity, OP_EQ, LOG_NOTICE);      tt_int_op(domain, OP_EQ, LD_HEARTBEAT);      tt_ptr_op(strstr(funcname, "log_heartbeat"), OP_NE, NULL);      tt_ptr_op(suffix, OP_EQ, NULL);      tt_str_op(format, OP_EQ,          "Heartbeat: Tor's uptime is %s, with %d circuits open. "          "I've sent %s and received %s.%s");      tt_str_op(va_arg(ap, char *), OP_EQ, "0:00 hours");  /* uptime */      tt_int_op(va_arg(ap, int), OP_EQ, 0);  /* count_circuits() */      tt_str_op(va_arg(ap, char *), OP_EQ, "0 kB");  /* bw_sent */      tt_str_op(va_arg(ap, char *), OP_EQ, "0 kB");  /* bw_rcvd */      tt_str_op(va_arg(ap, char *), OP_EQ, "");  /* hibernating */      break;    case 2:      tt_int_op(severity, OP_EQ, LOG_INFO);      break;    case 3:      tt_int_op(severity, OP_EQ, LOG_NOTICE);      tt_int_op(domain, OP_EQ, LD_HEARTBEAT);      tt_ptr_op(strstr(funcname, "rep_hist_log_circuit_handshake_stats"),                OP_NE, NULL);      tt_ptr_op(suffix, OP_EQ, NULL);      tt_str_op(format, OP_EQ,        "Circuit handshake stats since last time: %d/%d TAP, %d/%d NTor.");      tt_int_op(va_arg(ap, int), OP_EQ, 1);  /* handshakes assigned (TAP) */      tt_int_op(va_arg(ap, int), OP_EQ, 1);  /* handshakes requested (TAP) */      tt_int_op(va_arg(ap, int), OP_EQ, 1);  /* handshakes assigned (NTOR) */      tt_int_op(va_arg(ap, int), OP_EQ, 1);  /* handshakes requested (NTOR) */      break;    default:      tt_abort_msg("unexpected call to logv()");  // TODO: prettyprint args      break;  }  done:    CALLED(logv)++;}

static voidtest_md_generate(void *arg){  routerinfo_t *ri;  microdesc_t *md = NULL;  (void)arg;  ri = router_parse_entry_from_string(test_ri, NULL, 0, 0, NULL, NULL);  tt_assert(ri);  md = dirvote_create_microdescriptor(ri, 8);  tt_str_op(md->body, OP_EQ, test_md_8);  /* XXXX test family lines. */  /* XXXX test method 14 for A lines. */  /* XXXX test method 15 for P6 lines. */  microdesc_free(md);  md = NULL;  md = dirvote_create_microdescriptor(ri, 16);  tt_str_op(md->body, OP_EQ, test_md_16);  microdesc_free(md);  md = NULL;  md = dirvote_create_microdescriptor(ri, 18);  tt_str_op(md->body, OP_EQ, test_md_18);  microdesc_free(md);  md = NULL;  md = dirvote_create_microdescriptor(ri, 21);  tt_str_op(md->body, ==, test_md_18);  routerinfo_free(ri);  ri = router_parse_entry_from_string(test_ri2, NULL, 0, 0, NULL, NULL);  microdesc_free(md);  md = NULL;  md = dirvote_create_microdescriptor(ri, 18);  tt_str_op(md->body, ==, test_md2_18);  microdesc_free(md);  md = NULL;  md = dirvote_create_microdescriptor(ri, 21);  tt_str_op(md->body, ==, test_md2_21);  tt_assert(ed25519_pubkey_eq(md->ed25519_identity_pkey,                              &ri->signing_key_cert->signing_key)); done:  microdesc_free(md);  routerinfo_free(ri);}

/** Store apparent_skew and assert that the other arguments are as * expected. */static voidmock_clock_skew_warning(const connection_t *conn, long apparent_skew,                        int trusted, log_domain_mask_t domain,                        const char *received, const char *source){  (void)conn;  mock_apparent_skew = apparent_skew;  tt_int_op(trusted, OP_EQ, 1);  tt_int_op(domain, OP_EQ, LD_GENERAL);  tt_str_op(received, OP_EQ, "microdesc flavor consensus");  tt_str_op(source, OP_EQ, "CONSENSUS"); done:  ;}

static voidtest_ntor_handshake(void *arg){  /* client-side */  ntor_handshake_state_t *c_state = NULL;  uint8_t c_buf[NTOR_ONIONSKIN_LEN];  uint8_t c_keys[400];  /* server-side */  di_digest256_map_t *s_keymap=NULL;  curve25519_keypair_t s_keypair;  uint8_t s_buf[NTOR_REPLY_LEN];  uint8_t s_keys[400];  /* shared */  const curve25519_public_key_t *server_pubkey;  uint8_t node_id[20] = "abcdefghijklmnopqrst";  (void) arg;  /* Make the server some keys */  curve25519_secret_key_generate(&s_keypair.seckey, 0);  curve25519_public_key_generate(&s_keypair.pubkey, &s_keypair.seckey);  dimap_add_entry(&s_keymap, s_keypair.pubkey.public_key, &s_keypair);  server_pubkey = &s_keypair.pubkey;  /* client handshake 1. */  memset(c_buf, 0, NTOR_ONIONSKIN_LEN);  tt_int_op(0, OP_EQ, onion_skin_ntor_create(node_id, server_pubkey,                                          &c_state, c_buf));  /* server handshake */  memset(s_buf, 0, NTOR_REPLY_LEN);  memset(s_keys, 0, 40);  tt_int_op(0, OP_EQ, onion_skin_ntor_server_handshake(c_buf, s_keymap, NULL,                                                    node_id,                                                    s_buf, s_keys, 400));  /* client handshake 2 */  memset(c_keys, 0, 40);  tt_int_op(0, OP_EQ, onion_skin_ntor_client_handshake(c_state, s_buf,                                                       c_keys, 400, NULL));  tt_mem_op(c_keys,OP_EQ, s_keys, 400);  memset(s_buf, 0, 40);  tt_mem_op(c_keys,OP_NE, s_buf, 40);  /* Now try with a bogus server response. Zero input should trigger   * All The Problems. */  memset(c_keys, 0, 400);  memset(s_buf, 0, NTOR_REPLY_LEN);  const char *msg = NULL;  tt_int_op(-1, OP_EQ, onion_skin_ntor_client_handshake(c_state, s_buf,                                                        c_keys, 400, &msg));  tt_str_op(msg, OP_EQ, "Zero output from curve25519 handshake"); done:  ntor_handshake_state_free(c_state);  dimap_free(s_keymap, NULL);}

/** Run unit tests for concatenate-a-smartlist-of-strings functions. */static voidtest_container_smartlist_join(void *arg){  smartlist_t *sl = smartlist_new();  smartlist_t *sl2 = smartlist_new(), *sl3 = smartlist_new(),    *sl4 = smartlist_new();  char *joined=NULL;  /* unique, sorted. */  (void)arg;  smartlist_split_string(sl,                         "Abashments Ambush Anchorman Bacon Banks Borscht "                         "Bunks Inhumane Insurance Knish Know Manners "                         "Maraschinos Stamina Sunbonnets Unicorns Wombats",                         " ", 0, 0);  /* non-unique, sorted. */  smartlist_split_string(sl2,                         "Ambush Anchorman Anchorman Anemias Anemias Bacon "                         "Crossbowmen Inhumane Insurance Knish Know Manners "                         "Manners Maraschinos Wombats Wombats Work",                         " ", 0, 0);  SMARTLIST_FOREACH_JOIN(sl, char *, cp1,                         sl2, char *, cp2,                         strcmp(cp1,cp2),                         smartlist_add(sl3, cp2)) {    tt_str_op(cp1,OP_EQ, cp2);    smartlist_add(sl4, cp1);  } SMARTLIST_FOREACH_JOIN_END(cp1, cp2);

/** * Calling get_transport_by_bridge_addrport() with the address and port of a * configured bridge which uses a pluggable transport should return 0 and set * appropriate transport_t. */static voidtest_bridges_get_transport_by_bridge_addrport(void *arg){  transport_t *transport = NULL;  tor_addr_t *addr = tor_malloc(sizeof(tor_addr_t));  uint16_t port = 1234;  int ret;  helper_add_bridges_to_bridgelist(arg);  mark_transport_list(); // Also initialise our transport_list  ret = tor_addr_parse(addr, "1.2.3.4");  tt_int_op(ret, OP_EQ, 2); // it returns the address family on success?  /* After we mock transport_get_by_name() to return a bogus transport_t with   * the name it was asked for, the call should succeed.   */  MOCK(transport_get_by_name, mock_transport_get_by_name);  ret = get_transport_by_bridge_addrport((const tor_addr_t*)addr, port,                                         (const transport_t**)&transport);  tt_int_op(ret, OP_EQ, 0); // returns 0 on success  tt_ptr_op(transport, OP_NE, NULL);  tt_str_op(transport->name, OP_EQ, "obfs4"); done:  UNMOCK(transport_get_by_name);  tor_free(addr);  transport_free(transport);  mark_bridge_list();  sweep_bridge_list();}

/** * Calling get_configured_bridge_by_exact_addr_port_digest() with no digest, * and an addr:port pair we do have, should return the bridge. */static voidtest_bridges_get_configured_bridge_by_exact_addr_port_digest_aonly(void *arg){  bridge_info_t *bridge;  tor_addr_t *addr = tor_malloc(sizeof(tor_addr_t));  uint16_t port = 4444;  char ret_addr[16];  int ret;  helper_add_bridges_to_bridgelist(arg);  ret = tor_addr_parse(addr, "4.4.4.4");  tt_int_op(ret, OP_EQ, 2); // it returns the address family on success  bridge = get_configured_bridge_by_exact_addr_port_digest(addr, port, NULL);  tt_ptr_op(bridge, OP_NE, NULL);  tor_addr_to_str(ret_addr, &bridge_get_addr_port(bridge)->addr, 16, 0);  tt_str_op("4.4.4.4", OP_EQ, ret_addr); done:  tor_free(addr);  mark_bridge_list();  sweep_bridge_list();}

/** * Calling get_configured_bridge_by_exact_addr_port_digest() with a digest that * we do have, and an addr:port pair we do have, should return the bridge. */static voidtest_bridges_get_configured_bridge_by_exact_addr_port_digest_both(void *arg){  char digest[DIGEST_LEN];  bridge_info_t *bridge;  const char fingerprint[HEX_DIGEST_LEN] =    "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";  tor_addr_t *addr = tor_malloc(sizeof(tor_addr_t));  uint16_t port = 4444;  char ret_addr[16];  int ret;  helper_add_bridges_to_bridgelist(arg);  base16_decode(digest, DIGEST_LEN, fingerprint, HEX_DIGEST_LEN);  ret = tor_addr_parse(addr, "4.4.4.4");  tt_int_op(ret, OP_EQ, 2); // it returns the address family on success  bridge = get_configured_bridge_by_exact_addr_port_digest(addr, port, digest);  tt_ptr_op(bridge, OP_NE, NULL);  tor_addr_to_str(ret_addr, &bridge_get_addr_port(bridge)->addr, 16, 0);  tt_str_op("4.4.4.4", OP_EQ, ret_addr); done:  tor_free(addr);  mark_bridge_list();  sweep_bridge_list();}

static voidtest_fast_handshake(void *arg){  /* tests for the obsolete "CREATE_FAST" handshake. */  (void) arg;  fast_handshake_state_t *state = NULL;  uint8_t client_handshake[CREATE_FAST_LEN];  uint8_t server_handshake[CREATED_FAST_LEN];  uint8_t s_keys[100], c_keys[100];  /* First, test an entire handshake. */  memset(client_handshake, 0, sizeof(client_handshake));  tt_int_op(0, OP_EQ, fast_onionskin_create(&state, client_handshake));  tt_assert(! tor_mem_is_zero((char*)client_handshake,                              sizeof(client_handshake)));  tt_int_op(0, OP_EQ,            fast_server_handshake(client_handshake, server_handshake,                                  s_keys, 100));  const char *msg = NULL;  tt_int_op(0, OP_EQ,            fast_client_handshake(state, server_handshake, c_keys, 100, &msg));  tt_ptr_op(msg, OP_EQ, NULL);  tt_mem_op(s_keys, OP_EQ, c_keys, 100);  /* Now test a failing handshake. */  server_handshake[0] ^= 3;  tt_int_op(-1, OP_EQ,            fast_client_handshake(state, server_handshake, c_keys, 100, &msg));  tt_str_op(msg, OP_EQ, "Digest DOES NOT MATCH on fast handshake. "            "Bug or attack."); done:  fast_handshake_state_free(state);}

static voidtest_routerlist_initiate_descriptor_downloads(void *arg){  const char *prose = "unhurried and wise, we perceive.";  smartlist_t *digests = smartlist_new();  (void)arg;  for (int i = 0; i < 20; i++) {    smartlist_add(digests, (char*)prose);  }  MOCK(directory_get_from_dirserver, mock_get_from_dirserver);  initiate_descriptor_downloads(NULL, DIR_PURPOSE_FETCH_MICRODESC,                                digests, 3, 7, 0);  UNMOCK(directory_get_from_dirserver);  tt_str_op(output, OP_EQ, "d/"            "dW5odXJyaWVkIGFuZCB3aXNlLCB3ZSBwZXJjZWl2ZS4-"            "dW5odXJyaWVkIGFuZCB3aXNlLCB3ZSBwZXJjZWl2ZS4-"            "dW5odXJyaWVkIGFuZCB3aXNlLCB3ZSBwZXJjZWl2ZS4-"            "dW5odXJyaWVkIGFuZCB3aXNlLCB3ZSBwZXJjZWl2ZS4"            ".z"); done:  smartlist_free(digests);}

/* Make sure we always pick the right RP, given a well formatted * Tor2webRendezvousPoints value. */static voidtest_pick_tor2web_rendezvous_node(void *arg){  or_options_t *options = get_options_mutable();  const node_t *chosen_rp = NULL;  router_crn_flags_t flags = CRN_NEED_DESC;  int retval, i;  const char *tor2web_rendezvous_str = "test003r";  (void) arg;  /* Setup fake routerlist. */  helper_setup_fake_routerlist();  /* Parse Tor2webRendezvousPoints as a routerset. */  options->Tor2webRendezvousPoints = routerset_new();  retval = routerset_parse(options->Tor2webRendezvousPoints,                           tor2web_rendezvous_str,                           "test_tor2web_rp");  tt_int_op(retval, OP_GE, 0);  /* Pick rendezvous point. Make sure the correct one is     picked. Repeat many times to make sure it works properly. */  for (i = 0; i < 50 ; i++) {    chosen_rp = pick_tor2web_rendezvous_node(flags, options);    tt_assert(chosen_rp);    tt_str_op(chosen_rp->ri->nickname, OP_EQ, tor2web_rendezvous_str);  } done:  routerset_free(options->Tor2webRendezvousPoints);}

const node_t *NS(node_get_by_nickname)(const char *nickname, int warn_if_unused){  CALLED(node_get_by_nickname)++;  tt_str_op(nickname, OP_EQ, NS(mock_nickname));  tt_int_op(warn_if_unused, OP_EQ, 1);  done:    return &NS(mock_node);}

static voidNS(test_main)(void *arg){  int retval;  int made_pending = 0;  pending_connection_t *pending_conn = NULL;  edge_connection_t *exitconn = create_valid_exitconn();  or_circuit_t *on_circ = tor_malloc_zero(sizeof(or_circuit_t));  cached_resolve_t *cache_entry = NULL;  cached_resolve_t query;  (void)arg;  TO_CONN(exitconn)->address = tor_strdup("torproject.org");  strlcpy(query.address, TO_CONN(exitconn)->address, sizeof(query.address));  NS_MOCK(router_my_exit_policy_is_reject_star);  NS_MOCK(launch_resolve);  dns_init();  retval = dns_resolve_impl(exitconn, 1, on_circ, NULL, &made_pending,                            NULL);  tt_int_op(retval,OP_EQ,0);  tt_int_op(made_pending,OP_EQ,1);  cache_entry = dns_get_cache_entry(&query);  tt_assert(cache_entry);  pending_conn = cache_entry->pending_connections;  tt_assert(pending_conn != NULL);  tt_assert(pending_conn->conn == exitconn);  tt_assert(last_launched_resolve == cache_entry);  tt_str_op(cache_entry->address,OP_EQ,TO_CONN(exitconn)->address);  done:  NS_UNMOCK(router_my_exit_policy_is_reject_star);  NS_UNMOCK(launch_resolve);  tor_free(on_circ);  tor_free(TO_CONN(exitconn)->address);  if (cache_entry)    tor_free(cache_entry->pending_connections);  tor_free(cache_entry);  tor_free(exitconn);  return;}

static voidtest_conn_edge_ap_handshake_rewrite_and_attach_closes_conn_for_excluded_exit(void *data){  entry_connection_t *conn = entry_connection_new(CONN_TYPE_AP, AF_INET);  addressmap_init();  origin_circuit_t *circuit = NULL;  crypt_path_t *path = NULL;  (void) data;  MOCK(get_options, get_options_mock);  MOCK(connection_ap_handshake_rewrite, connection_ap_handshake_rewrite_mock);  MOCK(connection_mark_unattached_ap_, connection_mark_unattached_ap_mock);  MOCK(node_get_by_nickname, node_get_by_nickname_mock);  init_rewrite_mock();  init_exit_node_mock();  init_mock_options();  rewrite_mock->should_close = 0;  rewrite_mock->exit_source = ADDRMAPSRC_NONE;  SET_SOCKS_ADDRESS(conn->socks_request, "http://www.wellformed.exit");  conn->socks_request->command = SOCKS_COMMAND_CONNECT;  strlcpy(exit_node_mock->rs->nickname, "wellformed", MAX_NICKNAME_LEN+1);  options_mock->AllowDotExit = 1;  options_mock->StrictNodes = 0;  options_mock->SafeLogging_ = SAFELOG_SCRUB_NONE;  excluded_nodes = routerset_new();  smartlist_add(excluded_nodes->list, tor_strdup("wellformed"));  strmap_set(excluded_nodes->names, tor_strdup("wellformed"), exit_node_mock);  options_mock->ExcludeExitNodes = excluded_nodes;  int prev_log = setup_capture_of_logs(LOG_INFO);  int res = connection_ap_handshake_rewrite_and_attach(conn, circuit, path);  tt_int_op(unattachment_reason_spy, OP_EQ, END_STREAM_REASON_TORPROTOCOL);  tt_int_op(res, OP_EQ, -1);  tt_str_op(mock_saved_log_at(-1), OP_EQ, "Excluded relay in exit address 'http://www.exit'. Refusing./n");  done:    UNMOCK(get_options);    UNMOCK(connection_ap_handshake_rewrite);    UNMOCK(connection_mark_unattached_ap_);    UNMOCK(node_get_by_nickname);    destroy_rewrite_mock();    destroy_mock_options();    destroy_exit_node_mock();    tor_free(excluded_nodes);    tor_free(circuit);    tor_free(path);    teardown_capture_of_logs(prev_log);}

static voidtest_storagedir_deletion(void *arg){  (void)arg;  char *dirname = tor_strdup(get_fname_rnd("store_dir"));  storage_dir_t *d = NULL;  char *fn1 = NULL, *fn2 = NULL;  char *bytes = NULL;  int r;  const char str1[] = "There are nine and sixty ways to disguise communiques";  const char str2[] = "And rather more than one of them is right";  // Make sure the directory is there. */  d = storage_dir_new(dirname, 10);  storage_dir_free(d);  d = NULL;  tor_asprintf(&fn1, "%s/1007", dirname);  r = write_str_to_file(fn1, str1, 0);  tt_int_op(r, OP_EQ, 0);  tor_asprintf(&fn2, "%s/1003.tmp", dirname);  r = write_str_to_file(fn2, str2, 0);  tt_int_op(r, OP_EQ, 0);  // The tempfile should be deleted the next time we list the directory.  d = storage_dir_new(dirname, 10);  tt_int_op(1, OP_EQ, smartlist_len(storage_dir_list(d)));  tt_u64_op(strlen(str1), OP_EQ, storage_dir_get_usage(d));  tt_int_op(FN_FILE, OP_EQ, file_status(fn1));  tt_int_op(FN_NOENT, OP_EQ, file_status(fn2));  bytes = (char*) storage_dir_read(d, "1007", 1, NULL);  tt_str_op(bytes, OP_EQ, str1);  // Should have no effect; file already gone.  storage_dir_remove_file(d, "1003.tmp");  tt_int_op(1, OP_EQ, smartlist_len(storage_dir_list(d)));  tt_u64_op(strlen(str1), OP_EQ, storage_dir_get_usage(d));  // Actually remove a file.  storage_dir_remove_file(d, "1007");  tt_int_op(FN_NOENT, OP_EQ, file_status(fn1));  tt_int_op(0, OP_EQ, smartlist_len(storage_dir_list(d)));  tt_u64_op(0, OP_EQ, storage_dir_get_usage(d)); done:  tor_free(dirname);  tor_free(fn1);  tor_free(fn2);  storage_dir_free(d);  tor_free(bytes);}

static voidtest_pt_get_transport_options(void *arg){  char **execve_args;  smartlist_t *transport_list = smartlist_new();  managed_proxy_t *mp;  or_options_t *options = get_options_mutable();  char *opt_str = NULL;  config_line_t *cl = NULL;  (void)arg;  execve_args = tor_malloc(sizeof(char*)*2);  execve_args[0] = tor_strdup("cheeseshop");  execve_args[1] = NULL;  mp = managed_proxy_create(transport_list, execve_args, 1);  tt_ptr_op(mp, OP_NE, NULL);  opt_str = get_transport_options_for_server_proxy(mp);  tt_ptr_op(opt_str, OP_EQ, NULL);  smartlist_add_strdup(mp->transports_to_launch, "gruyere");  smartlist_add_strdup(mp->transports_to_launch, "roquefort");  smartlist_add_strdup(mp->transports_to_launch, "stnectaire");  tt_assert(options);  cl = tor_malloc_zero(sizeof(config_line_t));  cl->value = tor_strdup("gruyere melty=10 hardness=se;ven");  options->ServerTransportOptions = cl;  cl = tor_malloc_zero(sizeof(config_line_t));  cl->value = tor_strdup("stnectaire melty=4 hardness=three");  cl->next = options->ServerTransportOptions;  options->ServerTransportOptions = cl;  cl = tor_malloc_zero(sizeof(config_line_t));  cl->value = tor_strdup("pepperjack melty=12 hardness=five");  cl->next = options->ServerTransportOptions;  options->ServerTransportOptions = cl;  opt_str = get_transport_options_for_server_proxy(mp);  tt_str_op(opt_str, OP_EQ,            "gruyere:melty=10;gruyere:hardness=se//;ven;"            "stnectaire:melty=4;stnectaire:hardness=three"); done:  tor_free(opt_str);  config_free_lines(cl);  managed_proxy_destroy(mp, 0);  smartlist_free(transport_list);}

static voidtest_sigsafe_err(void *arg){  const char *fn=get_fname("sigsafe_err_log");  char *content=NULL;  log_severity_list_t include_bug;  smartlist_t *lines = smartlist_new();  (void)arg;  set_log_severity_config(LOG_WARN, LOG_ERR, &include_bug);  init_logging(1);  mark_logs_temp();  add_file_log(&include_bug, fn, 0);  tor_log_update_sigsafe_err_fds();  close_temp_logs();  close(STDERR_FILENO);  log_err(LD_BUG, "Say, this isn't too cool.");  tor_log_err_sigsafe("Minimal./n", NULL);  set_log_time_granularity(100*1000);  tor_log_err_sigsafe("Testing any ",                      "attempt to manually log ",                      "from a signal./n",                      NULL);  mark_logs_temp();  close_temp_logs();  close(STDERR_FILENO);  content = read_file_to_str(fn, 0, NULL);  tt_assert(content != NULL);  tor_split_lines(lines, content, (int)strlen(content));  tt_int_op(smartlist_len(lines), OP_GE, 5);  if (strstr(smartlist_get(lines, 0), "opening new log file"))    smartlist_del_keeporder(lines, 0);  tt_assert(strstr(smartlist_get(lines, 0), "Say, this isn't too cool"));  /* Next line is blank. */  tt_assert(!strcmpstart(smartlist_get(lines, 1), "=============="));  tt_assert(!strcmpstart(smartlist_get(lines, 2), "Minimal."));  /* Next line is blank. */  tt_assert(!strcmpstart(smartlist_get(lines, 3), "=============="));  tt_str_op(smartlist_get(lines, 4), OP_EQ,            "Testing any attempt to manually log from a signal."); done:  tor_free(content);  smartlist_free(lines);}

static voidtest_ratelim(void *arg){  (void) arg;  ratelim_t ten_min = RATELIM_INIT(10*60);  const time_t start = 1466091600;  time_t now = start;  /* Initially, we're ready. */  char *msg = NULL;  msg = rate_limit_log(&ten_min, now);  tt_assert(msg != NULL);  tt_str_op(msg, OP_EQ, ""); /* nothing was suppressed. */  tt_int_op(ten_min.last_allowed, OP_EQ, now);  tor_free(msg);  int i;  for (i = 0; i < 9; ++i) {    now += 60; /* one minute has passed. */    msg = rate_limit_log(&ten_min, now);    tt_assert(msg == NULL);    tt_int_op(ten_min.last_allowed, OP_EQ, start);    tt_int_op(ten_min.n_calls_since_last_time, OP_EQ, i + 1);  }  now += 240; /* Okay, we can be done. */  msg = rate_limit_log(&ten_min, now);  tt_assert(msg != NULL);  tt_str_op(msg, OP_EQ,            " [9 similar message(s) suppressed in last 600 seconds]"); done:  tor_free(msg);}