osi/test/data_dispatcher_test.cpp

   1 #include <gtest/gtest.h>
   2
   3 #include "AllocationTestHarness.h"
   4
   5 extern "C" {
   6 #include "data_dispatcher.h"
   7 #include "fixed_queue.h"
   8 #include "osi.h"
   9 }
  10
  11 #define DUMMY_TYPE_0 34
  12 #define DUMMY_TYPE_1 42
  13 #define TYPE_EDGE_CASE_ZERO 0
  14 #define TYPE_EDGE_CASE_MAX INT_MAX
  15
  16 #define DUMMY_QUEUE_SIZE 10
  17
  18 class DataDispatcherTest : public AllocationTestHarness {};
  19
  20 static char dummy_data_0[42] = "please test your code";
  21 static char dummy_data_1[42] = "testing is good for your sanity";
  22
  23 TEST_F(DataDispatcherTest, test_new_free_simple) {
  24   data_dispatcher_t *dispatcher = data_dispatcher_new("test_dispatcher");
  25   ASSERT_TRUE(dispatcher != NULL);
  26   data_dispatcher_free(dispatcher);
  27 }
  28
  29 TEST_F(DataDispatcherTest, test_dispatch_single_to_nowhere) {
  30   data_dispatcher_t *dispatcher = data_dispatcher_new("test_dispatcher");
  31   EXPECT_FALSE(data_dispatcher_dispatch(dispatcher, DUMMY_TYPE_0, dummy_data_0));
  32   data_dispatcher_free(dispatcher);
  33 }
  34
  35 TEST_F(DataDispatcherTest, test_dispatch_single_to_single) {
  36   data_dispatcher_t *dispatcher = data_dispatcher_new("test_dispatcher");
  37
  38   // Register a queue
  39   fixed_queue_t *dummy_queue = fixed_queue_new(DUMMY_QUEUE_SIZE);
  40   data_dispatcher_register(dispatcher, DUMMY_TYPE_0, dummy_queue);
  41   EXPECT_TRUE(fixed_queue_is_empty(dummy_queue));
  42
  43   // Send data to the queue
  44   EXPECT_TRUE(data_dispatcher_dispatch(dispatcher, DUMMY_TYPE_0, dummy_data_0));
  45
  46   // Did we get it?
  47   EXPECT_FALSE(fixed_queue_is_empty(dummy_queue));
  48   EXPECT_STREQ(dummy_data_0, (char *)fixed_queue_try_dequeue(dummy_queue));
  49   EXPECT_TRUE(fixed_queue_is_empty(dummy_queue));
  50
  51   fixed_queue_free(dummy_queue, NULL);
  52   data_dispatcher_free(dispatcher);
  53 }
  54
  55 TEST_F(DataDispatcherTest, test_dispatch_single_to_multiple) {
  56   data_dispatcher_t *dispatcher = data_dispatcher_new("test_dispatcher");
  57
  58   // Register two queues
  59   fixed_queue_t *dummy_queue0 = fixed_queue_new(DUMMY_QUEUE_SIZE);
  60   fixed_queue_t *dummy_queue1 = fixed_queue_new(DUMMY_QUEUE_SIZE);
  61   data_dispatcher_register(dispatcher, DUMMY_TYPE_0, dummy_queue0);
  62   data_dispatcher_register(dispatcher, DUMMY_TYPE_1, dummy_queue1);
  63   EXPECT_TRUE(fixed_queue_is_empty(dummy_queue0));
  64   EXPECT_TRUE(fixed_queue_is_empty(dummy_queue1));
  65
  66   // Send data to one of them
  67   EXPECT_TRUE(data_dispatcher_dispatch(dispatcher, DUMMY_TYPE_0, dummy_data_0));
  68
  69   // Did we get it?
  70   EXPECT_FALSE(fixed_queue_is_empty(dummy_queue0));
  71   EXPECT_TRUE(fixed_queue_is_empty(dummy_queue1));
  72   EXPECT_STREQ(dummy_data_0, (char *)fixed_queue_try_dequeue(dummy_queue0));
  73   EXPECT_TRUE(fixed_queue_is_empty(dummy_queue0));
  74
  75   fixed_queue_free(dummy_queue0, NULL);
  76   fixed_queue_free(dummy_queue1, NULL);
  77   data_dispatcher_free(dispatcher);
  78 }
  79
  80 TEST_F(DataDispatcherTest, test_dispatch_single_to_default) {
  81   data_dispatcher_t *dispatcher = data_dispatcher_new("test_dispatcher");
  82
  83   // Register two queues, a default and a typed one
  84   fixed_queue_t *dummy_queue = fixed_queue_new(DUMMY_QUEUE_SIZE);
  85   fixed_queue_t *default_queue = fixed_queue_new(DUMMY_QUEUE_SIZE);
  86   data_dispatcher_register(dispatcher, DUMMY_TYPE_0, dummy_queue);
  87   data_dispatcher_register_default(dispatcher, default_queue);
  88   EXPECT_TRUE(fixed_queue_is_empty(dummy_queue));
  89   EXPECT_TRUE(fixed_queue_is_empty(default_queue));
  90
  91   // Send data to nowhere
  92   EXPECT_TRUE(data_dispatcher_dispatch(dispatcher, DUMMY_TYPE_1, dummy_data_1));
  93
  94   // Did we get it?
  95   EXPECT_TRUE(fixed_queue_is_empty(dummy_queue));
  96   EXPECT_FALSE(fixed_queue_is_empty(default_queue));
  97   EXPECT_STREQ(dummy_data_1, (char *)fixed_queue_try_dequeue(default_queue));
  98   EXPECT_TRUE(fixed_queue_is_empty(default_queue));
  99
 100   fixed_queue_free(dummy_queue, NULL);
 101   fixed_queue_free(default_queue, NULL);
 102   data_dispatcher_free(dispatcher);
 103 }
 104
 105 TEST_F(DataDispatcherTest, test_dispatch_multiple_to_single) {
 106   data_dispatcher_t *dispatcher = data_dispatcher_new("test_dispatcher");
 107
 108   // Register a queue
 109   fixed_queue_t *dummy_queue = fixed_queue_new(DUMMY_QUEUE_SIZE);
 110   data_dispatcher_register(dispatcher, DUMMY_TYPE_0, dummy_queue);
 111   EXPECT_TRUE(fixed_queue_is_empty(dummy_queue));
 112
 113   // Send data to the queue
 114   EXPECT_TRUE(data_dispatcher_dispatch(dispatcher, DUMMY_TYPE_0, dummy_data_0));
 115   EXPECT_TRUE(data_dispatcher_dispatch(dispatcher, DUMMY_TYPE_0, dummy_data_1));
 116
 117   // Did we get it?
 118   EXPECT_FALSE(fixed_queue_is_empty(dummy_queue));
 119   EXPECT_STREQ(dummy_data_0, (char *)fixed_queue_try_dequeue(dummy_queue));
 120   EXPECT_FALSE(fixed_queue_is_empty(dummy_queue));
 121   EXPECT_STREQ(dummy_data_1, (char *)fixed_queue_try_dequeue(dummy_queue));
 122   EXPECT_TRUE(fixed_queue_is_empty(dummy_queue));
 123
 124   fixed_queue_free(dummy_queue, NULL);
 125   data_dispatcher_free(dispatcher);
 126 }
 127
 128 TEST_F(DataDispatcherTest, test_dispatch_multiple_to_multiple) {
 129   data_dispatcher_t *dispatcher = data_dispatcher_new("test_dispatcher");
 130
 131   // Register two queues
 132   fixed_queue_t *dummy_queue0 = fixed_queue_new(DUMMY_QUEUE_SIZE);
 133   fixed_queue_t *dummy_queue1 = fixed_queue_new(DUMMY_QUEUE_SIZE);
 134   data_dispatcher_register(dispatcher, DUMMY_TYPE_0, dummy_queue0);
 135   data_dispatcher_register(dispatcher, DUMMY_TYPE_1, dummy_queue1);
 136   EXPECT_TRUE(fixed_queue_is_empty(dummy_queue0));
 137   EXPECT_TRUE(fixed_queue_is_empty(dummy_queue1));
 138
 139   // Send data to both of them
 140   EXPECT_TRUE(data_dispatcher_dispatch(dispatcher, DUMMY_TYPE_0, dummy_data_0));
 141   EXPECT_TRUE(data_dispatcher_dispatch(dispatcher, DUMMY_TYPE_1, dummy_data_1));
 142
 143   // Did we get it?
 144   EXPECT_FALSE(fixed_queue_is_empty(dummy_queue0));
 145   EXPECT_FALSE(fixed_queue_is_empty(dummy_queue1));
 146   EXPECT_STREQ(dummy_data_0, (char *)fixed_queue_try_dequeue(dummy_queue0));
 147   EXPECT_STREQ(dummy_data_1, (char *)fixed_queue_try_dequeue(dummy_queue1));
 148   EXPECT_TRUE(fixed_queue_is_empty(dummy_queue0));
 149   EXPECT_TRUE(fixed_queue_is_empty(dummy_queue1));
 150
 151   fixed_queue_free(dummy_queue0, NULL);
 152   fixed_queue_free(dummy_queue1, NULL);
 153   data_dispatcher_free(dispatcher);
 154 }
 155
 156 TEST_F(DataDispatcherTest, test_dispatch_single_to_single_reregistered) {
 157   data_dispatcher_t *dispatcher = data_dispatcher_new("test_dispatcher");
 158
 159   // Register a queue, then reregister
 160   fixed_queue_t *dummy_queue = fixed_queue_new(DUMMY_QUEUE_SIZE);
 161   fixed_queue_t *dummy_queue_reregistered = fixed_queue_new(DUMMY_QUEUE_SIZE);
 162   data_dispatcher_register(dispatcher, DUMMY_TYPE_0, dummy_queue);
 163   data_dispatcher_register(dispatcher, DUMMY_TYPE_0, dummy_queue_reregistered);
 164   EXPECT_TRUE(fixed_queue_is_empty(dummy_queue));
 165   EXPECT_TRUE(fixed_queue_is_empty(dummy_queue_reregistered));
 166
 167   // Send data to the queue
 168   EXPECT_TRUE(data_dispatcher_dispatch(dispatcher, DUMMY_TYPE_0, dummy_data_0));
 169
 170   // Did we get it?
 171   EXPECT_TRUE(fixed_queue_is_empty(dummy_queue));
 172   EXPECT_FALSE(fixed_queue_is_empty(dummy_queue_reregistered));
 173   EXPECT_STREQ(dummy_data_0, (char *)fixed_queue_try_dequeue(dummy_queue_reregistered));
 174   EXPECT_TRUE(fixed_queue_is_empty(dummy_queue_reregistered));
 175
 176   fixed_queue_free(dummy_queue, NULL);
 177   fixed_queue_free(dummy_queue_reregistered, NULL);
 178   data_dispatcher_free(dispatcher);
 179 }
 180
 181 TEST_F(DataDispatcherTest, test_dispatch_single_to_reregistered_null) {
 182   data_dispatcher_t *dispatcher = data_dispatcher_new("test_dispatcher");
 183
 184   // Register a queue
 185   fixed_queue_t *dummy_queue = fixed_queue_new(DUMMY_QUEUE_SIZE);
 186   data_dispatcher_register(dispatcher, DUMMY_TYPE_0, dummy_queue);
 187   data_dispatcher_register(dispatcher, DUMMY_TYPE_0, NULL);
 188   EXPECT_TRUE(fixed_queue_is_empty(dummy_queue));
 189
 190   EXPECT_FALSE(data_dispatcher_dispatch(dispatcher, DUMMY_TYPE_0, dummy_data_0));
 191   EXPECT_TRUE(fixed_queue_is_empty(dummy_queue));
 192
 193   fixed_queue_free(dummy_queue, NULL);
 194   data_dispatcher_free(dispatcher);
 195 }
 196
 197 TEST_F(DataDispatcherTest, test_dispatch_single_to_default_reregistered_null) {
 198   data_dispatcher_t *dispatcher = data_dispatcher_new("test_dispatcher");
 199
 200   // Register a queue
 201   fixed_queue_t *dummy_queue = fixed_queue_new(DUMMY_QUEUE_SIZE);
 202   data_dispatcher_register_default(dispatcher, dummy_queue);
 203   data_dispatcher_register_default(dispatcher, NULL);
 204   EXPECT_TRUE(fixed_queue_is_empty(dummy_queue));
 205
 206   EXPECT_FALSE(data_dispatcher_dispatch(dispatcher, DUMMY_TYPE_0, dummy_data_0));
 207   EXPECT_TRUE(fixed_queue_is_empty(dummy_queue));
 208
 209   fixed_queue_free(dummy_queue, NULL);
 210   data_dispatcher_free(dispatcher);
 211 }
 212
 213 TEST_F(DataDispatcherTest, test_dispatch_edge_zero) {
 214   data_dispatcher_t *dispatcher = data_dispatcher_new("test_dispatcher");
 215
 216   // Register a queue
 217   fixed_queue_t *dummy_queue = fixed_queue_new(DUMMY_QUEUE_SIZE);
 218   data_dispatcher_register(dispatcher, TYPE_EDGE_CASE_ZERO, dummy_queue);
 219   EXPECT_TRUE(fixed_queue_is_empty(dummy_queue));
 220
 221   // Send data to the queue
 222   EXPECT_TRUE(data_dispatcher_dispatch(dispatcher, TYPE_EDGE_CASE_ZERO, dummy_data_0));
 223
 224   // Did we get it?
 225   EXPECT_FALSE(fixed_queue_is_empty(dummy_queue));
 226   EXPECT_STREQ(dummy_data_0, (char *)fixed_queue_try_dequeue(dummy_queue));
 227   EXPECT_TRUE(fixed_queue_is_empty(dummy_queue));
 228
 229   fixed_queue_free(dummy_queue, NULL);
 230   data_dispatcher_free(dispatcher);
 231 }
 232
 233 TEST_F(DataDispatcherTest, test_dispatch_edge_max) {
 234   data_dispatcher_t *dispatcher = data_dispatcher_new("test_dispatcher");
 235
 236   // Register a queue
 237   fixed_queue_t *dummy_queue = fixed_queue_new(DUMMY_QUEUE_SIZE);
 238   data_dispatcher_register(dispatcher, TYPE_EDGE_CASE_MAX, dummy_queue);
 239   EXPECT_TRUE(fixed_queue_is_empty(dummy_queue));
 240
 241   // Send data to the queue
 242   EXPECT_TRUE(data_dispatcher_dispatch(dispatcher, TYPE_EDGE_CASE_MAX, dummy_data_0));
 243
 244   // Did we get it?
 245   EXPECT_FALSE(fixed_queue_is_empty(dummy_queue));
 246   EXPECT_STREQ(dummy_data_0, (char *)fixed_queue_try_dequeue(dummy_queue));
 247   EXPECT_TRUE(fixed_queue_is_empty(dummy_queue));
 248
 249   fixed_queue_free(dummy_queue, NULL);
 250   data_dispatcher_free(dispatcher);
 251 }