device/serial/serial_io_handler_posix_unittest.cc

   1 // Copyright 2015 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "base/macros.h"
   6 #include "device/serial/serial_io_handler_posix.h"
   7 #include "testing/gtest/include/gtest/gtest.h"
   8
   9 namespace device {
  10
  11 class SerialIoHandlerPosixTest : public testing::Test {
  12  public:
  13   SerialIoHandlerPosixTest() = default;
  14
  15   void SetUp() override {
  16     serial_io_handler_posix_ = new SerialIoHandlerPosix(nullptr);
  17   }
  18
  19   void Initialize(bool parity_check_enabled,
  20                   const char* chars_stashed,
  21                   int num_chars_stashed) {
  22     serial_io_handler_posix_->error_detect_state_ = ErrorDetectState::NO_ERROR;
  23     serial_io_handler_posix_->parity_check_enabled_ = parity_check_enabled;
  24     serial_io_handler_posix_->num_chars_stashed_ = num_chars_stashed;
  25     for (int i = 0; i < num_chars_stashed; ++i) {
  26       serial_io_handler_posix_->chars_stashed_[i] = chars_stashed[i];
  27     }
  28   }
  29
  30   void TestHelper(char* buffer,
  31                   int buffer_len,
  32                   int bytes_read,
  33                   ErrorDetectState error_detect_state_expected,
  34                   const char* chars_stashed_expected,
  35                   int num_chars_stashed_expected,
  36                   const char* buffer_expected,
  37                   int new_bytes_read_expected,
  38                   bool break_detected_expected,
  39                   bool parity_error_detected_expected) {
  40     bool break_detected = false;
  41     bool parity_error_detected = false;
  42     int new_bytes_read = serial_io_handler_posix_->CheckReceiveError(
  43         buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
  44
  45     EXPECT_EQ(error_detect_state_expected,
  46               serial_io_handler_posix_->error_detect_state_);
  47     EXPECT_EQ(num_chars_stashed_expected,
  48               serial_io_handler_posix_->num_chars_stashed_);
  49     for (int i = 0; i < num_chars_stashed_expected; ++i) {
  50       EXPECT_EQ(chars_stashed_expected[i],
  51                 serial_io_handler_posix_->chars_stashed_[i]);
  52     }
  53     EXPECT_EQ(new_bytes_read_expected, new_bytes_read);
  54     for (int i = 0; i < new_bytes_read_expected; ++i) {
  55       EXPECT_EQ(buffer_expected[i], buffer[i]);
  56     }
  57     EXPECT_EQ(break_detected_expected, break_detected);
  58     EXPECT_EQ(parity_error_detected_expected, parity_error_detected);
  59   }
  60
  61  protected:
  62   scoped_refptr<SerialIoHandlerPosix> serial_io_handler_posix_;
  63
  64  private:
  65   DISALLOW_COPY_AND_ASSIGN(SerialIoHandlerPosixTest);
  66 };
  67
  68 // 'a' 'b' 'c'
  69 TEST_F(SerialIoHandlerPosixTest, NoErrorReadOnce) {
  70   for (int buffer_len = 3; buffer_len <= 20; ++buffer_len) {
  71     Initialize(true, "", 0);
  72
  73     char buffer[30] = {'a', 'b', 'c'};
  74     int bytes_read = 3;
  75     TestHelper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "",
  76                0, "abc", 3, false, false);
  77   }
  78 }
  79
  80 // 'a' 'b'
  81 // 'c'
  82 TEST_F(SerialIoHandlerPosixTest, NoErrorReadTwiceBytesReadTwoAndOne) {
  83   for (int buffer_len = 2; buffer_len <= 20; ++buffer_len) {
  84     Initialize(true, "", 0);
  85
  86     char buffer_1[30] = {'a', 'b'};
  87     int bytes_read = 2;
  88     TestHelper(buffer_1, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "",
  89                0, "ab", 2, false, false);
  90
  91     char buffer_2[30] = {'c'};
  92     bytes_read = 1;
  93     TestHelper(buffer_2, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "",
  94                0, "c", 1, false, false);
  95   }
  96 }
  97
  98 // 'a'
  99 // 'b' c'
 100 TEST_F(SerialIoHandlerPosixTest, NoErrorReadTwiceBytesReadOneAndTwo) {
 101   for (int buffer_len = 2; buffer_len <= 20; ++buffer_len) {
 102     Initialize(true, "", 0);
 103
 104     char buffer_1[30] = {'a'};
 105     int bytes_read = 1;
 106     TestHelper(buffer_1, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "",
 107                0, "a", 1, false, false);
 108
 109     char buffer_2[30] = {'b', 'c'};
 110     bytes_read = 2;
 111     TestHelper(buffer_2, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "",
 112                0, "bc", 2, false, false);
 113   }
 114 }
 115
 116 // 'a'
 117 // 'b'
 118 // 'c'
 119 TEST_F(SerialIoHandlerPosixTest, NoErrorReadThreeTimes) {
 120   for (int buffer_len = 1; buffer_len <= 20; ++buffer_len) {
 121     Initialize(true, "", 0);
 122
 123     char buffer_1[30] = {'a'};
 124     int bytes_read = 1;
 125     TestHelper(buffer_1, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "",
 126                0, "a", 1, false, false);
 127
 128     char buffer_2[30] = {'b'};
 129     bytes_read = 1;
 130     TestHelper(buffer_2, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "",
 131                0, "b", 1, false, false);
 132
 133     char buffer_3[30] = {'c'};
 134     bytes_read = 1;
 135     TestHelper(buffer_3, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "",
 136                0, "c", 1, false, false);
 137   }
 138 }
 139
 140 // '\377' '\0' '\0'
 141 TEST_F(SerialIoHandlerPosixTest, BreakReadOnce) {
 142   for (int buffer_len = 3; buffer_len <= 20; ++buffer_len) {
 143     Initialize(true, "", 0);
 144
 145     char buffer[30] = {'\377', '\0', '\0'};
 146     int bytes_read = 3;
 147     TestHelper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "",
 148                0, "", 0, true, false);
 149   }
 150 }
 151
 152 // 'a' 'b' '\377' '\0' '\0' 'c' 'd' 'e'
 153 TEST_F(SerialIoHandlerPosixTest, BreakReadOnceHasBytesBeforeAndAfterBreak) {
 154   for (int buffer_len = 8; buffer_len <= 20; ++buffer_len) {
 155     Initialize(true, "", 0);
 156
 157     char buffer[30] = {'a', 'b', '\377', '\0', '\0', 'c', 'd', 'e'};
 158     int bytes_read = 8;
 159     TestHelper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "",
 160                0, "abcde", 5, true, false);
 161   }
 162 }
 163
 164 // '\377' '\0'
 165 // '\0'
 166 TEST_F(SerialIoHandlerPosixTest, BreakReadTwiceBytesReadTwoAndOne) {
 167   for (int buffer_len = 2; buffer_len <= 20; ++buffer_len) {
 168     Initialize(true, "", 0);
 169
 170     char buffer_1[30] = {'\377', '\0'};
 171     int bytes_read = 2;
 172     TestHelper(buffer_1, buffer_len, bytes_read, ErrorDetectState::MARK_0_SEEN,
 173                "\377\0", 2, "", 0, false, false);
 174
 175     char buffer_2[30] = {'\0'};
 176     bytes_read = 1;
 177     TestHelper(buffer_2, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "",
 178                0, "", 0, true, false);
 179   }
 180 }
 181
 182 // 'a' 'b' 'c' '\377' '\0'
 183 // '\0' 'd' 'e'
 184 TEST_F(SerialIoHandlerPosixTest,
 185        BreakReadTwiceBytesReadTwoAndOneHasBytesBeforeAndAfterBreak) {
 186   for (int buffer_len = 5; buffer_len <= 20; ++buffer_len) {
 187     Initialize(true, "", 0);
 188
 189     char buffer_1[30] = {'a', 'b', 'c', '\377', '\0'};
 190     int bytes_read = 5;
 191     TestHelper(buffer_1, buffer_len, bytes_read, ErrorDetectState::MARK_0_SEEN,
 192                "\377\0", 2, "abc", 3, false, false);
 193
 194     char buffer_2[30] = {'\0', 'd', 'e'};
 195     bytes_read = 3;
 196     TestHelper(buffer_2, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "",
 197                0, "de", 2, true, false);
 198   }
 199 }
 200
 201 // '\377'
 202 // '\0' '\0'
 203 TEST_F(SerialIoHandlerPosixTest, BreakReadTwiceBytesReadOneAndTwo) {
 204   for (int buffer_len = 2; buffer_len <= 20; ++buffer_len) {
 205     Initialize(true, "", 0);
 206
 207     char buffer_1[30] = {'\377'};
 208     int bytes_read = 1;
 209     TestHelper(buffer_1, buffer_len, bytes_read,
 210                ErrorDetectState::MARK_377_SEEN, "\377", 1, "", 0, false, false);
 211
 212     char buffer_2[30] = {'\0', '\0'};
 213     bytes_read = 2;
 214     TestHelper(buffer_2, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "",
 215                0, "", 0, true, false);
 216   }
 217 }
 218
 219 // 'a' 'b' '\377'
 220 // '\0' '\0' 'c'
 221 TEST_F(SerialIoHandlerPosixTest,
 222        BreakReadTwiceBytesReadOneAndTwoHasBytesBeforeAndAfterBreak) {
 223   for (int buffer_len = 3; buffer_len <= 20; ++buffer_len) {
 224     Initialize(true, "", 0);
 225
 226     char buffer_1[30] = {'a', 'b', '\377'};
 227     int bytes_read = 3;
 228     TestHelper(buffer_1, buffer_len, bytes_read,
 229                ErrorDetectState::MARK_377_SEEN, "\377", 1, "ab", 2, false,
 230                false);
 231
 232     char buffer_2[30] = {'\0', '\0', 'c'};
 233     bytes_read = 3;
 234     TestHelper(buffer_2, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "",
 235                0, "c", 1, true, false);
 236   }
 237 }
 238
 239 // '\377'
 240 // '\0'
 241 // '\0'
 242 TEST_F(SerialIoHandlerPosixTest, BreakReadThreeTimes) {
 243   for (int buffer_len = 1; buffer_len <= 20; ++buffer_len) {
 244     Initialize(true, "", 0);
 245
 246     char buffer_1[30] = {'\377'};
 247     int bytes_read = 1;
 248     TestHelper(buffer_1, buffer_len, bytes_read,
 249                ErrorDetectState::MARK_377_SEEN, "\377", 1, "", 0, false, false);
 250
 251     char buffer_2[30] = {'\0'};
 252     bytes_read = 1;
 253     TestHelper(buffer_2, buffer_len, bytes_read, ErrorDetectState::MARK_0_SEEN,
 254                "\377\0", 2, "", 0, false, false);
 255
 256     char buffer_3[30] = {'\0'};
 257     bytes_read = 1;
 258     TestHelper(buffer_3, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "",
 259                0, "", 0, true, false);
 260   }
 261 }
 262
 263 // 'a' '\377'
 264 // '\0'
 265 // '\0' 'b'
 266 TEST_F(SerialIoHandlerPosixTest,
 267        BreakReadThreeTimesHasBytesBeforeAndAfterBreak) {
 268   for (int buffer_len = 2; buffer_len <= 20; ++buffer_len) {
 269     Initialize(true, "", 0);
 270
 271     char buffer_1[30] = {'a', '\377'};
 272     int bytes_read = 2;
 273     TestHelper(buffer_1, buffer_len, bytes_read,
 274                ErrorDetectState::MARK_377_SEEN, "\377", 1, "a", 1, false,
 275                false);
 276
 277     char buffer_2[30] = {'\0'};
 278     bytes_read = 1;
 279     TestHelper(buffer_2, buffer_len, bytes_read, ErrorDetectState::MARK_0_SEEN,
 280                "\377\0", 2, "", 0, false, false);
 281
 282     char buffer_3[30] = {'\0', 'b'};
 283     bytes_read = 2;
 284     TestHelper(buffer_3, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "",
 285                0, "b", 1, true, false);
 286   }
 287 }
 288
 289 // '\377' '\0' 'a'
 290 TEST_F(SerialIoHandlerPosixTest, ParityErrorReadOnce) {
 291   for (int buffer_len = 3; buffer_len <= 20; ++buffer_len) {
 292     Initialize(true, "", 0);
 293
 294     char buffer[30] = {'\377', '\0', 'a'};
 295     int bytes_read = 3;
 296     TestHelper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "",
 297                0, "", 0, false, true);
 298   }
 299 }
 300
 301 // 'b' 'c' '\377' '\0' 'a' 'd'
 302 TEST_F(SerialIoHandlerPosixTest,
 303        ParityErrorReadOnceHasBytesBeforeAndAfterParityError) {
 304   for (int buffer_len = 6; buffer_len <= 20; ++buffer_len) {
 305     Initialize(true, "", 0);
 306
 307     char buffer[30] = {'b', 'c', '\377', '\0', 'a', 'd'};
 308     int bytes_read = 6;
 309     TestHelper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "",
 310                0, "bcd", 3, false, true);
 311   }
 312 }
 313
 314 // '\377' '\0'
 315 // 'a'
 316 TEST_F(SerialIoHandlerPosixTest, ParityErrorReadTwiceBytesReadTwoAndOne) {
 317   for (int buffer_len = 2; buffer_len <= 20; ++buffer_len) {
 318     Initialize(true, "", 0);
 319
 320     char buffer_1[30] = {'\377', '\0'};
 321     int bytes_read = 2;
 322     TestHelper(buffer_1, buffer_len, bytes_read, ErrorDetectState::MARK_0_SEEN,
 323                "\377\0", 2, "", 0, false, false);
 324
 325     char buffer_2[30] = {'a'};
 326     bytes_read = 1;
 327     TestHelper(buffer_2, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "",
 328                0, "", 0, false, true);
 329   }
 330 }
 331
 332 // 'b' '\377' '\0'
 333 // 'a' 'c' 'd'
 334 TEST_F(
 335     SerialIoHandlerPosixTest,
 336     ParityErrorReadTwiceBytesReadTwoAndOneHasBytesBeforeAndAfterParityError) {
 337   for (int buffer_len = 3; buffer_len <= 20; ++buffer_len) {
 338     Initialize(true, "", 0);
 339
 340     char buffer_1[30] = {'b', '\377', '\0'};
 341     int bytes_read = 3;
 342     TestHelper(buffer_1, buffer_len, bytes_read, ErrorDetectState::MARK_0_SEEN,
 343                "\377\0", 2, "b", 1, false, false);
 344
 345     char buffer_2[30] = {'a', 'c', 'd'};
 346     bytes_read = 3;
 347     TestHelper(buffer_2, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "",
 348                0, "cd", 2, false, true);
 349   }
 350 }
 351
 352 // '\377'
 353 // '\0' 'a'
 354 TEST_F(SerialIoHandlerPosixTest, ParityErrorReadTwiceBytesReadOneAndTwo) {
 355   for (int buffer_len = 2; buffer_len <= 20; ++buffer_len) {
 356     Initialize(true, "", 0);
 357
 358     char buffer_1[30] = {'\377'};
 359     int bytes_read = 1;
 360     TestHelper(buffer_1, buffer_len, bytes_read,
 361                ErrorDetectState::MARK_377_SEEN, "\377", 1, "", 0, false, false);
 362
 363     char buffer_2[30] = {'\0', 'a'};
 364     bytes_read = 2;
 365     TestHelper(buffer_2, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "",
 366                0, "", 0, false, true);
 367   }
 368 }
 369
 370 // 'b' 'c' '\377'
 371 // '\0' 'a' 'd'
 372 TEST_F(
 373     SerialIoHandlerPosixTest,
 374     ParityErrorReadTwiceBytesReadOneAndTwoHasBytesBeforeAndAfterParityError) {
 375   for (int buffer_len = 3; buffer_len <= 20; ++buffer_len) {
 376     Initialize(true, "", 0);
 377
 378     char buffer_1[30] = {'b', 'c', '\377'};
 379     int bytes_read = 3;
 380     TestHelper(buffer_1, buffer_len, bytes_read,
 381                ErrorDetectState::MARK_377_SEEN, "\377", 1, "bc", 2, false,
 382                false);
 383
 384     char buffer_2[30] = {'\0', 'a', 'd'};
 385     bytes_read = 3;
 386     TestHelper(buffer_2, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "",
 387                0, "d", 1, false, true);
 388   }
 389 }
 390
 391 // '\377'
 392 // '\0'
 393 // 'a'
 394 TEST_F(SerialIoHandlerPosixTest, ParityErrorReadThreeTimes) {
 395   for (int buffer_len = 1; buffer_len <= 20; ++buffer_len) {
 396     Initialize(true, "", 0);
 397
 398     char buffer_1[30] = {'\377'};
 399     int bytes_read = 1;
 400     TestHelper(buffer_1, buffer_len, bytes_read,
 401                ErrorDetectState::MARK_377_SEEN, "\377", 1, "", 0, false, false);
 402
 403     char buffer_2[30] = {'\0'};
 404     bytes_read = 1;
 405     TestHelper(buffer_2, buffer_len, bytes_read, ErrorDetectState::MARK_0_SEEN,
 406                "\377\0", 2, "", 0, false, false);
 407
 408     char buffer_3[30] = {'a'};
 409     bytes_read = 1;
 410     TestHelper(buffer_3, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "",
 411                0, "", 0, false, true);
 412   }
 413 }
 414
 415 // 'b' '\377'
 416 // '\0'
 417 // 'a' 'c'
 418 TEST_F(SerialIoHandlerPosixTest,
 419        ParityErrorReadThreeTimesHasBytesBeforeAndAfterParityError) {
 420   for (int buffer_len = 2; buffer_len <= 20; ++buffer_len) {
 421     Initialize(true, "", 0);
 422
 423     char buffer_1[30] = {'b', '\377'};
 424     int bytes_read = 2;
 425     TestHelper(buffer_1, buffer_len, bytes_read,
 426                ErrorDetectState::MARK_377_SEEN, "\377", 1, "b", 1, false,
 427                false);
 428
 429     char buffer_2[30] = {'\0'};
 430     bytes_read = 1;
 431     TestHelper(buffer_2, buffer_len, bytes_read, ErrorDetectState::MARK_0_SEEN,
 432                "\377\0", 2, "", 0, false, false);
 433
 434     char buffer_3[30] = {'a', 'c'};
 435     bytes_read = 2;
 436     TestHelper(buffer_3, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "",
 437                0, "c", 1, false, true);
 438   }
 439 }
 440
 441 // '\377' '\377'
 442 TEST_F(SerialIoHandlerPosixTest, TwoEOFsReadOnce) {
 443   for (int buffer_len = 2; buffer_len <= 20; ++buffer_len) {
 444     Initialize(true, "", 0);
 445
 446     char buffer[30] = {'\377', '\377'};
 447     int bytes_read = 2;
 448     TestHelper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "",
 449                0, "\377", 1, false, false);
 450   }
 451 }
 452
 453 // 'a' '\377' '\377' 'b' 'c'
 454 TEST_F(SerialIoHandlerPosixTest, TwoEOFsReadOnceHasBytesBeforeAndAfterEOF) {
 455   for (int buffer_len = 5; buffer_len <= 20; ++buffer_len) {
 456     Initialize(true, "", 0);
 457
 458     char buffer[30] = {'a', '\377', '\377', 'b', 'c'};
 459     int bytes_read = 5;
 460     TestHelper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "",
 461                0, "a\377bc", 4, false, false);
 462   }
 463 }
 464
 465 // '\377'
 466 // '\377'
 467 TEST_F(SerialIoHandlerPosixTest, TwoEOFsReadTwice) {
 468   for (int buffer_len = 1; buffer_len <= 20; ++buffer_len) {
 469     Initialize(true, "", 0);
 470
 471     char buffer_1[30] = {'\377'};
 472     int bytes_read = 1;
 473     TestHelper(buffer_1, buffer_len, bytes_read,
 474                ErrorDetectState::MARK_377_SEEN, "\377", 1, "", 0, false, false);
 475
 476     char buffer_2[30] = {'\377'};
 477     bytes_read = 1;
 478     TestHelper(buffer_2, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "",
 479                0, "\377", 1, false, false);
 480   }
 481 }
 482
 483 // 'a' '\377'
 484 // '\377' 'b'
 485 TEST_F(SerialIoHandlerPosixTest, TwoEOFsReadTwiceHasBytesBeforeAndAfterEOF) {
 486   for (int buffer_len = 2; buffer_len <= 20; ++buffer_len) {
 487     Initialize(true, "", 0);
 488
 489     char buffer_1[30] = {'a', '\377'};
 490     int bytes_read = 2;
 491     TestHelper(buffer_1, buffer_len, bytes_read,
 492                ErrorDetectState::MARK_377_SEEN, "\377", 1, "a", 1, false,
 493                false);
 494
 495     char buffer_2[30] = {'\377', 'b'};
 496     bytes_read = 2;
 497     TestHelper(buffer_2, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "",
 498                0, "\377b", 2, false, false);
 499   }
 500 }
 501
 502 // '\377' '\0' 'a'
 503 TEST_F(SerialIoHandlerPosixTest, ParityCheckDisabledReadOnce) {
 504   for (int buffer_len = 3; buffer_len <= 20; ++buffer_len) {
 505     Initialize(false, "", 0);
 506
 507     char buffer[30] = {'\377', '\0', 'a'};
 508     int bytes_read = 3;
 509     TestHelper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "",
 510                0, "\377\0a", 3, false, false);
 511   }
 512 }
 513
 514 // 'b' '\377' '\0' 'a' 'c'
 515 TEST_F(SerialIoHandlerPosixTest,
 516        ParityCheckDisabledReadOnceHasBytesBeforeAndAfter) {
 517   for (int buffer_len = 5; buffer_len <= 20; ++buffer_len) {
 518     Initialize(false, "", 0);
 519
 520     char buffer[30] = {'b', '\377', '\0', 'a', 'c'};
 521     int bytes_read = 5;
 522     TestHelper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "",
 523                0, "b\377\0ac", 5, false, false);
 524   }
 525 }
 526
 527 // '\377' '\0'
 528 // 'a'
 529 TEST_F(SerialIoHandlerPosixTest,
 530        ParityCheckDisabledReadTwiceBytesReadTwoAndOne) {
 531   int buffer_len = 2;
 532   Initialize(false, "", 0);
 533
 534   char buffer_1[30] = {'\377', '\0'};
 535   int bytes_read = 2;
 536   TestHelper(buffer_1, buffer_len, bytes_read, ErrorDetectState::MARK_0_SEEN,
 537              "\377\0", 2, "", 0, false, false);
 538
 539   char buffer_2[30] = {'a'};
 540   bytes_read = 1;
 541   TestHelper(buffer_2, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "a",
 542              1, "\377\0", 2, false, false);
 543 }
 544
 545 // '\377' '\0'
 546 // 'a' 'b'
 547 TEST_F(SerialIoHandlerPosixTest,
 548        ParityCheckDisabledReadTwiceBytesReadTwoAndOneHasBytesAfter) {
 549   int buffer_len = 2;
 550   Initialize(false, "", 0);
 551
 552   char buffer_1[30] = {'\377', '\0'};
 553   int bytes_read = 2;
 554   TestHelper(buffer_1, buffer_len, bytes_read, ErrorDetectState::MARK_0_SEEN,
 555              "\377\0", 2, "", 0, false, false);
 556
 557   char buffer_2[30] = {'a', 'b'};
 558   bytes_read = 2;
 559   TestHelper(buffer_2, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "ab",
 560              2, "\377\0", 2, false, false);
 561 }
 562
 563 // '\377' '\0'
 564 // 'a'
 565 TEST_F(SerialIoHandlerPosixTest,
 566        ParityCheckDisabledReadTwiceBytesReadTwoAndOneLargerBufferLen) {
 567   for (int buffer_len = 3; buffer_len <= 20; ++buffer_len) {
 568     Initialize(false, "", 0);
 569
 570     char buffer_1[30] = {'\377', '\0'};
 571     int bytes_read = 2;
 572     TestHelper(buffer_1, buffer_len, bytes_read, ErrorDetectState::MARK_0_SEEN,
 573                "\377\0", 2, "", 0, false, false);
 574
 575     char buffer_2[30] = {'a'};
 576     bytes_read = 1;
 577     TestHelper(buffer_2, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "",
 578                0, "\377\0a", 3, false, false);
 579   }
 580 }
 581
 582 // 'b' '\377' '\0'
 583 // 'a' 'c'
 584 TEST_F(
 585     SerialIoHandlerPosixTest,
 586     ParityCheckDisabledReadTwiceBytesReadTwoAndOneBufferLenThreeHasBytesBeforeAndAfter) {
 587   int buffer_len = 3;
 588   Initialize(false, "", 0);
 589
 590   char buffer_1[30] = {'b', '\377', '\0'};
 591   int bytes_read = 3;
 592   TestHelper(buffer_1, buffer_len, bytes_read, ErrorDetectState::MARK_0_SEEN,
 593              "\377\0", 2, "b", 1, false, false);
 594
 595   char buffer_2[30] = {'a', 'c'};
 596   bytes_read = 2;
 597   TestHelper(buffer_2, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "c",
 598              1, "\377\0a", 3, false, false);
 599 }
 600
 601 // 'b' '\377' '\0'
 602 // 'a' 'c'
 603 TEST_F(
 604     SerialIoHandlerPosixTest,
 605     ParityCheckDisabledReadTwiceBytesReadTwoAndOneLargerBufferLenHasBytesBeforeAndAfter) {
 606   for (int buffer_len = 4; buffer_len <= 20; ++buffer_len) {
 607     Initialize(false, "", 0);
 608
 609     char buffer_1[30] = {'b', '\377', '\0'};
 610     int bytes_read = 3;
 611     TestHelper(buffer_1, buffer_len, bytes_read, ErrorDetectState::MARK_0_SEEN,
 612                "\377\0", 2, "b", 1, false, false);
 613
 614     char buffer_2[30] = {'a', 'c'};
 615     bytes_read = 2;
 616     TestHelper(buffer_2, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "",
 617                0, "\377\0ac", 4, false, false);
 618   }
 619 }
 620
 621 // '\377'
 622 // '\0' 'a'
 623 TEST_F(SerialIoHandlerPosixTest,
 624        ParityCheckDisabledReadTwiceBytesReadOneAndTwo) {
 625   int buffer_len = 2;
 626   Initialize(false, "", 0);
 627
 628   char buffer_1[30] = {'\377'};
 629   int bytes_read = 1;
 630   TestHelper(buffer_1, buffer_len, bytes_read, ErrorDetectState::MARK_377_SEEN,
 631              "\377", 1, "", 0, false, false);
 632
 633   char buffer_2[30] = {'\0', 'a'};
 634   bytes_read = 2;
 635   TestHelper(buffer_2, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "a",
 636              1, "\377\0", 2, false, false);
 637
 638   char buffer_3[30];
 639   bytes_read = 0;
 640   TestHelper(buffer_3, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "",
 641              0, "a", 1, false, false);
 642 }
 643
 644 // 'b' '\377'
 645 // '\0' 'a'
 646 TEST_F(SerialIoHandlerPosixTest,
 647        ParityCheckDisabledReadTwiceBytesReadOneAndTwoHasBytesBefore) {
 648   int buffer_len = 2;
 649   Initialize(false, "", 0);
 650
 651   char buffer_1[30] = {'b', '\377'};
 652   int bytes_read = 2;
 653   TestHelper(buffer_1, buffer_len, bytes_read, ErrorDetectState::MARK_377_SEEN,
 654              "\377", 1, "b", 1, false, false);
 655
 656   char buffer_2[30] = {'\0', 'a'};
 657   bytes_read = 2;
 658   TestHelper(buffer_2, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "a",
 659              1, "\377\0", 2, false, false);
 660
 661   char buffer_3[30];
 662   bytes_read = 0;
 663   TestHelper(buffer_3, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "",
 664              0, "a", 1, false, false);
 665 }
 666
 667 // '\377'
 668 // '\0' 'a'
 669 TEST_F(SerialIoHandlerPosixTest,
 670        ParityCheckDisabledReadTwiceBytesReadOneAndTwoLargerBufferLen) {
 671   for (int buffer_len = 3; buffer_len <= 20; ++buffer_len) {
 672     Initialize(false, "", 0);
 673
 674     char buffer_1[30] = {'\377'};
 675     int bytes_read = 1;
 676     TestHelper(buffer_1, buffer_len, bytes_read,
 677                ErrorDetectState::MARK_377_SEEN, "\377", 1, "", 0, false, false);
 678
 679     char buffer_2[30] = {'\0', 'a'};
 680     bytes_read = 2;
 681     TestHelper(buffer_2, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "",
 682                0, "\377\0a", 3, false, false);
 683   }
 684 }
 685
 686 // 'b' '\377'
 687 // '\0' 'a' 'c'
 688 TEST_F(
 689     SerialIoHandlerPosixTest,
 690     ParityCheckDisabledReadTwiceBytesReadOneAndTwoBufferLenThreeHasBytesBeforeAndAfter) {
 691   int buffer_len = 3;
 692   Initialize(false, "", 0);
 693
 694   char buffer_1[30] = {'b', '\377'};
 695   int bytes_read = 2;
 696   TestHelper(buffer_1, buffer_len, bytes_read, ErrorDetectState::MARK_377_SEEN,
 697              "\377", 1, "b", 1, false, false);
 698
 699   char buffer_2[30] = {'\0', 'a', 'c'};
 700   bytes_read = 3;
 701   TestHelper(buffer_2, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "c",
 702              1, "\377\0a", 3, false, false);
 703 }
 704
 705 // 'b' '\377'
 706 // '\0' 'a' 'c'
 707 TEST_F(
 708     SerialIoHandlerPosixTest,
 709     ParityCheckDisabledReadTwiceBytesReadOneAndTwoLargerBufferLenHasBytesBeforeAndAfter) {
 710   for (int buffer_len = 4; buffer_len <= 20; ++buffer_len) {
 711     Initialize(false, "", 0);
 712
 713     char buffer_1[30] = {'b', '\377'};
 714     int bytes_read = 2;
 715     TestHelper(buffer_1, buffer_len, bytes_read,
 716                ErrorDetectState::MARK_377_SEEN, "\377", 1, "b", 1, false,
 717                false);
 718
 719     char buffer_2[30] = {'\0', 'a', 'c'};
 720     bytes_read = 3;
 721     TestHelper(buffer_2, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "",
 722                0, "\377\0ac", 4, false, false);
 723   }
 724 }
 725
 726 // '\377'
 727 // '\0'
 728 // 'a'
 729 TEST_F(SerialIoHandlerPosixTest,
 730        ParityCheckDisabledReadThreeTimesBufferLenOne) {
 731   int buffer_len = 1;
 732   Initialize(false, "", 0);
 733
 734   char buffer_1[30] = {'\377'};
 735   int bytes_read = 1;
 736   TestHelper(buffer_1, buffer_len, bytes_read, ErrorDetectState::MARK_377_SEEN,
 737              "\377", 1, "", 0, false, false);
 738
 739   char buffer_2[30] = {'\0'};
 740   bytes_read = 1;
 741   TestHelper(buffer_2, buffer_len, bytes_read, ErrorDetectState::MARK_0_SEEN,
 742              "\377\0", 2, "", 0, false, false);
 743
 744   char buffer_3[30] = {'a'};
 745   bytes_read = 1;
 746   TestHelper(buffer_3, buffer_len, bytes_read, ErrorDetectState::NO_ERROR,
 747              "\0a", 2, "\377", 1, false, false);
 748 }
 749
 750 // '\377'
 751 // '\0'
 752 // 'a'
 753 TEST_F(SerialIoHandlerPosixTest,
 754        ParityCheckDisabledReadThreeTimesBufferLenTwo) {
 755   int buffer_len = 2;
 756   Initialize(false, "", 0);
 757
 758   char buffer_1[30] = {'\377'};
 759   int bytes_read = 1;
 760   TestHelper(buffer_1, buffer_len, bytes_read, ErrorDetectState::MARK_377_SEEN,
 761              "\377", 1, "", 0, false, false);
 762
 763   char buffer_2[30] = {'\0'};
 764   bytes_read = 1;
 765   TestHelper(buffer_2, buffer_len, bytes_read, ErrorDetectState::MARK_0_SEEN,
 766              "\377\0", 2, "", 0, false, false);
 767
 768   char buffer_3[30] = {'a'};
 769   bytes_read = 1;
 770   TestHelper(buffer_3, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "a",
 771              1, "\377\0", 2, false, false);
 772 }
 773
 774 // '\377'
 775 // '\0'
 776 // 'a'
 777 TEST_F(SerialIoHandlerPosixTest,
 778        ParityCheckDisabledReadThreeTimesLargerBufferLen) {
 779   for (int buffer_len = 3; buffer_len <= 20; ++buffer_len) {
 780     Initialize(false, "", 0);
 781
 782     char buffer_1[30] = {'\377'};
 783     int bytes_read = 1;
 784     TestHelper(buffer_1, buffer_len, bytes_read,
 785                ErrorDetectState::MARK_377_SEEN, "\377", 1, "", 0, false, false);
 786
 787     char buffer_2[30] = {'\0'};
 788     bytes_read = 1;
 789     TestHelper(buffer_2, buffer_len, bytes_read, ErrorDetectState::MARK_0_SEEN,
 790                "\377\0", 2, "", 0, false, false);
 791
 792     char buffer_3[30] = {'a'};
 793     bytes_read = 1;
 794     TestHelper(buffer_3, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "",
 795                0, "\377\0a", 3, false, false);
 796   }
 797 }
 798
 799 // 'b' '\377'
 800 // '\0'
 801 // 'a' 'c'
 802 TEST_F(SerialIoHandlerPosixTest,
 803        ParityCheckDisabledReadThreeTimesBufferLenThreeByteBeforeAndAfter) {
 804   int buffer_len = 3;
 805   Initialize(false, "", 0);
 806
 807   char buffer_1[30] = {'b', '\377'};
 808   int bytes_read = 2;
 809   TestHelper(buffer_1, buffer_len, bytes_read, ErrorDetectState::MARK_377_SEEN,
 810              "\377", 1, "b", 1, false, false);
 811
 812   char buffer_2[30] = {'\0'};
 813   bytes_read = 1;
 814   TestHelper(buffer_2, buffer_len, bytes_read, ErrorDetectState::MARK_0_SEEN,
 815              "\377\0", 2, "", 0, false, false);
 816
 817   char buffer_3[30] = {'a', 'c'};
 818   bytes_read = 2;
 819   TestHelper(buffer_3, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "c",
 820              1, "\377\0a", 3, false, false);
 821 }
 822
 823 // 'b' '\377'
 824 // '\0'
 825 // 'a' 'c'
 826 TEST_F(SerialIoHandlerPosixTest,
 827        ParityCheckDisabledReadThreeTimesLargerBufferLenHasBytesBeforeAndAfter) {
 828   for (int buffer_len = 4; buffer_len <= 20; ++buffer_len) {
 829     Initialize(false, "", 0);
 830
 831     char buffer_1[30] = {'b', '\377'};
 832     int bytes_read = 2;
 833     TestHelper(buffer_1, buffer_len, bytes_read,
 834                ErrorDetectState::MARK_377_SEEN, "\377", 1, "b", 1, false,
 835                false);
 836
 837     char buffer_2[30] = {'\0'};
 838     bytes_read = 1;
 839     TestHelper(buffer_2, buffer_len, bytes_read, ErrorDetectState::MARK_0_SEEN,
 840                "\377\0", 2, "", 0, false, false);
 841
 842     char buffer_3[30] = {'a', 'c'};
 843     bytes_read = 2;
 844     TestHelper(buffer_3, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "",
 845                0, "\377\0ac", 4, false, false);
 846   }
 847 }
 848
 849 TEST_F(SerialIoHandlerPosixTest, BytesReadZero) {
 850   for (int buffer_len = 1; buffer_len <= 20; ++buffer_len) {
 851     Initialize(true, "", 0);
 852
 853     char buffer[30];
 854     int bytes_read = 0;
 855     TestHelper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "",
 856                0, "", 0, false, false);
 857   }
 858 }
 859
 860 // '\377' 'a' 'b'
 861 TEST_F(SerialIoHandlerPosixTest, InvalidSequenceReadOnce) {
 862   for (int buffer_len = 3; buffer_len <= 20; ++buffer_len) {
 863     Initialize(true, "", 0);
 864
 865     char buffer[30] = {'\377', 'a', 'b'};
 866     int bytes_read = 3;
 867     TestHelper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "",
 868                0, "\377ab", 3, false, false);
 869   }
 870 }
 871
 872 // '\377' 'a'
 873 // 'b'
 874 TEST_F(SerialIoHandlerPosixTest, InvalidSequenceReadTwiceBytesReadTwoAndOne) {
 875   for (int buffer_len = 2; buffer_len <= 20; ++buffer_len) {
 876     Initialize(true, "", 0);
 877
 878     char buffer_1[30] = {'\377', 'a'};
 879     int bytes_read = 2;
 880     TestHelper(buffer_1, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "",
 881                0, "\377a", 2, false, false);
 882
 883     char buffer_2[30] = {'b'};
 884     bytes_read = 1;
 885     TestHelper(buffer_2, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "",
 886                0, "b", 1, false, false);
 887   }
 888 }
 889
 890 // '\377'
 891 // 'a' 'b'
 892 TEST_F(SerialIoHandlerPosixTest, InvalidSequenceReadTwiceBytesReadOneAndTwo) {
 893   int buffer_len = 2;
 894   Initialize(true, "", 0);
 895
 896   char buffer_1[30] = {'\377'};
 897   int bytes_read = 1;
 898   TestHelper(buffer_1, buffer_len, bytes_read, ErrorDetectState::MARK_377_SEEN,
 899              "\377", 1, "", 0, false, false);
 900
 901   char buffer_2[30] = {'a', 'b'};
 902   bytes_read = 2;
 903   TestHelper(buffer_2, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "b",
 904              1, "\377a", 2, false, false);
 905 }
 906
 907 // '\377'
 908 // 'a' 'b'
 909 TEST_F(SerialIoHandlerPosixTest,
 910        InvalidSequenceReadTwiceBytesReadOneAndTwoLargerBufferLen) {
 911   for (int buffer_len = 3; buffer_len <= 20; ++buffer_len) {
 912     Initialize(true, "", 0);
 913
 914     char buffer_1[30] = {'\377'};
 915     int bytes_read = 1;
 916     TestHelper(buffer_1, buffer_len, bytes_read,
 917                ErrorDetectState::MARK_377_SEEN, "\377", 1, "", 0, false, false);
 918
 919     char buffer_2[30] = {'a', 'b'};
 920     bytes_read = 2;
 921     TestHelper(buffer_2, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "",
 922                0, "\377ab", 3, false, false);
 923   }
 924 }
 925
 926 // '\377'
 927 // 'a'
 928 // 'b'
 929 TEST_F(SerialIoHandlerPosixTest, InvalidSequenceReadThreeTimes) {
 930   int buffer_len = 1;
 931   Initialize(true, "", 0);
 932
 933   char buffer_1[30] = {'\377'};
 934   int bytes_read = 1;
 935   TestHelper(buffer_1, buffer_len, bytes_read, ErrorDetectState::MARK_377_SEEN,
 936              "\377", 1, "", 0, false, false);
 937
 938   char buffer_2[30] = {'a'};
 939   bytes_read = 1;
 940   TestHelper(buffer_2, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "a",
 941              1, "\377", 1, false, false);
 942
 943   char buffer_3[30] = {'b'};
 944   bytes_read = 1;
 945   TestHelper(buffer_3, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "b",
 946              1, "a", 1, false, false);
 947 }
 948
 949 // '\377'
 950 // 'a'
 951 // 'b'
 952 TEST_F(SerialIoHandlerPosixTest, InvalidSequenceReadThreeTimesLargerBufferLen) {
 953   for (int buffer_len = 2; buffer_len <= 20; ++buffer_len) {
 954     Initialize(true, "", 0);
 955
 956     char buffer_1[30] = {'\377'};
 957     int bytes_read = 1;
 958     TestHelper(buffer_1, buffer_len, bytes_read,
 959                ErrorDetectState::MARK_377_SEEN, "\377", 1, "", 0, false, false);
 960
 961     char buffer_2[30] = {'a'};
 962     bytes_read = 1;
 963     TestHelper(buffer_2, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "",
 964                0, "\377a", 2, false, false);
 965
 966     char buffer_3[30] = {'b'};
 967     bytes_read = 1;
 968     TestHelper(buffer_3, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "",
 969                0, "b", 1, false, false);
 970   }
 971 }
 972
 973 // 'a' 'b' 'c' '\377'
 974 TEST_F(SerialIoHandlerPosixTest, CharsStashedPreset) {
 975   int buffer_len = 2;
 976   Initialize(true, "ab", 2);
 977
 978   char buffer[30] = {'c', '\377'};
 979   int bytes_read = 2;
 980   TestHelper(buffer, buffer_len, bytes_read, ErrorDetectState::MARK_377_SEEN,
 981              "c\377", 2, "ab", 2, false, false);
 982 }
 983
 984 // 'b' 'c' '\377' '\0' '\0' '\377' '\377' '\377' '\0' 'a' 'd' 'e'
 985 TEST_F(SerialIoHandlerPosixTest, BreakAndEOFAndParityError) {
 986   int buffer_len = 12;
 987   Initialize(true, "", 0);
 988
 989   char buffer[30] = {'b',    'c',    '\377', '\0', '\0', '\377',
 990                      '\377', '\377', '\0',   'a',  'd',  'e'};
 991   int bytes_read = 12;
 992   TestHelper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "", 0,
 993              "bc\377de", 5, true, true);
 994 }
 995
 996 // 'b' 'c' '\377' '\0' '\0' '\377'
 997 // '\377' '\377' '\0'
 998 // 'a' 'd' 'e'
 999 TEST_F(SerialIoHandlerPosixTest, BreakAndEOFAndParityErrorReadThreeTimes) {
1000   for (int buffer_len = 6; buffer_len <= 20; ++buffer_len) {
1001     Initialize(true, "", 0);
1002
1003     char buffer_1[30] = {'b', 'c', '\377', '\0', '\0', '\377'};
1004     int bytes_read = 6;
1005     TestHelper(buffer_1, buffer_len, bytes_read,
1006                ErrorDetectState::MARK_377_SEEN, "\377", 1, "bc", 2, true,
1007                false);
1008
1009     char buffer_2[30] = {'\377', '\377', '\0'};
1010     bytes_read = 3;
1011     TestHelper(buffer_2, buffer_len, bytes_read, ErrorDetectState::MARK_0_SEEN,
1012                "\377\0", 2, "\377", 1, false, false);
1013
1014     char buffer_3[30] = {'a', 'd', 'e'};
1015     bytes_read = 3;
1016     TestHelper(buffer_3, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "",
1017                0, "de", 2, false, true);
1018   }
1019 }
1020
1021 }  // namespace device