quantum/serial_link/tests/frame_router_tests.c

   1 /*
   2 The MIT License (MIT)
   3
   4 Copyright (c) 2016 Fred Sundvik
   5
   6 Permission is hereby granted, free of charge, to any person obtaining a copy
   7 of this software and associated documentation files (the "Software"), to deal
   8 in the Software without restriction, including without limitation the rights
   9 to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  10 copies of the Software, and to permit persons to whom the Software is
  11 furnished to do so, subject to the following conditions:
  12
  13 The above copyright notice and this permission notice shall be included in all
  14 copies or substantial portions of the Software.
  15
  16 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  17 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  18 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  19 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  20 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  21 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  22 SOFTWARE.
  23 */
  24
  25 #include <cgreen/cgreen.h>
  26 #include <cgreen/mocks.h>
  27 #include "serial_link/protocol/byte_stuffer.c"
  28 #include "serial_link/protocol/frame_validator.c"
  29 #include "serial_link/protocol/frame_router.c"
  30 #include "serial_link/protocol/transport.h"
  31
  32 static uint8_t received_data[256];
  33 static uint16_t received_data_size;
  34
  35 typedef struct {
  36     uint8_t sent_data[256];
  37     uint16_t sent_data_size;
  38 } receive_buffer_t;
  39
  40 typedef struct {
  41     receive_buffer_t send_buffers[2];
  42 } router_buffer_t;
  43
  44 router_buffer_t router_buffers[8];
  45
  46 router_buffer_t* current_router_buffer;
  47
  48
  49 Describe(FrameRouter);
  50 BeforeEach(FrameRouter) {
  51     init_byte_stuffer();
  52     memset(router_buffers, 0, sizeof(router_buffers));
  53     current_router_buffer = 0;
  54 }
  55 AfterEach(FrameRouter) {}
  56
  57 typedef struct {
  58     uint32_t data;
  59     uint8_t extra[16];
  60 } frame_buffer_t;
  61
  62
  63 void send_data(uint8_t link, const uint8_t* data, uint16_t size) {
  64     receive_buffer_t* buffer = &current_router_buffer->send_buffers[link];
  65     memcpy(buffer->sent_data + buffer->sent_data_size, data, size);
  66     buffer->sent_data_size += size;
  67 }
  68
  69 static void receive_data(uint8_t link, uint8_t* data, uint16_t size) {
  70     int i;
  71     for(i=0;i<size;i++) {
  72         byte_stuffer_recv_byte(link, data[i]);
  73     }
  74 }
  75
  76 static void activate_router(uint8_t num) {
  77     current_router_buffer = router_buffers + num;
  78     router_set_master(num==0);
  79 }
  80
  81 static void simulate_transport(uint8_t from, uint8_t to) {
  82    activate_router(to);
  83    if (from > to) {
  84        receive_data(DOWN_LINK,
  85                router_buffers[from].send_buffers[UP_LINK].sent_data,
  86                router_buffers[from].send_buffers[UP_LINK].sent_data_size);
  87    }
  88    else if(to > from) {
  89        receive_data(UP_LINK,
  90                router_buffers[from].send_buffers[DOWN_LINK].sent_data,
  91                router_buffers[from].send_buffers[DOWN_LINK].sent_data_size);
  92    }
  93 }
  94
  95 void transport_recv_frame(uint8_t from, uint8_t* data, uint16_t size) {
  96     mock(from, data, size);
  97 }
  98
  99
 100 Ensure(FrameRouter, master_broadcast_is_received_by_everyone) {
 101     frame_buffer_t data;
 102     data.data = 0xAB7055BB;
 103     activate_router(0);
 104     router_send_frame(0xFF, (uint8_t*)&data, 4);
 105     assert_that(router_buffers[0].send_buffers[DOWN_LINK].sent_data_size, is_greater_than(0));
 106     assert_that(router_buffers[0].send_buffers[UP_LINK].sent_data_size, is_equal_to(0));
 107
 108     expect(transport_recv_frame,
 109         when(from, is_equal_to(0)),
 110         when(size, is_equal_to(4)),
 111         when(data, is_equal_to_contents_of(&data.data, 4))
 112     );
 113     simulate_transport(0, 1);
 114     assert_that(router_buffers[1].send_buffers[DOWN_LINK].sent_data_size, is_greater_than(0));
 115     assert_that(router_buffers[1].send_buffers[UP_LINK].sent_data_size, is_equal_to(0));
 116
 117     expect(transport_recv_frame,
 118         when(from, is_equal_to(0)),
 119         when(size, is_equal_to(4)),
 120         when(data, is_equal_to_contents_of(&data.data, 4))
 121     );
 122     simulate_transport(1, 2);
 123     assert_that(router_buffers[2].send_buffers[DOWN_LINK].sent_data_size, is_greater_than(0));
 124     assert_that(router_buffers[2].send_buffers[UP_LINK].sent_data_size, is_equal_to(0));
 125 }
 126
 127 Ensure(FrameRouter, master_send_is_received_by_targets) {
 128     frame_buffer_t data;
 129     data.data = 0xAB7055BB;
 130     activate_router(0);
 131     router_send_frame((1 << 1) | (1 << 2), (uint8_t*)&data, 4);
 132     assert_that(router_buffers[0].send_buffers[DOWN_LINK].sent_data_size, is_greater_than(0));
 133     assert_that(router_buffers[0].send_buffers[UP_LINK].sent_data_size, is_equal_to(0));
 134
 135     simulate_transport(0, 1);
 136     assert_that(router_buffers[1].send_buffers[DOWN_LINK].sent_data_size, is_greater_than(0));
 137     assert_that(router_buffers[1].send_buffers[UP_LINK].sent_data_size, is_equal_to(0));
 138
 139     expect(transport_recv_frame,
 140         when(from, is_equal_to(0)),
 141         when(size, is_equal_to(4)),
 142         when(data, is_equal_to_contents_of(&data.data, 4))
 143     );
 144     simulate_transport(1, 2);
 145     assert_that(router_buffers[2].send_buffers[DOWN_LINK].sent_data_size, is_greater_than(0));
 146     assert_that(router_buffers[2].send_buffers[UP_LINK].sent_data_size, is_equal_to(0));
 147
 148     expect(transport_recv_frame,
 149         when(from, is_equal_to(0)),
 150         when(size, is_equal_to(4)),
 151         when(data, is_equal_to_contents_of(&data.data, 4))
 152     );
 153     simulate_transport(2, 3);
 154     assert_that(router_buffers[3].send_buffers[DOWN_LINK].sent_data_size, is_greater_than(0));
 155     assert_that(router_buffers[3].send_buffers[UP_LINK].sent_data_size, is_equal_to(0));
 156 }
 157
 158 Ensure(FrameRouter, first_link_sends_to_master) {
 159     frame_buffer_t data;
 160     data.data = 0xAB7055BB;
 161     activate_router(1);
 162     router_send_frame(0, (uint8_t*)&data, 4);
 163     assert_that(router_buffers[1].send_buffers[UP_LINK].sent_data_size, is_greater_than(0));
 164     assert_that(router_buffers[1].send_buffers[DOWN_LINK].sent_data_size, is_equal_to(0));
 165
 166     expect(transport_recv_frame,
 167         when(from, is_equal_to(1)),
 168         when(size, is_equal_to(4)),
 169         when(data, is_equal_to_contents_of(&data.data, 4))
 170     );
 171     simulate_transport(1, 0);
 172     assert_that(router_buffers[0].send_buffers[DOWN_LINK].sent_data_size, is_equal_to(0));
 173     assert_that(router_buffers[0].send_buffers[UP_LINK].sent_data_size, is_equal_to(0));
 174 }
 175
 176 Ensure(FrameRouter, second_link_sends_to_master) {
 177     frame_buffer_t data;
 178     data.data = 0xAB7055BB;
 179     activate_router(2);
 180     router_send_frame(0, (uint8_t*)&data, 4);
 181     assert_that(router_buffers[2].send_buffers[UP_LINK].sent_data_size, is_greater_than(0));
 182     assert_that(router_buffers[2].send_buffers[DOWN_LINK].sent_data_size, is_equal_to(0));
 183
 184     simulate_transport(2, 1);
 185     assert_that(router_buffers[1].send_buffers[UP_LINK].sent_data_size, is_greater_than(0));
 186     assert_that(router_buffers[1].send_buffers[DOWN_LINK].sent_data_size, is_equal_to(0));
 187
 188     expect(transport_recv_frame,
 189         when(from, is_equal_to(2)),
 190         when(size, is_equal_to(4)),
 191         when(data, is_equal_to_contents_of(&data.data, 4))
 192     );
 193     simulate_transport(1, 0);
 194     assert_that(router_buffers[0].send_buffers[DOWN_LINK].sent_data_size, is_equal_to(0));
 195     assert_that(router_buffers[0].send_buffers[UP_LINK].sent_data_size, is_equal_to(0));
 196 }
 197
 198 Ensure(FrameRouter, master_sends_to_master_does_nothing) {
 199     frame_buffer_t data;
 200     data.data = 0xAB7055BB;
 201     activate_router(0);
 202     router_send_frame(0, (uint8_t*)&data, 4);
 203     assert_that(router_buffers[0].send_buffers[UP_LINK].sent_data_size, is_equal_to(0));
 204     assert_that(router_buffers[0].send_buffers[DOWN_LINK].sent_data_size, is_equal_to(0));
 205 }
 206
 207 Ensure(FrameRouter, link_sends_to_other_link_does_nothing) {
 208     frame_buffer_t data;
 209     data.data = 0xAB7055BB;
 210     activate_router(1);
 211     router_send_frame(2, (uint8_t*)&data, 4);
 212     assert_that(router_buffers[1].send_buffers[UP_LINK].sent_data_size, is_equal_to(0));
 213     assert_that(router_buffers[1].send_buffers[DOWN_LINK].sent_data_size, is_equal_to(0));
 214 }
 215
 216 Ensure(FrameRouter, master_receives_on_uplink_does_nothing) {
 217     frame_buffer_t data;
 218     data.data = 0xAB7055BB;
 219     activate_router(1);
 220     router_send_frame(0, (uint8_t*)&data, 4);
 221     assert_that(router_buffers[1].send_buffers[UP_LINK].sent_data_size, is_greater_than(0));
 222     assert_that(router_buffers[1].send_buffers[DOWN_LINK].sent_data_size, is_equal_to(0));
 223
 224     never_expect(transport_recv_frame);
 225     activate_router(0);
 226     receive_data(UP_LINK,
 227         router_buffers[1].send_buffers[UP_LINK].sent_data,
 228         router_buffers[1].send_buffers[UP_LINK].sent_data_size);
 229     assert_that(router_buffers[0].send_buffers[UP_LINK].sent_data_size, is_equal_to(0));
 230     assert_that(router_buffers[0].send_buffers[DOWN_LINK].sent_data_size, is_equal_to(0));
 231 }