Add scheduler/compare_channels unit test

src/test/test_scheduler.c

@@ -13,13 +13,16 @@
 #endif
 
 #define TOR_CHANNEL_INTERNAL_
+#define CHANNEL_PRIVATE_
 #include "or.h"
 #include "compat_libevent.h"
+#include "channel.h"
 #define SCHEDULER_PRIVATE_
 #include "scheduler.h"
 
 /* Test suite stuff */
 #include "test.h"
+#include "fakechans.h"
 
 /* Statics in scheduler.c exposed to the test suite */
 extern smartlist_t *channels_pending;
@@ -30,15 +33,30 @@ extern time_t queue_heuristic_timestamp;
 /* Event base for scheduelr tests */
 static struct event_base *mock_event_base = NULL;
 
+/* Statics controlling mocks */
+static circuitmux_t *mock_ccm_tgt_1 = NULL;
+static circuitmux_t *mock_ccm_tgt_2 = NULL;
+
+static circuitmux_t *mock_cgp_tgt_1 = NULL;
+static const circuitmux_policy_t *mock_cgp_val_1 = NULL;
+static circuitmux_t *mock_cgp_tgt_2 = NULL;
+static const circuitmux_policy_t *mock_cgp_val_2 = NULL;
+
 /* Setup for mock event stuff */
 static void mock_event_free_all(void);
 static void mock_event_init(void);
 
 /* Mocks used by scheduler tests */
+static int circuitmux_compare_muxes_mock(circuitmux_t *cmux_1,
+                                         circuitmux_t *cmux_2);
+static const circuitmux_policy_t * circuitmux_get_policy_mock(
+    circuitmux_t *cmux);
 static struct event_base * tor_libevent_get_base_mock(void);
 
 /* Scheduler test cases */
+static void test_scheduler_compare_channels(void *arg);
 static void test_scheduler_initfree(void *arg);
+static void test_scheduler_queue_heuristic(void *arg);
 
 /* Mock event init/free */
 
@@ -99,6 +117,51 @@ mock_event_init(void)
 
 /* Mocks */
 
+static int
+circuitmux_compare_muxes_mock(circuitmux_t *cmux_1,
+                              circuitmux_t *cmux_2)
+{
+  int result = 0;
+
+  test_assert(cmux_1 != NULL);
+  test_assert(cmux_2 != NULL);
+
+  if (cmux_1 != cmux_2) {
+    if (cmux_1 == mock_ccm_tgt_1 && cmux_2 == mock_ccm_tgt_2) result = -1;
+    else if (cmux_1 == mock_ccm_tgt_2 && cmux_2 == mock_ccm_tgt_1) {
+      result = 1;
+    }
+    else {
+      if (cmux_1 == mock_ccm_tgt_1 || cmux_1 == mock_ccm_tgt_1) result = -1;
+      else if (cmux_2 == mock_ccm_tgt_1 || cmux_2 == mock_ccm_tgt_2) {
+        result = 1;
+      } else {
+        result = circuitmux_compare_muxes__real(cmux_1, cmux_2);
+      }
+    }
+  }
+  /* else result = 0 always */
+
+ done:
+  return result;
+}
+
+static const circuitmux_policy_t *
+circuitmux_get_policy_mock(circuitmux_t *cmux)
+{
+  const circuitmux_policy_t *result = NULL;
+
+  test_assert(cmux != NULL);
+  if (cmux) {
+    if (cmux == mock_cgp_tgt_1) result = mock_cgp_val_1;
+    else if (cmux == mock_cgp_tgt_2) result = mock_cgp_val_2;
+    else result = circuitmux_get_policy__real(cmux);
+  }
+
+ done:
+  return result;
+}
+
 static struct event_base *
 tor_libevent_get_base_mock(void)
 {
@@ -107,6 +170,76 @@ tor_libevent_get_base_mock(void)
 
 /* Test cases */
 
+static void
+test_scheduler_compare_channels(void *arg)
+{
+  /* We don't actually need whole fake channels... */
+  channel_t c1, c2;
+  /* ...and some dummy circuitmuxes too */
+  circuitmux_t *cm1 = NULL, *cm2 = NULL;
+  int result;
+
+  (void)arg;
+
+  /* We can't actually see sizeof(circuitmux_t) from here */
+  cm1 = tor_malloc_zero(sizeof(void *));
+  cm2 = tor_malloc_zero(sizeof(void *));
+
+  c1.cmux = cm1;
+  c2.cmux = cm2;
+
+  /* Configure circuitmux_get_policy() mock */
+  mock_cgp_tgt_1 = cm1;
+  /*
+   * This is to test the different-policies case, which uses the policy
+   * cast to an intptr_t as an arbitrary but definite thing to compare.
+   */
+  mock_cgp_val_1 = (const circuitmux_policy_t *)(1);
+  mock_cgp_tgt_2 = cm2;
+  mock_cgp_val_2 = (const circuitmux_policy_t *)(2);
+
+  MOCK(circuitmux_get_policy, circuitmux_get_policy_mock);
+
+  /* Now set up circuitmux_compare_muxes() mock using cm1/cm2 */
+  mock_ccm_tgt_1 = cm1;
+  mock_ccm_tgt_2 = cm2;
+  MOCK(circuitmux_compare_muxes, circuitmux_compare_muxes_mock);
+
+  /* Equal-channel case */
+  result = scheduler_compare_channels(&c1, &c1);
+  test_eq(result, 0);
+  
+  /* Distinct channels, distinct policies */
+  result = scheduler_compare_channels(&c1, &c2);
+  test_eq(result, -1);
+  result = scheduler_compare_channels(&c2, &c1);
+  test_eq(result, 1);
+
+  /* Distinct channels, same policy */
+  mock_cgp_val_2 = mock_cgp_val_1;
+  result = scheduler_compare_channels(&c1, &c2);
+  test_eq(result, -1);
+  result = scheduler_compare_channels(&c2, &c1);
+  test_eq(result, 1);
+
+ done:
+
+  UNMOCK(circuitmux_compare_muxes);
+  mock_ccm_tgt_1 = NULL;
+  mock_ccm_tgt_2 = NULL;
+
+  UNMOCK(circuitmux_get_policy);
+  mock_cgp_tgt_1 = NULL;
+  mock_cgp_val_1 = NULL;
+  mock_cgp_tgt_2 = NULL;
+  mock_cgp_val_2 = NULL;
+
+  tor_free(cm1);
+  tor_free(cm2);
+
+  return;
+}
+
 static void
 test_scheduler_initfree(void *arg)
 {
@@ -170,6 +303,8 @@ test_scheduler_queue_heuristic(void *arg)
 }
 
 struct testcase_t scheduler_tests[] = {
+  { "compare_channels", test_scheduler_compare_channels,
+    TT_FORK, NULL, NULL },
   { "initfree", test_scheduler_initfree, TT_FORK, NULL, NULL },
   { "queue_heuristic", test_scheduler_queue_heuristic,
     TT_FORK, NULL, NULL },