nodelist: Rename functions that look at the family list.

We want to be really careful to make it clear that the family-list
is not the same as the family itself.

diff --git a/src/feature/nodelist/nodelist.c b/src/feature/nodelist/nodelist.c
index 18550f3235dbdb8d1e18b6b1c48f912e985eefbc..8f0f46d132f0c4330abb0f0b005f1f769330d3f7 100644 (file)
--- a/src/feature/nodelist/nodelist.c
+++ b/src/feature/nodelist/nodelist.c
@@ -2142,7 +2142,7 @@ node_in_nickname_smartlist(const smartlist_t *lst, const node_t *node)
 
 /** Return true iff n1's declared family contains n2. */
 STATIC int
-node_family_contains(const node_t *n1, const node_t *n2)
+node_family_list_contains(const node_t *n1, const node_t *n2)
 {
   if (n1->ri && n1->ri->declared_family) {
     return node_in_nickname_smartlist(n1->ri->declared_family, n2);
@@ -2157,7 +2157,7 @@ node_family_contains(const node_t *n1, const node_t *n2)
  * Return true iff <b>node</b> has declared a nonempty family.
  **/
 STATIC bool
-node_has_declared_family(const node_t *node)
+node_has_declared_family_list(const node_t *node)
 {
   if (node->ri && node->ri->declared_family &&
       smartlist_len(node->ri->declared_family)) {
@@ -2177,7 +2177,7 @@ node_has_declared_family(const node_t *node)
  * also agree that node is in their family.)
  **/
 STATIC void
-node_lookup_declared_family(smartlist_t *out, const node_t *node)
+node_lookup_declared_family_list(smartlist_t *out, const node_t *node)
 {
   if (node->ri && node->ri->declared_family &&
       smartlist_len(node->ri->declared_family)) {
@@ -2218,8 +2218,8 @@ nodes_in_same_family(const node_t *node1, const node_t *node2)
   }
 
   /* Are they in the same family because the agree they are? */
-  if (node_family_contains(node1, node2) &&
-      node_family_contains(node2, node1)) {
+  if (node_family_list_contains(node1, node2) &&
+      node_family_list_contains(node2, node1)) {
     return 1;
   }
 
@@ -2279,14 +2279,14 @@ nodelist_add_node_and_family(smartlist_t *sl, const node_t *node)
 
   /* Now, add all nodes in the declared family of this node, if they
    * also declare this node to be in their family. */
-  if (node_has_declared_family(node)) {
+  if (node_has_declared_family_list(node)) {
     smartlist_t *declared_family = smartlist_new();
-    node_lookup_declared_family(declared_family, node);
+    node_lookup_declared_family_list(declared_family, node);
 
     /* Add every r such that router declares familyness with node, and node
      * declares familyhood with router. */
     SMARTLIST_FOREACH_BEGIN(declared_family, const node_t *, node2) {
-      if (node_family_contains(node2, node)) {
+      if (node_family_list_contains(node2, node)) {
         smartlist_add(sl, (void*)node2);
       }
     } SMARTLIST_FOREACH_END(node2);

diff --git a/src/feature/nodelist/nodelist.h b/src/feature/nodelist/nodelist.h
index 948a293f0ca194e95f4fc8e4fb4878a0bee8bca8..ae80dca6e8b92d891a9da427205a71aa2343b44d 100644 (file)
--- a/src/feature/nodelist/nodelist.h
+++ b/src/feature/nodelist/nodelist.h
@@ -170,9 +170,10 @@ int count_loading_descriptors_progress(void);
 STATIC int node_nickname_matches(const node_t *node, const char *nickname);
 STATIC int node_in_nickname_smartlist(const smartlist_t *lst,
                                       const node_t *node);
-STATIC int node_family_contains(const node_t *n1, const node_t *n2);
-STATIC bool node_has_declared_family(const node_t *node);
-STATIC void node_lookup_declared_family(smartlist_t *out, const node_t *node);
+STATIC int node_family_list_contains(const node_t *n1, const node_t *n2);
+STATIC bool node_has_declared_family_list(const node_t *node);
+STATIC void node_lookup_declared_family_list(smartlist_t *out,
+                                             const node_t *node);
 
 #ifdef TOR_UNIT_TESTS
 

diff --git a/src/test/test_nodelist.c b/src/test/test_nodelist.c
index ecd29f54645c03e74acd0cc086bc9498b592448e..f387684d577f8b3de919ed61e6d48dd7c8c9ef59 100644 (file)
--- a/src/test/test_nodelist.c
+++ b/src/test/test_nodelist.c
@@ -559,34 +559,34 @@ test_nodelist_node_nodefamily(void *arg)
   memcpy(mock_node2.identity, "SecondNodeWe'reTestn", DIGEST_LEN);
 
   // empty families.
-  tt_assert(! node_family_contains(&mock_node1, &mock_node2));
-  tt_assert(! node_family_contains(&mock_node2, &mock_node1));
+  tt_assert(! node_family_list_contains(&mock_node1, &mock_node2));
+  tt_assert(! node_family_list_contains(&mock_node2, &mock_node1));
 
   // Families contain nodes, but not these nodes
   mock_ri.declared_family = smartlist_new();
   smartlist_add(mock_ri.declared_family, (char*)"NodeThree");
   mock_md.family = nodefamily_parse("NodeFour", NULL, 0);
-  tt_assert(! node_family_contains(&mock_node1, &mock_node2));
-  tt_assert(! node_family_contains(&mock_node2, &mock_node1));
+  tt_assert(! node_family_list_contains(&mock_node1, &mock_node2));
+  tt_assert(! node_family_list_contains(&mock_node2, &mock_node1));
 
   // Families contain one another.
   smartlist_add(mock_ri.declared_family, (char*)
                 "4e6f64654f6e654e6f6465314e6f64654f6e6531");
-  tt_assert(! node_family_contains(&mock_node1, &mock_node2));
-  tt_assert(node_family_contains(&mock_node2, &mock_node1));
+  tt_assert(! node_family_list_contains(&mock_node1, &mock_node2));
+  tt_assert(node_family_list_contains(&mock_node2, &mock_node1));
 
   nodefamily_free(mock_md.family);
   mock_md.family = nodefamily_parse(
             "NodeFour "
             "5365636f6e644e6f64655765277265546573746e", NULL, 0);
-  tt_assert(node_family_contains(&mock_node1, &mock_node2));
-  tt_assert(node_family_contains(&mock_node2, &mock_node1));
+  tt_assert(node_family_list_contains(&mock_node1, &mock_node2));
+  tt_assert(node_family_list_contains(&mock_node2, &mock_node1));
 
   // Try looking up families now.
   MOCK(node_get_by_nickname, mock_node_get_by_nickname);
   MOCK(node_get_by_id, mock_node_get_by_id);
 
-  node_lookup_declared_family(nodes, &mock_node1);
+  node_lookup_declared_family_list(nodes, &mock_node1);
   tt_int_op(smartlist_len(nodes), OP_EQ, 2);
   const node_t *n = smartlist_get(nodes, 0);
   tt_mem_op(n->identity, OP_EQ, "SecondNodeWe'reTestn", DIGEST_LEN);
@@ -597,7 +597,7 @@ test_nodelist_node_nodefamily(void *arg)
   SMARTLIST_FOREACH(nodes, node_t *, x, tor_free(x));
   smartlist_clear(nodes);
 
-  node_lookup_declared_family(nodes, &mock_node2);
+  node_lookup_declared_family_list(nodes, &mock_node2);
   tt_int_op(smartlist_len(nodes), OP_EQ, 2);
   n = smartlist_get(nodes, 0);
   // This gets a truncated hex hex ID since it was looked up by name