Add code to detect new added ReceiveError on Linux

device/serial/serial_io_handler_posix_unittest.cc

Index: device/serial/serial_io_handler_posix_unittest.cc
diff --git a/device/serial/serial_io_handler_posix_unittest.cc b/device/serial/serial_io_handler_posix_unittest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..208396575881d97cbf19531d6bdfa748e9ea39e5
--- /dev/null
+++ b/device/serial/serial_io_handler_posix_unittest.cc
@@ -0,0 +1,1080 @@
+// Copyright 2015 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "device/serial/serial_io_handler_posix.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace device {
+
+class SerialIoHandlerPosixTest : public testing::Test {
+ public:
+  SerialIoHandlerPosixTest() {}
+
+  void SetUp() override {
+    serial_io_handler_posix_ = new SerialIoHandlerPosix(nullptr, nullptr);
+  }
+
+  void set_error_detect_state(ErrorDetectState state) {
+    serial_io_handler_posix_->error_detect_state_ = state;
+  }
+
+  ErrorDetectState get_error_detect_state() {
+    return serial_io_handler_posix_->error_detect_state_;
+  }
+
+  void set_parity_check_enabled(bool enabled) {
+    serial_io_handler_posix_->parity_check_enabled_ = enabled;
+  }
+
+  void set_num_chars_ignored(int n) {
+    serial_io_handler_posix_->num_chars_ignored_ = n;
+  }
+
+  int num_chars_ignored() {
+    return serial_io_handler_posix_->num_chars_ignored_;
+  }
+
+  void set_chars_ignored(int index, char ch) {
+    serial_io_handler_posix_->chars_ignored_[index] = ch;
+  }
+
+  char get_chars_ignored(int index) {

[Reilly Grant (use Gerrit), 2015/07/30 00:00:41]

You don't need these wrappers anymore.

[juncai, 2015/07/30 16:04:37]

Done.

+    return serial_io_handler_posix_->chars_ignored_[index];
+  }
+
+  void initialize(ErrorDetectState error_detect_state,

[Reilly Grant (use Gerrit), 2015/07/30 00:00:41]

initialize -> Initialize

[juncai, 2015/07/30 16:04:37]

Done.

+                  bool parity_check_enabled,
+                  const char* chars_ignored,
+                  int num_chars_ignored) {
+    set_error_detect_state(error_detect_state);
+    set_parity_check_enabled(parity_check_enabled);
+    set_num_chars_ignored(num_chars_ignored);
+    for (int i = 0; i < num_chars_ignored; ++i) {
+      set_chars_ignored(i, chars_ignored[i]);
+    }
+  }
+
+  void test_helper(char* buffer,

[Reilly Grant (use Gerrit), 2015/07/30 00:00:41]

test_helper -> TestHelper

[juncai, 2015/07/30 16:04:36]

Done.

+                   int buffer_len,
+                   int bytes_read,
+                   ErrorDetectState error_detect_state_expected,
+                   const char* chars_ignored_expected,
+                   int num_chars_ignored_expected,
+                   const char* buffer_expected,
+                   int new_bytes_read_expected,
+                   bool break_detected_expected,
+                   bool parity_error_detected_expected) {
+    bool break_detected = false;
+    bool parity_error_detected = false;
+    int new_bytes_read = serial_io_handler_posix_->CheckReceiveError(
+        buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
+
+    EXPECT_EQ(error_detect_state_expected, get_error_detect_state());
+    EXPECT_EQ(num_chars_ignored_expected, num_chars_ignored());
+    for (int i = 0; i < num_chars_ignored_expected; ++i) {
+      EXPECT_EQ(chars_ignored_expected[i], get_chars_ignored(i));
+    }
+    EXPECT_EQ(new_bytes_read_expected, new_bytes_read);
+    for (int i = 0; i < new_bytes_read_expected; ++i) {
+      EXPECT_EQ(buffer_expected[i], buffer[i]);
+    }
+    EXPECT_EQ(break_detected_expected, break_detected);
+    EXPECT_EQ(parity_error_detected_expected, parity_error_detected);
+  }
+
+ protected:
+  scoped_refptr<SerialIoHandlerPosix> serial_io_handler_posix_;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(SerialIoHandlerPosixTest);
+};
+
+// 'a' 'b' 'c'
+TEST_F(SerialIoHandlerPosixTest, NoErrorReadOnce) {
+  char buffer[30];
+  for (int buffer_len = 3; buffer_len <= 20; ++buffer_len) {
+    initialize(ErrorDetectState::NO_ERROR, true, "", 0);
+
+    int bytes_read = 3;
+    memcpy(buffer, "abc", bytes_read);

[Reilly Grant (use Gerrit), 2015/07/30 00:00:41]

Use an array literal instead of memcpy:

char buffer[30] = { 'a', 'b', 'c' };

[juncai, 2015/07/30 16:04:36]

Done.

+    test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "",
+                0, "abc", 3, false, false);
+  }
+}
+
+// 'a' 'b'
+// 'c'
+TEST_F(SerialIoHandlerPosixTest, NoErrorReadTwiceBytesReadTwoAndOne) {
+  char buffer[30];
+  for (int buffer_len = 2; buffer_len <= 20; ++buffer_len) {
+    initialize(ErrorDetectState::NO_ERROR, true, "", 0);
+
+    int bytes_read = 2;
+    memcpy(buffer, "ab", bytes_read);
+    test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "",
+                0, "ab", 2, false, false);
+
+    bytes_read = 1;
+    memcpy(buffer, "c", bytes_read);
+    test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "",
+                0, "c", 1, false, false);
+  }
+}
+
+// 'a'
+// 'b' c'
+TEST_F(SerialIoHandlerPosixTest, NoErrorReadTwiceBytesReadOneAndTwo) {
+  char buffer[30];
+  for (int buffer_len = 2; buffer_len <= 20; ++buffer_len) {
+    initialize(ErrorDetectState::NO_ERROR, true, "", 0);
+
+    int bytes_read = 1;
+    memcpy(buffer, "a", bytes_read);
+    test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "",
+                0, "a", 1, false, false);
+
+    bytes_read = 2;
+    memcpy(buffer, "bc", bytes_read);
+    test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "",
+                0, "bc", 2, false, false);
+  }
+}
+
+// 'a'
+// 'b'
+// 'c'
+TEST_F(SerialIoHandlerPosixTest, NoErrorReadThreeTimes) {
+  char buffer[30];
+  for (int buffer_len = 1; buffer_len <= 20; ++buffer_len) {
+    initialize(ErrorDetectState::NO_ERROR, true, "", 0);
+
+    int bytes_read = 1;
+    memcpy(buffer, "a", bytes_read);
+    test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "",
+                0, "a", 1, false, false);
+
+    bytes_read = 1;
+    memcpy(buffer, "b", bytes_read);
+    test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "",
+                0, "b", 1, false, false);
+
+    bytes_read = 1;
+    memcpy(buffer, "c", bytes_read);
+    test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "",
+                0, "c", 1, false, false);
+  }
+}
+
+// '\377' '\0' '\0'
+TEST_F(SerialIoHandlerPosixTest, BreakReadOnce) {
+  char buffer[30];
+  for (int buffer_len = 3; buffer_len <= 20; ++buffer_len) {
+    initialize(ErrorDetectState::NO_ERROR, true, "", 0);
+
+    int bytes_read = 3;
+    memcpy(buffer, "\377\0\0", bytes_read);
+    test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "",
+                0, "", 0, true, false);
+  }
+}
+
+// 'a' 'b' '\377' '\0' '\0' 'c' 'd' 'e'
+TEST_F(SerialIoHandlerPosixTest, BreakReadOnceHasBytesBeforeAndAfterBreak) {
+  char buffer[30];
+  for (int buffer_len = 8; buffer_len <= 20; ++buffer_len) {
+    initialize(ErrorDetectState::NO_ERROR, true, "", 0);
+
+    int bytes_read = 8;
+    memcpy(buffer, "ab\377\0\000cde", bytes_read);
+    test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "",
+                0, "abcde", 5, true, false);
+  }
+}
+
+// '\377' '\0'
+// '\0'
+TEST_F(SerialIoHandlerPosixTest, BreakReadTwiceBytesReadTwoAndOne) {
+  char buffer[30];
+  for (int buffer_len = 2; buffer_len <= 20; ++buffer_len) {
+    initialize(ErrorDetectState::NO_ERROR, true, "", 0);
+
+    int bytes_read = 2;
+    memcpy(buffer, "\377\0", bytes_read);
+    test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::MARK_0_SEEN,
+                "\377\0", 2, "", 0, false, false);
+
+    bytes_read = 1;
+    memcpy(buffer, "\0", bytes_read);
+    test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "",
+                0, "", 0, true, false);
+  }
+}
+
+// 'a' 'b' 'c' \377' '\0'
+// '\0' 'd' 'e'
+TEST_F(SerialIoHandlerPosixTest,
+       BreakReadTwiceBytesReadTwoAndOneHasBytesBeforeAndAfterBreak) {
+  char buffer[30];
+  for (int buffer_len = 5; buffer_len <= 20; ++buffer_len) {
+    initialize(ErrorDetectState::NO_ERROR, true, "", 0);
+
+    int bytes_read = 5;
+    memcpy(buffer, "abc\377\0", bytes_read);
+    test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::MARK_0_SEEN,
+                "\377\0", 2, "abc", 3, false, false);
+
+    bytes_read = 3;
+    memcpy(buffer, "\000de", bytes_read);
+    test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "",
+                0, "de", 2, true, false);
+  }
+}
+
+// '\377'
+// '\0' '\0'
+TEST_F(SerialIoHandlerPosixTest, BreakReadTwiceBytesReadOneAndTwo) {
+  char buffer[30];
+  for (int buffer_len = 2; buffer_len <= 20; ++buffer_len) {
+    initialize(ErrorDetectState::NO_ERROR, true, "", 0);
+
+    int bytes_read = 1;
+    memcpy(buffer, "\377", bytes_read);
+    test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::MARK_377_SEEN,
+                "\377", 1, "", 0, false, false);
+
+    bytes_read = 2;
+    memcpy(buffer, "\0\0", bytes_read);
+    test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "",
+                0, "", 0, true, false);
+  }
+}
+
+// 'a' 'b' \377'
+// '\0' '\0' 'c'
+TEST_F(SerialIoHandlerPosixTest,
+       BreakReadTwiceBytesReadOneAndTwoHasBytesBeforeAndAfterBreak) {
+  char buffer[30];
+  for (int buffer_len = 3; buffer_len <= 20; ++buffer_len) {
+    initialize(ErrorDetectState::NO_ERROR, true, "", 0);
+
+    int bytes_read = 3;
+    memcpy(buffer, "ab\377", bytes_read);
+    test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::MARK_377_SEEN,
+                "\377", 1, "ab", 2, false, false);
+
+    bytes_read = 3;
+    memcpy(buffer, "\0\000c", bytes_read);
+    test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "",
+                0, "c", 1, true, false);
+  }
+}
+
+// '\377'
+// '\0'
+// '\0'
+TEST_F(SerialIoHandlerPosixTest, BreakReadThreeTimes) {
+  char buffer[30];
+  for (int buffer_len = 1; buffer_len <= 20; ++buffer_len) {
+    initialize(ErrorDetectState::NO_ERROR, true, "", 0);
+
+    int bytes_read = 1;
+    memcpy(buffer, "\377", bytes_read);
+    test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::MARK_377_SEEN,
+                "\377", 1, "", 0, false, false);
+
+    bytes_read = 1;
+    memcpy(buffer, "\0", bytes_read);
+    test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::MARK_0_SEEN,
+                "\377\0", 2, "", 0, false, false);
+
+    bytes_read = 1;
+    memcpy(buffer, "\0", bytes_read);
+    test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "",
+                0, "", 0, true, false);
+  }
+}
+
+// 'a' \377'
+// '\0'
+// '\0' 'b'
+TEST_F(SerialIoHandlerPosixTest,
+       BreakReadThreeTimesHasBytesBeforeAndAfterBreak) {
+  char buffer[30];
+  for (int buffer_len = 2; buffer_len <= 20; ++buffer_len) {
+    initialize(ErrorDetectState::NO_ERROR, true, "", 0);
+
+    int bytes_read = 2;
+    memcpy(buffer, "a\377", bytes_read);
+    test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::MARK_377_SEEN,
+                "\377", 1, "a", 1, false, false);
+
+    bytes_read = 1;
+    memcpy(buffer, "\0", bytes_read);
+    test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::MARK_0_SEEN,
+                "\377\0", 2, "", 0, false, false);
+
+    bytes_read = 2;
+    memcpy(buffer, "\000b", bytes_read);
+    test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "",
+                0, "b", 1, true, false);
+  }
+}
+
+// '\377' '\0' 'a'
+TEST_F(SerialIoHandlerPosixTest, ParityErrorReadOnce) {
+  char buffer[30];
+  for (int buffer_len = 3; buffer_len <= 20; ++buffer_len) {
+    initialize(ErrorDetectState::NO_ERROR, true, "", 0);
+
+    int bytes_read = 3;
+    memcpy(buffer, "\377\000a", bytes_read);
+    test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "",
+                0, "", 0, false, true);
+  }
+}
+
+// 'b' 'c' \377' '\0' 'a' 'd'
+TEST_F(SerialIoHandlerPosixTest,
+       ParityErrorReadOnceHasBytesBeforeAndAfterParityError) {
+  char buffer[30];
+  for (int buffer_len = 6; buffer_len <= 20; ++buffer_len) {
+    initialize(ErrorDetectState::NO_ERROR, true, "", 0);
+
+    int bytes_read = 6;
+    memcpy(buffer, "bc\377\000ad", bytes_read);
+    test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "",
+                0, "bcd", 3, false, true);
+  }
+}
+
+// '\377' '\0'
+// 'a'
+TEST_F(SerialIoHandlerPosixTest, ParityErrorReadTwiceBytesReadTwoAndOne) {
+  char buffer[30];
+  for (int buffer_len = 2; buffer_len <= 20; ++buffer_len) {
+    initialize(ErrorDetectState::NO_ERROR, true, "", 0);
+
+    int bytes_read = 2;
+    memcpy(buffer, "\377\0", bytes_read);
+    test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::MARK_0_SEEN,
+                "\377\0", 2, "", 0, false, false);
+
+    bytes_read = 1;
+    memcpy(buffer, "a", bytes_read);
+    test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "",
+                0, "", 0, false, true);
+  }
+}
+
+// 'b' \377' '\0'
+// 'a' 'c' 'd'
+TEST_F(
+    SerialIoHandlerPosixTest,
+    ParityErrorReadTwiceBytesReadTwoAndOneHasBytesBeforeAndAfterParityError) {
+  char buffer[30];
+  for (int buffer_len = 3; buffer_len <= 20; ++buffer_len) {
+    initialize(ErrorDetectState::NO_ERROR, true, "", 0);
+
+    int bytes_read = 3;
+    memcpy(buffer, "b\377\0", bytes_read);
+    test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::MARK_0_SEEN,
+                "\377\0", 2, "b", 1, false, false);
+
+    bytes_read = 3;
+    memcpy(buffer, "acd", bytes_read);
+    test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "",
+                0, "cd", 2, false, true);
+  }
+}
+
+// '\377'
+// '\0' 'a'
+TEST_F(SerialIoHandlerPosixTest, ParityErrorReadTwiceBytesReadOneAndTwo) {
+  char buffer[30];
+  for (int buffer_len = 2; buffer_len <= 20; ++buffer_len) {
+    initialize(ErrorDetectState::NO_ERROR, true, "", 0);
+
+    int bytes_read = 1;
+    memcpy(buffer, "\377", bytes_read);
+    test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::MARK_377_SEEN,
+                "\377", 1, "", 0, false, false);
+
+    bytes_read = 2;
+    memcpy(buffer, "\00a", bytes_read);
+    test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "",
+                0, "", 0, false, true);
+  }
+}
+
+// 'b' 'c' \377'
+// '\0' 'a' 'd'
+TEST_F(
+    SerialIoHandlerPosixTest,
+    ParityErrorReadTwiceBytesReadOneAndTwoHasBytesBeforeAndAfterParityError) {
+  char buffer[30];
+  for (int buffer_len = 3; buffer_len <= 20; ++buffer_len) {
+    initialize(ErrorDetectState::NO_ERROR, true, "", 0);
+
+    int bytes_read = 3;
+    memcpy(buffer, "bc\377", bytes_read);
+    test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::MARK_377_SEEN,
+                "\377", 1, "bc", 2, false, false);
+
+    bytes_read = 3;
+    memcpy(buffer, "\000ad", bytes_read);
+    test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "",
+                0, "d", 1, false, true);
+  }
+}
+
+// '\377'
+// '\0'
+// 'a'
+TEST_F(SerialIoHandlerPosixTest, ParityErrorReadThreeTimes) {
+  char buffer[30];
+  for (int buffer_len = 1; buffer_len <= 20; ++buffer_len) {
+    initialize(ErrorDetectState::NO_ERROR, true, "", 0);
+
+    int bytes_read = 1;
+    memcpy(buffer, "\377", bytes_read);
+    test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::MARK_377_SEEN,
+                "\377", 1, "", 0, false, false);
+
+    bytes_read = 1;
+    memcpy(buffer, "\0", bytes_read);
+    test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::MARK_0_SEEN,
+                "\377\0", 2, "", 0, false, false);
+
+    bytes_read = 1;
+    memcpy(buffer, "a", bytes_read);
+    test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "",
+                0, "", 0, false, true);
+  }
+}
+
+// 'b' '\377'
+// '\0'
+// 'a' 'c'
+TEST_F(SerialIoHandlerPosixTest,
+       ParityErrorReadThreeTimesHasBytesBeforeAndAfterParityError) {
+  char buffer[30];
+  for (int buffer_len = 2; buffer_len <= 20; ++buffer_len) {
+    initialize(ErrorDetectState::NO_ERROR, true, "", 0);
+
+    int bytes_read = 2;
+    memcpy(buffer, "b\377", bytes_read);
+    test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::MARK_377_SEEN,
+                "\377", 1, "b", 1, false, false);
+
+    bytes_read = 1;
+    memcpy(buffer, "\0", bytes_read);
+    test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::MARK_0_SEEN,
+                "\377\0", 2, "", 0, false, false);
+
+    bytes_read = 2;
+    memcpy(buffer, "ac", bytes_read);
+    test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "",
+                0, "c", 1, false, true);
+  }
+}
+
+// '\377' '\377'
+TEST_F(SerialIoHandlerPosixTest, TwoEOFsReadOnce) {
+  char buffer[30];
+  for (int buffer_len = 2; buffer_len <= 20; ++buffer_len) {
+    initialize(ErrorDetectState::NO_ERROR, true, "", 0);
+
+    int bytes_read = 2;
+    memcpy(buffer, "\377\377", bytes_read);
+    test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "",
+                0, "\377", 1, false, false);
+  }
+}
+
+// 'a' \377' '\377' 'b' 'c'
+TEST_F(SerialIoHandlerPosixTest, TwoEOFsReadOnceHasBytesBeforeAndAfterEOF) {
+  char buffer[30];
+  for (int buffer_len = 5; buffer_len <= 20; ++buffer_len) {
+    initialize(ErrorDetectState::NO_ERROR, true, "", 0);
+
+    int bytes_read = 5;
+    memcpy(buffer, "a\377\377bc", bytes_read);
+    test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "",
+                0, "a\377bc", 4, false, false);
+  }
+}
+
+// '\377'
+// '\377'
+TEST_F(SerialIoHandlerPosixTest, TwoEOFsReadTwice) {
+  char buffer[30];
+  for (int buffer_len = 1; buffer_len <= 20; ++buffer_len) {
+    initialize(ErrorDetectState::NO_ERROR, true, "", 0);
+
+    int bytes_read = 1;
+    memcpy(buffer, "\377", bytes_read);
+    test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::MARK_377_SEEN,
+                "\377", 1, "", 0, false, false);
+
+    bytes_read = 1;
+    memcpy(buffer, "\377", bytes_read);
+    test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "",
+                0, "\377", 1, false, false);
+  }
+}
+
+// 'a' \377'
+// '\377' 'b'
+TEST_F(SerialIoHandlerPosixTest, TwoEOFsReadTwiceHasBytesBeforeAndAfterEOF) {
+  char buffer[30];
+  for (int buffer_len = 2; buffer_len <= 20; ++buffer_len) {
+    initialize(ErrorDetectState::NO_ERROR, true, "", 0);
+
+    int bytes_read = 2;
+    memcpy(buffer, "a\377", bytes_read);
+    test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::MARK_377_SEEN,
+                "\377", 1, "a", 1, false, false);
+
+    bytes_read = 2;
+    memcpy(buffer, "\377b", bytes_read);
+    test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "",
+                0, "\377b", 2, false, false);
+  }
+}
+
+// '\377' '\0' 'a'
+TEST_F(SerialIoHandlerPosixTest, ParityCheckDisabledReadOnce) {
+  char buffer[30];
+  for (int buffer_len = 3; buffer_len <= 20; ++buffer_len) {
+    initialize(ErrorDetectState::NO_ERROR, false, "", 0);
+
+    int bytes_read = 3;
+    memcpy(buffer, "\377\000a", bytes_read);
+    test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "",
+                0, "\377\000a", 3, false, false);
+  }
+}
+
+// 'b' '\377' '\0' 'a' 'c'
+TEST_F(SerialIoHandlerPosixTest,
+       ParityCheckDisabledReadOnceHasBytesBeforeAndAfter) {
+  char buffer[30];
+  for (int buffer_len = 5; buffer_len <= 20; ++buffer_len) {
+    initialize(ErrorDetectState::NO_ERROR, false, "", 0);
+
+    int bytes_read = 5;
+    memcpy(buffer, "b\377\000ac", bytes_read);
+    test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "",
+                0, "b\377\000ac", 5, false, false);
+  }
+}
+
+// '\377' '\0'
+// 'a'
+TEST_F(SerialIoHandlerPosixTest,
+       ParityCheckDisabledReadTwiceBytesReadTwoAndOne) {
+  char buffer[30];
+  int buffer_len = 2;
+  initialize(ErrorDetectState::NO_ERROR, false, "", 0);
+
+  int bytes_read = 2;
+  memcpy(buffer, "\377\0", bytes_read);
+  test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::MARK_0_SEEN,
+              "\377\0", 2, "", 0, false, false);
+
+  bytes_read = 1;
+  memcpy(buffer, "a", bytes_read);
+  test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "a",
+              1, "\377\0", 2, false, false);
+}
+
+// '\377' '\0'
+// 'a' 'b'
+TEST_F(SerialIoHandlerPosixTest,
+       ParityCheckDisabledReadTwiceBytesReadTwoAndOneHasBytesAfter) {
+  char buffer[30];
+  int buffer_len = 2;
+  initialize(ErrorDetectState::NO_ERROR, false, "", 0);
+
+  int bytes_read = 2;
+  memcpy(buffer, "\377\0", bytes_read);
+  test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::MARK_0_SEEN,
+              "\377\0", 2, "", 0, false, false);
+
+  bytes_read = 2;
+  memcpy(buffer, "ab", bytes_read);
+  test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "ab",
+              2, "\377\0", 2, false, false);
+}
+
+// '\377' '\0'
+// 'a'
+TEST_F(SerialIoHandlerPosixTest,
+       ParityCheckDisabledReadTwiceBytesReadTwoAndOneLargerBufferLen) {
+  char buffer[30];
+  for (int buffer_len = 3; buffer_len <= 20; ++buffer_len) {
+    initialize(ErrorDetectState::NO_ERROR, false, "", 0);
+
+    int bytes_read = 2;
+    memcpy(buffer, "\377\0", bytes_read);
+    test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::MARK_0_SEEN,
+                "\377\0", 2, "", 0, false, false);
+
+    bytes_read = 1;
+    memcpy(buffer, "a", bytes_read);
+    test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "",
+                0, "\377\000a", 3, false, false);
+  }
+}
+
+// 'b' '\377' '\0'
+// 'a' 'c'
+TEST_F(
+    SerialIoHandlerPosixTest,
+    ParityCheckDisabledReadTwiceBytesReadTwoAndOneBufferLenThreeHasBytesBeforeAndAfter) {
+  char buffer[30];
+  int buffer_len = 3;
+  initialize(ErrorDetectState::NO_ERROR, false, "", 0);
+
+  int bytes_read = 3;
+  memcpy(buffer, "b\377\0", bytes_read);
+  test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::MARK_0_SEEN,
+              "\377\0", 2, "b", 1, false, false);
+
+  bytes_read = 2;
+  memcpy(buffer, "ac", bytes_read);
+  test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "c",
+              1, "\377\000a", 3, false, false);
+}
+
+// 'b' '\377' '\0'
+// 'a' 'c'
+TEST_F(
+    SerialIoHandlerPosixTest,
+    ParityCheckDisabledReadTwiceBytesReadTwoAndOneLargerBufferLenHasBytesBeforeAndAfter) {
+  char buffer[30];
+  for (int buffer_len = 4; buffer_len <= 20; ++buffer_len) {
+    initialize(ErrorDetectState::NO_ERROR, false, "", 0);
+
+    int bytes_read = 3;
+    memcpy(buffer, "b\377\0", bytes_read);
+    test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::MARK_0_SEEN,
+                "\377\0", 2, "b", 1, false, false);
+
+    bytes_read = 2;
+    memcpy(buffer, "ac", bytes_read);
+    test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "",
+                0, "\377\000ac", 4, false, false);
+  }
+}
+
+// '\377'
+// '\0' 'a'
+TEST_F(SerialIoHandlerPosixTest,
+       ParityCheckDisabledReadTwiceBytesReadOneAndTwo) {
+  char buffer[30];
+  int buffer_len = 2;
+  initialize(ErrorDetectState::NO_ERROR, false, "", 0);
+
+  int bytes_read = 1;
+  memcpy(buffer, "\377", bytes_read);
+  test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::MARK_377_SEEN,
+              "\377", 1, "", 0, false, false);
+
+  bytes_read = 2;
+  memcpy(buffer, "\000a", bytes_read);
+  test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "a",
+              1, "\377\0", 2, false, false);
+}
+
+// 'b' '\377'
+// '\0' 'a'
+TEST_F(SerialIoHandlerPosixTest,
+       ParityCheckDisabledReadTwiceBytesReadOneAndTwoHasBytesBefore) {
+  char buffer[30];
+  int buffer_len = 2;
+  initialize(ErrorDetectState::NO_ERROR, false, "", 0);
+
+  int bytes_read = 2;
+  memcpy(buffer, "b\377", bytes_read);
+  test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::MARK_377_SEEN,
+              "\377", 1, "b", 1, false, false);
+
+  bytes_read = 2;
+  memcpy(buffer, "\000a", bytes_read);
+  test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "a",
+              1, "\377\0", 2, false, false);
+}
+
+// '\377'
+// '\0' 'a'
+TEST_F(SerialIoHandlerPosixTest,
+       ParityCheckDisabledReadTwiceBytesReadOneAndTwoLargerBufferLen) {
+  char buffer[30];
+  for (int buffer_len = 3; buffer_len <= 20; ++buffer_len) {
+    initialize(ErrorDetectState::NO_ERROR, false, "", 0);
+
+    int bytes_read = 1;
+    memcpy(buffer, "\377", bytes_read);
+    test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::MARK_377_SEEN,
+                "\377", 1, "", 0, false, false);
+
+    bytes_read = 2;
+    memcpy(buffer, "\000a", bytes_read);
+    test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "",
+                0, "\377\000a", 3, false, false);
+  }
+}
+
+// 'b' '\377'
+// '\0' 'a' 'c'
+TEST_F(
+    SerialIoHandlerPosixTest,
+    ParityCheckDisabledReadTwiceBytesReadOneAndTwoBufferLenThreeHasBytesBeforeAndAfter) {
+  char buffer[30];
+  int buffer_len = 3;
+
+  initialize(ErrorDetectState::NO_ERROR, false, "", 0);
+
+  int bytes_read = 2;
+  memcpy(buffer, "b\377", bytes_read);
+  test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::MARK_377_SEEN,
+              "\377", 1, "b", 1, false, false);
+
+  bytes_read = 3;
+  memcpy(buffer, "\000ac", bytes_read);
+  test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "c",
+              1, "\377\000a", 3, false, false);
+}
+
+// 'b' '\377'
+// '\0' 'a' 'c'
+TEST_F(
+    SerialIoHandlerPosixTest,
+    ParityCheckDisabledReadTwiceBytesReadOneAndTwoLargerBufferLenHasBytesBeforeAndAfter) {
+  char buffer[30];
+  for (int buffer_len = 4; buffer_len <= 20; ++buffer_len) {
+    initialize(ErrorDetectState::NO_ERROR, false, "", 0);
+
+    int bytes_read = 2;
+    memcpy(buffer, "b\377", bytes_read);
+    test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::MARK_377_SEEN,
+                "\377", 1, "b", 1, false, false);
+
+    bytes_read = 3;
+    memcpy(buffer, "\000ac", bytes_read);
+    test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "",
+                0, "\377\000ac", 4, false, false);
+  }
+}
+
+// '\377'
+// '\0'
+// 'a'
+TEST_F(SerialIoHandlerPosixTest,
+       ParityCheckDisabledReadThreeTimesBufferLenOne) {
+  char buffer[30];
+  int buffer_len = 1;
+
+  initialize(ErrorDetectState::NO_ERROR, false, "", 0);
+
+  int bytes_read = 1;
+  memcpy(buffer, "\377", bytes_read);
+  test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::MARK_377_SEEN,
+              "\377", 1, "", 0, false, false);
+
+  bytes_read = 1;
+  memcpy(buffer, "\0", bytes_read);
+  test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::MARK_0_SEEN,
+              "\377\0", 2, "", 0, false, false);
+
+  bytes_read = 1;
+  memcpy(buffer, "a", bytes_read);
+  test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR,
+              "\000a", 2, "\377", 1, false, false);
+}
+
+// '\377'
+// '\0'
+// 'a'
+TEST_F(SerialIoHandlerPosixTest,
+       ParityCheckDisabledReadThreeTimesBufferLenTwo) {
+  char buffer[30];
+  int buffer_len = 2;
+
+  initialize(ErrorDetectState::NO_ERROR, false, "", 0);
+
+  int bytes_read = 1;
+  memcpy(buffer, "\377", bytes_read);
+  test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::MARK_377_SEEN,
+              "\377", 1, "", 0, false, false);
+
+  bytes_read = 1;
+  memcpy(buffer, "\0", bytes_read);
+  test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::MARK_0_SEEN,
+              "\377\0", 2, "", 0, false, false);
+
+  bytes_read = 1;
+  memcpy(buffer, "a", bytes_read);
+  test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "a",
+              1, "\377\0", 2, false, false);
+}
+
+// '\377'
+// '\0'
+// 'a'
+TEST_F(SerialIoHandlerPosixTest,
+       ParityCheckDisabledReadThreeTimesLargerBufferLen) {
+  char buffer[30];
+  for (int buffer_len = 3; buffer_len <= 20; ++buffer_len) {
+    initialize(ErrorDetectState::NO_ERROR, false, "", 0);
+
+    int bytes_read = 1;
+    memcpy(buffer, "\377", bytes_read);
+    test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::MARK_377_SEEN,
+                "\377", 1, "", 0, false, false);
+
+    bytes_read = 1;
+    memcpy(buffer, "\0", bytes_read);
+    test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::MARK_0_SEEN,
+                "\377\0", 2, "", 0, false, false);
+
+    bytes_read = 1;
+    memcpy(buffer, "a", bytes_read);
+    test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "",
+                0, "\377\000a", 3, false, false);
+  }
+}
+
+// 'b' '\377'
+// '\0'
+// 'a' 'c'
+TEST_F(SerialIoHandlerPosixTest,
+       ParityCheckDisabledReadThreeTimesBufferLenThreeByteBeforeAndAfter) {
+  char buffer[30];
+  int buffer_len = 3;
+  initialize(ErrorDetectState::NO_ERROR, false, "", 0);
+
+  int bytes_read = 2;
+  memcpy(buffer, "b\377", bytes_read);
+  test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::MARK_377_SEEN,
+              "\377", 1, "b", 1, false, false);
+
+  bytes_read = 1;
+  memcpy(buffer, "\0", bytes_read);
+  test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::MARK_0_SEEN,
+              "\377\0", 2, "", 0, false, false);
+
+  bytes_read = 2;
+  memcpy(buffer, "ac", bytes_read);
+  test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "c",
+              1, "\377\000a", 3, false, false);
+}
+
+// 'b' '\377'
+// '\0'
+// 'a' 'c'
+TEST_F(SerialIoHandlerPosixTest,
+       ParityCheckDisabledReadThreeTimesLargerBufferLenHasBytesBeforeAndAfter) {
+  char buffer[30];
+  for (int buffer_len = 4; buffer_len <= 20; ++buffer_len) {
+    initialize(ErrorDetectState::NO_ERROR, false, "", 0);
+
+    int bytes_read = 2;
+    memcpy(buffer, "b\377", bytes_read);
+    test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::MARK_377_SEEN,
+                "\377", 1, "b", 1, false, false);
+
+    bytes_read = 1;
+    memcpy(buffer, "\0", bytes_read);
+    test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::MARK_0_SEEN,
+                "\377\0", 2, "", 0, false, false);
+
+    bytes_read = 2;
+    memcpy(buffer, "ac", bytes_read);
+    test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "",
+                0, "\377\000ac", 4, false, false);
+  }
+}
+
+TEST_F(SerialIoHandlerPosixTest, BytesReadZero) {
+  char buffer[30];
+  for (int buffer_len = 1; buffer_len <= 20; ++buffer_len) {
+    initialize(ErrorDetectState::NO_ERROR, true, "", 0);
+
+    int bytes_read = 0;
+    test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "",
+                0, "", 0, false, false);
+  }
+}
+
+// '\377' 'a' 'b'
+TEST_F(SerialIoHandlerPosixTest, InvalidSequenceReadOnce) {
+  char buffer[30];
+  for (int buffer_len = 3; buffer_len <= 20; ++buffer_len) {
+    initialize(ErrorDetectState::NO_ERROR, true, "", 0);
+
+    int bytes_read = 3;
+    memcpy(buffer, "\377ab", bytes_read);
+    test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "",
+                0, "\377ab", 3, false, false);
+  }
+}
+
+// '\377' 'a'
+// 'b'
+TEST_F(SerialIoHandlerPosixTest, InvalidSequenceReadTwiceBytesReadTwoAndOne) {
+  char buffer[30];
+  for (int buffer_len = 2; buffer_len <= 20; ++buffer_len) {
+    initialize(ErrorDetectState::NO_ERROR, true, "", 0);
+
+    int bytes_read = 2;
+    memcpy(buffer, "\377a", bytes_read);
+    test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "",
+                0, "\377a", 2, false, false);
+
+    bytes_read = 1;
+    memcpy(buffer, "b", bytes_read);
+    test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "",
+                0, "b", 1, false, false);
+  }
+}
+
+// '\377'
+// 'a' 'b'
+TEST_F(SerialIoHandlerPosixTest, InvalidSequenceReadTwiceBytesReadOneAndTwo) {
+  char buffer[30];
+  int buffer_len = 2;
+  initialize(ErrorDetectState::NO_ERROR, true, "", 0);
+
+  int bytes_read = 1;
+  memcpy(buffer, "\377", bytes_read);
+  test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::MARK_377_SEEN,
+              "\377", 1, "", 0, false, false);
+
+  bytes_read = 2;
+  memcpy(buffer, "ab", bytes_read);
+  test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "b",
+              1, "\377a", 2, false, false);
+}
+
+// '\377'
+// 'a' 'b'
+TEST_F(SerialIoHandlerPosixTest,
+       InvalidSequenceReadTwiceBytesReadOneAndTwoLargerBufferLen) {
+  char buffer[30];
+  for (int buffer_len = 3; buffer_len <= 20; ++buffer_len) {
+    initialize(ErrorDetectState::NO_ERROR, true, "", 0);
+
+    int bytes_read = 1;
+    memcpy(buffer, "\377", bytes_read);
+    test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::MARK_377_SEEN,
+                "\377", 1, "", 0, false, false);
+
+    bytes_read = 2;
+    memcpy(buffer, "ab", bytes_read);
+    test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "",
+                0, "\377ab", 3, false, false);
+  }
+}
+
+// '\377'
+// 'a'
+// 'b'
+TEST_F(SerialIoHandlerPosixTest, InvalidSequenceReadThreeTimes) {
+  char buffer[30];
+  int buffer_len = 1;
+  initialize(ErrorDetectState::NO_ERROR, true, "", 0);
+
+  int bytes_read = 1;
+  memcpy(buffer, "\377", bytes_read);
+  test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::MARK_377_SEEN,
+              "\377", 1, "", 0, false, false);
+
+  bytes_read = 1;
+  memcpy(buffer, "a", bytes_read);
+  test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "a",
+              1, "\377", 1, false, false);
+
+  bytes_read = 1;
+  memcpy(buffer, "b", bytes_read);
+  test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "b",
+              1, "a", 1, false, false);
+}
+
+// '\377'
+// 'a'
+// 'b'
+TEST_F(SerialIoHandlerPosixTest, InvalidSequenceReadThreeTimesLargerBufferLen) {
+  char buffer[30];
+  for (int buffer_len = 2; buffer_len <= 20; ++buffer_len) {
+    initialize(ErrorDetectState::NO_ERROR, true, "", 0);
+
+    int bytes_read = 1;
+    memcpy(buffer, "\377", bytes_read);
+    test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::MARK_377_SEEN,
+                "\377", 1, "", 0, false, false);
+
+    bytes_read = 1;
+    memcpy(buffer, "a", bytes_read);
+    test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "",
+                0, "\377a", 2, false, false);
+
+    bytes_read = 1;
+    memcpy(buffer, "b", bytes_read);
+    test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "",
+                0, "b", 1, false, false);
+  }
+}
+
+// 'a' 'b' 'c' '\377'
+TEST_F(SerialIoHandlerPosixTest, CharsIgnoredPreset) {
+  char buffer[30];
+  int buffer_len = 2;
+  initialize(ErrorDetectState::NO_ERROR, true, "ab", 2);
+
+  int bytes_read = 2;
+  memcpy(buffer, "c\377", bytes_read);
+  test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::MARK_377_SEEN,
+              "c\377", 2, "ab", 2, false, false);
+}
+
+// 'b' 'c' '\377' '\0' '\0' '\377' '\377' '\377' '\0' 'a' 'd' 'e'
+TEST_F(SerialIoHandlerPosixTest, BreakAndEOFAndParityError) {
+  char buffer[30];
+  int buffer_len = 12;
+  initialize(ErrorDetectState::NO_ERROR, true, "", 0);
+
+  int bytes_read = 12;
+  memcpy(buffer, "bc\377\0\0\377\377\377\000ade", bytes_read);
+  test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "", 0,
+              "bc\377de", 5, true, true);
+}
+
+// 'b' 'c' '\377' '\0' '\0' '\377'
+// '\377' '\377' '\0'
+// 'a' 'd' 'e'
+TEST_F(SerialIoHandlerPosixTest, BreakAndEOFAndParityErrorReadThreeTimes) {
+  char buffer[30];
+  for (int buffer_len = 6; buffer_len <= 20; ++buffer_len) {
+    initialize(ErrorDetectState::NO_ERROR, true, "", 0);
+
+    int bytes_read = 6;
+    memcpy(buffer, "bc\377\0\0\377", bytes_read);
+    test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::MARK_377_SEEN,
+                "\377", 1, "bc", 2, true, false);
+
+    bytes_read = 3;
+    memcpy(buffer, "\377\377\0", bytes_read);
+    test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::MARK_0_SEEN,
+                "\377\0", 2, "\377", 1, false, false);
+
+    bytes_read = 3;
+    memcpy(buffer, "ade", bytes_read);
+    test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "",
+                0, "de", 2, false, true);
+  }
+}
+
+}  // namespace device