services/device/serial/serial_io_handler_posix_unittest.cc

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