quantum/serial_link/tests/byte_stuffer_tests.cpp

   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 "gtest/gtest.h"
  26 #include "gmock/gmock.h"
  27 #include <vector>
  28 #include <algorithm>
  29 extern "C" {
  30 #include "serial_link/protocol/byte_stuffer.h"
  31 #include "serial_link/protocol/frame_validator.h"
  32 #include "serial_link/protocol/physical.h"
  33 }
  34
  35 using testing::_;
  36 using testing::ElementsAreArray;
  37 using testing::Args;
  38
  39 class ByteStuffer : public ::testing::Test{
  40 public:
  41     ByteStuffer() {
  42         Instance = this;
  43         init_byte_stuffer();
  44     }
  45
  46     ~ByteStuffer() {
  47         Instance = nullptr;
  48     }
  49
  50     MOCK_METHOD3(validator_recv_frame, void (uint8_t link, uint8_t* data, uint16_t size));
  51
  52     void send_data(uint8_t link, const uint8_t* data, uint16_t size) {
  53         std::copy(data, data + size, std::back_inserter(sent_data));
  54     }
  55     std::vector<uint8_t> sent_data;
  56
  57     static ByteStuffer* Instance;
  58 };
  59
  60 ByteStuffer* ByteStuffer::Instance = nullptr;
  61
  62 extern "C" {
  63     void validator_recv_frame(uint8_t link, uint8_t* data, uint16_t size) {
  64         ByteStuffer::Instance->validator_recv_frame(link, data, size);
  65     }
  66
  67     void send_data(uint8_t link, const uint8_t* data, uint16_t size) {
  68         ByteStuffer::Instance->send_data(link, data, size);
  69     }
  70 }
  71
  72 TEST_F(ByteStuffer, receives_no_frame_for_a_single_zero_byte) {
  73     EXPECT_CALL(*this, validator_recv_frame(_, _, _))
  74         .Times(0);
  75     byte_stuffer_recv_byte(0, 0);
  76 }
  77
  78 TEST_F(ByteStuffer, receives_no_frame_for_a_single_FF_byte) {
  79     EXPECT_CALL(*this, validator_recv_frame(_, _, _))
  80         .Times(0);
  81     byte_stuffer_recv_byte(0, 0xFF);
  82 }
  83
  84 TEST_F(ByteStuffer, receives_no_frame_for_a_single_random_byte) {
  85     EXPECT_CALL(*this, validator_recv_frame(_, _, _))
  86         .Times(0);
  87     byte_stuffer_recv_byte(0, 0x4A);
  88 }
  89
  90 TEST_F(ByteStuffer, receives_no_frame_for_a_zero_length_frame) {
  91     EXPECT_CALL(*this, validator_recv_frame(_, _, _))
  92         .Times(0);
  93     byte_stuffer_recv_byte(0, 1);
  94     byte_stuffer_recv_byte(0, 0);
  95 }
  96
  97 TEST_F(ByteStuffer, receives_single_byte_valid_frame) {
  98     uint8_t expected[] = {0x37};
  99     EXPECT_CALL(*this, validator_recv_frame(_, _, _))
 100         .With(Args<1, 2>(ElementsAreArray(expected)));
 101     byte_stuffer_recv_byte(0, 2);
 102     byte_stuffer_recv_byte(0, 0x37);
 103     byte_stuffer_recv_byte(0, 0);
 104 }
 105 TEST_F(ByteStuffer, receives_three_bytes_valid_frame) {
 106     uint8_t expected[] = {0x37, 0x99, 0xFF};
 107     EXPECT_CALL(*this, validator_recv_frame(_, _, _))
 108         .With(Args<1, 2>(ElementsAreArray(expected)));
 109     byte_stuffer_recv_byte(0, 4);
 110     byte_stuffer_recv_byte(0, 0x37);
 111     byte_stuffer_recv_byte(0, 0x99);
 112     byte_stuffer_recv_byte(0, 0xFF);
 113     byte_stuffer_recv_byte(0, 0);
 114 }
 115
 116 TEST_F(ByteStuffer, receives_single_zero_valid_frame) {
 117     uint8_t expected[] = {0};
 118     EXPECT_CALL(*this, validator_recv_frame(_, _, _))
 119         .With(Args<1, 2>(ElementsAreArray(expected)));
 120     byte_stuffer_recv_byte(0, 1);
 121     byte_stuffer_recv_byte(0, 1);
 122     byte_stuffer_recv_byte(0, 0);
 123 }
 124
 125 TEST_F(ByteStuffer, receives_valid_frame_with_zeroes) {
 126     uint8_t expected[] = {5, 0, 3, 0};
 127     EXPECT_CALL(*this, validator_recv_frame(_, _, _))
 128         .With(Args<1, 2>(ElementsAreArray(expected)));
 129     byte_stuffer_recv_byte(0, 2);
 130     byte_stuffer_recv_byte(0, 5);
 131     byte_stuffer_recv_byte(0, 2);
 132     byte_stuffer_recv_byte(0, 3);
 133     byte_stuffer_recv_byte(0, 1);
 134     byte_stuffer_recv_byte(0, 0);
 135 }
 136
 137
 138 TEST_F(ByteStuffer, receives_two_valid_frames) {
 139     uint8_t expected1[] = {5, 0};
 140     uint8_t expected2[] = {3};
 141     EXPECT_CALL(*this, validator_recv_frame(_, _, _))
 142         .With(Args<1, 2>(ElementsAreArray(expected1)));
 143     EXPECT_CALL(*this, validator_recv_frame(_, _, _))
 144         .With(Args<1, 2>(ElementsAreArray(expected2)));
 145     byte_stuffer_recv_byte(1, 2);
 146     byte_stuffer_recv_byte(1, 5);
 147     byte_stuffer_recv_byte(1, 1);
 148     byte_stuffer_recv_byte(1, 0);
 149     byte_stuffer_recv_byte(1, 2);
 150     byte_stuffer_recv_byte(1, 3);
 151     byte_stuffer_recv_byte(1, 0);
 152 }
 153
 154 TEST_F(ByteStuffer, receives_valid_frame_after_unexpected_zero) {
 155     uint8_t expected[] = {5, 7};
 156     EXPECT_CALL(*this, validator_recv_frame(_, _, _))
 157         .With(Args<1, 2>(ElementsAreArray(expected)));
 158     byte_stuffer_recv_byte(1, 3);
 159     byte_stuffer_recv_byte(1, 1);
 160     byte_stuffer_recv_byte(1, 0);
 161     byte_stuffer_recv_byte(1, 3);
 162     byte_stuffer_recv_byte(1, 5);
 163     byte_stuffer_recv_byte(1, 7);
 164     byte_stuffer_recv_byte(1, 0);
 165 }
 166
 167 TEST_F(ByteStuffer, receives_valid_frame_after_unexpected_non_zero) {
 168     uint8_t expected[] = {5, 7};
 169     EXPECT_CALL(*this, validator_recv_frame(_, _, _))
 170         .With(Args<1, 2>(ElementsAreArray(expected)));
 171     byte_stuffer_recv_byte(0, 2);
 172     byte_stuffer_recv_byte(0, 9);
 173     byte_stuffer_recv_byte(0, 4); // This should have been zero
 174     byte_stuffer_recv_byte(0, 0);
 175     byte_stuffer_recv_byte(0, 3);
 176     byte_stuffer_recv_byte(0, 5);
 177     byte_stuffer_recv_byte(0, 7);
 178     byte_stuffer_recv_byte(0, 0);
 179 }
 180
 181 TEST_F(ByteStuffer, receives_a_valid_frame_with_over254_non_zeroes_and_then_end_of_frame) {
 182     uint8_t expected[254];
 183     int i;
 184     for (i=0;i<254;i++) {
 185         expected[i] = i + 1;
 186     }
 187     EXPECT_CALL(*this, validator_recv_frame(_, _, _))
 188         .With(Args<1, 2>(ElementsAreArray(expected)));
 189     byte_stuffer_recv_byte(0, 0xFF);
 190     for (i=0;i<254;i++) {
 191         byte_stuffer_recv_byte(0, i+1);
 192     }
 193     byte_stuffer_recv_byte(0, 0);
 194 }
 195
 196 TEST_F(ByteStuffer, receives_a_valid_frame_with_over254_non_zeroes_next_byte_is_non_zero) {
 197     uint8_t expected[255];
 198     int i;
 199     for (i=0;i<254;i++) {
 200         expected[i] = i + 1;
 201     }
 202     expected[254] = 7;
 203     EXPECT_CALL(*this, validator_recv_frame(_, _, _))
 204         .With(Args<1, 2>(ElementsAreArray(expected)));
 205     byte_stuffer_recv_byte(0, 0xFF);
 206     for (i=0;i<254;i++) {
 207         byte_stuffer_recv_byte(0, i+1);
 208     }
 209     byte_stuffer_recv_byte(0, 2);
 210     byte_stuffer_recv_byte(0, 7);
 211     byte_stuffer_recv_byte(0, 0);
 212 }
 213
 214 TEST_F(ByteStuffer, receives_a_valid_frame_with_over254_non_zeroes_next_byte_is_zero) {
 215     uint8_t expected[255];
 216     int i;
 217     for (i=0;i<254;i++) {
 218         expected[i] = i + 1;
 219     }
 220     expected[254] = 0;
 221     EXPECT_CALL(*this, validator_recv_frame(_, _, _))
 222         .With(Args<1, 2>(ElementsAreArray(expected)));
 223     byte_stuffer_recv_byte(0, 0xFF);
 224     for (i=0;i<254;i++) {
 225         byte_stuffer_recv_byte(0, i+1);
 226     }
 227     byte_stuffer_recv_byte(0, 1);
 228     byte_stuffer_recv_byte(0, 1);
 229     byte_stuffer_recv_byte(0, 0);
 230 }
 231
 232 TEST_F(ByteStuffer, receives_two_long_frames_and_some_more) {
 233     uint8_t expected[515];
 234     int i;
 235     int j;
 236     for (j=0;j<2;j++) {
 237         for (i=0;i<254;i++) {
 238             expected[i+254*j] = i + 1;
 239         }
 240     }
 241     for (i=0;i<7;i++) {
 242         expected[254*2+i] = i + 1;
 243     }
 244     EXPECT_CALL(*this, validator_recv_frame(_, _, _))
 245         .With(Args<1, 2>(ElementsAreArray(expected)));
 246     byte_stuffer_recv_byte(0, 0xFF);
 247     for (i=0;i<254;i++) {
 248         byte_stuffer_recv_byte(0, i+1);
 249     }
 250     byte_stuffer_recv_byte(0, 0xFF);
 251     for (i=0;i<254;i++) {
 252         byte_stuffer_recv_byte(0, i+1);
 253     }
 254     byte_stuffer_recv_byte(0, 8);
 255     byte_stuffer_recv_byte(0, 1);
 256     byte_stuffer_recv_byte(0, 2);
 257     byte_stuffer_recv_byte(0, 3);
 258     byte_stuffer_recv_byte(0, 4);
 259     byte_stuffer_recv_byte(0, 5);
 260     byte_stuffer_recv_byte(0, 6);
 261     byte_stuffer_recv_byte(0, 7);
 262     byte_stuffer_recv_byte(0, 0);
 263 }
 264
 265 TEST_F(ByteStuffer, receives_an_all_zeros_frame_that_is_maximum_size) {
 266     uint8_t expected[MAX_FRAME_SIZE] = {};
 267     EXPECT_CALL(*this, validator_recv_frame(_, _, _))
 268         .With(Args<1, 2>(ElementsAreArray(expected)));
 269     int i;
 270     byte_stuffer_recv_byte(0, 1);
 271     for(i=0;i<MAX_FRAME_SIZE;i++) {
 272        byte_stuffer_recv_byte(0, 1);
 273     }
 274     byte_stuffer_recv_byte(0, 0);
 275 }
 276
 277 TEST_F(ByteStuffer, doesnt_recv_a_frame_thats_too_long_all_zeroes) {
 278     uint8_t expected[1] = {0};
 279     EXPECT_CALL(*this, validator_recv_frame(_, _, _))
 280         .Times(0);
 281     int i;
 282     byte_stuffer_recv_byte(0, 1);
 283     for(i=0;i<MAX_FRAME_SIZE;i++) {
 284        byte_stuffer_recv_byte(0, 1);
 285     }
 286     byte_stuffer_recv_byte(0, 1);
 287     byte_stuffer_recv_byte(0, 0);
 288 }
 289
 290 TEST_F(ByteStuffer, received_frame_is_aborted_when_its_too_long) {
 291     uint8_t expected[1] = {1};
 292     EXPECT_CALL(*this, validator_recv_frame(_, _, _))
 293         .With(Args<1, 2>(ElementsAreArray(expected)));
 294     int i;
 295     byte_stuffer_recv_byte(0, 1);
 296     for(i=0;i<MAX_FRAME_SIZE;i++) {
 297        byte_stuffer_recv_byte(0, 1);
 298     }
 299     byte_stuffer_recv_byte(0, 2);
 300     byte_stuffer_recv_byte(0, 1);
 301     byte_stuffer_recv_byte(0, 0);
 302 }
 303
 304 TEST_F(ByteStuffer, does_nothing_when_sending_zero_size_frame) {
 305     EXPECT_EQ(sent_data.size(), 0);
 306     byte_stuffer_send_frame(0, NULL, 0);
 307 }
 308
 309 TEST_F(ByteStuffer, send_one_byte_frame) {
 310     uint8_t data[] = {5};
 311     byte_stuffer_send_frame(1, data, 1);
 312     uint8_t expected[] = {2, 5, 0};
 313     EXPECT_THAT(sent_data, ElementsAreArray(expected));
 314 }
 315
 316 TEST_F(ByteStuffer, sends_two_byte_frame) {
 317     uint8_t data[] = {5, 0x77};
 318     byte_stuffer_send_frame(0, data, 2);
 319     uint8_t expected[] = {3, 5, 0x77, 0};
 320     EXPECT_THAT(sent_data, ElementsAreArray(expected));
 321 }
 322
 323 TEST_F(ByteStuffer, sends_one_byte_frame_with_zero) {
 324     uint8_t data[] = {0};
 325     byte_stuffer_send_frame(0, data, 1);
 326     uint8_t expected[] = {1, 1, 0};
 327     EXPECT_THAT(sent_data, ElementsAreArray(expected));
 328 }
 329
 330 TEST_F(ByteStuffer, sends_two_byte_frame_starting_with_zero) {
 331     uint8_t data[] = {0, 9};
 332     byte_stuffer_send_frame(1, data, 2);
 333     uint8_t expected[] = {1, 2, 9, 0};
 334     EXPECT_THAT(sent_data, ElementsAreArray(expected));
 335 }
 336
 337 TEST_F(ByteStuffer, sends_two_byte_frame_starting_with_non_zero) {
 338     uint8_t data[] = {9, 0};
 339     byte_stuffer_send_frame(1, data, 2);
 340     uint8_t expected[] = {2, 9, 1, 0};
 341     EXPECT_THAT(sent_data, ElementsAreArray(expected));
 342 }
 343
 344 TEST_F(ByteStuffer, sends_three_byte_frame_zero_in_the_middle) {
 345     uint8_t data[] = {9, 0, 0x68};
 346     byte_stuffer_send_frame(0, data, 3);
 347     uint8_t expected[] = {2, 9, 2, 0x68, 0};
 348     EXPECT_THAT(sent_data, ElementsAreArray(expected));
 349 }
 350
 351 TEST_F(ByteStuffer, sends_three_byte_frame_data_in_the_middle) {
 352     uint8_t data[] = {0, 0x55, 0};
 353     byte_stuffer_send_frame(0, data, 3);
 354     uint8_t expected[] = {1, 2, 0x55, 1, 0};
 355     EXPECT_THAT(sent_data, ElementsAreArray(expected));
 356 }
 357
 358 TEST_F(ByteStuffer, sends_three_byte_frame_with_all_zeroes) {
 359     uint8_t data[] = {0, 0, 0};
 360     byte_stuffer_send_frame(0, data, 3);
 361     uint8_t expected[] = {1, 1, 1, 1, 0};
 362     EXPECT_THAT(sent_data, ElementsAreArray(expected));
 363 }
 364
 365 TEST_F(ByteStuffer, sends_frame_with_254_non_zeroes) {
 366     uint8_t data[254];
 367     int i;
 368     for(i=0;i<254;i++) {
 369         data[i] = i + 1;
 370     }
 371     byte_stuffer_send_frame(0, data, 254);
 372     uint8_t expected[256];
 373     expected[0] = 0xFF;
 374     for(i=1;i<255;i++) {
 375         expected[i] = i;
 376     }
 377     expected[255] = 0;
 378     EXPECT_THAT(sent_data, ElementsAreArray(expected));
 379 }
 380
 381 TEST_F(ByteStuffer, sends_frame_with_255_non_zeroes) {
 382     uint8_t data[255];
 383     int i;
 384     for(i=0;i<255;i++) {
 385         data[i] = i + 1;
 386     }
 387     byte_stuffer_send_frame(0, data, 255);
 388     uint8_t expected[258];
 389     expected[0] = 0xFF;
 390     for(i=1;i<255;i++) {
 391         expected[i] = i;
 392     }
 393     expected[255] = 2;
 394     expected[256] = 255;
 395     expected[257] = 0;
 396     EXPECT_THAT(sent_data, ElementsAreArray(expected));
 397 }
 398
 399 TEST_F(ByteStuffer, sends_frame_with_254_non_zeroes_followed_by_zero) {
 400     uint8_t data[255];
 401     int i;
 402     for(i=0;i<254;i++) {
 403         data[i] = i + 1;
 404     }
 405     data[254] = 0;
 406     byte_stuffer_send_frame(0, data, 255);
 407     uint8_t expected[258];
 408     expected[0] = 0xFF;
 409     for(i=1;i<255;i++) {
 410         expected[i] = i;
 411     }
 412     expected[255] = 1;
 413     expected[256] = 1;
 414     expected[257] = 0;
 415     EXPECT_THAT(sent_data, ElementsAreArray(expected));
 416 }
 417
 418 TEST_F(ByteStuffer, sends_and_receives_full_roundtrip_small_packet) {
 419     uint8_t original_data[] = { 1, 2, 3};
 420     byte_stuffer_send_frame(0, original_data, sizeof(original_data));
 421     EXPECT_CALL(*this, validator_recv_frame(_, _, _))
 422         .With(Args<1, 2>(ElementsAreArray(original_data)));
 423     int i;
 424     for(auto& d : sent_data) {
 425        byte_stuffer_recv_byte(1, d);
 426     }
 427 }
 428
 429 TEST_F(ByteStuffer, sends_and_receives_full_roundtrip_small_packet_with_zeros) {
 430     uint8_t original_data[] = { 1, 0, 3, 0, 0, 9};
 431     byte_stuffer_send_frame(1, original_data, sizeof(original_data));
 432     EXPECT_CALL(*this, validator_recv_frame(_, _, _))
 433         .With(Args<1, 2>(ElementsAreArray(original_data)));
 434     int i;
 435     for(auto& d : sent_data) {
 436        byte_stuffer_recv_byte(1, d);
 437     }
 438 }
 439
 440 TEST_F(ByteStuffer, sends_and_receives_full_roundtrip_254_bytes) {
 441     uint8_t original_data[254];
 442     int i;
 443     for(i=0;i<254;i++) {
 444         original_data[i] = i + 1;
 445     }
 446     byte_stuffer_send_frame(0, original_data, sizeof(original_data));
 447     EXPECT_CALL(*this, validator_recv_frame(_, _, _))
 448         .With(Args<1, 2>(ElementsAreArray(original_data)));
 449     for(auto& d : sent_data) {
 450        byte_stuffer_recv_byte(1, d);
 451     }
 452 }
 453
 454 TEST_F(ByteStuffer, sends_and_receives_full_roundtrip_256_bytes) {
 455     uint8_t original_data[256];
 456     int i;
 457     for(i=0;i<254;i++) {
 458         original_data[i] = i + 1;
 459     }
 460     original_data[254] = 22;
 461     original_data[255] = 23;
 462     byte_stuffer_send_frame(0, original_data, sizeof(original_data));
 463     EXPECT_CALL(*this, validator_recv_frame(_, _, _))
 464         .With(Args<1, 2>(ElementsAreArray(original_data)));
 465     for(auto& d : sent_data) {
 466        byte_stuffer_recv_byte(1, d);
 467     }
 468 }
 469
 470 TEST_F(ByteStuffer, sends_and_receives_full_roundtrip_254_bytes_and_then_zero) {
 471     uint8_t original_data[255];
 472     int i;
 473     for(i=0;i<254;i++) {
 474         original_data[i] = i + 1;
 475     }
 476     original_data[254] = 0;
 477     byte_stuffer_send_frame(0, original_data, sizeof(original_data));
 478     EXPECT_CALL(*this, validator_recv_frame(_, _, _))
 479         .With(Args<1, 2>(ElementsAreArray(original_data)));
 480     for(auto& d : sent_data) {
 481        byte_stuffer_recv_byte(1, d);
 482     }
 483 }