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
#

1 files changed, 336 insertions, 268 deletions

diff --git a/src/test/test_status.c b/src/test/test_status.c
index 88053a34fa..ffce848dbb 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
 };