[tor/master] Remove all usage of the NS*() macros in test*.c - tor-commits

9 Jan 2020

commit 23c77f79fd6e05b4eba83c5e1fced571bb2a362a
Author: Nick Mathewson nickm@torproject.org
Date:   Thu Jan 9 10:26:10 2020 -0500
Remove all usage of the NS*() macros in test*.c
This is an automatically generated commit, made with the following
    kludgey perl script. It results in a number of wide lines, which
    I'll clean up in a subsequent commit.
#/usr/bin/perl -w -i
    $mod = "NS_MODULE";
    $submod = "NS_SUBMODULE";
    $last_was_empty = 0;
while (<>) {
s/\bASPECT(\s*(\w+)\s*,\s*(\w+)\s*)/$1_$2/;
if (/# *define +NS_MODULE +(\w+)/) {
            $mod = $1;
            next;
        } elsif (/# *define +NS_SUBMODULE +(\w+)/) {
            $submod = $1;
            next;
        }
next if (/#undef NS_(SUB)?MODULE/);
s/NS(\s*test_main\s*)/test_${mod}_${submod}/;
        s/NS(\s*(\w+)\s*)/${mod}_${submod}_$1/g;
        s/NS_FULL(\s*(\w+)\s*,\s*(\w+),\s*(\w+)\s*)/$1_$2_$3/;
        s/^(\s*)NS_MOCK(\s*(\w+)\s*)/$1MOCK($2,\n$1     ${mod}_${submod}_$2)/;
        s/NS_UNMOCK(\s*(\w+)\s*)/UNMOCK($1)/;
        s/TEST_CASE(\s*(\w+)\s*)/{ "$1", test_${mod}_$1, TT_FORK, NULL, NULL }/;
        s/TEST_CASE_ASPECT(\s*(\w+)\s*,\s*(\w+)\s*)/{ "$1_$2", test_${mod}_$1_$2, TT_FORK, NULL, NULL }/;
        s/NS_DECL(\s*([^,]+)\s*,\s*([^,]+)\s*,\s*((.*));/static $1 ${mod}_${submod}_$2$3;\nATTR_UNUSED static int ${mod}_${submod}_$2_called = 0;/;
        s/\bCALLED(\s*(\w+)\s*)/${mod}_${submod}_$1_called/;
if (/^$/) {
            print if (! $last_was_empty);
            $last_was_empty = 1;
        } else {
            $last_was_empty = 0;
            print;
        }
if (eof) {
            $mod = "NS_MODULE";
            $submod = "NS_SUBMODULE";
            $last_was_empty = 0;
        }
    }
# Please enter the commit message for your changes. Lines starting
    # with '#' will be kept; you may remove them yourself if you want to.
    # An empty message aborts the commit.
    #
    # Date:      Thu Jan 9 10:26:10 2020 -0500
    #
    # On branch disable_ns_macro
    # Changes to be committed:
    #       modified:   src/test/test_accounting.c
    #       modified:   src/test/test_compat_libevent.c
    #       modified:   src/test/test_dir.c
    #       modified:   src/test/test_dir_handle_get.c
    #       modified:   src/test/test_dns.c
    #       modified:   src/test/test_options.c
    #       modified:   src/test/test_procmon.c
    #       modified:   src/test/test_rendcache.c
    #       modified:   src/test/test_router.c
    #       modified:   src/test/test_routerset.c
    #       modified:   src/test/test_status.c
    #       modified:   src/test/test_tortls.c
    #       modified:   src/test/test_tortls_openssl.c
    #       modified:   src/test/test_util_format.c
    #       modified:   src/test/test_util_process.c
    #
    # Untracked files:
    #       experiments/
    #       locate_options.sh
    #       un_ns.pl
    #
# Please enter the commit message for your changes. Lines starting
    # with '#' will be kept; you may remove them yourself if you want to.
    # An empty message aborts the commit.
    #
    # Date:      Thu Jan 9 10:26:10 2020 -0500
    #
    # On branch disable_ns_macro
    # Changes to be committed:
    #       modified:   src/test/test_accounting.c
    #       modified:   src/test/test_compat_libevent.c
    #       modified:   src/test/test_dir.c
    #       modified:   src/test/test_dir_handle_get.c
    #       modified:   src/test/test_dns.c
    #       modified:   src/test/test_options.c
    #       modified:   src/test/test_procmon.c
    #       modified:   src/test/test_rendcache.c
    #       modified:   src/test/test_router.c
    #       modified:   src/test/test_routerset.c
    #       modified:   src/test/test_status.c
    #       modified:   src/test/test_tortls.c
    #       modified:   src/test/test_tortls_openssl.c
    #       modified:   src/test/test_util_format.c
    #       modified:   src/test/test_util_process.c
    #
    # Untracked files:
    #       experiments/
    #       locate_options.sh
    #       un_ns.pl
    #
---
 src/test/test_accounting.c      |  16 +-
 src/test/test_compat_libevent.c |   2 -
 src/test/test_dir.c             |  63 +--
 src/test/test_dir_handle_get.c  |  70 +--
 src/test/test_dns.c             | 175 ++++----
 src/test/test_options.c         |  25 +-
 src/test/test_procmon.c         |   2 -
 src/test/test_rendcache.c       |  42 +-
 src/test/test_router.c          |  13 +-
 src/test/test_routerset.c       | 937 ++++++++++++++++++----------------------
 src/test/test_status.c          | 604 ++++++++++++++------------
 src/test/test_tortls.c          |   2 +-
 src/test/test_tortls_openssl.c  |   4 -
 src/test/test_util_format.c     |   2 -
 src/test/test_util_process.c    |   1 -
 15 files changed, 946 insertions(+), 1012 deletions(-)

diff --git a/src/test/test_accounting.c b/src/test/test_accounting.c
index 58a1dbf81..7933df5e3 100644
--- a/src/test/test_accounting.c
+++ b/src/test/test_accounting.c
@@ -11,19 +11,16 @@
#include "app/config/or_state_st.h"
-#define NS_MODULE acct
-
-#define NS_SUBMODULE limits
-
 /*
  * Test to make sure accounting triggers hibernation
  * correctly with both sum or max rules set
  */
static or_state_t *or_state;
-NS_DECL(or_state_t *, get_or_state, (void));
+static or_state_t * acct_limits_get_or_state(void);
+ATTR_UNUSED static int acct_limits_get_or_state_called = 0;
 static or_state_t *
-NS(get_or_state)(void)
+acct_limits_get_or_state(void)
 {
   return or_state;
 }
@@ -35,7 +32,8 @@ test_accounting_limits(void *arg)
   time_t fake_time = time(NULL);
   (void) arg;
-  NS_MOCK(get_or_state);
+  MOCK(get_or_state,
+       acct_limits_get_or_state);
   or_state = or_state_new();
options->AccountingMax = 100;
@@ -94,12 +92,10 @@ test_accounting_limits(void *arg)
goto done;
  done:
-  NS_UNMOCK(get_or_state);
+  UNMOCK(get_or_state);
   or_state_free(or_state);
 }
-#undef NS_SUBMODULE
-
 struct testcase_t accounting_tests[] = {
   { "bwlimits", test_accounting_limits, TT_FORK, NULL, NULL },
   END_OF_TESTCASES
diff --git a/src/test/test_compat_libevent.c b/src/test/test_compat_libevent.c
index 4e675c66f..5376e08fb 100644
--- a/src/test/test_compat_libevent.c
+++ b/src/test/test_compat_libevent.c
@@ -13,8 +13,6 @@
#include "test/log_test_helpers.h"
-#define NS_MODULE le
-
 static void
 test_compat_libevent_logging_callback(void *ignored)
 {
diff --git a/src/test/test_dir.c b/src/test/test_dir.c
index 88a099695..a0f854cf7 100644
--- a/src/test/test_dir.c
+++ b/src/test/test_dir.c
@@ -94,9 +94,6 @@
 #include <unistd.h>
 #endif
-#define NS_MODULE dir
-#define NS_SUBMODULE tests
-
 static networkstatus_t *
 networkstatus_parse_vote_from_string_(const char *s,
                                       const char **eos_out,
@@ -5473,14 +5470,15 @@ test_dir_conn_purpose_to_string(void *data)
   teardown_capture_of_logs();
 }
-NS_DECL(int, public_server_mode, (const or_options_t *options));
+static int dir_tests_public_server_mode(const or_options_t *options);
+ATTR_UNUSED static int dir_tests_public_server_mode_called = 0;
static int
-NS(public_server_mode)(const or_options_t *options)
+dir_tests_public_server_mode(const or_options_t *options)
 {
   (void)options;
-  if (CALLED(public_server_mode)++ == 0) {
+  if (dir_tests_public_server_mode_called++ == 0) {
     return 1;
   }
@@ -5494,13 +5492,14 @@ test_dir_should_use_directory_guards(void *data)
   char *errmsg = NULL;
   (void)data;
-  NS_MOCK(public_server_mode);
+  MOCK(public_server_mode,
+       dir_tests_public_server_mode);
options = options_new();
   options_init(options);
tt_int_op(should_use_directory_guards(options), OP_EQ, 0);
-  tt_int_op(CALLED(public_server_mode), OP_EQ, 1);
+  tt_int_op(dir_tests_public_server_mode_called, OP_EQ, 1);
options->UseEntryGuards = 1;
   options->DownloadExtraInfo = 0;
@@ -5508,40 +5507,41 @@ test_dir_should_use_directory_guards(void *data)
   options->FetchDirInfoExtraEarly = 0;
   options->FetchUselessDescriptors = 0;
   tt_int_op(should_use_directory_guards(options), OP_EQ, 1);
-  tt_int_op(CALLED(public_server_mode), OP_EQ, 2);
+  tt_int_op(dir_tests_public_server_mode_called, OP_EQ, 2);
options->UseEntryGuards = 0;
   tt_int_op(should_use_directory_guards(options), OP_EQ, 0);
-  tt_int_op(CALLED(public_server_mode), OP_EQ, 3);
+  tt_int_op(dir_tests_public_server_mode_called, OP_EQ, 3);
   options->UseEntryGuards = 1;
options->DownloadExtraInfo = 1;
   tt_int_op(should_use_directory_guards(options), OP_EQ, 0);
-  tt_int_op(CALLED(public_server_mode), OP_EQ, 4);
+  tt_int_op(dir_tests_public_server_mode_called, OP_EQ, 4);
   options->DownloadExtraInfo = 0;
options->FetchDirInfoEarly = 1;
   tt_int_op(should_use_directory_guards(options), OP_EQ, 0);
-  tt_int_op(CALLED(public_server_mode), OP_EQ, 5);
+  tt_int_op(dir_tests_public_server_mode_called, OP_EQ, 5);
   options->FetchDirInfoEarly = 0;
options->FetchDirInfoExtraEarly = 1;
   tt_int_op(should_use_directory_guards(options), OP_EQ, 0);
-  tt_int_op(CALLED(public_server_mode), OP_EQ, 6);
+  tt_int_op(dir_tests_public_server_mode_called, OP_EQ, 6);
   options->FetchDirInfoExtraEarly = 0;
options->FetchUselessDescriptors = 1;
   tt_int_op(should_use_directory_guards(options), OP_EQ, 0);
-  tt_int_op(CALLED(public_server_mode), OP_EQ, 7);
+  tt_int_op(dir_tests_public_server_mode_called, OP_EQ, 7);
   options->FetchUselessDescriptors = 0;
done:
-    NS_UNMOCK(public_server_mode);
+    UNMOCK(public_server_mode);
     or_options_free(options);
     tor_free(errmsg);
 }
-NS_DECL(void, directory_initiate_request, (directory_request_t *req));
+static void dir_tests_directory_initiate_request(directory_request_t *req);
+ATTR_UNUSED static int dir_tests_directory_initiate_request_called = 0;
static void
 test_dir_should_not_init_request_to_ourselves(void *data)
@@ -5551,7 +5551,8 @@ test_dir_should_not_init_request_to_ourselves(void *data)
   crypto_pk_t *key = pk_generate(2);
   (void) data;
-  NS_MOCK(directory_initiate_request);
+  MOCK(directory_initiate_request,
+       dir_tests_directory_initiate_request);
clear_dir_servers();
   routerlist_free_all();
@@ -5566,15 +5567,15 @@ test_dir_should_not_init_request_to_ourselves(void *data)
   dir_server_add(ourself);
directory_get_from_all_authorities(DIR_PURPOSE_FETCH_STATUS_VOTE, 0, NULL);
-  tt_int_op(CALLED(directory_initiate_request), OP_EQ, 0);
+  tt_int_op(dir_tests_directory_initiate_request_called, OP_EQ, 0);
directory_get_from_all_authorities(DIR_PURPOSE_FETCH_DETACHED_SIGNATURES, 0,
                                      NULL);
-  tt_int_op(CALLED(directory_initiate_request), OP_EQ, 0);
+  tt_int_op(dir_tests_directory_initiate_request_called, OP_EQ, 0);
done:
-    NS_UNMOCK(directory_initiate_request);
+    UNMOCK(directory_initiate_request);
     clear_dir_servers();
     routerlist_free_all();
     crypto_pk_free(key);
@@ -5588,7 +5589,8 @@ test_dir_should_not_init_request_to_dir_auths_without_v3_info(void *data)
                                 | MICRODESC_DIRINFO;
   (void) data;
-  NS_MOCK(directory_initiate_request);
+  MOCK(directory_initiate_request,
+       dir_tests_directory_initiate_request);
clear_dir_servers();
   routerlist_free_all();
@@ -5599,14 +5601,14 @@ test_dir_should_not_init_request_to_dir_auths_without_v3_info(void *data)
   dir_server_add(ds);
directory_get_from_all_authorities(DIR_PURPOSE_FETCH_STATUS_VOTE, 0, NULL);
-  tt_int_op(CALLED(directory_initiate_request), OP_EQ, 0);
+  tt_int_op(dir_tests_directory_initiate_request_called, OP_EQ, 0);
directory_get_from_all_authorities(DIR_PURPOSE_FETCH_DETACHED_SIGNATURES, 0,
                                      NULL);
-  tt_int_op(CALLED(directory_initiate_request), OP_EQ, 0);
+  tt_int_op(dir_tests_directory_initiate_request_called, OP_EQ, 0);
done:
-    NS_UNMOCK(directory_initiate_request);
+    UNMOCK(directory_initiate_request);
     clear_dir_servers();
     routerlist_free_all();
 }
@@ -5617,7 +5619,8 @@ test_dir_should_init_request_to_dir_auths(void *data)
   dir_server_t *ds = NULL;
   (void) data;
-  NS_MOCK(directory_initiate_request);
+  MOCK(directory_initiate_request,
+       dir_tests_directory_initiate_request);
clear_dir_servers();
   routerlist_free_all();
@@ -5628,23 +5631,23 @@ test_dir_should_init_request_to_dir_auths(void *data)
   dir_server_add(ds);
directory_get_from_all_authorities(DIR_PURPOSE_FETCH_STATUS_VOTE, 0, NULL);
-  tt_int_op(CALLED(directory_initiate_request), OP_EQ, 1);
+  tt_int_op(dir_tests_directory_initiate_request_called, OP_EQ, 1);
directory_get_from_all_authorities(DIR_PURPOSE_FETCH_DETACHED_SIGNATURES, 0,
                                      NULL);
-  tt_int_op(CALLED(directory_initiate_request), OP_EQ, 2);
+  tt_int_op(dir_tests_directory_initiate_request_called, OP_EQ, 2);
done:
-    NS_UNMOCK(directory_initiate_request);
+    UNMOCK(directory_initiate_request);
     clear_dir_servers();
     routerlist_free_all();
 }
void
-NS(directory_initiate_request)(directory_request_t *req)
+dir_tests_directory_initiate_request(directory_request_t *req)
 {
   (void)req;
-  CALLED(directory_initiate_request)++;
+  dir_tests_directory_initiate_request_called++;
 }
static void
diff --git a/src/test/test_dir_handle_get.c b/src/test/test_dir_handle_get.c
index 308675ba5..86e6edd44 100644
--- a/src/test/test_dir_handle_get.c
+++ b/src/test/test_dir_handle_get.c
@@ -64,9 +64,6 @@ DISABLE_GCC_WARNING("-Woverlength-strings")
 ENABLE_GCC_WARNING("-Woverlength-strings")
 #endif
-#define NS_MODULE dhg
-#define NS_SUBMODULE tests
-
 #define NOT_FOUND "HTTP/1.0 404 Not found\r\n\r\n"
 #define BAD_REQUEST "HTTP/1.0 400 Bad request\r\n\r\n"
 #define SERVER_BUSY "HTTP/1.0 503 Directory busy, try again later\r\n\r\n"
@@ -365,12 +362,13 @@ test_dir_handle_get_rendezvous2_not_found(void *data)
     rend_cache_free_all();
 }
-NS_DECL(const routerinfo_t *, router_get_my_routerinfo, (void));
+static const routerinfo_t * dhg_tests_router_get_my_routerinfo(void);
+ATTR_UNUSED static int dhg_tests_router_get_my_routerinfo_called = 0;
static routerinfo_t *mock_routerinfo;
static const routerinfo_t *
-NS(router_get_my_routerinfo)(void)
+dhg_tests_router_get_my_routerinfo(void)
 {
   if (!mock_routerinfo) {
     mock_routerinfo = tor_malloc_zero(sizeof(routerinfo_t));
@@ -395,7 +393,8 @@ test_dir_handle_get_rendezvous2_on_encrypted_conn_success(void *data)
   (void) data;
MOCK(connection_write_to_buf_impl_, connection_write_to_buf_mock);
-  NS_MOCK(router_get_my_routerinfo);
+  MOCK(router_get_my_routerinfo,
+       dhg_tests_router_get_my_routerinfo);
rend_cache_init();
@@ -438,7 +437,7 @@ test_dir_handle_get_rendezvous2_on_encrypted_conn_success(void *data)
done:
     UNMOCK(connection_write_to_buf_impl_);
-    NS_UNMOCK(router_get_my_routerinfo);
+    UNMOCK(router_get_my_routerinfo);
connection_free_minimal(TO_CONN(conn));
     tor_free(header);
@@ -770,7 +769,8 @@ test_dir_handle_get_server_descriptors_all(void* data)
   helper_setup_fake_routerlist();
//TODO: change to router_get_my_extrainfo when testing "extra" path
-  NS_MOCK(router_get_my_routerinfo);
+  MOCK(router_get_my_routerinfo,
+       dhg_tests_router_get_my_routerinfo);
   MOCK(connection_write_to_buf_impl_, connection_write_to_buf_mock);
// We are one of the routers
@@ -812,7 +812,7 @@ test_dir_handle_get_server_descriptors_all(void* data)
   tt_ptr_op(conn->spool, OP_EQ, NULL);
done:
-    NS_UNMOCK(router_get_my_routerinfo);
+    UNMOCK(router_get_my_routerinfo);
     UNMOCK(connection_write_to_buf_impl_);
     connection_free_minimal(TO_CONN(conn));
     tor_free(header);
@@ -869,7 +869,8 @@ test_dir_handle_get_server_descriptors_authority(void* data)
   crypto_pk_t *identity_pkey = pk_generate(0);
   (void) data;
-  NS_MOCK(router_get_my_routerinfo);
+  MOCK(router_get_my_routerinfo,
+       dhg_tests_router_get_my_routerinfo);
   MOCK(connection_write_to_buf_impl_, connection_write_to_buf_mock);
/* init mock */
@@ -914,7 +915,7 @@ test_dir_handle_get_server_descriptors_authority(void* data)
   tt_ptr_op(conn->spool, OP_EQ, NULL);
done:
-    NS_UNMOCK(router_get_my_routerinfo);
+    UNMOCK(router_get_my_routerinfo);
     UNMOCK(connection_write_to_buf_impl_);
     tor_free(mock_routerinfo->cache_info.signed_descriptor_body);
     tor_free(mock_routerinfo);
@@ -934,7 +935,8 @@ test_dir_handle_get_server_descriptors_fp(void* data)
   crypto_pk_t *identity_pkey = pk_generate(0);
   (void) data;
-  NS_MOCK(router_get_my_routerinfo);
+  MOCK(router_get_my_routerinfo,
+       dhg_tests_router_get_my_routerinfo);
   MOCK(connection_write_to_buf_impl_, connection_write_to_buf_mock);
/* init mock */
@@ -986,7 +988,7 @@ test_dir_handle_get_server_descriptors_fp(void* data)
   tt_ptr_op(conn->spool, OP_EQ, NULL);
done:
-    NS_UNMOCK(router_get_my_routerinfo);
+    UNMOCK(router_get_my_routerinfo);
     UNMOCK(connection_write_to_buf_impl_);
     tor_free(mock_routerinfo->cache_info.signed_descriptor_body);
     tor_free(mock_routerinfo);
@@ -1790,13 +1792,14 @@ test_dir_handle_get_status_vote_current_consensus_too_old(void *data)
     or_options_free(mock_options); mock_options = NULL;
 }
-NS_DECL(int, geoip_get_country_by_addr, (const tor_addr_t *addr));
+static int dhg_tests_geoip_get_country_by_addr(const tor_addr_t *addr);
+ATTR_UNUSED static int dhg_tests_geoip_get_country_by_addr_called = 0;
int
-NS(geoip_get_country_by_addr)(const tor_addr_t *addr)
+dhg_tests_geoip_get_country_by_addr(const tor_addr_t *addr)
 {
   (void)addr;
-  CALLED(geoip_get_country_by_addr)++;
+  dhg_tests_geoip_get_country_by_addr_called++;
   return 1;
 }
@@ -1860,7 +1863,8 @@ test_dir_handle_get_status_vote_current_consensus_ns(void* data)
   dirserv_free_all();
   clear_geoip_db();
-  NS_MOCK(geoip_get_country_by_addr);
+  MOCK(geoip_get_country_by_addr,
+       dhg_tests_geoip_get_country_by_addr);
   MOCK(get_options, mock_get_options);
init_mock_options();
@@ -1897,7 +1901,7 @@ test_dir_handle_get_status_vote_current_consensus_ns(void* data)
   tt_str_op("ab=8", OP_EQ, hist);
done:
-    NS_UNMOCK(geoip_get_country_by_addr);
+    UNMOCK(geoip_get_country_by_addr);
     UNMOCK(get_options);
     tor_free(header);
     tor_free(comp_body);
@@ -2249,10 +2253,11 @@ test_dir_handle_get_status_vote_next_bandwidth_not_found(void* data)
     tor_free(header);
 }
-NS_DECL(const char*, dirvote_get_pending_consensus, (consensus_flavor_t flav));
+static const char* dhg_tests_dirvote_get_pending_consensus(consensus_flavor_t flav);
+ATTR_UNUSED static int dhg_tests_dirvote_get_pending_consensus_called = 0;
const char*
-NS(dirvote_get_pending_consensus)(consensus_flavor_t flav)
+dhg_tests_dirvote_get_pending_consensus(consensus_flavor_t flav)
 {
   (void)flav;
   return "pending consensus";
@@ -2265,7 +2270,8 @@ test_dir_handle_get_status_vote_next_consensus(void* data)
   size_t body_used = 0;
   (void) data;
-  NS_MOCK(dirvote_get_pending_consensus);
+  MOCK(dirvote_get_pending_consensus,
+       dhg_tests_dirvote_get_pending_consensus);
status_vote_next_consensus_test(&header, &body, &body_used);
   tt_assert(header);
@@ -2278,7 +2284,7 @@ test_dir_handle_get_status_vote_next_consensus(void* data)
   tt_str_op("pending consensus", OP_EQ, body);
done:
-    NS_UNMOCK(dirvote_get_pending_consensus);
+    UNMOCK(dirvote_get_pending_consensus);
     tor_free(header);
     tor_free(body);
 }
@@ -2291,7 +2297,8 @@ test_dir_handle_get_status_vote_next_consensus_busy(void* data)
   (void) data;
MOCK(get_options, mock_get_options);
-  NS_MOCK(dirvote_get_pending_consensus);
+  MOCK(dirvote_get_pending_consensus,
+       dhg_tests_dirvote_get_pending_consensus);
//Make it busy
   init_mock_options();
@@ -2303,7 +2310,7 @@ test_dir_handle_get_status_vote_next_consensus_busy(void* data)
   tt_str_op(SERVER_BUSY, OP_EQ, header);
done:
-    NS_UNMOCK(dirvote_get_pending_consensus);
+    UNMOCK(dirvote_get_pending_consensus);
     UNMOCK(get_options);
     tor_free(header);
     tor_free(body);
@@ -2347,10 +2354,11 @@ test_dir_handle_get_status_vote_next_consensus_signatures_not_found(void* data)
     tor_free(body);
 }
-NS_DECL(const char*, dirvote_get_pending_detached_signatures, (void));
+static const char* dhg_tests_dirvote_get_pending_detached_signatures(void);
+ATTR_UNUSED static int dhg_tests_dirvote_get_pending_detached_signatures_called = 0;
const char*
-NS(dirvote_get_pending_detached_signatures)(void)
+dhg_tests_dirvote_get_pending_detached_signatures(void)
 {
   return "pending detached sigs";
 }
@@ -2362,7 +2370,8 @@ test_dir_handle_get_status_vote_next_consensus_signatures(void* data)
   size_t body_used = 0;
   (void) data;
-  NS_MOCK(dirvote_get_pending_detached_signatures);
+  MOCK(dirvote_get_pending_detached_signatures,
+       dhg_tests_dirvote_get_pending_detached_signatures);
status_vote_next_consensus_signatures_test(&header, &body, &body_used);
   tt_assert(header);
@@ -2375,7 +2384,7 @@ test_dir_handle_get_status_vote_next_consensus_signatures(void* data)
   tt_str_op("pending detached sigs", OP_EQ, body);
done:
-    NS_UNMOCK(dirvote_get_pending_detached_signatures);
+    UNMOCK(dirvote_get_pending_detached_signatures);
     tor_free(header);
     tor_free(body);
 }
@@ -2387,7 +2396,8 @@ test_dir_handle_get_status_vote_next_consensus_signatures_busy(void* data)
   size_t body_used;
   (void) data;
-  NS_MOCK(dirvote_get_pending_detached_signatures);
+  MOCK(dirvote_get_pending_detached_signatures,
+       dhg_tests_dirvote_get_pending_detached_signatures);
   MOCK(get_options, mock_get_options);
//Make it busy
@@ -2401,7 +2411,7 @@ test_dir_handle_get_status_vote_next_consensus_signatures_busy(void* data)
done:
     UNMOCK(get_options);
-    NS_UNMOCK(dirvote_get_pending_detached_signatures);
+    UNMOCK(dirvote_get_pending_detached_signatures);
     tor_free(header);
     tor_free(body);
     or_options_free(mock_options); mock_options = NULL;
diff --git a/src/test/test_dns.c b/src/test/test_dns.c
index 6ca858224..443538326 100644
--- a/src/test/test_dns.c
+++ b/src/test/test_dns.c
@@ -20,10 +20,7 @@
 #include <event2/event.h>
 #include <event2/dns.h>
-#define NS_MODULE dns
-
 #ifdef HAVE_EVDNS_BASE_GET_NAMESERVER_ADDR
-#define NS_SUBMODULE configure_ns_fallback
static or_options_t options = {
   .ORPort_set = 1,
@@ -36,7 +33,7 @@ mock_get_options(void)
 }
static void
-NS(test_main)(void *arg)
+test_dns_configure_ns_fallback(void *arg)
 {
   (void)arg;
   tor_addr_t *nameserver_addr = NULL;
@@ -76,13 +73,10 @@ NS(test_main)(void *arg)
   return;
 }
-#undef NS_SUBMODULE
 #endif /* defined(HAVE_EVDNS_BASE_GET_NAMESERVER_ADDR) */
-#define NS_SUBMODULE clip_ttl
-
 static void
-NS(test_main)(void *arg)
+test_dns_clip_ttl(void *arg)
 {
   (void)arg;
@@ -96,10 +90,6 @@ NS(test_main)(void *arg)
   return;
 }
-#undef NS_SUBMODULE
-
-#define NS_SUBMODULE resolve
-
 static int resolve_retval = 0;
 static int resolve_made_conn_pending = 0;
 static char *resolved_name = NULL;
@@ -107,7 +97,8 @@ static cached_resolve_t *cache_entry_mock = NULL;
static int n_fake_impl = 0;
-NS_DECL(int, dns_resolve_impl, (edge_connection_t *exitconn, int is_resolve, or_circuit_t *oncirc, char **hostname_out, int *made_connection_pending_out, cached_resolve_t **resolve_out));
+static int dns_resolve_dns_resolve_impl(edge_connection_t *exitconn, int is_resolve, or_circuit_t *oncirc, char **hostname_out, int *made_connection_pending_out, cached_resolve_t **resolve_out);
+ATTR_UNUSED static int dns_resolve_dns_resolve_impl_called = 0;
/** This will be our configurable substitute for <b>dns_resolve_impl</b> in
  * dns.c. It will return <b>resolve_retval</b>,
@@ -118,7 +109,7 @@ NS_DECL(int, dns_resolve_impl, (edge_connection_t *exitconn, int is_resolve, or_
  * 1.
  */
 static int
-NS(dns_resolve_impl)(edge_connection_t *exitconn, int is_resolve,
+dns_resolve_dns_resolve_impl(edge_connection_t *exitconn, int is_resolve,
                      or_circuit_t *oncirc, char **hostname_out,
                      int *made_connection_pending_out,
                      cached_resolve_t **resolve_out)
@@ -148,7 +139,7 @@ static uint8_t last_answer_type = 0;
 static cached_resolve_t *last_resolved;
static void
-NS(send_resolved_cell)(edge_connection_t *conn, uint8_t answer_type,
+dns_resolve_send_resolved_cell(edge_connection_t *conn, uint8_t answer_type,
                        const cached_resolve_t *resolved)
 {
   conn_for_resolved_cell = conn;
@@ -164,7 +155,7 @@ static int n_send_resolved_hostname_cell_replacement = 0;
 static char *last_resolved_hostname = NULL;
static void
-NS(send_resolved_hostname_cell)(edge_connection_t *conn,
+dns_resolve_send_resolved_hostname_cell(edge_connection_t *conn,
                                 const char *hostname)
 {
   conn_for_resolved_cell = conn;
@@ -178,7 +169,7 @@ NS(send_resolved_hostname_cell)(edge_connection_t *conn,
 static int n_dns_cancel_pending_resolve_replacement = 0;
static void
-NS(dns_cancel_pending_resolve)(const char *address)
+dns_resolve_dns_cancel_pending_resolve(const char *address)
 {
   (void) address;
   n_dns_cancel_pending_resolve_replacement++;
@@ -188,7 +179,7 @@ static int n_connection_free = 0;
 static connection_t *last_freed_conn = NULL;
static void
-NS(connection_free_)(connection_t *conn)
+dns_resolve_connection_free_(connection_t *conn)
 {
    n_connection_free++;
@@ -196,7 +187,7 @@ NS(connection_free_)(connection_t *conn)
 }
static void
-NS(test_main)(void *arg)
+test_dns_resolve(void *arg)
 {
   (void) arg;
   int retval;
@@ -215,9 +206,12 @@ NS(test_main)(void *arg)
   memset(exitconn,0,sizeof(edge_connection_t));
   memset(nextconn,0,sizeof(edge_connection_t));
-  NS_MOCK(dns_resolve_impl);
-  NS_MOCK(send_resolved_cell);
-  NS_MOCK(send_resolved_hostname_cell);
+  MOCK(dns_resolve_impl,
+       dns_resolve_dns_resolve_impl);
+  MOCK(send_resolved_cell,
+       dns_resolve_send_resolved_cell);
+  MOCK(send_resolved_hostname_cell,
+       dns_resolve_send_resolved_hostname_cell);
/*
    * CASE 1: dns_resolve_impl returns 1 and sets a hostname. purpose is
@@ -330,8 +324,10 @@ NS(test_main)(void *arg)
    * on exitconn with type being RESOLVED_TYPE_ERROR.
    */
-  NS_MOCK(dns_cancel_pending_resolve);
-  NS_MOCK(connection_free_);
+  MOCK(dns_cancel_pending_resolve,
+       dns_resolve_dns_cancel_pending_resolve);
+  MOCK(connection_free_,
+       dns_resolve_connection_free_);
exitconn->on_circuit = &(on_circuit->base_);
   exitconn->base_.purpose = EXIT_PURPOSE_RESOLVE;
@@ -354,11 +350,11 @@ NS(test_main)(void *arg)
   tt_assert(last_freed_conn == TO_CONN(exitconn));
done:
-  NS_UNMOCK(dns_resolve_impl);
-  NS_UNMOCK(send_resolved_cell);
-  NS_UNMOCK(send_resolved_hostname_cell);
-  NS_UNMOCK(dns_cancel_pending_resolve);
-  NS_UNMOCK(connection_free_);
+  UNMOCK(dns_resolve_impl);
+  UNMOCK(send_resolved_cell);
+  UNMOCK(send_resolved_hostname_cell);
+  UNMOCK(dns_cancel_pending_resolve);
+  UNMOCK(connection_free_);
   tor_free(on_circuit);
   tor_free(exitconn);
   tor_free(nextconn);
@@ -368,8 +364,6 @@ NS(test_main)(void *arg)
   return;
 }
-#undef NS_SUBMODULE
-
 /** Create an <b>edge_connection_t</b> instance that is considered a
  * valid exit connection by asserts in dns_resolve_impl.
  */
@@ -386,8 +380,6 @@ create_valid_exitconn(void)
   return exitconn;
 }
-#define NS_SUBMODULE ASPECT(impl, addr_is_ip)
-
 /*
  * Given that <b>exitconn->base_.address</b> is IP address string, we
  * want dns_resolve_impl() to parse it and store in
@@ -396,7 +388,7 @@ create_valid_exitconn(void)
  */
static void
-NS(test_main)(void *arg)
+test_dns_impl_addr_is_ip(void *arg)
 {
   int retval;
   int made_pending;
@@ -429,21 +421,17 @@ NS(test_main)(void *arg)
   return;
 }
-#undef NS_SUBMODULE
-
-#define NS_SUBMODULE ASPECT(impl, non_exit)
-
 /** Given that Tor instance is not configured as an exit node, we want
  * dns_resolve_impl() to fail with return value -1.
  */
 static int
-NS(router_my_exit_policy_is_reject_star)(void)
+dns_impl_non_exit_router_my_exit_policy_is_reject_star(void)
 {
   return 1;
 }
static void
-NS(test_main)(void *arg)
+test_dns_impl_non_exit(void *arg)
 {
   int retval;
   int made_pending;
@@ -455,7 +443,8 @@ NS(test_main)(void *arg)
TO_CONN(exitconn)->address = tor_strdup("torproject.org");
-  NS_MOCK(router_my_exit_policy_is_reject_star);
+  MOCK(router_my_exit_policy_is_reject_star,
+       dns_impl_non_exit_router_my_exit_policy_is_reject_star);
retval = dns_resolve_impl(exitconn, 1, on_circ, NULL, &made_pending,
                             NULL);
@@ -466,27 +455,23 @@ NS(test_main)(void *arg)
   tor_free(TO_CONN(exitconn)->address);
   tor_free(exitconn);
   tor_free(on_circ);
-  NS_UNMOCK(router_my_exit_policy_is_reject_star);
+  UNMOCK(router_my_exit_policy_is_reject_star);
   return;
 }
-#undef NS_SUBMODULE
-
-#define NS_SUBMODULE ASPECT(impl, addr_is_invalid_dest)
-
 /** Given that address is not a valid destination (as judged by
  * address_is_invalid_destination() function), we want dns_resolve_impl()
  * function to fail with return value -1.
  */
static int
-NS(router_my_exit_policy_is_reject_star)(void)
+dns_impl_addr_is_invalid_dest_router_my_exit_policy_is_reject_star(void)
 {
   return 0;
 }
static void
-NS(test_main)(void *arg)
+test_dns_impl_addr_is_invalid_dest(void *arg)
 {
   int retval;
   int made_pending;
@@ -496,7 +481,8 @@ NS(test_main)(void *arg)
(void)arg;
-  NS_MOCK(router_my_exit_policy_is_reject_star);
+  MOCK(router_my_exit_policy_is_reject_star,
+       dns_impl_addr_is_invalid_dest_router_my_exit_policy_is_reject_star);
TO_CONN(exitconn)->address = tor_strdup("invalid#@!.org");
@@ -506,29 +492,25 @@ NS(test_main)(void *arg)
   tt_int_op(retval,OP_EQ,-1);
done:
-  NS_UNMOCK(router_my_exit_policy_is_reject_star);
+  UNMOCK(router_my_exit_policy_is_reject_star);
   tor_free(TO_CONN(exitconn)->address);
   tor_free(exitconn);
   tor_free(on_circ);
   return;
 }
-#undef NS_SUBMODULE
-
-#define NS_SUBMODULE ASPECT(impl, malformed_ptr)
-
 /** Given that address is a malformed PTR name, we want dns_resolve_impl to
  * fail.
  */
static int
-NS(router_my_exit_policy_is_reject_star)(void)
+dns_impl_malformed_ptr_router_my_exit_policy_is_reject_star(void)
 {
   return 0;
 }
static void
-NS(test_main)(void *arg)
+test_dns_impl_malformed_ptr(void *arg)
 {
   int retval;
   int made_pending;
@@ -540,7 +522,8 @@ NS(test_main)(void *arg)
TO_CONN(exitconn)->address = tor_strdup("1.0.0.127.in-addr.arpa");
-  NS_MOCK(router_my_exit_policy_is_reject_star);
+  MOCK(router_my_exit_policy_is_reject_star,
+       dns_impl_malformed_ptr_router_my_exit_policy_is_reject_star);
retval = dns_resolve_impl(exitconn, 1, on_circ, NULL, &made_pending,
                             NULL);
@@ -558,30 +541,26 @@ NS(test_main)(void *arg)
   tt_int_op(retval,OP_EQ,-1);
done:
-  NS_UNMOCK(router_my_exit_policy_is_reject_star);
+  UNMOCK(router_my_exit_policy_is_reject_star);
   tor_free(TO_CONN(exitconn)->address);
   tor_free(exitconn);
   tor_free(on_circ);
   return;
 }
-#undef NS_SUBMODULE
-
-#define NS_SUBMODULE ASPECT(impl, cache_hit_pending)
-
 /* Given that there is already a pending resolve for the given address,
  * we want dns_resolve_impl to append our exit connection to list
  * of pending connections for the pending DNS request and return 0.
  */
static int
-NS(router_my_exit_policy_is_reject_star)(void)
+dns_impl_cache_hit_pending_router_my_exit_policy_is_reject_star(void)
 {
   return 0;
 }
static void
-NS(test_main)(void *arg)
+test_dns_impl_cache_hit_pending(void *arg)
 {
   int retval;
   int made_pending = 0;
@@ -604,7 +583,8 @@ NS(test_main)(void *arg)
   strlcpy(cache_entry->address, TO_CONN(exitconn)->address,
           sizeof(cache_entry->address));
-  NS_MOCK(router_my_exit_policy_is_reject_star);
+  MOCK(router_my_exit_policy_is_reject_star,
+       dns_impl_cache_hit_pending_router_my_exit_policy_is_reject_star);
dns_init();
@@ -622,7 +602,7 @@ NS(test_main)(void *arg)
   tt_assert(pending_conn->conn == exitconn);
done:
-  NS_UNMOCK(router_my_exit_policy_is_reject_star);
+  UNMOCK(router_my_exit_policy_is_reject_star);
   tor_free(on_circ);
   tor_free(TO_CONN(exitconn)->address);
   tor_free(cache_entry->pending_connections);
@@ -631,16 +611,12 @@ NS(test_main)(void *arg)
   return;
 }
-#undef NS_SUBMODULE
-
-#define NS_SUBMODULE ASPECT(impl, cache_hit_cached)
-
 /* Given that a finished DNS resolve is available in our cache, we want
  * dns_resolve_impl() return it to called via resolve_out and pass the
  * handling to set_exitconn_info_from_resolve function.
  */
 static int
-NS(router_my_exit_policy_is_reject_star)(void)
+dns_impl_cache_hit_cached_router_my_exit_policy_is_reject_star(void)
 {
   return 0;
 }
@@ -649,7 +625,7 @@ static edge_connection_t *last_exitconn = NULL;
 static cached_resolve_t *last_resolve = NULL;
static int
-NS(set_exitconn_info_from_resolve)(edge_connection_t *exitconn,
+dns_impl_cache_hit_cached_set_exitconn_info_from_resolve(edge_connection_t *exitconn,
                                    const cached_resolve_t *resolve,
                                    char **hostname_out)
 {
@@ -662,7 +638,7 @@ NS(set_exitconn_info_from_resolve)(edge_connection_t *exitconn,
 }
static void
-NS(test_main)(void *arg)
+test_dns_impl_cache_hit_cached(void *arg)
 {
   int retval;
   int made_pending = 0;
@@ -685,8 +661,10 @@ NS(test_main)(void *arg)
   strlcpy(cache_entry->address, TO_CONN(exitconn)->address,
           sizeof(cache_entry->address));
-  NS_MOCK(router_my_exit_policy_is_reject_star);
-  NS_MOCK(set_exitconn_info_from_resolve);
+  MOCK(router_my_exit_policy_is_reject_star,
+       dns_impl_cache_hit_cached_router_my_exit_policy_is_reject_star);
+  MOCK(set_exitconn_info_from_resolve,
+       dns_impl_cache_hit_cached_set_exitconn_info_from_resolve);
dns_init();
@@ -703,8 +681,8 @@ NS(test_main)(void *arg)
   tt_assert(last_resolve == cache_entry);
done:
-  NS_UNMOCK(router_my_exit_policy_is_reject_star);
-  NS_UNMOCK(set_exitconn_info_from_resolve);
+  UNMOCK(router_my_exit_policy_is_reject_star);
+  UNMOCK(set_exitconn_info_from_resolve);
   tor_free(on_circ);
   tor_free(TO_CONN(exitconn)->address);
   tor_free(cache_entry->pending_connections);
@@ -712,10 +690,6 @@ NS(test_main)(void *arg)
   return;
 }
-#undef NS_SUBMODULE
-
-#define NS_SUBMODULE ASPECT(impl, cache_miss)
-
 /* Given that there are neither pending nor pre-cached resolve for a given
  * address, we want dns_resolve_impl() to create a new cached_resolve_t
  * object, mark it as pending, insert it into the cache, attach the exit
@@ -723,7 +697,7 @@ NS(test_main)(void *arg)
  * with the cached_resolve_t object it created.
  */
 static int
-NS(router_my_exit_policy_is_reject_star)(void)
+dns_impl_cache_miss_router_my_exit_policy_is_reject_star(void)
 {
   return 0;
 }
@@ -731,7 +705,7 @@ NS(router_my_exit_policy_is_reject_star)(void)
 static cached_resolve_t *last_launched_resolve = NULL;
static int
-NS(launch_resolve)(cached_resolve_t *resolve)
+dns_impl_cache_miss_launch_resolve(cached_resolve_t *resolve)
 {
   last_launched_resolve = resolve;
@@ -739,7 +713,7 @@ NS(launch_resolve)(cached_resolve_t *resolve)
 }
static void
-NS(test_main)(void *arg)
+test_dns_impl_cache_miss(void *arg)
 {
   int retval;
   int made_pending = 0;
@@ -758,8 +732,10 @@ NS(test_main)(void *arg)
strlcpy(query.address, TO_CONN(exitconn)->address, sizeof(query.address));
-  NS_MOCK(router_my_exit_policy_is_reject_star);
-  NS_MOCK(launch_resolve);
+  MOCK(router_my_exit_policy_is_reject_star,
+       dns_impl_cache_miss_router_my_exit_policy_is_reject_star);
+  MOCK(launch_resolve,
+       dns_impl_cache_miss_launch_resolve);
dns_init();
@@ -782,8 +758,8 @@ NS(test_main)(void *arg)
   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);
+  UNMOCK(router_my_exit_policy_is_reject_star);
+  UNMOCK(launch_resolve);
   tor_free(on_circ);
   tor_free(TO_CONN(exitconn)->address);
   if (cache_entry)
@@ -793,22 +769,19 @@ NS(test_main)(void *arg)
   return;
 }
-#undef NS_SUBMODULE
-
 struct testcase_t dns_tests[] = {
 #ifdef HAVE_EVDNS_BASE_GET_NAMESERVER_ADDR
-   TEST_CASE(configure_ns_fallback),
+   { "configure_ns_fallback", test_dns_configure_ns_fallback, TT_FORK, NULL, NULL },
 #endif
-   TEST_CASE(clip_ttl),
-   TEST_CASE(resolve),
-   TEST_CASE_ASPECT(impl, addr_is_ip),
-   TEST_CASE_ASPECT(impl, non_exit),
-   TEST_CASE_ASPECT(impl, addr_is_invalid_dest),
-   TEST_CASE_ASPECT(impl, malformed_ptr),
-   TEST_CASE_ASPECT(impl, cache_hit_pending),
-   TEST_CASE_ASPECT(impl, cache_hit_cached),
-   TEST_CASE_ASPECT(impl, cache_miss),
+   { "clip_ttl", test_dns_clip_ttl, TT_FORK, NULL, NULL },
+   { "resolve", test_dns_resolve, TT_FORK, NULL, NULL },
+   { "impl_addr_is_ip", test_dns_impl_addr_is_ip, TT_FORK, NULL, NULL },
+   { "impl_non_exit", test_dns_impl_non_exit, TT_FORK, NULL, NULL },
+   { "impl_addr_is_invalid_dest", test_dns_impl_addr_is_invalid_dest, TT_FORK, NULL, NULL },
+   { "impl_malformed_ptr", test_dns_impl_malformed_ptr, TT_FORK, NULL, NULL },
+   { "impl_cache_hit_pending", test_dns_impl_cache_hit_pending, TT_FORK, NULL, NULL },
+   { "impl_cache_hit_cached", test_dns_impl_cache_hit_cached, TT_FORK, NULL, NULL },
+   { "impl_cache_miss", test_dns_impl_cache_miss, TT_FORK, NULL, NULL },
    END_OF_TESTCASES
 };
-#undef NS_MODULE
diff --git a/src/test/test_options.c b/src/test/test_options.c
index a363eca67..fb12821ae 100644
--- a/src/test/test_options.c
+++ b/src/test/test_options.c
@@ -35,9 +35,6 @@
 #include <sys/param.h>
 #endif
-#define NS_MODULE opt
-#define NS_SUBMODULE tests
-
 typedef struct {
   int severity;
   log_domain_mask_t domain;
@@ -1167,13 +1164,14 @@ test_options_validate__transproxy(void *ignored)
   tor_free(msg);
 }
-NS_DECL(country_t, geoip_get_country, (const char *country));
+static country_t opt_tests_geoip_get_country(const char *country);
+ATTR_UNUSED static int opt_tests_geoip_get_country_called = 0;
static country_t
-NS(geoip_get_country)(const char *countrycode)
+opt_tests_geoip_get_country(const char *countrycode)
 {
   (void)countrycode;
-  CALLED(geoip_get_country)++;
+  opt_tests_geoip_get_country_called++;
return 1;
 }
@@ -1183,7 +1181,8 @@ test_options_validate__exclude_nodes(void *ignored)
 {
   (void)ignored;
-  NS_MOCK(geoip_get_country);
+  MOCK(geoip_get_country,
+       opt_tests_geoip_get_country);
int ret;
   char *msg;
@@ -1247,7 +1246,7 @@ test_options_validate__exclude_nodes(void *ignored)
   tor_free(msg);
done:
-  NS_UNMOCK(geoip_get_country);
+  UNMOCK(geoip_get_country);
   teardown_capture_of_logs();
   free_options_test_data(tdata);
   tor_free(msg);
@@ -1752,7 +1751,8 @@ test_options_validate__use_bridges(void *ignored)
             " the Internet, so they must not set UseBridges.");
   tor_free(msg);
-  NS_MOCK(geoip_get_country);
+  MOCK(geoip_get_country,
+       opt_tests_geoip_get_country);
   free_options_test_data(tdata);
   tdata = get_options_test_data("UseBridges 1\n"
                                 "EntryNodes {cn}\n");
@@ -1795,7 +1795,7 @@ test_options_validate__use_bridges(void *ignored)
   tor_free(msg);
done:
-  NS_UNMOCK(geoip_get_country);
+  UNMOCK(geoip_get_country);
   policies_free_all();
   free_options_test_data(tdata);
   tor_free(msg);
@@ -1807,7 +1807,8 @@ test_options_validate__entry_nodes(void *ignored)
   (void)ignored;
   int ret;
   char *msg;
-  NS_MOCK(geoip_get_country);
+  MOCK(geoip_get_country,
+       opt_tests_geoip_get_country);
   options_test_data_t *tdata = get_options_test_data(
                                          "EntryNodes {cn}\n"
                                          "UseEntryGuards 0\n");
@@ -1827,7 +1828,7 @@ test_options_validate__entry_nodes(void *ignored)
   tor_free(msg);
done:
-  NS_UNMOCK(geoip_get_country);
+  UNMOCK(geoip_get_country);
   free_options_test_data(tdata);
   tor_free(msg);
 }
diff --git a/src/test/test_procmon.c b/src/test/test_procmon.c
index 6893fe8b6..1752008f6 100644
--- a/src/test/test_procmon.c
+++ b/src/test/test_procmon.c
@@ -9,8 +9,6 @@
#include "test/log_test_helpers.h"
-#define NS_MODULE procmon
-
 struct event_base;
static void
diff --git a/src/test/test_rendcache.c b/src/test/test_rendcache.c
index 5771ca1d2..d0cb4378a 100644
--- a/src/test/test_rendcache.c
+++ b/src/test/test_rendcache.c
@@ -21,8 +21,6 @@
 #include "test/rend_test_helpers.h"
 #include "test/log_test_helpers.h"
-#define NS_MODULE rcache
-
 static const int RECENT_TIME = -10;
 static const int TIME_IN_THE_PAST = -(REND_CACHE_MAX_AGE + \
                                       REND_CACHE_MAX_SKEW + 60);
@@ -369,13 +367,13 @@ test_rend_cache_store_v2_desc_as_client_with_different_time(void *data)
   rend_data_free(mock_rend_query);
 }
-#define NS_SUBMODULE lookup_v2_desc_as_dir
-NS_DECL(const routerinfo_t *, router_get_my_routerinfo, (void));
+static const routerinfo_t * rcache_lookup_v2_desc_as_dir_router_get_my_routerinfo(void);
+ATTR_UNUSED static int rcache_lookup_v2_desc_as_dir_router_get_my_routerinfo_called = 0;
static routerinfo_t *mock_routerinfo;
static const routerinfo_t *
-NS(router_get_my_routerinfo)(void)
+rcache_lookup_v2_desc_as_dir_router_get_my_routerinfo(void)
 {
   if (!mock_routerinfo) {
     mock_routerinfo = tor_malloc(sizeof(routerinfo_t));
@@ -395,7 +393,8 @@ test_rend_cache_lookup_v2_desc_as_dir(void *data)
(void)data;
-  NS_MOCK(router_get_my_routerinfo);
+  MOCK(router_get_my_routerinfo,
+       rcache_lookup_v2_desc_as_dir_router_get_my_routerinfo);
rend_cache_init();
@@ -418,20 +417,18 @@ test_rend_cache_lookup_v2_desc_as_dir(void *data)
   tt_assert(ret_desc);
done:
-  NS_UNMOCK(router_get_my_routerinfo);
+  UNMOCK(router_get_my_routerinfo);
   tor_free(mock_routerinfo);
   rend_cache_free_all();
   rend_encoded_v2_service_descriptor_free(desc_holder);
   tor_free(service_id);
 }
-#undef NS_SUBMODULE
-
-#define NS_SUBMODULE store_v2_desc_as_dir
-NS_DECL(const routerinfo_t *, router_get_my_routerinfo, (void));
+static const routerinfo_t * rcache_store_v2_desc_as_dir_router_get_my_routerinfo(void);
+ATTR_UNUSED static int rcache_store_v2_desc_as_dir_router_get_my_routerinfo_called = 0;
static const routerinfo_t *
-NS(router_get_my_routerinfo)(void)
+rcache_store_v2_desc_as_dir_router_get_my_routerinfo(void)
 {
   return mock_routerinfo;
 }
@@ -444,7 +441,8 @@ test_rend_cache_store_v2_desc_as_dir(void *data)
   rend_encoded_v2_service_descriptor_t *desc_holder = NULL;
   char *service_id = NULL;
-  NS_MOCK(router_get_my_routerinfo);
+  MOCK(router_get_my_routerinfo,
+       rcache_store_v2_desc_as_dir_router_get_my_routerinfo);
rend_cache_init();
@@ -485,7 +483,7 @@ test_rend_cache_store_v2_desc_as_dir(void *data)
   tt_int_op(ret, OP_EQ, 0);
done:
-  NS_UNMOCK(router_get_my_routerinfo);
+  UNMOCK(router_get_my_routerinfo);
   rend_encoded_v2_service_descriptor_free(desc_holder);
   tor_free(service_id);
   rend_cache_free_all();
@@ -505,7 +503,8 @@ test_rend_cache_store_v2_desc_as_dir_with_different_time(void *data)
   rend_encoded_v2_service_descriptor_t *desc_holder_newer;
   rend_encoded_v2_service_descriptor_t *desc_holder_older;
-  NS_MOCK(router_get_my_routerinfo);
+  MOCK(router_get_my_routerinfo,
+       rcache_store_v2_desc_as_dir_router_get_my_routerinfo);
rend_cache_init();
@@ -543,7 +542,7 @@ test_rend_cache_store_v2_desc_as_dir_with_different_time(void *data)
   tt_int_op(ret, OP_EQ, 0);
done:
-  NS_UNMOCK(router_get_my_routerinfo);
+  UNMOCK(router_get_my_routerinfo);
   rend_cache_free_all();
   rend_service_descriptor_free(generated);
   tor_free(service_id);
@@ -568,7 +567,8 @@ test_rend_cache_store_v2_desc_as_dir_with_different_content(void *data)
   rend_encoded_v2_service_descriptor_t *desc_holder_one = NULL;
   rend_encoded_v2_service_descriptor_t *desc_holder_two = NULL;
-  NS_MOCK(router_get_my_routerinfo);
+  MOCK(router_get_my_routerinfo,
+       rcache_store_v2_desc_as_dir_router_get_my_routerinfo);
rend_cache_init();
@@ -602,7 +602,7 @@ test_rend_cache_store_v2_desc_as_dir_with_different_content(void *data)
   tt_int_op(ret, OP_EQ, 0);
done:
-  NS_UNMOCK(router_get_my_routerinfo);
+  UNMOCK(router_get_my_routerinfo);
   rend_cache_free_all();
   rend_service_descriptor_free(generated);
   tor_free(service_id);
@@ -613,8 +613,6 @@ test_rend_cache_store_v2_desc_as_dir_with_different_content(void *data)
   rend_encoded_v2_service_descriptor_free(desc_holder_two);
 }
-#undef NS_SUBMODULE
-
 static void
 test_rend_cache_init(void *data)
 {
@@ -1074,8 +1072,6 @@ test_rend_cache_intro_failure_note(void *data)
   rend_cache_free_all();
 }
-#define NS_SUBMODULE clean_v2_descs_as_dir
-
 static void
 test_rend_cache_clean_v2_descs_as_dir(void *data)
 {
@@ -1116,8 +1112,6 @@ test_rend_cache_clean_v2_descs_as_dir(void *data)
   rend_cache_free_all();
 }
-#undef NS_SUBMODULE
-
 static void
 test_rend_cache_entry_allocation(void *data)
 {
diff --git a/src/test/test_router.c b/src/test/test_router.c
index a1ea2967f..572ddceaa 100644
--- a/src/test/test_router.c
+++ b/src/test/test_router.c
@@ -31,15 +31,13 @@
 #include "test/test.h"
 #include "test/log_test_helpers.h"
-#define NS_MODULE rtr
-#define NS_SUBMODULE tests
-
-NS_DECL(const routerinfo_t *, router_get_my_routerinfo, (void));
+static const routerinfo_t * rtr_tests_router_get_my_routerinfo(void);
+ATTR_UNUSED static int rtr_tests_router_get_my_routerinfo_called = 0;
static routerinfo_t* mock_routerinfo;
static const routerinfo_t*
-NS(router_get_my_routerinfo)(void)
+rtr_tests_router_get_my_routerinfo(void)
 {
   crypto_pk_t* ident_key;
   crypto_pk_t* tap_key;
@@ -89,7 +87,8 @@ test_router_dump_router_to_string_no_bridge_distribution_method(void *arg)
   char* found = NULL;
   (void)arg;
-  NS_MOCK(router_get_my_routerinfo);
+  MOCK(router_get_my_routerinfo,
+       rtr_tests_router_get_my_routerinfo);
options->ORPort_set = 1;
   options->BridgeRelay = 1;
@@ -123,7 +122,7 @@ test_router_dump_router_to_string_no_bridge_distribution_method(void *arg)
   tt_ptr_op(found, OP_NE, NULL);
done:
-  NS_UNMOCK(router_get_my_routerinfo);
+  UNMOCK(router_get_my_routerinfo);
tor_free(desc);
 }
diff --git a/src/test/test_routerset.c b/src/test/test_routerset.c
index c5a453d0a..a64f7c1d1 100644
--- a/src/test/test_routerset.c
+++ b/src/test/test_routerset.c
@@ -18,17 +18,13 @@
#include "test/test.h"
-#define NS_MODULE rset
-
-#define NS_SUBMODULE new
-
 /*
  * Functional (blackbox) test to determine that each member of the routerset
  * is non-NULL
  */
static void
-NS(test_main)(void *arg)
+test_rset_new(void *arg)
 {
   routerset_t *rs;
   (void)arg;
@@ -46,15 +42,12 @@ NS(test_main)(void *arg)
     routerset_free(rs);
 }
-#undef NS_SUBMODULE
-#define NS_SUBMODULE get_countryname
-
 /*
  * Functional test to strip the braces from a "{xx}" country code string.
  */
static void
-NS(test_main)(void *arg)
+test_rset_get_countryname(void *arg)
 {
   const char *input;
   char *name;
@@ -91,257 +84,264 @@ NS(test_main)(void *arg)
     tor_free(name);
 }
-#undef NS_SUBMODULE
-#define NS_SUBMODULE ASPECT(refresh, geoip_not_loaded)
-
 /*
  * Structural (whitebox) test for routerset_refresh_counties, when the GeoIP DB
  * is not loaded.
  */
-NS_DECL(int, geoip_is_loaded, (sa_family_t family));
-NS_DECL(int, geoip_get_n_countries, (void));
+static int rset_refresh_geoip_not_loaded_geoip_is_loaded(sa_family_t family);
+ATTR_UNUSED static int rset_refresh_geoip_not_loaded_geoip_is_loaded_called = 0;
+static int rset_refresh_geoip_not_loaded_geoip_get_n_countries(void);
+ATTR_UNUSED static int rset_refresh_geoip_not_loaded_geoip_get_n_countries_called = 0;
static void
-NS(test_main)(void *arg)
+test_rset_refresh_geoip_not_loaded(void *arg)
 {
   routerset_t *set = routerset_new();
   (void)arg;
-  NS_MOCK(geoip_is_loaded);
-  NS_MOCK(geoip_get_n_countries);
+  MOCK(geoip_is_loaded,
+       rset_refresh_geoip_not_loaded_geoip_is_loaded);
+  MOCK(geoip_get_n_countries,
+       rset_refresh_geoip_not_loaded_geoip_get_n_countries);
routerset_refresh_countries(set);
tt_ptr_op(set->countries, OP_EQ, NULL);
   tt_int_op(set->n_countries, OP_EQ, 0);
-  tt_int_op(CALLED(geoip_is_loaded), OP_EQ, 1);
-  tt_int_op(CALLED(geoip_get_n_countries), OP_EQ, 0);
+  tt_int_op(rset_refresh_geoip_not_loaded_geoip_is_loaded_called, OP_EQ, 1);
+  tt_int_op(rset_refresh_geoip_not_loaded_geoip_get_n_countries_called, OP_EQ, 0);
done:
-    NS_UNMOCK(geoip_is_loaded);
-    NS_UNMOCK(geoip_get_n_countries);
+    UNMOCK(geoip_is_loaded);
+    UNMOCK(geoip_get_n_countries);
     routerset_free(set);
 }
static int
-NS(geoip_is_loaded)(sa_family_t family)
+rset_refresh_geoip_not_loaded_geoip_is_loaded(sa_family_t family)
 {
   (void)family;
-  CALLED(geoip_is_loaded)++;
+  rset_refresh_geoip_not_loaded_geoip_is_loaded_called++;
return 0;
 }
static int
-NS(geoip_get_n_countries)(void)
+rset_refresh_geoip_not_loaded_geoip_get_n_countries(void)
 {
-  CALLED(geoip_get_n_countries)++;
+  rset_refresh_geoip_not_loaded_geoip_get_n_countries_called++;
return 0;
 }
-#undef NS_SUBMODULE
-#define NS_SUBMODULE ASPECT(refresh, no_countries)
-
 /*
  * Structural test for routerset_refresh_counties, when there are no countries.
  */
-NS_DECL(int, geoip_is_loaded, (sa_family_t family));
-NS_DECL(int, geoip_get_n_countries, (void));
-NS_DECL(country_t, geoip_get_country, (const char *country));
+static int rset_refresh_no_countries_geoip_is_loaded(sa_family_t family);
+ATTR_UNUSED static int rset_refresh_no_countries_geoip_is_loaded_called = 0;
+static int rset_refresh_no_countries_geoip_get_n_countries(void);
+ATTR_UNUSED static int rset_refresh_no_countries_geoip_get_n_countries_called = 0;
+static country_t rset_refresh_no_countries_geoip_get_country(const char *country);
+ATTR_UNUSED static int rset_refresh_no_countries_geoip_get_country_called = 0;
static void
-NS(test_main)(void *arg)
+test_rset_refresh_no_countries(void *arg)
 {
   routerset_t *set = routerset_new();
   (void)arg;
-  NS_MOCK(geoip_is_loaded);
-  NS_MOCK(geoip_get_n_countries);
-  NS_MOCK(geoip_get_country);
+  MOCK(geoip_is_loaded,
+       rset_refresh_no_countries_geoip_is_loaded);
+  MOCK(geoip_get_n_countries,
+       rset_refresh_no_countries_geoip_get_n_countries);
+  MOCK(geoip_get_country,
+       rset_refresh_no_countries_geoip_get_country);
routerset_refresh_countries(set);
tt_ptr_op(set->countries, OP_NE, NULL);
   tt_int_op(set->n_countries, OP_EQ, 1);
   tt_int_op((unsigned int)(*set->countries), OP_EQ, 0);
-  tt_int_op(CALLED(geoip_is_loaded), OP_EQ, 1);
-  tt_int_op(CALLED(geoip_get_n_countries), OP_EQ, 1);
-  tt_int_op(CALLED(geoip_get_country), OP_EQ, 0);
+  tt_int_op(rset_refresh_no_countries_geoip_is_loaded_called, OP_EQ, 1);
+  tt_int_op(rset_refresh_no_countries_geoip_get_n_countries_called, OP_EQ, 1);
+  tt_int_op(rset_refresh_no_countries_geoip_get_country_called, OP_EQ, 0);
done:
-    NS_UNMOCK(geoip_is_loaded);
-    NS_UNMOCK(geoip_get_n_countries);
-    NS_UNMOCK(geoip_get_country);
+    UNMOCK(geoip_is_loaded);
+    UNMOCK(geoip_get_n_countries);
+    UNMOCK(geoip_get_country);
     routerset_free(set);
 }
static int
-NS(geoip_is_loaded)(sa_family_t family)
+rset_refresh_no_countries_geoip_is_loaded(sa_family_t family)
 {
   (void)family;
-  CALLED(geoip_is_loaded)++;
+  rset_refresh_no_countries_geoip_is_loaded_called++;
return 1;
 }
static int
-NS(geoip_get_n_countries)(void)
+rset_refresh_no_countries_geoip_get_n_countries(void)
 {
-  CALLED(geoip_get_n_countries)++;
+  rset_refresh_no_countries_geoip_get_n_countries_called++;
return 1;
 }
static country_t
-NS(geoip_get_country)(const char *countrycode)
+rset_refresh_no_countries_geoip_get_country(const char *countrycode)
 {
   (void)countrycode;
-  CALLED(geoip_get_country)++;
+  rset_refresh_no_countries_geoip_get_country_called++;
return 1;
 }
-#undef NS_SUBMODULE
-#define NS_SUBMODULE ASPECT(refresh, one_valid_country)
-
 /*
  * Structural test for routerset_refresh_counties, with one valid country.
  */
-NS_DECL(int, geoip_is_loaded, (sa_family_t family));
-NS_DECL(int, geoip_get_n_countries, (void));
-NS_DECL(country_t, geoip_get_country, (const char *country));
+static int rset_refresh_one_valid_country_geoip_is_loaded(sa_family_t family);
+ATTR_UNUSED static int rset_refresh_one_valid_country_geoip_is_loaded_called = 0;
+static int rset_refresh_one_valid_country_geoip_get_n_countries(void);
+ATTR_UNUSED static int rset_refresh_one_valid_country_geoip_get_n_countries_called = 0;
+static country_t rset_refresh_one_valid_country_geoip_get_country(const char *country);
+ATTR_UNUSED static int rset_refresh_one_valid_country_geoip_get_country_called = 0;
static void
-NS(test_main)(void *arg)
+test_rset_refresh_one_valid_country(void *arg)
 {
   routerset_t *set = routerset_new();
   (void)arg;
-  NS_MOCK(geoip_is_loaded);
-  NS_MOCK(geoip_get_n_countries);
-  NS_MOCK(geoip_get_country);
+  MOCK(geoip_is_loaded,
+       rset_refresh_one_valid_country_geoip_is_loaded);
+  MOCK(geoip_get_n_countries,
+       rset_refresh_one_valid_country_geoip_get_n_countries);
+  MOCK(geoip_get_country,
+       rset_refresh_one_valid_country_geoip_get_country);
   smartlist_add(set->country_names, tor_strndup("foo", 3));
routerset_refresh_countries(set);
tt_ptr_op(set->countries, OP_NE, NULL);
   tt_int_op(set->n_countries, OP_EQ, 2);
-  tt_int_op(CALLED(geoip_is_loaded), OP_EQ, 1);
-  tt_int_op(CALLED(geoip_get_n_countries), OP_EQ, 1);
-  tt_int_op(CALLED(geoip_get_country), OP_EQ, 1);
+  tt_int_op(rset_refresh_one_valid_country_geoip_is_loaded_called, OP_EQ, 1);
+  tt_int_op(rset_refresh_one_valid_country_geoip_get_n_countries_called, OP_EQ, 1);
+  tt_int_op(rset_refresh_one_valid_country_geoip_get_country_called, OP_EQ, 1);
   tt_int_op((unsigned int)(*set->countries), OP_NE, 0);
done:
-    NS_UNMOCK(geoip_is_loaded);
-    NS_UNMOCK(geoip_get_n_countries);
-    NS_UNMOCK(geoip_get_country);
+    UNMOCK(geoip_is_loaded);
+    UNMOCK(geoip_get_n_countries);
+    UNMOCK(geoip_get_country);
     routerset_free(set);
 }
static int
-NS(geoip_is_loaded)(sa_family_t family)
+rset_refresh_one_valid_country_geoip_is_loaded(sa_family_t family)
 {
   (void)family;
-  CALLED(geoip_is_loaded)++;
+  rset_refresh_one_valid_country_geoip_is_loaded_called++;
return 1;
 }
static int
-NS(geoip_get_n_countries)(void)
+rset_refresh_one_valid_country_geoip_get_n_countries(void)
 {
-  CALLED(geoip_get_n_countries)++;
+  rset_refresh_one_valid_country_geoip_get_n_countries_called++;
return 2;
 }
static country_t
-NS(geoip_get_country)(const char *countrycode)
+rset_refresh_one_valid_country_geoip_get_country(const char *countrycode)
 {
   (void)countrycode;
-  CALLED(geoip_get_country)++;
+  rset_refresh_one_valid_country_geoip_get_country_called++;
return 1;
 }
-#undef NS_SUBMODULE
-#define NS_SUBMODULE ASPECT(refresh, one_invalid_country)
-
 /*
  * Structural test for routerset_refresh_counties, with one invalid
  * country code..
  */
-NS_DECL(int, geoip_is_loaded, (sa_family_t family));
-NS_DECL(int, geoip_get_n_countries, (void));
-NS_DECL(country_t, geoip_get_country, (const char *country));
+static int rset_refresh_one_invalid_country_geoip_is_loaded(sa_family_t family);
+ATTR_UNUSED static int rset_refresh_one_invalid_country_geoip_is_loaded_called = 0;
+static int rset_refresh_one_invalid_country_geoip_get_n_countries(void);
+ATTR_UNUSED static int rset_refresh_one_invalid_country_geoip_get_n_countries_called = 0;
+static country_t rset_refresh_one_invalid_country_geoip_get_country(const char *country);
+ATTR_UNUSED static int rset_refresh_one_invalid_country_geoip_get_country_called = 0;
static void
-NS(test_main)(void *arg)
+test_rset_refresh_one_invalid_country(void *arg)
 {
   routerset_t *set = routerset_new();
   (void)arg;
-  NS_MOCK(geoip_is_loaded);
-  NS_MOCK(geoip_get_n_countries);
-  NS_MOCK(geoip_get_country);
+  MOCK(geoip_is_loaded,
+       rset_refresh_one_invalid_country_geoip_is_loaded);
+  MOCK(geoip_get_n_countries,
+       rset_refresh_one_invalid_country_geoip_get_n_countries);
+  MOCK(geoip_get_country,
+       rset_refresh_one_invalid_country_geoip_get_country);
   smartlist_add(set->country_names, tor_strndup("foo", 3));
routerset_refresh_countries(set);
tt_ptr_op(set->countries, OP_NE, NULL);
   tt_int_op(set->n_countries, OP_EQ, 2);
-  tt_int_op(CALLED(geoip_is_loaded), OP_EQ, 1);
-  tt_int_op(CALLED(geoip_get_n_countries), OP_EQ, 1);
-  tt_int_op(CALLED(geoip_get_country), OP_EQ, 1);
+  tt_int_op(rset_refresh_one_invalid_country_geoip_is_loaded_called, OP_EQ, 1);
+  tt_int_op(rset_refresh_one_invalid_country_geoip_get_n_countries_called, OP_EQ, 1);
+  tt_int_op(rset_refresh_one_invalid_country_geoip_get_country_called, OP_EQ, 1);
   tt_int_op((unsigned int)(*set->countries), OP_EQ, 0);
done:
-    NS_UNMOCK(geoip_is_loaded);
-    NS_UNMOCK(geoip_get_n_countries);
-    NS_UNMOCK(geoip_get_country);
+    UNMOCK(geoip_is_loaded);
+    UNMOCK(geoip_get_n_countries);
+    UNMOCK(geoip_get_country);
     routerset_free(set);
 }
static int
-NS(geoip_is_loaded)(sa_family_t family)
+rset_refresh_one_invalid_country_geoip_is_loaded(sa_family_t family)
 {
   (void)family;
-  CALLED(geoip_is_loaded)++;
+  rset_refresh_one_invalid_country_geoip_is_loaded_called++;
return 1;
 }
static int
-NS(geoip_get_n_countries)(void)
+rset_refresh_one_invalid_country_geoip_get_n_countries(void)
 {
-  CALLED(geoip_get_n_countries)++;
+  rset_refresh_one_invalid_country_geoip_get_n_countries_called++;
return 2;
 }
static country_t
-NS(geoip_get_country)(const char *countrycode)
+rset_refresh_one_invalid_country_geoip_get_country(const char *countrycode)
 {
   (void)countrycode;
-  CALLED(geoip_get_country)++;
+  rset_refresh_one_invalid_country_geoip_get_country_called++;
return -1;
 }
-#undef NS_SUBMODULE
-#define NS_SUBMODULE ASPECT(parse, malformed)
-
 /*
  * Functional test, with a malformed string to parse.
  */
static void
-NS(test_main)(void *arg)
+test_rset_parse_malformed(void *arg)
 {
   routerset_t *set = routerset_new();
   const char *s = "_";
@@ -356,16 +356,13 @@ NS(test_main)(void *arg)
     routerset_free(set);
 }
-#undef NS_SUBMODULE
-#define NS_SUBMODULE ASPECT(parse, valid_hexdigest)
-
 /*
  * Functional test for routerset_parse, that routerset_parse returns 0
  * on a valid hexdigest entry.
  */
static void
-NS(test_main)(void *arg)
+test_rset_parse_valid_hexdigest(void *arg)
 {
   routerset_t *set;
   const char *s;
@@ -382,15 +379,12 @@ NS(test_main)(void *arg)
     routerset_free(set);
 }
-#undef NS_SUBMODULE
-#define NS_SUBMODULE ASPECT(parse, valid_nickname)
-
 /*
  * Functional test for routerset_parse, when given a valid nickname as input.
  */
static void
-NS(test_main)(void *arg)
+test_rset_parse_valid_nickname(void *arg)
 {
   routerset_t *set;
   const char *s;
@@ -407,15 +401,12 @@ NS(test_main)(void *arg)
     routerset_free(set);
 }
-#undef NS_SUBMODULE
-#define NS_SUBMODULE ASPECT(parse, get_countryname)
-
 /*
  * Functional test for routerset_parse, when given a valid countryname.
  */
static void
-NS(test_main)(void *arg)
+test_rset_parse_get_countryname(void *arg)
 {
   routerset_t *set;
   const char *s;
@@ -432,155 +423,150 @@ NS(test_main)(void *arg)
     routerset_free(set);
 }
-#undef NS_SUBMODULE
-#define NS_SUBMODULE ASPECT(parse, policy_wildcard)
-
 /*
  * Structural test for routerset_parse, when given a valid wildcard policy.
  */
-NS_DECL(addr_policy_t *, router_parse_addr_policy_item_from_string, (const char *s, int assume_action, int *malformed_list));
+static addr_policy_t * rset_parse_policy_wildcard_router_parse_addr_policy_item_from_string(const char *s, int assume_action, int *malformed_list);
+ATTR_UNUSED static int rset_parse_policy_wildcard_router_parse_addr_policy_item_from_string_called = 0;
-static addr_policy_t *NS(mock_addr_policy);
+static addr_policy_t *rset_parse_policy_wildcard_mock_addr_policy;
static void
-NS(test_main)(void *arg)
+test_rset_parse_policy_wildcard(void *arg)
 {
   routerset_t *set;
   const char *s;
   int r;
   (void)arg;
-  NS_MOCK(router_parse_addr_policy_item_from_string);
-  NS(mock_addr_policy) = tor_malloc_zero(sizeof(addr_policy_t));
+  MOCK(router_parse_addr_policy_item_from_string,
+       rset_parse_policy_wildcard_router_parse_addr_policy_item_from_string);
+  rset_parse_policy_wildcard_mock_addr_policy = tor_malloc_zero(sizeof(addr_policy_t));
set = routerset_new();
   s = "*";
   r = routerset_parse(set, s, "");
   tt_int_op(r, OP_EQ, 0);
   tt_int_op(smartlist_len(set->policies), OP_NE, 0);
-  tt_int_op(CALLED(router_parse_addr_policy_item_from_string), OP_EQ, 1);
+  tt_int_op(rset_parse_policy_wildcard_router_parse_addr_policy_item_from_string_called, OP_EQ, 1);
done:
     routerset_free(set);
 }
addr_policy_t *
-NS(router_parse_addr_policy_item_from_string)(const char *s,
+rset_parse_policy_wildcard_router_parse_addr_policy_item_from_string(const char *s,
                                               int assume_action,
                                               int *malformed_list)
 {
   (void)s;
   (void)assume_action;
   (void)malformed_list;
-  CALLED(router_parse_addr_policy_item_from_string)++;
+  rset_parse_policy_wildcard_router_parse_addr_policy_item_from_string_called++;
-  return NS(mock_addr_policy);
+  return rset_parse_policy_wildcard_mock_addr_policy;
 }
-#undef NS_SUBMODULE
-#define NS_SUBMODULE ASPECT(parse, policy_ipv4)
-
 /*
  * Structural test for routerset_parse, when given a valid IPv4 address
  * literal policy.
  */
-NS_DECL(addr_policy_t *, router_parse_addr_policy_item_from_string, (const char *s, int assume_action, int *bogus));
+static addr_policy_t * rset_parse_policy_ipv4_router_parse_addr_policy_item_from_string(const char *s, int assume_action, int *bogus);
+ATTR_UNUSED static int rset_parse_policy_ipv4_router_parse_addr_policy_item_from_string_called = 0;
-static addr_policy_t *NS(mock_addr_policy);
+static addr_policy_t *rset_parse_policy_ipv4_mock_addr_policy;
static void
-NS(test_main)(void *arg)
+test_rset_parse_policy_ipv4(void *arg)
 {
   routerset_t *set;
   const char *s;
   int r;
   (void)arg;
-  NS_MOCK(router_parse_addr_policy_item_from_string);
-  NS(mock_addr_policy) = tor_malloc_zero(sizeof(addr_policy_t));
+  MOCK(router_parse_addr_policy_item_from_string,
+       rset_parse_policy_ipv4_router_parse_addr_policy_item_from_string);
+  rset_parse_policy_ipv4_mock_addr_policy = tor_malloc_zero(sizeof(addr_policy_t));
set = routerset_new();
   s = "127.0.0.1";
   r = routerset_parse(set, s, "");
   tt_int_op(r, OP_EQ, 0);
   tt_int_op(smartlist_len(set->policies), OP_NE, 0);
-  tt_int_op(CALLED(router_parse_addr_policy_item_from_string), OP_EQ, 1);
+  tt_int_op(rset_parse_policy_ipv4_router_parse_addr_policy_item_from_string_called, OP_EQ, 1);
done:
   routerset_free(set);
 }
addr_policy_t *
-NS(router_parse_addr_policy_item_from_string)(const char *s, int assume_action,
+rset_parse_policy_ipv4_router_parse_addr_policy_item_from_string(const char *s, int assume_action,
                                               int *bogus)
 {
   (void)s;
   (void)assume_action;
-  CALLED(router_parse_addr_policy_item_from_string)++;
+  rset_parse_policy_ipv4_router_parse_addr_policy_item_from_string_called++;
   *bogus = 0;
-  return NS(mock_addr_policy);
+  return rset_parse_policy_ipv4_mock_addr_policy;
 }
-#undef NS_SUBMODULE
-#define NS_SUBMODULE ASPECT(parse, policy_ipv6)
-
 /*
  * Structural test for routerset_parse, when given a valid IPv6 address
  * literal policy.
  */
-NS_DECL(addr_policy_t *, router_parse_addr_policy_item_from_string, (const char *s, int assume_action, int *bad));
+static addr_policy_t * rset_parse_policy_ipv6_router_parse_addr_policy_item_from_string(const char *s, int assume_action, int *bad);
+ATTR_UNUSED static int rset_parse_policy_ipv6_router_parse_addr_policy_item_from_string_called = 0;
-static addr_policy_t *NS(mock_addr_policy);
+static addr_policy_t *rset_parse_policy_ipv6_mock_addr_policy;
static void
-NS(test_main)(void *arg)
+test_rset_parse_policy_ipv6(void *arg)
 {
   routerset_t *set;
   const char *s;
   int r;
   (void)arg;
-  NS_MOCK(router_parse_addr_policy_item_from_string);
-  NS(mock_addr_policy) = tor_malloc_zero(sizeof(addr_policy_t));
+  MOCK(router_parse_addr_policy_item_from_string,
+       rset_parse_policy_ipv6_router_parse_addr_policy_item_from_string);
+  rset_parse_policy_ipv6_mock_addr_policy = tor_malloc_zero(sizeof(addr_policy_t));
set = routerset_new();
   s = "::1";
   r = routerset_parse(set, s, "");
   tt_int_op(r, OP_EQ, 0);
   tt_int_op(smartlist_len(set->policies), OP_NE, 0);
-  tt_int_op(CALLED(router_parse_addr_policy_item_from_string), OP_EQ, 1);
+  tt_int_op(rset_parse_policy_ipv6_router_parse_addr_policy_item_from_string_called, OP_EQ, 1);
done:
   routerset_free(set);
 }
addr_policy_t *
-NS(router_parse_addr_policy_item_from_string)(const char *s,
+rset_parse_policy_ipv6_router_parse_addr_policy_item_from_string(const char *s,
                                               int assume_action, int *bad)
 {
   (void)s;
   (void)assume_action;
-  CALLED(router_parse_addr_policy_item_from_string)++;
+  rset_parse_policy_ipv6_router_parse_addr_policy_item_from_string_called++;
   *bad = 0;
-  return NS(mock_addr_policy);
+  return rset_parse_policy_ipv6_mock_addr_policy;
 }
-#undef NS_SUBMODULE
-#define NS_SUBMODULE ASPECT(union, source_bad)
-
 /*
  * Structural test for routerset_union, when given a bad source argument.
  */
-NS_DECL(smartlist_t *, smartlist_new, (void));
+static smartlist_t * rset_union_source_bad_smartlist_new(void);
+ATTR_UNUSED static int rset_union_source_bad_smartlist_new_called = 0;
static void
-NS(test_main)(void *arg)
+test_rset_union_source_bad(void *arg)
 {
   routerset_t *set, *bad_set;
   (void)arg;
@@ -590,16 +576,17 @@ NS(test_main)(void *arg)
   smartlist_free(bad_set->list);
   bad_set->list = NULL;
-  NS_MOCK(smartlist_new);
+  MOCK(smartlist_new,
+       rset_union_source_bad_smartlist_new);
routerset_union(set, NULL);
-  tt_int_op(CALLED(smartlist_new), OP_EQ, 0);
+  tt_int_op(rset_union_source_bad_smartlist_new_called, OP_EQ, 0);
routerset_union(set, bad_set);
-  tt_int_op(CALLED(smartlist_new), OP_EQ, 0);
+  tt_int_op(rset_union_source_bad_smartlist_new_called, OP_EQ, 0);
done:
-    NS_UNMOCK(smartlist_new);
+    UNMOCK(smartlist_new);
     routerset_free(set);
/* Just recreate list, so we can simply use routerset_free. */
@@ -608,22 +595,19 @@ NS(test_main)(void *arg)
 }
static smartlist_t *
-NS(smartlist_new)(void)
+rset_union_source_bad_smartlist_new(void)
 {
-  CALLED(smartlist_new)++;
+  rset_union_source_bad_smartlist_new_called++;
return NULL;
 }
-#undef NS_SUBMODULE
-#define NS_SUBMODULE ASPECT(union, one)
-
 /*
  * Functional test for routerset_union.
  */
static void
-NS(test_main)(void *arg)
+test_rset_union_one(void *arg)
 {
   routerset_t *src = routerset_new();
   routerset_t *tgt;
@@ -640,15 +624,12 @@ NS(test_main)(void *arg)
     routerset_free(tgt);
 }
-#undef NS_SUBMODULE
-#define NS_SUBMODULE is_list
-
 /*
  * Functional tests for routerset_is_list.
  */
static void
-NS(test_main)(void *arg)
+test_rset_is_list(void *arg)
 {
   routerset_t *set;
   addr_policy_t *policy;
@@ -693,15 +674,12 @@ NS(test_main)(void *arg)
     ;
 }
-#undef NS_SUBMODULE
-#define NS_SUBMODULE needs_geoip
-
 /*
  * Functional tests for routerset_needs_geoip.
  */
static void
-NS(test_main)(void *arg)
+test_rset_needs_geoip(void *arg)
 {
   routerset_t *set;
   int needs_geoip;
@@ -728,15 +706,12 @@ NS(test_main)(void *arg)
     ;
 }
-#undef NS_SUBMODULE
-#define NS_SUBMODULE is_empty
-
 /*
  * Functional tests for routerset_is_empty.
  */
static void
-NS(test_main)(void *arg)
+test_rset_is_empty(void *arg)
 {
   routerset_t *set = NULL;
   int is_empty;
@@ -762,16 +737,13 @@ NS(test_main)(void *arg)
     ;
 }
-#undef NS_SUBMODULE
-#define NS_SUBMODULE ASPECT(contains, null_set_or_list)
-
 /*
  * Functional test for routerset_contains, when given a NULL set or the
  * set has a NULL list.
  */
static void
-NS(test_main)(void *arg)
+test_rset_contains_null_set_or_list(void *arg)
 {
   routerset_t *set = NULL;
   int contains;
@@ -791,16 +763,13 @@ NS(test_main)(void *arg)
     ;
 }
-#undef NS_SUBMODULE
-#define NS_SUBMODULE ASPECT(contains, null_nickname)
-
 /*
  * Functional test for routerset_contains, when given a valid routerset but a
  * NULL nickname.
  */
static void
-NS(test_main)(void *arg)
+test_rset_contains_null_nickname(void *arg)
 {
   routerset_t *set = routerset_new();
   char *nickname = NULL;
@@ -816,16 +785,13 @@ NS(test_main)(void *arg)
     ;
 }
-#undef NS_SUBMODULE
-#define NS_SUBMODULE ASPECT(contains, nickname)
-
 /*
  * Functional test for routerset_contains, when given a valid routerset
  * and the nickname is in the routerset.
  */
static void
-NS(test_main)(void *arg)
+test_rset_contains_nickname(void *arg)
 {
   routerset_t *set = routerset_new();
   const char *nickname;
@@ -842,16 +808,13 @@ NS(test_main)(void *arg)
     ;
 }
-#undef NS_SUBMODULE
-#define NS_SUBMODULE ASPECT(contains, no_nickname)
-
 /*
  * Functional test for routerset_contains, when given a valid routerset
  * and the nickname is not in the routerset.
  */
static void
-NS(test_main)(void *arg)
+test_rset_contains_no_nickname(void *arg)
 {
   routerset_t *set = routerset_new();
   int contains;
@@ -866,16 +829,13 @@ NS(test_main)(void *arg)
     ;
 }
-#undef NS_SUBMODULE
-#define NS_SUBMODULE ASPECT(contains, digest)
-
 /*
  * Functional test for routerset_contains, when given a valid routerset
  * and the digest is contained in the routerset.
  */
static void
-NS(test_main)(void *arg)
+test_rset_contains_digest(void *arg)
 {
   routerset_t *set = routerset_new();
   int contains;
@@ -891,16 +851,13 @@ NS(test_main)(void *arg)
     ;
 }
-#undef NS_SUBMODULE
-#define NS_SUBMODULE ASPECT(contains, no_digest)
-
 /*
  * Functional test for routerset_contains, when given a valid routerset
  * and the digest is not contained in the routerset.
  */
static void
-NS(test_main)(void *arg)
+test_rset_contains_no_digest(void *arg)
 {
   routerset_t *set = routerset_new();
   int contains;
@@ -917,16 +874,13 @@ NS(test_main)(void *arg)
     ;
 }
-#undef NS_SUBMODULE
-#define NS_SUBMODULE ASPECT(contains, null_digest)
-
 /*
  * Functional test for routerset_contains, when given a valid routerset
  * and the digest is NULL.
  */
static void
-NS(test_main)(void *arg)
+test_rset_contains_null_digest(void *arg)
 {
   routerset_t *set = routerset_new();
   int contains;
@@ -942,33 +896,32 @@ NS(test_main)(void *arg)
     ;
 }
-#undef NS_SUBMODULE
-#define NS_SUBMODULE ASPECT(contains, addr)
-
 /*
  * Structural test for routerset_contains, when given a valid routerset
  * and the address is rejected by policy.
  */
-NS_DECL(addr_policy_result_t, compare_tor_addr_to_addr_policy, (const tor_addr_t *addr, uint16_t port, const smartlist_t *policy));
+static addr_policy_result_t rset_contains_addr_compare_tor_addr_to_addr_policy(const tor_addr_t *addr, uint16_t port, const smartlist_t *policy);
+ATTR_UNUSED static int rset_contains_addr_compare_tor_addr_to_addr_policy_called = 0;
static tor_addr_t MOCK_TOR_ADDR;
 #define MOCK_TOR_ADDR_PTR (&MOCK_TOR_ADDR)
static void
-NS(test_main)(void *arg)
+test_rset_contains_addr(void *arg)
 {
   routerset_t *set = routerset_new();
   tor_addr_t *addr = MOCK_TOR_ADDR_PTR;
   int contains;
   (void)arg;
-  NS_MOCK(compare_tor_addr_to_addr_policy);
+  MOCK(compare_tor_addr_to_addr_policy,
+       rset_contains_addr_compare_tor_addr_to_addr_policy);
contains = routerset_contains(set, addr, 0, NULL, NULL, 0);
   routerset_free(set);
-  tt_int_op(CALLED(compare_tor_addr_to_addr_policy), OP_EQ, 1);
+  tt_int_op(rset_contains_addr_compare_tor_addr_to_addr_policy_called, OP_EQ, 1);
   tt_int_op(contains, OP_EQ, 3);
done:
@@ -976,12 +929,12 @@ NS(test_main)(void *arg)
 }
addr_policy_result_t
-NS(compare_tor_addr_to_addr_policy)(const tor_addr_t *addr, uint16_t port,
+rset_contains_addr_compare_tor_addr_to_addr_policy(const tor_addr_t *addr, uint16_t port,
     const smartlist_t *policy)
 {
   (void)port;
   (void)policy;
-  CALLED(compare_tor_addr_to_addr_policy)++;
+  rset_contains_addr_compare_tor_addr_to_addr_policy_called++;
   tt_ptr_op(addr, OP_EQ, MOCK_TOR_ADDR_PTR);
   return ADDR_POLICY_REJECTED;
@@ -989,30 +942,29 @@ NS(compare_tor_addr_to_addr_policy)(const tor_addr_t *addr, uint16_t port,
     return 0;
 }
-#undef NS_SUBMODULE
-#define NS_SUBMODULE ASPECT(contains, no_addr)
-
 /*
  * Structural test for routerset_contains, when given a valid routerset
  * and the address is not rejected by policy.
  */
-NS_DECL(addr_policy_result_t, compare_tor_addr_to_addr_policy, (const tor_addr_t *addr, uint16_t port, const smartlist_t *policy));
+static addr_policy_result_t rset_contains_no_addr_compare_tor_addr_to_addr_policy(const tor_addr_t *addr, uint16_t port, const smartlist_t *policy);
+ATTR_UNUSED static int rset_contains_no_addr_compare_tor_addr_to_addr_policy_called = 0;
static void
-NS(test_main)(void *arg)
+test_rset_contains_no_addr(void *arg)
 {
   routerset_t *set = routerset_new();
   tor_addr_t *addr = MOCK_TOR_ADDR_PTR;
   int contains;
   (void)arg;
-  NS_MOCK(compare_tor_addr_to_addr_policy);
+  MOCK(compare_tor_addr_to_addr_policy,
+       rset_contains_no_addr_compare_tor_addr_to_addr_policy);
contains = routerset_contains(set, addr, 0, NULL, NULL, 0);
   routerset_free(set);
-  tt_int_op(CALLED(compare_tor_addr_to_addr_policy), OP_EQ, 1);
+  tt_int_op(rset_contains_no_addr_compare_tor_addr_to_addr_policy_called, OP_EQ, 1);
   tt_int_op(contains, OP_EQ, 0);
done:
@@ -1020,12 +972,12 @@ NS(test_main)(void *arg)
 }
addr_policy_result_t
-NS(compare_tor_addr_to_addr_policy)(const tor_addr_t *addr, uint16_t port,
+rset_contains_no_addr_compare_tor_addr_to_addr_policy(const tor_addr_t *addr, uint16_t port,
     const smartlist_t *policy)
 {
   (void)port;
   (void)policy;
-  CALLED(compare_tor_addr_to_addr_policy)++;
+  rset_contains_no_addr_compare_tor_addr_to_addr_policy_called++;
   tt_ptr_op(addr, OP_EQ, MOCK_TOR_ADDR_PTR);
return ADDR_POLICY_ACCEPTED;
@@ -1034,24 +986,23 @@ NS(compare_tor_addr_to_addr_policy)(const tor_addr_t *addr, uint16_t port,
       return 0;
 }
-#undef NS_SUBMODULE
-#define NS_SUBMODULE ASPECT(contains, null_addr)
-
 /*
  * Structural test for routerset_contains, when given a valid routerset
  * and the address is NULL.
  */
-NS_DECL(addr_policy_result_t, compare_tor_addr_to_addr_policy, (const tor_addr_t *addr, uint16_t port, const smartlist_t *policy));
+static addr_policy_result_t rset_contains_null_addr_compare_tor_addr_to_addr_policy(const tor_addr_t *addr, uint16_t port, const smartlist_t *policy);
+ATTR_UNUSED static int rset_contains_null_addr_compare_tor_addr_to_addr_policy_called = 0;
static void
-NS(test_main)(void *arg)
+test_rset_contains_null_addr(void *arg)
 {
   routerset_t *set = routerset_new();
   int contains;
   (void)arg;
-  NS_MOCK(compare_tor_addr_to_addr_policy);
+  MOCK(compare_tor_addr_to_addr_policy,
+       rset_contains_null_addr_compare_tor_addr_to_addr_policy);
contains = routerset_contains(set, NULL, 0, NULL, NULL, 0);
   routerset_free(set);
@@ -1063,12 +1014,12 @@ NS(test_main)(void *arg)
 }
addr_policy_result_t
-NS(compare_tor_addr_to_addr_policy)(const tor_addr_t *addr, uint16_t port,
+rset_contains_null_addr_compare_tor_addr_to_addr_policy(const tor_addr_t *addr, uint16_t port,
     const smartlist_t *policy)
 {
   (void)port;
   (void)policy;
-  CALLED(compare_tor_addr_to_addr_policy)++;
+  rset_contains_null_addr_compare_tor_addr_to_addr_policy_called++;
   tt_ptr_op(addr, OP_EQ, MOCK_TOR_ADDR_PTR);
return ADDR_POLICY_ACCEPTED;
@@ -1077,26 +1028,27 @@ NS(compare_tor_addr_to_addr_policy)(const tor_addr_t *addr, uint16_t port,
     return 0;
 }
-#undef NS_SUBMODULE
-#define NS_SUBMODULE ASPECT(contains, countries_no_geoip)
-
 /*
  * Structural test for routerset_contains, when there is no matching country
  * for the address.
  */
-NS_DECL(addr_policy_result_t, compare_tor_addr_to_addr_policy, (const tor_addr_t *addr, uint16_t port, const smartlist_t *policy));
-NS_DECL(int, geoip_get_country_by_addr, (const tor_addr_t *addr));
+static addr_policy_result_t rset_contains_countries_no_geoip_compare_tor_addr_to_addr_policy(const tor_addr_t *addr, uint16_t port, const smartlist_t *policy);
+ATTR_UNUSED static int rset_contains_countries_no_geoip_compare_tor_addr_to_addr_policy_called = 0;
+static int rset_contains_countries_no_geoip_geoip_get_country_by_addr(const tor_addr_t *addr);
+ATTR_UNUSED static int rset_contains_countries_no_geoip_geoip_get_country_by_addr_called = 0;
static void
-NS(test_main)(void *arg)
+test_rset_contains_countries_no_geoip(void *arg)
 {
   routerset_t *set = routerset_new();
   int contains = 1;
   (void)arg;
-  NS_MOCK(compare_tor_addr_to_addr_policy);
-  NS_MOCK(geoip_get_country_by_addr);
+  MOCK(compare_tor_addr_to_addr_policy,
+       rset_contains_countries_no_geoip_compare_tor_addr_to_addr_policy);
+  MOCK(geoip_get_country_by_addr,
+       rset_contains_countries_no_geoip_geoip_get_country_by_addr);
set->countries = bitarray_init_zero(1);
   bitarray_set(set->countries, 1);
@@ -1104,20 +1056,20 @@ NS(test_main)(void *arg)
   routerset_free(set);
tt_int_op(contains, OP_EQ, 0);
-  tt_int_op(CALLED(compare_tor_addr_to_addr_policy), OP_EQ, 1);
-  tt_int_op(CALLED(geoip_get_country_by_addr), OP_EQ, 1);
+  tt_int_op(rset_contains_countries_no_geoip_compare_tor_addr_to_addr_policy_called, OP_EQ, 1);
+  tt_int_op(rset_contains_countries_no_geoip_geoip_get_country_by_addr_called, OP_EQ, 1);
done:
     ;
 }
addr_policy_result_t
-NS(compare_tor_addr_to_addr_policy)(const tor_addr_t *addr, uint16_t port,
+rset_contains_countries_no_geoip_compare_tor_addr_to_addr_policy(const tor_addr_t *addr, uint16_t port,
     const smartlist_t *policy)
 {
   (void)port;
   (void)policy;
-  CALLED(compare_tor_addr_to_addr_policy)++;
+  rset_contains_countries_no_geoip_compare_tor_addr_to_addr_policy_called++;
   tt_ptr_op(addr, OP_EQ, MOCK_TOR_ADDR_PTR);
done:
@@ -1125,35 +1077,36 @@ NS(compare_tor_addr_to_addr_policy)(const tor_addr_t *addr, uint16_t port,
 }
int
-NS(geoip_get_country_by_addr)(const tor_addr_t *addr)
+rset_contains_countries_no_geoip_geoip_get_country_by_addr(const tor_addr_t *addr)
 {
-  CALLED(geoip_get_country_by_addr)++;
+  rset_contains_countries_no_geoip_geoip_get_country_by_addr_called++;
   tt_ptr_op(addr, OP_EQ, MOCK_TOR_ADDR_PTR);
done:
     return -1;
 }
-#undef NS_SUBMODULE
-#define NS_SUBMODULE ASPECT(contains, countries_geoip)
-
 /*
  * Structural test for routerset_contains, when there a matching country
  * for the address.
  */
-NS_DECL(addr_policy_result_t, compare_tor_addr_to_addr_policy, (const tor_addr_t *addr, uint16_t port, const smartlist_t *policy));
-NS_DECL(int, geoip_get_country_by_addr, (const tor_addr_t *addr));
+static addr_policy_result_t rset_contains_countries_geoip_compare_tor_addr_to_addr_policy(const tor_addr_t *addr, uint16_t port, const smartlist_t *policy);
+ATTR_UNUSED static int rset_contains_countries_geoip_compare_tor_addr_to_addr_policy_called = 0;
+static int rset_contains_countries_geoip_geoip_get_country_by_addr(const tor_addr_t *addr);
+ATTR_UNUSED static int rset_contains_countries_geoip_geoip_get_country_by_addr_called = 0;
static void
-NS(test_main)(void *arg)
+test_rset_contains_countries_geoip(void *arg)
 {
   routerset_t *set = routerset_new();
   int contains = 1;
   (void)arg;
-  NS_MOCK(compare_tor_addr_to_addr_policy);
-  NS_MOCK(geoip_get_country_by_addr);
+  MOCK(compare_tor_addr_to_addr_policy,
+       rset_contains_countries_geoip_compare_tor_addr_to_addr_policy);
+  MOCK(geoip_get_country_by_addr,
+       rset_contains_countries_geoip_geoip_get_country_by_addr);
set->n_countries = 2;
   set->countries = bitarray_init_zero(1);
@@ -1162,20 +1115,20 @@ NS(test_main)(void *arg)
   routerset_free(set);
tt_int_op(contains, OP_EQ, 2);
-  tt_int_op(CALLED(compare_tor_addr_to_addr_policy), OP_EQ, 1);
-  tt_int_op(CALLED(geoip_get_country_by_addr), OP_EQ, 1);
+  tt_int_op(rset_contains_countries_geoip_compare_tor_addr_to_addr_policy_called, OP_EQ, 1);
+  tt_int_op(rset_contains_countries_geoip_geoip_get_country_by_addr_called, OP_EQ, 1);
done:
     ;
 }
addr_policy_result_t
-NS(compare_tor_addr_to_addr_policy)(const tor_addr_t *addr, uint16_t port,
+rset_contains_countries_geoip_compare_tor_addr_to_addr_policy(const tor_addr_t *addr, uint16_t port,
     const smartlist_t *policy)
 {
   (void)port;
   (void)policy;
-  CALLED(compare_tor_addr_to_addr_policy)++;
+  rset_contains_countries_geoip_compare_tor_addr_to_addr_policy_called++;
   tt_ptr_op(addr, OP_EQ, MOCK_TOR_ADDR_PTR);
done:
@@ -1183,25 +1136,22 @@ NS(compare_tor_addr_to_addr_policy)(const tor_addr_t *addr, uint16_t port,
 }
int
-NS(geoip_get_country_by_addr)(const tor_addr_t *addr)
+rset_contains_countries_geoip_geoip_get_country_by_addr(const tor_addr_t *addr)
 {
-  CALLED(geoip_get_country_by_addr)++;
+  rset_contains_countries_geoip_geoip_get_country_by_addr_called++;
   tt_ptr_op(addr, OP_EQ, MOCK_TOR_ADDR_PTR);
done:
     return 1;
 }
-#undef NS_SUBMODULE
-#define NS_SUBMODULE ASPECT(add_unknown_ccs, only_flag)
-
 /*
  * Functional test for routerset_add_unknown_ccs, where only_if_some_cc_set
  * is set and there are no country names.
  */
static void
-NS(test_main)(void *arg)
+test_rset_add_unknown_ccs_only_flag(void *arg)
 {
   routerset_t *set = routerset_new();
   routerset_t **setp = &set;
@@ -1216,26 +1166,25 @@ NS(test_main)(void *arg)
     routerset_free(set);
 }
-#undef NS_SUBMODULE
-#define NS_SUBMODULE ASPECT(add_unknown_ccs, creates_set)
-
 /*
  * Functional test for routerset_add_unknown_ccs, where the set argument
  * is created if passed in as NULL.
  */
/* The mock is only used to stop the test from asserting erroneously. */
-NS_DECL(country_t, geoip_get_country, (const char *country));
+static country_t rset_add_unknown_ccs_creates_set_geoip_get_country(const char *country);
+ATTR_UNUSED static int rset_add_unknown_ccs_creates_set_geoip_get_country_called = 0;
static void
-NS(test_main)(void *arg)
+test_rset_add_unknown_ccs_creates_set(void *arg)
 {
   routerset_t *set = NULL;
   routerset_t **setp = &set;
   int r;
   (void)arg;
-  NS_MOCK(geoip_get_country);
+  MOCK(geoip_get_country,
+       rset_add_unknown_ccs_creates_set_geoip_get_country);
r = routerset_add_unknown_ccs(setp, 0);
@@ -1248,35 +1197,36 @@ NS(test_main)(void *arg)
 }
country_t
-NS(geoip_get_country)(const char *country)
+rset_add_unknown_ccs_creates_set_geoip_get_country(const char *country)
 {
   (void)country;
-  CALLED(geoip_get_country)++;
+  rset_add_unknown_ccs_creates_set_geoip_get_country_called++;
return -1;
 }
-#undef NS_SUBMODULE
-#define NS_SUBMODULE ASPECT(add_unknown_ccs, add_unknown)
-
 /*
  * Structural test for routerset_add_unknown_ccs, that the "{??}"
  * country code is added to the list.
  */
-NS_DECL(country_t, geoip_get_country, (const char *country));
-NS_DECL(int, geoip_is_loaded, (sa_family_t family));
+static country_t rset_add_unknown_ccs_add_unknown_geoip_get_country(const char *country);
+ATTR_UNUSED static int rset_add_unknown_ccs_add_unknown_geoip_get_country_called = 0;
+static int rset_add_unknown_ccs_add_unknown_geoip_is_loaded(sa_family_t family);
+ATTR_UNUSED static int rset_add_unknown_ccs_add_unknown_geoip_is_loaded_called = 0;
static void
-NS(test_main)(void *arg)
+test_rset_add_unknown_ccs_add_unknown(void *arg)
 {
   routerset_t *set = routerset_new();
   routerset_t **setp = &set;
   int r;
   (void)arg;
-  NS_MOCK(geoip_get_country);
-  NS_MOCK(geoip_is_loaded);
+  MOCK(geoip_get_country,
+       rset_add_unknown_ccs_add_unknown_geoip_get_country);
+  MOCK(geoip_is_loaded,
+       rset_add_unknown_ccs_add_unknown_geoip_is_loaded);
r = routerset_add_unknown_ccs(setp, 0);
@@ -1290,11 +1240,11 @@ NS(test_main)(void *arg)
 }
country_t
-NS(geoip_get_country)(const char *country)
+rset_add_unknown_ccs_add_unknown_geoip_get_country(const char *country)
 {
   int arg_is_qq, arg_is_a1;
-  CALLED(geoip_get_country)++;
+  rset_add_unknown_ccs_add_unknown_geoip_get_country_called++;
arg_is_qq = !strcmp(country, "??");
   arg_is_a1 = !strcmp(country, "A1");
@@ -1309,9 +1259,9 @@ NS(geoip_get_country)(const char *country)
 }
int
-NS(geoip_is_loaded)(sa_family_t family)
+rset_add_unknown_ccs_add_unknown_geoip_is_loaded(sa_family_t family)
 {
-  CALLED(geoip_is_loaded)++;
+  rset_add_unknown_ccs_add_unknown_geoip_is_loaded_called++;
tt_int_op(family, OP_EQ, AF_INET);
@@ -1319,27 +1269,28 @@ NS(geoip_is_loaded)(sa_family_t family)
     return 0;
 }
-#undef NS_SUBMODULE
-#define NS_SUBMODULE ASPECT(add_unknown_ccs, add_a1)
-
 /*
  * Structural test for routerset_add_unknown_ccs, that the "{a1}"
  * country code is added to the list.
  */
-NS_DECL(country_t, geoip_get_country, (const char *country));
-NS_DECL(int, geoip_is_loaded, (sa_family_t family));
+static country_t rset_add_unknown_ccs_add_a1_geoip_get_country(const char *country);
+ATTR_UNUSED static int rset_add_unknown_ccs_add_a1_geoip_get_country_called = 0;
+static int rset_add_unknown_ccs_add_a1_geoip_is_loaded(sa_family_t family);
+ATTR_UNUSED static int rset_add_unknown_ccs_add_a1_geoip_is_loaded_called = 0;
static void
-NS(test_main)(void *arg)
+test_rset_add_unknown_ccs_add_a1(void *arg)
 {
   routerset_t *set = routerset_new();
   routerset_t **setp = &set;
   int r;
   (void)arg;
-  NS_MOCK(geoip_get_country);
-  NS_MOCK(geoip_is_loaded);
+  MOCK(geoip_get_country,
+       rset_add_unknown_ccs_add_a1_geoip_get_country);
+  MOCK(geoip_is_loaded,
+       rset_add_unknown_ccs_add_a1_geoip_is_loaded);
r = routerset_add_unknown_ccs(setp, 0);
@@ -1353,11 +1304,11 @@ NS(test_main)(void *arg)
 }
country_t
-NS(geoip_get_country)(const char *country)
+rset_add_unknown_ccs_add_a1_geoip_get_country(const char *country)
 {
   int arg_is_qq, arg_is_a1;
-  CALLED(geoip_get_country)++;
+  rset_add_unknown_ccs_add_a1_geoip_get_country_called++;
arg_is_qq = !strcmp(country, "??");
   arg_is_a1 = !strcmp(country, "A1");
@@ -1372,9 +1323,9 @@ NS(geoip_get_country)(const char *country)
 }
int
-NS(geoip_is_loaded)(sa_family_t family)
+rset_add_unknown_ccs_add_a1_geoip_is_loaded(sa_family_t family)
 {
-  CALLED(geoip_is_loaded)++;
+  rset_add_unknown_ccs_add_a1_geoip_is_loaded_called++;
tt_int_op(family, OP_EQ, AF_INET);
@@ -1382,15 +1333,12 @@ NS(geoip_is_loaded)(sa_family_t family)
     return 0;
 }
-#undef NS_SUBMODULE
-#define NS_SUBMODULE contains_extendinfo
-
 /*
  * Functional test for routerset_contains_extendinfo.
  */
static void
-NS(test_main)(void *arg)
+test_rset_contains_extendinfo(void *arg)
 {
   routerset_t *set = routerset_new();
   extend_info_t ei;
@@ -1410,15 +1358,12 @@ NS(test_main)(void *arg)
     routerset_free(set);
 }
-#undef NS_SUBMODULE
-#define NS_SUBMODULE contains_router
-
 /*
  * Functional test for routerset_contains_router.
  */
static void
-NS(test_main)(void *arg)
+test_rset_contains_router(void *arg)
 {
   routerset_t *set = routerset_new();
   routerinfo_t ri;
@@ -1438,9 +1383,6 @@ NS(test_main)(void *arg)
     routerset_free(set);
 }
-#undef NS_SUBMODULE
-#define NS_SUBMODULE contains_routerstatus
-
 /*
  * Functional test for routerset_contains_routerstatus.
  */
@@ -1450,7 +1392,7 @@ NS(test_main)(void *arg)
 // a bit more or test a bit more.
static void
-NS(test_main)(void *arg)
+test_rset_contains_routerstatus(void *arg)
 {
   routerset_t *set = routerset_new();
   routerstatus_t rs;
@@ -1471,46 +1413,40 @@ NS(test_main)(void *arg)
     routerset_free(set);
 }
-#undef NS_SUBMODULE
-#define NS_SUBMODULE ASPECT(contains, none)
-
 /*
  * Functional test for routerset_contains_node, when the node has no
  * routerset or routerinfo.
  */
-static node_t NS(mock_node);
+static node_t rset_contains_none_mock_node;
static void
-NS(test_main)(void *arg)
+test_rset_contains_none(void *arg)
 {
   routerset_t *set = routerset_new();
   int r;
   (void)arg;
-  memset(&NS(mock_node), 0, sizeof(NS(mock_node)));
-  NS(mock_node).ri = NULL;
-  NS(mock_node).rs = NULL;
+  memset(&rset_contains_none_mock_node, 0, sizeof(rset_contains_none_mock_node));
+  rset_contains_none_mock_node.ri = NULL;
+  rset_contains_none_mock_node.rs = NULL;
-  r = routerset_contains_node(set, &NS(mock_node));
+  r = routerset_contains_node(set, &rset_contains_none_mock_node);
   tt_int_op(r, OP_EQ, 0);
done:
     routerset_free(set);
 }
-#undef NS_SUBMODULE
-#define NS_SUBMODULE ASPECT(contains, rs)
-
 /*
  * Functional test for routerset_contains_node, when the node has a
  * routerset and no routerinfo.
  */
-static node_t NS(mock_node);
+static node_t rset_contains_rs_mock_node;
static void
-NS(test_main)(void *arg)
+test_rset_contains_rs(void *arg)
 {
   routerset_t *set = routerset_new();
   int r;
@@ -1522,27 +1458,24 @@ NS(test_main)(void *arg)
strncpy(rs.nickname, nickname, sizeof(rs.nickname) - 1);
   rs.nickname[sizeof(rs.nickname) - 1] = '\0';
-  memset(&NS(mock_node), 0, sizeof(NS(mock_node)));
-  NS(mock_node).ri = NULL;
-  NS(mock_node).rs = &rs;
+  memset(&rset_contains_rs_mock_node, 0, sizeof(rset_contains_rs_mock_node));
+  rset_contains_rs_mock_node.ri = NULL;
+  rset_contains_rs_mock_node.rs = &rs;
-  r = routerset_contains_node(set, &NS(mock_node));
+  r = routerset_contains_node(set, &rset_contains_rs_mock_node);
tt_int_op(r, OP_EQ, 4);
   done:
     routerset_free(set);
 }
-#undef NS_SUBMODULE
-#define NS_SUBMODULE ASPECT(contains, routerinfo)
-
 /*
  * Functional test for routerset_contains_node, when the node has no
  * routerset and a routerinfo.
  */
static void
-NS(test_main)(void *arg)
+test_rset_contains_routerinfo(void *arg)
 {
   routerset_t *set = routerset_new();
   int r;
@@ -1565,16 +1498,13 @@ NS(test_main)(void *arg)
     routerset_free(set);
 }
-#undef NS_SUBMODULE
-#define NS_SUBMODULE ASPECT(get_all, no_routerset)
-
 /*
  * Functional test for routerset_get_all_nodes, when routerset is NULL or
  * the routerset list is NULL.
  */
static void
-NS(test_main)(void *arg)
+test_rset_get_all_no_routerset(void *arg)
 {
   smartlist_t *out = smartlist_new();
   routerset_t *set = NULL;
@@ -1598,29 +1528,28 @@ NS(test_main)(void *arg)
   smartlist_free(out);
 }
-#undef NS_SUBMODULE
-#define NS_SUBMODULE ASPECT(get_all, l_no_nodes)
-
 /*
  * Structural test for routerset_get_all_nodes, when the routerset list
  * is empty.
  */
-NS_DECL(const node_t *, node_get_by_nickname, (const char *nickname, unsigned flags));
-static const char *NS(mock_nickname);
+static const node_t * rset_get_all_l_no_nodes_node_get_by_nickname(const char *nickname, unsigned flags);
+ATTR_UNUSED static int rset_get_all_l_no_nodes_node_get_by_nickname_called = 0;
+static const char *rset_get_all_l_no_nodes_mock_nickname;
static void
-NS(test_main)(void *arg)
+test_rset_get_all_l_no_nodes(void *arg)
 {
   smartlist_t *out = smartlist_new();
   routerset_t *set = routerset_new();
   int out_len;
   (void)arg;
-  NS_MOCK(node_get_by_nickname);
+  MOCK(node_get_by_nickname,
+       rset_get_all_l_no_nodes_node_get_by_nickname);
-  NS(mock_nickname) = "foo";
-  smartlist_add_strdup(set->list, NS(mock_nickname));
+  rset_get_all_l_no_nodes_mock_nickname = "foo";
+  smartlist_add_strdup(set->list, rset_get_all_l_no_nodes_mock_nickname);
routerset_get_all_nodes(out, set, NULL, 0);
   out_len = smartlist_len(out);
@@ -1629,48 +1558,47 @@ NS(test_main)(void *arg)
   routerset_free(set);
tt_int_op(out_len, OP_EQ, 0);
-  tt_int_op(CALLED(node_get_by_nickname), OP_EQ, 1);
+  tt_int_op(rset_get_all_l_no_nodes_node_get_by_nickname_called, OP_EQ, 1);
done:
     ;
 }
const node_t *
-NS(node_get_by_nickname)(const char *nickname, unsigned flags)
+rset_get_all_l_no_nodes_node_get_by_nickname(const char *nickname, unsigned flags)
 {
-  CALLED(node_get_by_nickname)++;
-  tt_str_op(nickname, OP_EQ, NS(mock_nickname));
+  rset_get_all_l_no_nodes_node_get_by_nickname_called++;
+  tt_str_op(nickname, OP_EQ, rset_get_all_l_no_nodes_mock_nickname);
   tt_uint_op(flags, OP_EQ, 0);
done:
     return NULL;
 }
-#undef NS_SUBMODULE
-#define NS_SUBMODULE ASPECT(get_all, l_not_running)
-
 /*
  * Structural test for routerset_get_all_nodes, with the running_only flag
  * is set but the nodes are not running.
  */
-NS_DECL(const node_t *, node_get_by_nickname, (const char *nickname, unsigned flags));
-static const char *NS(mock_nickname);
-static node_t NS(mock_node);
+static const node_t * rset_get_all_l_not_running_node_get_by_nickname(const char *nickname, unsigned flags);
+ATTR_UNUSED static int rset_get_all_l_not_running_node_get_by_nickname_called = 0;
+static const char *rset_get_all_l_not_running_mock_nickname;
+static node_t rset_get_all_l_not_running_mock_node;
static void
-NS(test_main)(void *arg)
+test_rset_get_all_l_not_running(void *arg)
 {
   smartlist_t *out = smartlist_new();
   routerset_t *set = routerset_new();
   int out_len;
   (void)arg;
-  NS_MOCK(node_get_by_nickname);
+  MOCK(node_get_by_nickname,
+       rset_get_all_l_not_running_node_get_by_nickname);
-  NS(mock_node).is_running = 0;
-  NS(mock_nickname) = "foo";
-  smartlist_add_strdup(set->list, NS(mock_nickname));
+  rset_get_all_l_not_running_mock_node.is_running = 0;
+  rset_get_all_l_not_running_mock_nickname = "foo";
+  smartlist_add_strdup(set->list, rset_get_all_l_not_running_mock_nickname);
routerset_get_all_nodes(out, set, NULL, 1);
   out_len = smartlist_len(out);
@@ -1679,36 +1607,34 @@ NS(test_main)(void *arg)
   routerset_free(set);
tt_int_op(out_len, OP_EQ, 0);
-  tt_int_op(CALLED(node_get_by_nickname), OP_EQ, 1);
+  tt_int_op(rset_get_all_l_not_running_node_get_by_nickname_called, OP_EQ, 1);
done:
     ;
 }
const node_t *
-NS(node_get_by_nickname)(const char *nickname, unsigned flags)
+rset_get_all_l_not_running_node_get_by_nickname(const char *nickname, unsigned flags)
 {
-  CALLED(node_get_by_nickname)++;
-  tt_str_op(nickname, OP_EQ, NS(mock_nickname));
+  rset_get_all_l_not_running_node_get_by_nickname_called++;
+  tt_str_op(nickname, OP_EQ, rset_get_all_l_not_running_mock_nickname);
   tt_int_op(flags, OP_EQ, 0);
done:
-    return &NS(mock_node);
+    return &rset_get_all_l_not_running_mock_node;
 }
-#undef NS_SUBMODULE
-#define NS_SUBMODULE ASPECT(get_all, list)
-
 /*
  * Structural test for routerset_get_all_nodes.
  */
-NS_DECL(const node_t *, node_get_by_nickname, (const char *nickname, unsigned flags));
-static char *NS(mock_nickname);
-static node_t NS(mock_node);
+static const node_t * rset_get_all_list_node_get_by_nickname(const char *nickname, unsigned flags);
+ATTR_UNUSED static int rset_get_all_list_node_get_by_nickname_called = 0;
+static char *rset_get_all_list_mock_nickname;
+static node_t rset_get_all_list_mock_node;
static void
-NS(test_main)(void *arg)
+test_rset_get_all_list(void *arg)
 {
   smartlist_t *out = smartlist_new();
   routerset_t *set = routerset_new();
@@ -1716,10 +1642,11 @@ NS(test_main)(void *arg)
   node_t *ent;
   (void)arg;
-  NS_MOCK(node_get_by_nickname);
+  MOCK(node_get_by_nickname,
+       rset_get_all_list_node_get_by_nickname);
-  NS(mock_nickname) = tor_strdup("foo");
-  smartlist_add(set->list, NS(mock_nickname));
+  rset_get_all_list_mock_nickname = tor_strdup("foo");
+  smartlist_add(set->list, rset_get_all_list_mock_nickname);
routerset_get_all_nodes(out, set, NULL, 0);
   out_len = smartlist_len(out);
@@ -1729,126 +1656,121 @@ NS(test_main)(void *arg)
   routerset_free(set);
tt_int_op(out_len, OP_EQ, 1);
-  tt_ptr_op(ent, OP_EQ, &NS(mock_node));
-  tt_int_op(CALLED(node_get_by_nickname), OP_EQ, 1);
+  tt_ptr_op(ent, OP_EQ, &rset_get_all_list_mock_node);
+  tt_int_op(rset_get_all_list_node_get_by_nickname_called, OP_EQ, 1);
done:
     ;
 }
const node_t *
-NS(node_get_by_nickname)(const char *nickname, unsigned flags)
+rset_get_all_list_node_get_by_nickname(const char *nickname, unsigned flags)
 {
-  CALLED(node_get_by_nickname)++;
-  tt_str_op(nickname, OP_EQ, NS(mock_nickname));
+  rset_get_all_list_node_get_by_nickname_called++;
+  tt_str_op(nickname, OP_EQ, rset_get_all_list_mock_nickname);
   tt_int_op(flags, OP_EQ, 0);
done:
-    return &NS(mock_node);
+    return &rset_get_all_list_mock_node;
 }
-#undef NS_SUBMODULE
-#define NS_SUBMODULE ASPECT(get_all, n_no_nodes)
-
 /*
  * Structural test for routerset_get_all_nodes, when the nodelist has no nodes.
  */
-NS_DECL(const smartlist_t *, nodelist_get_list, (void));
+static const smartlist_t * rset_get_all_n_no_nodes_nodelist_get_list(void);
+ATTR_UNUSED static int rset_get_all_n_no_nodes_nodelist_get_list_called = 0;
-static smartlist_t *NS(mock_smartlist);
+static smartlist_t *rset_get_all_n_no_nodes_mock_smartlist;
 static void
-NS(test_main)(void *arg)
+test_rset_get_all_n_no_nodes(void *arg)
 {
   routerset_t *set = routerset_new();
   smartlist_t *out = smartlist_new();
   int r;
   (void)arg;
-  NS_MOCK(nodelist_get_list);
+  MOCK(nodelist_get_list,
+       rset_get_all_n_no_nodes_nodelist_get_list);
smartlist_add_strdup(set->country_names, "{xx}");
-  NS(mock_smartlist) = smartlist_new();
+  rset_get_all_n_no_nodes_mock_smartlist = smartlist_new();
routerset_get_all_nodes(out, set, NULL, 1);
   r = smartlist_len(out);
   routerset_free(set);
   smartlist_free(out);
-  smartlist_free(NS(mock_smartlist));
+  smartlist_free(rset_get_all_n_no_nodes_mock_smartlist);
tt_int_op(r, OP_EQ, 0);
-  tt_int_op(CALLED(nodelist_get_list), OP_EQ, 1);
+  tt_int_op(rset_get_all_n_no_nodes_nodelist_get_list_called, OP_EQ, 1);
done:
     ;
 }
const smartlist_t *
-NS(nodelist_get_list)(void)
+rset_get_all_n_no_nodes_nodelist_get_list(void)
 {
-  CALLED(nodelist_get_list)++;
+  rset_get_all_n_no_nodes_nodelist_get_list_called++;
-  return NS(mock_smartlist);
+  return rset_get_all_n_no_nodes_mock_smartlist;
 }
-#undef NS_SUBMODULE
-#define NS_SUBMODULE ASPECT(get_all, n_not_running)
-
 /*
  * Structural test for routerset_get_all_nodes, with a non-list routerset
  * the running_only flag is set, but the nodes are not running.
  */
-NS_DECL(const smartlist_t *, nodelist_get_list, (void));
+static const smartlist_t * rset_get_all_n_not_running_nodelist_get_list(void);
+ATTR_UNUSED static int rset_get_all_n_not_running_nodelist_get_list_called = 0;
-static smartlist_t *NS(mock_smartlist);
-static node_t NS(mock_node);
+static smartlist_t *rset_get_all_n_not_running_mock_smartlist;
+static node_t rset_get_all_n_not_running_mock_node;
static void
-NS(test_main)(void *arg)
+test_rset_get_all_n_not_running(void *arg)
 {
   routerset_t *set = routerset_new();
   smartlist_t *out = smartlist_new();
   int r;
   (void)arg;
-  NS_MOCK(nodelist_get_list);
+  MOCK(nodelist_get_list,
+       rset_get_all_n_not_running_nodelist_get_list);
smartlist_add_strdup(set->country_names, "{xx}");
-  NS(mock_smartlist) = smartlist_new();
-  NS(mock_node).is_running = 0;
-  smartlist_add(NS(mock_smartlist), (void *)&NS(mock_node));
+  rset_get_all_n_not_running_mock_smartlist = smartlist_new();
+  rset_get_all_n_not_running_mock_node.is_running = 0;
+  smartlist_add(rset_get_all_n_not_running_mock_smartlist, (void *)&rset_get_all_n_not_running_mock_node);
routerset_get_all_nodes(out, set, NULL, 1);
   r = smartlist_len(out);
   routerset_free(set);
   smartlist_free(out);
-  smartlist_free(NS(mock_smartlist));
+  smartlist_free(rset_get_all_n_not_running_mock_smartlist);
tt_int_op(r, OP_EQ, 0);
-  tt_int_op(CALLED(nodelist_get_list), OP_EQ, 1);
+  tt_int_op(rset_get_all_n_not_running_nodelist_get_list_called, OP_EQ, 1);
done:
     ;
 }
const smartlist_t *
-NS(nodelist_get_list)(void)
+rset_get_all_n_not_running_nodelist_get_list(void)
 {
-  CALLED(nodelist_get_list)++;
+  rset_get_all_n_not_running_nodelist_get_list_called++;
-  return NS(mock_smartlist);
+  return rset_get_all_n_not_running_mock_smartlist;
 }
-#undef NS_SUBMODULE
-#define NS_SUBMODULE subtract_nodes
-
 /*
  * Functional test for routerset_subtract_nodes.
  */
static void
-NS(test_main)(void *arg)
+test_rset_subtract_nodes(void *arg)
 {
   routerset_t *set = routerset_new();
   smartlist_t *list = smartlist_new();
@@ -1873,15 +1795,12 @@ NS(test_main)(void *arg)
     smartlist_free(list);
 }
-#undef NS_SUBMODULE
-#define NS_SUBMODULE ASPECT(subtract_nodes, null_routerset)
-
 /*
  * Functional test for routerset_subtract_nodes, with a NULL routerset.
  */
static void
-NS(test_main)(void *arg)
+test_rset_subtract_nodes_null_routerset(void *arg)
 {
   routerset_t *set = NULL;
   smartlist_t *list = smartlist_new();
@@ -1903,15 +1822,12 @@ NS(test_main)(void *arg)
     smartlist_free(list);
 }
-#undef NS_SUBMODULE
-#define NS_SUBMODULE to_string
-
 /*
  * Functional test for routerset_to_string.
  */
static void
-NS(test_main)(void *arg)
+test_rset_to_string(void *arg)
 {
   routerset_t *set = NULL;
   char *s = NULL;
@@ -1948,15 +1864,12 @@ NS(test_main)(void *arg)
   routerset_free(set);
 }
-#undef NS_SUBMODULE
-#define NS_SUBMODULE ASPECT(equal, empty_empty)
-
 /*
  * Functional test for routerset_equal, with both routersets empty.
  */
static void
-NS(test_main)(void *arg)
+test_rset_equal_empty_empty(void *arg)
 {
   routerset_t *a = routerset_new(), *b = routerset_new();
   int r;
@@ -1972,15 +1885,12 @@ NS(test_main)(void *arg)
     ;
 }
-#undef NS_SUBMODULE
-#define NS_SUBMODULE ASPECT(equal, empty_not_empty)
-
 /*
  * Functional test for routerset_equal, with one routersets empty.
  */
static void
-NS(test_main)(void *arg)
+test_rset_equal_empty_not_empty(void *arg)
 {
   routerset_t *a = routerset_new(), *b = routerset_new();
   int r;
@@ -1996,16 +1906,13 @@ NS(test_main)(void *arg)
     ;
 }
-#undef NS_SUBMODULE
-#define NS_SUBMODULE ASPECT(equal, differing_lengths)
-
 /*
  * Functional test for routerset_equal, with the routersets having
  * differing lengths.
  */
static void
-NS(test_main)(void *arg)
+test_rset_equal_differing_lengths(void *arg)
 {
   routerset_t *a = routerset_new(), *b = routerset_new();
   int r;
@@ -2023,16 +1930,13 @@ NS(test_main)(void *arg)
     ;
 }
-#undef NS_SUBMODULE
-#define NS_SUBMODULE ASPECT(equal, unequal)
-
 /*
  * Functional test for routerset_equal, with the routersets being
  * different.
  */
static void
-NS(test_main)(void *arg)
+test_rset_equal_unequal(void *arg)
 {
   routerset_t *a = routerset_new(), *b = routerset_new();
   int r;
@@ -2049,16 +1953,13 @@ NS(test_main)(void *arg)
     ;
 }
-#undef NS_SUBMODULE
-#define NS_SUBMODULE ASPECT(equal, equal)
-
 /*
  * Functional test for routerset_equal, with the routersets being
  * equal.
  */
static void
-NS(test_main)(void *arg)
+test_rset_equal_equal(void *arg)
 {
   routerset_t *a = routerset_new(), *b = routerset_new();
   int r;
@@ -2075,147 +1976,147 @@ NS(test_main)(void *arg)
     ;
 }
-#undef NS_SUBMODULE
-#define NS_SUBMODULE ASPECT(free, null_routerset)
-
 /*
  * Structural test for routerset_free, where the routerset is NULL.
  */
-NS_DECL(void, smartlist_free_, (smartlist_t *sl));
+static void rset_free_null_routerset_smartlist_free_(smartlist_t *sl);
+ATTR_UNUSED static int rset_free_null_routerset_smartlist_free__called = 0;
static void
-NS(test_main)(void *arg)
+test_rset_free_null_routerset(void *arg)
 {
   (void)arg;
-  NS_MOCK(smartlist_free_);
+  MOCK(smartlist_free_,
+       rset_free_null_routerset_smartlist_free_);
routerset_free_(NULL);
-  tt_int_op(CALLED(smartlist_free_), OP_EQ, 0);
+  tt_int_op(rset_free_null_routerset_smartlist_free__called, OP_EQ, 0);
done:
     ;
 }
void
-NS(smartlist_free_)(smartlist_t *s)
+rset_free_null_routerset_smartlist_free_(smartlist_t *s)
 {
   (void)s;
-  CALLED(smartlist_free_)++;
+  rset_free_null_routerset_smartlist_free__called++;
 }
-#undef NS_SUBMODULE
-#define NS_SUBMODULE free
-
 /*
  * Structural test for routerset_free.
  */
-NS_DECL(void, smartlist_free_, (smartlist_t *sl));
-NS_DECL(void, strmap_free_,(strmap_t *map, void (*free_val)(void*)));
-NS_DECL(void, digestmap_free_, (digestmap_t *map, void (*free_val)(void*)));
+static void rset_free_smartlist_free_(smartlist_t *sl);
+ATTR_UNUSED static int rset_free_smartlist_free__called = 0;
+static void rset_free_strmap_free_(strmap_t *map, void (*free_val)(void*));
+ATTR_UNUSED static int rset_free_strmap_free__called = 0;
+static void rset_free_digestmap_free_(digestmap_t *map, void (*free_val)(void*));
+ATTR_UNUSED static int rset_free_digestmap_free__called = 0;
static void
-NS(test_main)(void *arg)
+test_rset_free(void *arg)
 {
   routerset_t *routerset = routerset_new();
   (void)arg;
-  NS_MOCK(smartlist_free_);
-  NS_MOCK(strmap_free_);
-  NS_MOCK(digestmap_free_);
+  MOCK(smartlist_free_,
+       rset_free_smartlist_free_);
+  MOCK(strmap_free_,
+       rset_free_strmap_free_);
+  MOCK(digestmap_free_,
+       rset_free_digestmap_free_);
routerset_free(routerset);
-  tt_int_op(CALLED(smartlist_free_), OP_NE, 0);
-  tt_int_op(CALLED(strmap_free_), OP_NE, 0);
-  tt_int_op(CALLED(digestmap_free_), OP_NE, 0);
+  tt_int_op(rset_free_smartlist_free__called, OP_NE, 0);
+  tt_int_op(rset_free_strmap_free__called, OP_NE, 0);
+  tt_int_op(rset_free_digestmap_free__called, OP_NE, 0);
done:
     ;
 }
void
-NS(smartlist_free_)(smartlist_t *s)
+rset_free_smartlist_free_(smartlist_t *s)
 {
-  CALLED(smartlist_free_)++;
+  rset_free_smartlist_free__called++;
   smartlist_free___real(s);
 }
void
-NS(strmap_free_)(strmap_t *map, void (*free_val)(void*))
+rset_free_strmap_free_(strmap_t *map, void (*free_val)(void*))
 {
-  CALLED(strmap_free_)++;
+  rset_free_strmap_free__called++;
   strmap_free___real(map, free_val);
 }
void
-NS(digestmap_free_)(digestmap_t *map, void (*free_val)(void*))
+rset_free_digestmap_free_(digestmap_t *map, void (*free_val)(void*))
 {
-  CALLED(digestmap_free_)++;
+  rset_free_digestmap_free__called++;
   digestmap_free___real(map, free_val);
 }
-#undef NS_SUBMODULE
-
 struct testcase_t routerset_tests[] = {
-  TEST_CASE(new),
-  TEST_CASE(get_countryname),
-  TEST_CASE(is_list),
-  TEST_CASE(needs_geoip),
-  TEST_CASE(is_empty),
-  TEST_CASE_ASPECT(contains, null_set_or_list),
-  TEST_CASE_ASPECT(contains, nickname),
-  TEST_CASE_ASPECT(contains, null_nickname),
-  TEST_CASE_ASPECT(contains, no_nickname),
-  TEST_CASE_ASPECT(contains, digest),
-  TEST_CASE_ASPECT(contains, no_digest),
-  TEST_CASE_ASPECT(contains, null_digest),
-  TEST_CASE_ASPECT(contains, addr),
-  TEST_CASE_ASPECT(contains, no_addr),
-  TEST_CASE_ASPECT(contains, null_addr),
-  TEST_CASE_ASPECT(contains, countries_no_geoip),
-  TEST_CASE_ASPECT(contains, countries_geoip),
-  TEST_CASE_ASPECT(add_unknown_ccs, only_flag),
-  TEST_CASE_ASPECT(add_unknown_ccs, creates_set),
-  TEST_CASE_ASPECT(add_unknown_ccs, add_unknown),
-  TEST_CASE_ASPECT(add_unknown_ccs, add_a1),
-  TEST_CASE(contains_extendinfo),
-  TEST_CASE(contains_router),
-  TEST_CASE(contains_routerstatus),
-  TEST_CASE_ASPECT(contains, none),
-  TEST_CASE_ASPECT(contains, routerinfo),
-  TEST_CASE_ASPECT(contains, rs),
-  TEST_CASE_ASPECT(get_all, no_routerset),
-  TEST_CASE_ASPECT(get_all, l_no_nodes),
-  TEST_CASE_ASPECT(get_all, l_not_running),
-  TEST_CASE_ASPECT(get_all, list),
-  TEST_CASE_ASPECT(get_all, n_no_nodes),
-  TEST_CASE_ASPECT(get_all, n_not_running),
-  TEST_CASE_ASPECT(refresh, geoip_not_loaded),
-  TEST_CASE_ASPECT(refresh, no_countries),
-  TEST_CASE_ASPECT(refresh, one_valid_country),
-  TEST_CASE_ASPECT(refresh, one_invalid_country),
-  TEST_CASE_ASPECT(union, source_bad),
-  TEST_CASE_ASPECT(union, one),
-  TEST_CASE_ASPECT(parse, malformed),
-  TEST_CASE_ASPECT(parse, valid_hexdigest),
-  TEST_CASE_ASPECT(parse, valid_nickname),
-  TEST_CASE_ASPECT(parse, get_countryname),
-  TEST_CASE_ASPECT(parse, policy_wildcard),
-  TEST_CASE_ASPECT(parse, policy_ipv4),
-  TEST_CASE_ASPECT(parse, policy_ipv6),
-  TEST_CASE(subtract_nodes),
-  TEST_CASE_ASPECT(subtract_nodes, null_routerset),
-  TEST_CASE(to_string),
-  TEST_CASE_ASPECT(equal, empty_empty),
-  TEST_CASE_ASPECT(equal, empty_not_empty),
-  TEST_CASE_ASPECT(equal, differing_lengths),
-  TEST_CASE_ASPECT(equal, unequal),
-  TEST_CASE_ASPECT(equal, equal),
-  TEST_CASE_ASPECT(free, null_routerset),
-  TEST_CASE(free),
+  { "new", test_rset_new, TT_FORK, NULL, NULL },
+  { "get_countryname", test_rset_get_countryname, TT_FORK, NULL, NULL },
+  { "is_list", test_rset_is_list, TT_FORK, NULL, NULL },
+  { "needs_geoip", test_rset_needs_geoip, TT_FORK, NULL, NULL },
+  { "is_empty", test_rset_is_empty, TT_FORK, NULL, NULL },
+  { "contains_null_set_or_list", test_rset_contains_null_set_or_list, TT_FORK, NULL, NULL },
+  { "contains_nickname", test_rset_contains_nickname, TT_FORK, NULL, NULL },
+  { "contains_null_nickname", test_rset_contains_null_nickname, TT_FORK, NULL, NULL },
+  { "contains_no_nickname", test_rset_contains_no_nickname, TT_FORK, NULL, NULL },
+  { "contains_digest", test_rset_contains_digest, TT_FORK, NULL, NULL },
+  { "contains_no_digest", test_rset_contains_no_digest, TT_FORK, NULL, NULL },
+  { "contains_null_digest", test_rset_contains_null_digest, TT_FORK, NULL, NULL },
+  { "contains_addr", test_rset_contains_addr, TT_FORK, NULL, NULL },
+  { "contains_no_addr", test_rset_contains_no_addr, TT_FORK, NULL, NULL },
+  { "contains_null_addr", test_rset_contains_null_addr, TT_FORK, NULL, NULL },
+  { "contains_countries_no_geoip", test_rset_contains_countries_no_geoip, TT_FORK, NULL, NULL },
+  { "contains_countries_geoip", test_rset_contains_countries_geoip, TT_FORK, NULL, NULL },
+  { "add_unknown_ccs_only_flag", test_rset_add_unknown_ccs_only_flag, TT_FORK, NULL, NULL },
+  { "add_unknown_ccs_creates_set", test_rset_add_unknown_ccs_creates_set, TT_FORK, NULL, NULL },
+  { "add_unknown_ccs_add_unknown", test_rset_add_unknown_ccs_add_unknown, TT_FORK, NULL, NULL },
+  { "add_unknown_ccs_add_a1", test_rset_add_unknown_ccs_add_a1, TT_FORK, NULL, NULL },
+  { "contains_extendinfo", test_rset_contains_extendinfo, TT_FORK, NULL, NULL },
+  { "contains_router", test_rset_contains_router, TT_FORK, NULL, NULL },
+  { "contains_routerstatus", test_rset_contains_routerstatus, TT_FORK, NULL, NULL },
+  { "contains_none", test_rset_contains_none, TT_FORK, NULL, NULL },
+  { "contains_routerinfo", test_rset_contains_routerinfo, TT_FORK, NULL, NULL },
+  { "contains_rs", test_rset_contains_rs, TT_FORK, NULL, NULL },
+  { "get_all_no_routerset", test_rset_get_all_no_routerset, TT_FORK, NULL, NULL },
+  { "get_all_l_no_nodes", test_rset_get_all_l_no_nodes, TT_FORK, NULL, NULL },
+  { "get_all_l_not_running", test_rset_get_all_l_not_running, TT_FORK, NULL, NULL },
+  { "get_all_list", test_rset_get_all_list, TT_FORK, NULL, NULL },
+  { "get_all_n_no_nodes", test_rset_get_all_n_no_nodes, TT_FORK, NULL, NULL },
+  { "get_all_n_not_running", test_rset_get_all_n_not_running, TT_FORK, NULL, NULL },
+  { "refresh_geoip_not_loaded", test_rset_refresh_geoip_not_loaded, TT_FORK, NULL, NULL },
+  { "refresh_no_countries", test_rset_refresh_no_countries, TT_FORK, NULL, NULL },
+  { "refresh_one_valid_country", test_rset_refresh_one_valid_country, TT_FORK, NULL, NULL },
+  { "refresh_one_invalid_country", test_rset_refresh_one_invalid_country, TT_FORK, NULL, NULL },
+  { "union_source_bad", test_rset_union_source_bad, TT_FORK, NULL, NULL },
+  { "union_one", test_rset_union_one, TT_FORK, NULL, NULL },
+  { "parse_malformed", test_rset_parse_malformed, TT_FORK, NULL, NULL },
+  { "parse_valid_hexdigest", test_rset_parse_valid_hexdigest, TT_FORK, NULL, NULL },
+  { "parse_valid_nickname", test_rset_parse_valid_nickname, TT_FORK, NULL, NULL },
+  { "parse_get_countryname", test_rset_parse_get_countryname, TT_FORK, NULL, NULL },
+  { "parse_policy_wildcard", test_rset_parse_policy_wildcard, TT_FORK, NULL, NULL },
+  { "parse_policy_ipv4", test_rset_parse_policy_ipv4, TT_FORK, NULL, NULL },
+  { "parse_policy_ipv6", test_rset_parse_policy_ipv6, TT_FORK, NULL, NULL },
+  { "subtract_nodes", test_rset_subtract_nodes, TT_FORK, NULL, NULL },
+  { "subtract_nodes_null_routerset", test_rset_subtract_nodes_null_routerset, TT_FORK, NULL, NULL },
+  { "to_string", test_rset_to_string, TT_FORK, NULL, NULL },
+  { "equal_empty_empty", test_rset_equal_empty_empty, TT_FORK, NULL, NULL },
+  { "equal_empty_not_empty", test_rset_equal_empty_not_empty, TT_FORK, NULL, NULL },
+  { "equal_differing_lengths", test_rset_equal_differing_lengths, TT_FORK, NULL, NULL },
+  { "equal_unequal", test_rset_equal_unequal, TT_FORK, NULL, NULL },
+  { "equal_equal", test_rset_equal_equal, TT_FORK, NULL, NULL },
+  { "free_null_routerset", test_rset_free_null_routerset, TT_FORK, NULL, NULL },
+  { "free", test_rset_free, TT_FORK, NULL, NULL },
   END_OF_TESTCASES
 };
diff --git a/src/test/test_status.c b/src/test/test_status.c
index 88053a34f..ffce848db 100644
--- a/src/test/test_status.c
+++ b/src/test/test_status.c
@@ -33,10 +33,6 @@
#include "test/test.h"
-#define NS_MODULE status
-
-#define NS_SUBMODULE count_circuits
-
 /*
  * Test that count_circuits() is correctly counting the number of
  * global circuits.
@@ -44,10 +40,11 @@
static smartlist_t * mock_global_circuitlist = NULL;
-NS_DECL(smartlist_t *, circuit_get_global_list, (void));
+static smartlist_t * status_count_circuits_circuit_get_global_list(void);
+ATTR_UNUSED static int status_count_circuits_circuit_get_global_list_called = 0;
static void
-NS(test_main)(void *arg)
+test_status_count_circuits(void *arg)
 {
   /* Choose origin_circuit_t wlog. */
   origin_circuit_t *mock_circuit1, *mock_circuit2;
@@ -61,7 +58,8 @@ NS(test_main)(void *arg)
   smartlist_add(mock_global_circuitlist, TO_CIRCUIT(mock_circuit1));
   smartlist_add(mock_global_circuitlist, TO_CIRCUIT(mock_circuit2));
-  NS_MOCK(circuit_get_global_list);
+  MOCK(circuit_get_global_list,
+       status_count_circuits_circuit_get_global_list);
actual_circuits = count_circuits();
@@ -72,25 +70,22 @@ NS(test_main)(void *arg)
   tor_free(mock_circuit2);
   smartlist_free(mock_global_circuitlist);
   mock_global_circuitlist = NULL;
-  NS_UNMOCK(circuit_get_global_list);
+  UNMOCK(circuit_get_global_list);
 }
static smartlist_t *
-NS(circuit_get_global_list)(void)
+status_count_circuits_circuit_get_global_list(void)
 {
   return mock_global_circuitlist;
 }
-#undef NS_SUBMODULE
-#define NS_SUBMODULE secs_to_uptime
-
 /*
  * Test that secs_to_uptime() is converting the number of seconds that
  * Tor is up for into the appropriate string form containing hours and minutes.
  */
static void
-NS(test_main)(void *arg)
+test_status_secs_to_uptime(void *arg)
 {
   const char *expected;
   char *actual;
@@ -161,9 +156,6 @@ NS(test_main)(void *arg)
       tor_free(actual);
 }
-#undef NS_SUBMODULE
-#define NS_SUBMODULE bytes_to_usage
-
 /*
  * Test that bytes_to_usage() is correctly converting the number of bytes that
  * Tor has read/written into the appropriate string form containing kilobytes,
@@ -171,7 +163,7 @@ NS(test_main)(void *arg)
  */
static void
-NS(test_main)(void *arg)
+test_status_bytes_to_usage(void *arg)
 {
   const char *expected;
   char *actual;
@@ -242,29 +234,34 @@ NS(test_main)(void *arg)
       tor_free(actual);
 }
-#undef NS_SUBMODULE
-#define NS_SUBMODULE ASPECT(hb, fails)
-
 /*
  * Tests that log_heartbeat() fails when in the public server mode,
  * not hibernating, and we couldn't get the current routerinfo.
  */
-NS_DECL(double, tls_get_write_overhead_ratio, (void));
-NS_DECL(int, we_are_hibernating, (void));
-NS_DECL(int, public_server_mode, (const or_options_t *options));
-NS_DECL(const routerinfo_t *, router_get_my_routerinfo, (void));
+static double status_hb_fails_tls_get_write_overhead_ratio(void);
+ATTR_UNUSED static int status_hb_fails_tls_get_write_overhead_ratio_called = 0;
+static int status_hb_fails_we_are_hibernating(void);
+ATTR_UNUSED static int status_hb_fails_we_are_hibernating_called = 0;
+static int status_hb_fails_public_server_mode(const or_options_t *options);
+ATTR_UNUSED static int status_hb_fails_public_server_mode_called = 0;
+static const routerinfo_t * status_hb_fails_router_get_my_routerinfo(void);
+ATTR_UNUSED static int status_hb_fails_router_get_my_routerinfo_called = 0;
static void
-NS(test_main)(void *arg)
+test_status_hb_fails(void *arg)
 {
   int expected, actual;
   (void)arg;
-  NS_MOCK(tls_get_write_overhead_ratio);
-  NS_MOCK(we_are_hibernating);
-  NS_MOCK(public_server_mode);
-  NS_MOCK(router_get_my_routerinfo);
+  MOCK(tls_get_write_overhead_ratio,
+       status_hb_fails_tls_get_write_overhead_ratio);
+  MOCK(we_are_hibernating,
+       status_hb_fails_we_are_hibernating);
+  MOCK(public_server_mode,
+       status_hb_fails_public_server_mode);
+  MOCK(router_get_my_routerinfo,
+       status_hb_fails_router_get_my_routerinfo);
expected = -1;
   actual = log_heartbeat(0);
@@ -272,26 +269,26 @@ NS(test_main)(void *arg)
   tt_int_op(actual, OP_EQ, expected);
done:
-    NS_UNMOCK(tls_get_write_overhead_ratio);
-    NS_UNMOCK(we_are_hibernating);
-    NS_UNMOCK(public_server_mode);
-    NS_UNMOCK(router_get_my_routerinfo);
+    UNMOCK(tls_get_write_overhead_ratio);
+    UNMOCK(we_are_hibernating);
+    UNMOCK(public_server_mode);
+    UNMOCK(router_get_my_routerinfo);
 }
static double
-NS(tls_get_write_overhead_ratio)(void)
+status_hb_fails_tls_get_write_overhead_ratio(void)
 {
   return 2.0;
 }
static int
-NS(we_are_hibernating)(void)
+status_hb_fails_we_are_hibernating(void)
 {
   return 0;
 }
static int
-NS(public_server_mode)(const or_options_t *options)
+status_hb_fails_public_server_mode(const or_options_t *options)
 {
   (void)options;
@@ -299,42 +296,53 @@ NS(public_server_mode)(const or_options_t *options)
 }
static const routerinfo_t *
-NS(router_get_my_routerinfo)(void)
+status_hb_fails_router_get_my_routerinfo(void)
 {
   return NULL;
 }
-#undef NS_SUBMODULE
-#define NS_SUBMODULE ASPECT(hb, not_in_consensus)
-
 /*
  * Tests that log_heartbeat() logs appropriately if we are not in the cached
  * consensus.
  */
-NS_DECL(double, tls_get_write_overhead_ratio, (void));
-NS_DECL(int, we_are_hibernating, (void));
-NS_DECL(int, public_server_mode, (const or_options_t *options));
-NS_DECL(const routerinfo_t *, router_get_my_routerinfo, (void));
-NS_DECL(const node_t *, node_get_by_id, (const char *identity_digest));
-NS_DECL(void, logv, (int severity, log_domain_mask_t domain, const char *funcname, const char *suffix, const char *format, va_list ap));
-NS_DECL(int, server_mode, (const or_options_t *options));
+static double status_hb_not_in_consensus_tls_get_write_overhead_ratio(void);
+ATTR_UNUSED static int status_hb_not_in_consensus_tls_get_write_overhead_ratio_called = 0;
+static int status_hb_not_in_consensus_we_are_hibernating(void);
+ATTR_UNUSED static int status_hb_not_in_consensus_we_are_hibernating_called = 0;
+static int status_hb_not_in_consensus_public_server_mode(const or_options_t *options);
+ATTR_UNUSED static int status_hb_not_in_consensus_public_server_mode_called = 0;
+static const routerinfo_t * status_hb_not_in_consensus_router_get_my_routerinfo(void);
+ATTR_UNUSED static int status_hb_not_in_consensus_router_get_my_routerinfo_called = 0;
+static const node_t * status_hb_not_in_consensus_node_get_by_id(const char *identity_digest);
+ATTR_UNUSED static int status_hb_not_in_consensus_node_get_by_id_called = 0;
+static void status_hb_not_in_consensus_logv(int severity, log_domain_mask_t domain, const char *funcname, const char *suffix, const char *format, va_list ap);
+ATTR_UNUSED static int status_hb_not_in_consensus_logv_called = 0;
+static int status_hb_not_in_consensus_server_mode(const or_options_t *options);
+ATTR_UNUSED static int status_hb_not_in_consensus_server_mode_called = 0;
static routerinfo_t *mock_routerinfo;
static void
-NS(test_main)(void *arg)
+test_status_hb_not_in_consensus(void *arg)
 {
   int expected, actual;
   (void)arg;
-  NS_MOCK(tls_get_write_overhead_ratio);
-  NS_MOCK(we_are_hibernating);
-  NS_MOCK(public_server_mode);
-  NS_MOCK(router_get_my_routerinfo);
-  NS_MOCK(node_get_by_id);
-  NS_MOCK(logv);
-  NS_MOCK(server_mode);
+  MOCK(tls_get_write_overhead_ratio,
+       status_hb_not_in_consensus_tls_get_write_overhead_ratio);
+  MOCK(we_are_hibernating,
+       status_hb_not_in_consensus_we_are_hibernating);
+  MOCK(public_server_mode,
+       status_hb_not_in_consensus_public_server_mode);
+  MOCK(router_get_my_routerinfo,
+       status_hb_not_in_consensus_router_get_my_routerinfo);
+  MOCK(node_get_by_id,
+       status_hb_not_in_consensus_node_get_by_id);
+  MOCK(logv,
+       status_hb_not_in_consensus_logv);
+  MOCK(server_mode,
+       status_hb_not_in_consensus_server_mode);
log_global_min_severity_ = LOG_DEBUG;
   onion_handshakes_requested[ONION_HANDSHAKE_TYPE_TAP] = 1;
@@ -346,33 +354,33 @@ NS(test_main)(void *arg)
   actual = log_heartbeat(0);
tt_int_op(actual, OP_EQ, expected);
-  tt_int_op(CALLED(logv), OP_EQ, 6);
+  tt_int_op(status_hb_not_in_consensus_logv_called, OP_EQ, 6);
done:
-    NS_UNMOCK(tls_get_write_overhead_ratio);
-    NS_UNMOCK(we_are_hibernating);
-    NS_UNMOCK(public_server_mode);
-    NS_UNMOCK(router_get_my_routerinfo);
-    NS_UNMOCK(node_get_by_id);
-    NS_UNMOCK(logv);
-    NS_UNMOCK(server_mode);
+    UNMOCK(tls_get_write_overhead_ratio);
+    UNMOCK(we_are_hibernating);
+    UNMOCK(public_server_mode);
+    UNMOCK(router_get_my_routerinfo);
+    UNMOCK(node_get_by_id);
+    UNMOCK(logv);
+    UNMOCK(server_mode);
     tor_free(mock_routerinfo);
 }
static double
-NS(tls_get_write_overhead_ratio)(void)
+status_hb_not_in_consensus_tls_get_write_overhead_ratio(void)
 {
   return 1.0;
 }
static int
-NS(we_are_hibernating)(void)
+status_hb_not_in_consensus_we_are_hibernating(void)
 {
   return 0;
 }
static int
-NS(public_server_mode)(const or_options_t *options)
+status_hb_not_in_consensus_public_server_mode(const or_options_t *options)
 {
   (void)options;
@@ -380,7 +388,7 @@ NS(public_server_mode)(const or_options_t *options)
 }
static const routerinfo_t *
-NS(router_get_my_routerinfo)(void)
+status_hb_not_in_consensus_router_get_my_routerinfo(void)
 {
   mock_routerinfo = tor_malloc(sizeof(routerinfo_t));
@@ -388,7 +396,7 @@ NS(router_get_my_routerinfo)(void)
 }
static const node_t *
-NS(node_get_by_id)(const char *identity_digest)
+status_hb_not_in_consensus_node_get_by_id(const char *identity_digest)
 {
   (void)identity_digest;
@@ -396,10 +404,10 @@ NS(node_get_by_id)(const char *identity_digest)
 }
static void
-NS(logv)(int severity, log_domain_mask_t domain,
+status_hb_not_in_consensus_logv(int severity, log_domain_mask_t domain,
   const char *funcname, const char *suffix, const char *format, va_list ap)
 {
-  switch (CALLED(logv))
+  switch (status_hb_not_in_consensus_logv_called)
   {
     case 0:
       tt_int_op(severity, OP_EQ, LOG_NOTICE);
@@ -462,50 +470,63 @@ NS(logv)(int severity, log_domain_mask_t domain,
   }
done:
-    CALLED(logv)++;
+    status_hb_not_in_consensus_logv_called++;
 }
static int
-NS(server_mode)(const or_options_t *options)
+status_hb_not_in_consensus_server_mode(const or_options_t *options)
 {
   (void)options;
return 0;
 }
-#undef NS_SUBMODULE
-#define NS_SUBMODULE ASPECT(hb, simple)
-
 /*
  * Tests that log_heartbeat() correctly logs heartbeat information
  * normally.
  */
-NS_DECL(double, tls_get_write_overhead_ratio, (void));
-NS_DECL(int, we_are_hibernating, (void));
-NS_DECL(int, public_server_mode, (const or_options_t *options));
-NS_DECL(long, get_uptime, (void));
-NS_DECL(uint64_t, get_bytes_read, (void));
-NS_DECL(uint64_t, get_bytes_written, (void));
-NS_DECL(void, logv, (int severity, log_domain_mask_t domain, const char *funcname, const char *suffix, const char *format, va_list ap));
-NS_DECL(int, server_mode, (const or_options_t *options));
-
-static int NS(n_msgs) = 0;
+static double status_hb_simple_tls_get_write_overhead_ratio(void);
+ATTR_UNUSED static int status_hb_simple_tls_get_write_overhead_ratio_called = 0;
+static int status_hb_simple_we_are_hibernating(void);
+ATTR_UNUSED static int status_hb_simple_we_are_hibernating_called = 0;
+static int status_hb_simple_public_server_mode(const or_options_t *options);
+ATTR_UNUSED static int status_hb_simple_public_server_mode_called = 0;
+static long status_hb_simple_get_uptime(void);
+ATTR_UNUSED static int status_hb_simple_get_uptime_called = 0;
+static uint64_t status_hb_simple_get_bytes_read(void);
+ATTR_UNUSED static int status_hb_simple_get_bytes_read_called = 0;
+static uint64_t status_hb_simple_get_bytes_written(void);
+ATTR_UNUSED static int status_hb_simple_get_bytes_written_called = 0;
+static void status_hb_simple_logv(int severity, log_domain_mask_t domain, const char *funcname, const char *suffix, const char *format, va_list ap);
+ATTR_UNUSED static int status_hb_simple_logv_called = 0;
+static int status_hb_simple_server_mode(const or_options_t *options);
+ATTR_UNUSED static int status_hb_simple_server_mode_called = 0;
+
+static int status_hb_simple_n_msgs = 0;
static void
-NS(test_main)(void *arg)
+test_status_hb_simple(void *arg)
 {
   int expected, actual;
   (void)arg;
-  NS_MOCK(tls_get_write_overhead_ratio);
-  NS_MOCK(we_are_hibernating);
-  NS_MOCK(public_server_mode);
-  NS_MOCK(get_uptime);
-  NS_MOCK(get_bytes_read);
-  NS_MOCK(get_bytes_written);
-  NS_MOCK(logv);
-  NS_MOCK(server_mode);
+  MOCK(tls_get_write_overhead_ratio,
+       status_hb_simple_tls_get_write_overhead_ratio);
+  MOCK(we_are_hibernating,
+       status_hb_simple_we_are_hibernating);
+  MOCK(public_server_mode,
+       status_hb_simple_public_server_mode);
+  MOCK(get_uptime,
+       status_hb_simple_get_uptime);
+  MOCK(get_bytes_read,
+       status_hb_simple_get_bytes_read);
+  MOCK(get_bytes_written,
+       status_hb_simple_get_bytes_written);
+  MOCK(logv,
+       status_hb_simple_logv);
+  MOCK(server_mode,
+       status_hb_simple_server_mode);
log_global_min_severity_ = LOG_DEBUG;
@@ -513,33 +534,33 @@ NS(test_main)(void *arg)
   actual = log_heartbeat(0);
tt_int_op(actual, OP_EQ, expected);
-  tt_int_op(NS(n_msgs), OP_EQ, 1);
+  tt_int_op(status_hb_simple_n_msgs, OP_EQ, 1);
done:
-    NS_UNMOCK(tls_get_write_overhead_ratio);
-    NS_UNMOCK(we_are_hibernating);
-    NS_UNMOCK(public_server_mode);
-    NS_UNMOCK(get_uptime);
-    NS_UNMOCK(get_bytes_read);
-    NS_UNMOCK(get_bytes_written);
-    NS_UNMOCK(logv);
-    NS_UNMOCK(server_mode);
+    UNMOCK(tls_get_write_overhead_ratio);
+    UNMOCK(we_are_hibernating);
+    UNMOCK(public_server_mode);
+    UNMOCK(get_uptime);
+    UNMOCK(get_bytes_read);
+    UNMOCK(get_bytes_written);
+    UNMOCK(logv);
+    UNMOCK(server_mode);
 }
static double
-NS(tls_get_write_overhead_ratio)(void)
+status_hb_simple_tls_get_write_overhead_ratio(void)
 {
   return 1.0;
 }
static int
-NS(we_are_hibernating)(void)
+status_hb_simple_we_are_hibernating(void)
 {
   return 1;
 }
static int
-NS(public_server_mode)(const or_options_t *options)
+status_hb_simple_public_server_mode(const or_options_t *options)
 {
   (void)options;
@@ -547,30 +568,30 @@ NS(public_server_mode)(const or_options_t *options)
 }
static long
-NS(get_uptime)(void)
+status_hb_simple_get_uptime(void)
 {
   return 0;
 }
static uint64_t
-NS(get_bytes_read)(void)
+status_hb_simple_get_bytes_read(void)
 {
   return 0;
 }
static uint64_t
-NS(get_bytes_written)(void)
+status_hb_simple_get_bytes_written(void)
 {
   return 0;
 }
static void
-NS(logv)(int severity, log_domain_mask_t domain, const char *funcname,
+status_hb_simple_logv(int severity, log_domain_mask_t domain, const char *funcname,
   const char *suffix, const char *format, va_list ap)
 {
   if (severity == LOG_INFO)
     return;
-  ++NS(n_msgs);
+  ++status_hb_simple_n_msgs;
tt_int_op(severity, OP_EQ, LOG_NOTICE);
   tt_u64_op(domain, OP_EQ, LD_HEARTBEAT);
@@ -590,53 +611,72 @@ NS(logv)(int severity, log_domain_mask_t domain, const char *funcname,
 }
static int
-NS(server_mode)(const or_options_t *options)
+status_hb_simple_server_mode(const or_options_t *options)
 {
   (void)options;
return 0;
 }
-#undef NS_SUBMODULE
-#define NS_SUBMODULE ASPECT(hb, calls_log_accounting)
-
 /*
  * Tests that log_heartbeat() correctly logs heartbeat information
  * and accounting information when configured.
  */
-NS_DECL(double, tls_get_write_overhead_ratio, (void));
-NS_DECL(int, we_are_hibernating, (void));
-NS_DECL(int, public_server_mode, (const or_options_t *options));
-NS_DECL(long, get_uptime, (void));
-NS_DECL(uint64_t, get_bytes_read, (void));
-NS_DECL(uint64_t, get_bytes_written, (void));
-NS_DECL(void, logv, (int severity, log_domain_mask_t domain, const char *funcname, const char *suffix, const char *format, va_list ap));
-NS_DECL(int, server_mode, (const or_options_t *options));
-NS_DECL(or_state_t *, get_or_state, (void));
-NS_DECL(int, accounting_is_enabled, (const or_options_t *options));
-NS_DECL(time_t, accounting_get_end_time, (void));
-
-static or_state_t * NS(mock_state) = NULL;
-static or_options_t * NS(mock_options) = NULL;
+static double status_hb_calls_log_accounting_tls_get_write_overhead_ratio(void);
+ATTR_UNUSED static int status_hb_calls_log_accounting_tls_get_write_overhead_ratio_called = 0;
+static int status_hb_calls_log_accounting_we_are_hibernating(void);
+ATTR_UNUSED static int status_hb_calls_log_accounting_we_are_hibernating_called = 0;
+static int status_hb_calls_log_accounting_public_server_mode(const or_options_t *options);
+ATTR_UNUSED static int status_hb_calls_log_accounting_public_server_mode_called = 0;
+static long status_hb_calls_log_accounting_get_uptime(void);
+ATTR_UNUSED static int status_hb_calls_log_accounting_get_uptime_called = 0;
+static uint64_t status_hb_calls_log_accounting_get_bytes_read(void);
+ATTR_UNUSED static int status_hb_calls_log_accounting_get_bytes_read_called = 0;
+static uint64_t status_hb_calls_log_accounting_get_bytes_written(void);
+ATTR_UNUSED static int status_hb_calls_log_accounting_get_bytes_written_called = 0;
+static void status_hb_calls_log_accounting_logv(int severity, log_domain_mask_t domain, const char *funcname, const char *suffix, const char *format, va_list ap);
+ATTR_UNUSED static int status_hb_calls_log_accounting_logv_called = 0;
+static int status_hb_calls_log_accounting_server_mode(const or_options_t *options);
+ATTR_UNUSED static int status_hb_calls_log_accounting_server_mode_called = 0;
+static or_state_t * status_hb_calls_log_accounting_get_or_state(void);
+ATTR_UNUSED static int status_hb_calls_log_accounting_get_or_state_called = 0;
+static int status_hb_calls_log_accounting_accounting_is_enabled(const or_options_t *options);
+ATTR_UNUSED static int status_hb_calls_log_accounting_accounting_is_enabled_called = 0;
+static time_t status_hb_calls_log_accounting_accounting_get_end_time(void);
+ATTR_UNUSED static int status_hb_calls_log_accounting_accounting_get_end_time_called = 0;
+
+static or_state_t * status_hb_calls_log_accounting_mock_state = NULL;
+static or_options_t * status_hb_calls_log_accounting_mock_options = NULL;
static void
-NS(test_main)(void *arg)
+test_status_hb_calls_log_accounting(void *arg)
 {
   int expected, actual;
   (void)arg;
-  NS_MOCK(tls_get_write_overhead_ratio);
-  NS_MOCK(we_are_hibernating);
-  NS_MOCK(public_server_mode);
-  NS_MOCK(get_uptime);
-  NS_MOCK(get_bytes_read);
-  NS_MOCK(get_bytes_written);
-  NS_MOCK(logv);
-  NS_MOCK(server_mode);
-  NS_MOCK(get_or_state);
-  NS_MOCK(accounting_is_enabled);
-  NS_MOCK(accounting_get_end_time);
+  MOCK(tls_get_write_overhead_ratio,
+       status_hb_calls_log_accounting_tls_get_write_overhead_ratio);
+  MOCK(we_are_hibernating,
+       status_hb_calls_log_accounting_we_are_hibernating);
+  MOCK(public_server_mode,
+       status_hb_calls_log_accounting_public_server_mode);
+  MOCK(get_uptime,
+       status_hb_calls_log_accounting_get_uptime);
+  MOCK(get_bytes_read,
+       status_hb_calls_log_accounting_get_bytes_read);
+  MOCK(get_bytes_written,
+       status_hb_calls_log_accounting_get_bytes_written);
+  MOCK(logv,
+       status_hb_calls_log_accounting_logv);
+  MOCK(server_mode,
+       status_hb_calls_log_accounting_server_mode);
+  MOCK(get_or_state,
+       status_hb_calls_log_accounting_get_or_state);
+  MOCK(accounting_is_enabled,
+       status_hb_calls_log_accounting_accounting_is_enabled);
+  MOCK(accounting_get_end_time,
+       status_hb_calls_log_accounting_accounting_get_end_time);
log_global_min_severity_ = LOG_DEBUG;
@@ -644,37 +684,37 @@ NS(test_main)(void *arg)
   actual = log_heartbeat(0);
tt_int_op(actual, OP_EQ, expected);
-  tt_int_op(CALLED(logv), OP_EQ, 3);
+  tt_int_op(status_hb_calls_log_accounting_logv_called, OP_EQ, 3);
done:
-    NS_UNMOCK(tls_get_write_overhead_ratio);
-    NS_UNMOCK(we_are_hibernating);
-    NS_UNMOCK(public_server_mode);
-    NS_UNMOCK(get_uptime);
-    NS_UNMOCK(get_bytes_read);
-    NS_UNMOCK(get_bytes_written);
-    NS_UNMOCK(logv);
-    NS_UNMOCK(server_mode);
-    NS_UNMOCK(accounting_is_enabled);
-    NS_UNMOCK(accounting_get_end_time);
-    tor_free_(NS(mock_state));
-    tor_free_(NS(mock_options));
+    UNMOCK(tls_get_write_overhead_ratio);
+    UNMOCK(we_are_hibernating);
+    UNMOCK(public_server_mode);
+    UNMOCK(get_uptime);
+    UNMOCK(get_bytes_read);
+    UNMOCK(get_bytes_written);
+    UNMOCK(logv);
+    UNMOCK(server_mode);
+    UNMOCK(accounting_is_enabled);
+    UNMOCK(accounting_get_end_time);
+    tor_free_(status_hb_calls_log_accounting_mock_state);
+    tor_free_(status_hb_calls_log_accounting_mock_options);
 }
static double
-NS(tls_get_write_overhead_ratio)(void)
+status_hb_calls_log_accounting_tls_get_write_overhead_ratio(void)
 {
   return 1.0;
 }
static int
-NS(we_are_hibernating)(void)
+status_hb_calls_log_accounting_we_are_hibernating(void)
 {
   return 0;
 }
static int
-NS(public_server_mode)(const or_options_t *options)
+status_hb_calls_log_accounting_public_server_mode(const or_options_t *options)
 {
   (void)options;
@@ -682,28 +722,28 @@ NS(public_server_mode)(const or_options_t *options)
 }
static long
-NS(get_uptime)(void)
+status_hb_calls_log_accounting_get_uptime(void)
 {
   return 0;
 }
static uint64_t
-NS(get_bytes_read)(void)
+status_hb_calls_log_accounting_get_bytes_read(void)
 {
   return 0;
 }
static uint64_t
-NS(get_bytes_written)(void)
+status_hb_calls_log_accounting_get_bytes_written(void)
 {
   return 0;
 }
static void
-NS(logv)(int severity, log_domain_mask_t domain,
+status_hb_calls_log_accounting_logv(int severity, log_domain_mask_t domain,
   const char *funcname, const char *suffix, const char *format, va_list ap)
 {
-  switch (CALLED(logv))
+  switch (status_hb_calls_log_accounting_logv_called)
   {
     case 0:
       tt_int_op(severity, OP_EQ, LOG_NOTICE);
@@ -748,11 +788,11 @@ NS(logv)(int severity, log_domain_mask_t domain,
   }
done:
-    CALLED(logv)++;
+    status_hb_calls_log_accounting_logv_called++;
 }
static int
-NS(server_mode)(const or_options_t *options)
+status_hb_calls_log_accounting_server_mode(const or_options_t *options)
 {
   (void)options;
@@ -760,7 +800,7 @@ NS(server_mode)(const or_options_t *options)
 }
static int
-NS(accounting_is_enabled)(const or_options_t *options)
+status_hb_calls_log_accounting_accounting_is_enabled(const or_options_t *options)
 {
   (void)options;
@@ -768,54 +808,69 @@ NS(accounting_is_enabled)(const or_options_t *options)
 }
static time_t
-NS(accounting_get_end_time)(void)
+status_hb_calls_log_accounting_accounting_get_end_time(void)
 {
   return 60;
 }
static or_state_t *
-NS(get_or_state)(void)
+status_hb_calls_log_accounting_get_or_state(void)
 {
-  NS(mock_state) = tor_malloc_zero(sizeof(or_state_t));
-  NS(mock_state)->AccountingBytesReadInInterval = 0;
-  NS(mock_state)->AccountingBytesWrittenInInterval = 0;
+  status_hb_calls_log_accounting_mock_state = tor_malloc_zero(sizeof(or_state_t));
+  status_hb_calls_log_accounting_mock_state->AccountingBytesReadInInterval = 0;
+  status_hb_calls_log_accounting_mock_state->AccountingBytesWrittenInInterval = 0;
-  return NS(mock_state);
+  return status_hb_calls_log_accounting_mock_state;
 }
-#undef NS_SUBMODULE
-#define NS_SUBMODULE ASPECT(hb, packaged_cell_fullness)
-
 /*
  * Tests that log_heartbeat() correctly logs packaged cell
  * fullness information.
  */
-NS_DECL(double, tls_get_write_overhead_ratio, (void));
-NS_DECL(int, we_are_hibernating, (void));
-NS_DECL(int, public_server_mode, (const or_options_t *options));
-NS_DECL(long, get_uptime, (void));
-NS_DECL(uint64_t, get_bytes_read, (void));
-NS_DECL(uint64_t, get_bytes_written, (void));
-NS_DECL(void, logv, (int severity, log_domain_mask_t domain, const char *funcname, const char *suffix, const char *format, va_list ap));
-NS_DECL(int, server_mode, (const or_options_t *options));
-NS_DECL(int, accounting_is_enabled, (const or_options_t *options));
+static double status_hb_packaged_cell_fullness_tls_get_write_overhead_ratio(void);
+ATTR_UNUSED static int status_hb_packaged_cell_fullness_tls_get_write_overhead_ratio_called = 0;
+static int status_hb_packaged_cell_fullness_we_are_hibernating(void);
+ATTR_UNUSED static int status_hb_packaged_cell_fullness_we_are_hibernating_called = 0;
+static int status_hb_packaged_cell_fullness_public_server_mode(const or_options_t *options);
+ATTR_UNUSED static int status_hb_packaged_cell_fullness_public_server_mode_called = 0;
+static long status_hb_packaged_cell_fullness_get_uptime(void);
+ATTR_UNUSED static int status_hb_packaged_cell_fullness_get_uptime_called = 0;
+static uint64_t status_hb_packaged_cell_fullness_get_bytes_read(void);
+ATTR_UNUSED static int status_hb_packaged_cell_fullness_get_bytes_read_called = 0;
+static uint64_t status_hb_packaged_cell_fullness_get_bytes_written(void);
+ATTR_UNUSED static int status_hb_packaged_cell_fullness_get_bytes_written_called = 0;
+static void status_hb_packaged_cell_fullness_logv(int severity, log_domain_mask_t domain, const char *funcname, const char *suffix, const char *format, va_list ap);
+ATTR_UNUSED static int status_hb_packaged_cell_fullness_logv_called = 0;
+static int status_hb_packaged_cell_fullness_server_mode(const or_options_t *options);
+ATTR_UNUSED static int status_hb_packaged_cell_fullness_server_mode_called = 0;
+static int status_hb_packaged_cell_fullness_accounting_is_enabled(const or_options_t *options);
+ATTR_UNUSED static int status_hb_packaged_cell_fullness_accounting_is_enabled_called = 0;
static void
-NS(test_main)(void *arg)
+test_status_hb_packaged_cell_fullness(void *arg)
 {
   int expected, actual;
   (void)arg;
-  NS_MOCK(tls_get_write_overhead_ratio);
-  NS_MOCK(we_are_hibernating);
-  NS_MOCK(public_server_mode);
-  NS_MOCK(get_uptime);
-  NS_MOCK(get_bytes_read);
-  NS_MOCK(get_bytes_written);
-  NS_MOCK(logv);
-  NS_MOCK(server_mode);
-  NS_MOCK(accounting_is_enabled);
+  MOCK(tls_get_write_overhead_ratio,
+       status_hb_packaged_cell_fullness_tls_get_write_overhead_ratio);
+  MOCK(we_are_hibernating,
+       status_hb_packaged_cell_fullness_we_are_hibernating);
+  MOCK(public_server_mode,
+       status_hb_packaged_cell_fullness_public_server_mode);
+  MOCK(get_uptime,
+       status_hb_packaged_cell_fullness_get_uptime);
+  MOCK(get_bytes_read,
+       status_hb_packaged_cell_fullness_get_bytes_read);
+  MOCK(get_bytes_written,
+       status_hb_packaged_cell_fullness_get_bytes_written);
+  MOCK(logv,
+       status_hb_packaged_cell_fullness_logv);
+  MOCK(server_mode,
+       status_hb_packaged_cell_fullness_server_mode);
+  MOCK(accounting_is_enabled,
+       status_hb_packaged_cell_fullness_accounting_is_enabled);
   log_global_min_severity_ = LOG_DEBUG;
stats_n_data_bytes_packaged = RELAY_PAYLOAD_SIZE;
@@ -824,36 +879,36 @@ NS(test_main)(void *arg)
   actual = log_heartbeat(0);
tt_int_op(actual, OP_EQ, expected);
-  tt_int_op(CALLED(logv), OP_EQ, 2);
+  tt_int_op(status_hb_packaged_cell_fullness_logv_called, OP_EQ, 2);
done:
     stats_n_data_bytes_packaged = 0;
     stats_n_data_cells_packaged = 0;
-    NS_UNMOCK(tls_get_write_overhead_ratio);
-    NS_UNMOCK(we_are_hibernating);
-    NS_UNMOCK(public_server_mode);
-    NS_UNMOCK(get_uptime);
-    NS_UNMOCK(get_bytes_read);
-    NS_UNMOCK(get_bytes_written);
-    NS_UNMOCK(logv);
-    NS_UNMOCK(server_mode);
-    NS_UNMOCK(accounting_is_enabled);
+    UNMOCK(tls_get_write_overhead_ratio);
+    UNMOCK(we_are_hibernating);
+    UNMOCK(public_server_mode);
+    UNMOCK(get_uptime);
+    UNMOCK(get_bytes_read);
+    UNMOCK(get_bytes_written);
+    UNMOCK(logv);
+    UNMOCK(server_mode);
+    UNMOCK(accounting_is_enabled);
 }
static double
-NS(tls_get_write_overhead_ratio)(void)
+status_hb_packaged_cell_fullness_tls_get_write_overhead_ratio(void)
 {
   return 1.0;
 }
static int
-NS(we_are_hibernating)(void)
+status_hb_packaged_cell_fullness_we_are_hibernating(void)
 {
   return 0;
 }
static int
-NS(public_server_mode)(const or_options_t *options)
+status_hb_packaged_cell_fullness_public_server_mode(const or_options_t *options)
 {
   (void)options;
@@ -861,28 +916,28 @@ NS(public_server_mode)(const or_options_t *options)
 }
static long
-NS(get_uptime)(void)
+status_hb_packaged_cell_fullness_get_uptime(void)
 {
   return 0;
 }
static uint64_t
-NS(get_bytes_read)(void)
+status_hb_packaged_cell_fullness_get_bytes_read(void)
 {
   return 0;
 }
static uint64_t
-NS(get_bytes_written)(void)
+status_hb_packaged_cell_fullness_get_bytes_written(void)
 {
   return 0;
 }
static void
-NS(logv)(int severity, log_domain_mask_t domain, const char *funcname,
+status_hb_packaged_cell_fullness_logv(int severity, log_domain_mask_t domain, const char *funcname,
     const char *suffix, const char *format, va_list ap)
 {
-  switch (CALLED(logv))
+  switch (status_hb_packaged_cell_fullness_logv_called)
   {
     case 0:
       tt_int_op(severity, OP_EQ, LOG_NOTICE);
@@ -915,11 +970,11 @@ NS(logv)(int severity, log_domain_mask_t domain, const char *funcname,
   }
done:
-    CALLED(logv)++;
+    status_hb_packaged_cell_fullness_logv_called++;
 }
static int
-NS(server_mode)(const or_options_t *options)
+status_hb_packaged_cell_fullness_server_mode(const or_options_t *options)
 {
   (void)options;
@@ -927,46 +982,61 @@ NS(server_mode)(const or_options_t *options)
 }
static int
-NS(accounting_is_enabled)(const or_options_t *options)
+status_hb_packaged_cell_fullness_accounting_is_enabled(const or_options_t *options)
 {
   (void)options;
return 0;
 }
-#undef NS_SUBMODULE
-#define NS_SUBMODULE ASPECT(hb, tls_write_overhead)
-
 /*
  * Tests that log_heartbeat() correctly logs the TLS write overhead information
  * when the TLS write overhead ratio exceeds 1.
  */
-NS_DECL(double, tls_get_write_overhead_ratio, (void));
-NS_DECL(int, we_are_hibernating, (void));
-NS_DECL(int, public_server_mode, (const or_options_t *options));
-NS_DECL(long, get_uptime, (void));
-NS_DECL(uint64_t, get_bytes_read, (void));
-NS_DECL(uint64_t, get_bytes_written, (void));
-NS_DECL(void, logv, (int severity, log_domain_mask_t domain, const char *funcname, const char *suffix, const char *format, va_list ap));
-NS_DECL(int, server_mode, (const or_options_t *options));
-NS_DECL(int, accounting_is_enabled, (const or_options_t *options));
+static double status_hb_tls_write_overhead_tls_get_write_overhead_ratio(void);
+ATTR_UNUSED static int status_hb_tls_write_overhead_tls_get_write_overhead_ratio_called = 0;
+static int status_hb_tls_write_overhead_we_are_hibernating(void);
+ATTR_UNUSED static int status_hb_tls_write_overhead_we_are_hibernating_called = 0;
+static int status_hb_tls_write_overhead_public_server_mode(const or_options_t *options);
+ATTR_UNUSED static int status_hb_tls_write_overhead_public_server_mode_called = 0;
+static long status_hb_tls_write_overhead_get_uptime(void);
+ATTR_UNUSED static int status_hb_tls_write_overhead_get_uptime_called = 0;
+static uint64_t status_hb_tls_write_overhead_get_bytes_read(void);
+ATTR_UNUSED static int status_hb_tls_write_overhead_get_bytes_read_called = 0;
+static uint64_t status_hb_tls_write_overhead_get_bytes_written(void);
+ATTR_UNUSED static int status_hb_tls_write_overhead_get_bytes_written_called = 0;
+static void status_hb_tls_write_overhead_logv(int severity, log_domain_mask_t domain, const char *funcname, const char *suffix, const char *format, va_list ap);
+ATTR_UNUSED static int status_hb_tls_write_overhead_logv_called = 0;
+static int status_hb_tls_write_overhead_server_mode(const or_options_t *options);
+ATTR_UNUSED static int status_hb_tls_write_overhead_server_mode_called = 0;
+static int status_hb_tls_write_overhead_accounting_is_enabled(const or_options_t *options);
+ATTR_UNUSED static int status_hb_tls_write_overhead_accounting_is_enabled_called = 0;
static void
-NS(test_main)(void *arg)
+test_status_hb_tls_write_overhead(void *arg)
 {
   int expected, actual;
   (void)arg;
-  NS_MOCK(tls_get_write_overhead_ratio);
-  NS_MOCK(we_are_hibernating);
-  NS_MOCK(public_server_mode);
-  NS_MOCK(get_uptime);
-  NS_MOCK(get_bytes_read);
-  NS_MOCK(get_bytes_written);
-  NS_MOCK(logv);
-  NS_MOCK(server_mode);
-  NS_MOCK(accounting_is_enabled);
+  MOCK(tls_get_write_overhead_ratio,
+       status_hb_tls_write_overhead_tls_get_write_overhead_ratio);
+  MOCK(we_are_hibernating,
+       status_hb_tls_write_overhead_we_are_hibernating);
+  MOCK(public_server_mode,
+       status_hb_tls_write_overhead_public_server_mode);
+  MOCK(get_uptime,
+       status_hb_tls_write_overhead_get_uptime);
+  MOCK(get_bytes_read,
+       status_hb_tls_write_overhead_get_bytes_read);
+  MOCK(get_bytes_written,
+       status_hb_tls_write_overhead_get_bytes_written);
+  MOCK(logv,
+       status_hb_tls_write_overhead_logv);
+  MOCK(server_mode,
+       status_hb_tls_write_overhead_server_mode);
+  MOCK(accounting_is_enabled,
+       status_hb_tls_write_overhead_accounting_is_enabled);
   stats_n_data_cells_packaged = 0;
   log_global_min_severity_ = LOG_DEBUG;
@@ -974,34 +1044,34 @@ NS(test_main)(void *arg)
   actual = log_heartbeat(0);
tt_int_op(actual, OP_EQ, expected);
-  tt_int_op(CALLED(logv), OP_EQ, 2);
+  tt_int_op(status_hb_tls_write_overhead_logv_called, OP_EQ, 2);
done:
-    NS_UNMOCK(tls_get_write_overhead_ratio);
-    NS_UNMOCK(we_are_hibernating);
-    NS_UNMOCK(public_server_mode);
-    NS_UNMOCK(get_uptime);
-    NS_UNMOCK(get_bytes_read);
-    NS_UNMOCK(get_bytes_written);
-    NS_UNMOCK(logv);
-    NS_UNMOCK(server_mode);
-    NS_UNMOCK(accounting_is_enabled);
+    UNMOCK(tls_get_write_overhead_ratio);
+    UNMOCK(we_are_hibernating);
+    UNMOCK(public_server_mode);
+    UNMOCK(get_uptime);
+    UNMOCK(get_bytes_read);
+    UNMOCK(get_bytes_written);
+    UNMOCK(logv);
+    UNMOCK(server_mode);
+    UNMOCK(accounting_is_enabled);
 }
static double
-NS(tls_get_write_overhead_ratio)(void)
+status_hb_tls_write_overhead_tls_get_write_overhead_ratio(void)
 {
   return 2.0;
 }
static int
-NS(we_are_hibernating)(void)
+status_hb_tls_write_overhead_we_are_hibernating(void)
 {
   return 0;
 }
static int
-NS(public_server_mode)(const or_options_t *options)
+status_hb_tls_write_overhead_public_server_mode(const or_options_t *options)
 {
   (void)options;
@@ -1009,28 +1079,28 @@ NS(public_server_mode)(const or_options_t *options)
 }
static long
-NS(get_uptime)(void)
+status_hb_tls_write_overhead_get_uptime(void)
 {
   return 0;
 }
static uint64_t
-NS(get_bytes_read)(void)
+status_hb_tls_write_overhead_get_bytes_read(void)
 {
   return 0;
 }
static uint64_t
-NS(get_bytes_written)(void)
+status_hb_tls_write_overhead_get_bytes_written(void)
 {
   return 0;
 }
static void
-NS(logv)(int severity, log_domain_mask_t domain,
+status_hb_tls_write_overhead_logv(int severity, log_domain_mask_t domain,
   const char *funcname, const char *suffix, const char *format, va_list ap)
 {
-  switch (CALLED(logv))
+  switch (status_hb_tls_write_overhead_logv_called)
   {
     case 0:
       tt_int_op(severity, OP_EQ, LOG_NOTICE);
@@ -1063,11 +1133,11 @@ NS(logv)(int severity, log_domain_mask_t domain,
   }
done:
-    CALLED(logv)++;
+    status_hb_tls_write_overhead_logv_called++;
 }
static int
-NS(server_mode)(const or_options_t *options)
+status_hb_tls_write_overhead_server_mode(const or_options_t *options)
 {
   (void)options;
@@ -1075,24 +1145,22 @@ NS(server_mode)(const or_options_t *options)
 }
static int
-NS(accounting_is_enabled)(const or_options_t *options)
+status_hb_tls_write_overhead_accounting_is_enabled(const or_options_t *options)
 {
   (void)options;
return 0;
 }
-#undef NS_SUBMODULE
-
 struct testcase_t status_tests[] = {
-  TEST_CASE(count_circuits),
-  TEST_CASE(secs_to_uptime),
-  TEST_CASE(bytes_to_usage),
-  TEST_CASE_ASPECT(hb, fails),
-  TEST_CASE_ASPECT(hb, simple),
-  TEST_CASE_ASPECT(hb, not_in_consensus),
-  TEST_CASE_ASPECT(hb, calls_log_accounting),
-  TEST_CASE_ASPECT(hb, packaged_cell_fullness),
-  TEST_CASE_ASPECT(hb, tls_write_overhead),
+  { "count_circuits", test_status_count_circuits, TT_FORK, NULL, NULL },
+  { "secs_to_uptime", test_status_secs_to_uptime, TT_FORK, NULL, NULL },
+  { "bytes_to_usage", test_status_bytes_to_usage, TT_FORK, NULL, NULL },
+  { "hb_fails", test_status_hb_fails, TT_FORK, NULL, NULL },
+  { "hb_simple", test_status_hb_simple, TT_FORK, NULL, NULL },
+  { "hb_not_in_consensus", test_status_hb_not_in_consensus, TT_FORK, NULL, NULL },
+  { "hb_calls_log_accounting", test_status_hb_calls_log_accounting, TT_FORK, NULL, NULL },
+  { "hb_packaged_cell_fullness", test_status_hb_packaged_cell_fullness, TT_FORK, NULL, NULL },
+  { "hb_tls_write_overhead", test_status_hb_tls_write_overhead, TT_FORK, NULL, NULL },
   END_OF_TESTCASES
 };
diff --git a/src/test/test_tortls.c b/src/test/test_tortls.c
index 5f6de6cd1..a822bc5ad 100644
--- a/src/test/test_tortls.c
+++ b/src/test/test_tortls.c
@@ -214,7 +214,7 @@ test_tortls_tor_tls_get_error(void *data)
done:
   UNMOCK(tor_tls_cert_matches_key);
-  NS_UNMOCK(logv);
+  UNMOCK(logv);
   crypto_pk_free(key1);
   crypto_pk_free(key2);
   tor_tls_free(tls);
diff --git a/src/test/test_tortls_openssl.c b/src/test/test_tortls_openssl.c
index 8ccad20bb..4318f7f1e 100644
--- a/src/test/test_tortls_openssl.c
+++ b/src/test/test_tortls_openssl.c
@@ -46,8 +46,6 @@ ENABLE_GCC_WARNING("-Wredundant-decls")
 #include "test/log_test_helpers.h"
 #include "test/test_tortls.h"
-#define NS_MODULE tortls
-
 #ifndef HAVE_SSL_STATE
 #define OPENSSL_OPAQUE
 #endif
@@ -123,8 +121,6 @@ test_tortls_tor_tls_new(void *data)
   tor_tls_free_all();
 }
-#define NS_MODULE tortls
-
 static void
 library_init(void)
 {
diff --git a/src/test/test_util_format.c b/src/test/test_util_format.c
index bbbf365f1..726e8e742 100644
--- a/src/test/test_util_format.c
+++ b/src/test/test_util_format.c
@@ -9,8 +9,6 @@
 #include "lib/crypt_ops/crypto_rand.h"
 #include "lib/encoding/binascii.h"
-#define NS_MODULE util_format
-
 static void
 test_util_format_unaligned_accessors(void *ignored)
 {
diff --git a/src/test/test_util_process.c b/src/test/test_util_process.c
index 5de729dd6..0e17e009f 100644
--- a/src/test/test_util_process.c
+++ b/src/test/test_util_process.c
@@ -11,7 +11,6 @@
 #include "test/log_test_helpers.h"
#ifndef _WIN32
-#define NS_MODULE util_process
static void
 temp_callback(int r, void *s)

    