Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(2579)

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: device/serial/serial_io_handler_posix_unittest.cc

Issue 1249933004: Add code to detect new added ReceiveError on Linux (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@master
Patch Set: added more test code. Created 5 years, 5 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« device/serial/serial_io_handler_posix.h ('K') | « device/serial/serial_io_handler_posix.cc ('k') | no next file » | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
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..0f6921bd0fd64f4750c65844f0d083a5dafff704
--- /dev/null
+++ b/device/serial/serial_io_handler_posix_unittest.cc
@@ -0,0 +1,2187 @@
+// 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);
+ }
+
+ int call_CheckReceiveError(char* buffer,
Reilly Grant (use Gerrit) 2015/07/29 17:34:18 Don't mix underscores and camel-case in function n
juncai 2015/07/29 23:29:36 Done.
+ int buffer_len,
+ int bytes_read,
+ bool& break_detected,
+ bool& parity_error_detected) {
+ return serial_io_handler_posix_->CheckReceiveError(
+ buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
+ }
+
+ 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 get_num_chars_ignored() {
Reilly Grant (use Gerrit) 2015/07/29 17:34:18 No need to prefix getters with "get_", "num_chars_
juncai 2015/07/29 23:29:36 Done.
+ 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) {
+ return serial_io_handler_posix_->chars_ignored_[index];
+ }
+
+ protected:
+ scoped_refptr<SerialIoHandlerPosix> serial_io_handler_posix_;
+
+ private:
+ DISALLOW_COPY_AND_ASSIGN(SerialIoHandlerPosixTest);
+};
+
+// 'a' 'b' 'c'
+TEST_F(SerialIoHandlerPosixTest, NoErrorReadOnce) {
+ for (int buffer_len = 3; buffer_len <= 20; ++buffer_len) {
+ set_error_detect_state(NO_ERROR);
+ set_parity_check_enabled(true);
+ set_num_chars_ignored(0);
+ char buffer[buffer_len];
+
+ buffer[0] = 'a';
Reilly Grant (use Gerrit) 2015/07/29 17:34:18 This would be more readable if you built the buffe
juncai 2015/07/29 23:29:36 Done.
+ buffer[1] = 'b';
+ buffer[2] = 'c';
+ int bytes_read = 3;
+ bool break_detected = false;
+ bool parity_error_detected = false;
+ int new_bytes_read = call_CheckReceiveError(
+ buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
+ EXPECT_EQ(NO_ERROR, get_error_detect_state());
+ EXPECT_EQ(0, get_num_chars_ignored());
+ EXPECT_EQ(3, new_bytes_read);
+ EXPECT_EQ('a', buffer[0]);
+ EXPECT_EQ('b', buffer[1]);
+ EXPECT_EQ('c', buffer[2]);
+ EXPECT_EQ(break_detected, false);
+ EXPECT_EQ(parity_error_detected, false);
+ }
+}
+
+// 'a' 'b'
+// 'c'
+TEST_F(SerialIoHandlerPosixTest, NoErrorReadTwiceBytesReadTwoAndOne) {
+ for (int buffer_len = 2; buffer_len <= 20; ++buffer_len) {
+ set_error_detect_state(NO_ERROR);
+ set_parity_check_enabled(true);
+ set_num_chars_ignored(0);
+ char buffer[buffer_len];
+
+ buffer[0] = 'a';
+ buffer[1] = 'b';
+ int bytes_read = 2;
+ bool break_detected = false;
+ bool parity_error_detected = false;
+ int new_bytes_read = call_CheckReceiveError(
+ buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
+ EXPECT_EQ(NO_ERROR, get_error_detect_state());
+ EXPECT_EQ(0, get_num_chars_ignored());
+ EXPECT_EQ(bytes_read, new_bytes_read);
+ EXPECT_EQ('a', buffer[0]);
+ EXPECT_EQ('b', buffer[1]);
+ EXPECT_EQ(break_detected, false);
+ EXPECT_EQ(parity_error_detected, false);
+
+ buffer[0] = 'c';
+ bytes_read = 1;
+ break_detected = false;
+ parity_error_detected = false;
+ new_bytes_read = call_CheckReceiveError(
+ buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
+ EXPECT_EQ(NO_ERROR, get_error_detect_state());
+ EXPECT_EQ(0, get_num_chars_ignored());
+ EXPECT_EQ(1, new_bytes_read);
+ EXPECT_EQ('c', buffer[0]);
+ EXPECT_EQ(break_detected, false);
+ EXPECT_EQ(parity_error_detected, false);
+ }
+}
+
+// 'a'
+// 'b' c'
+TEST_F(SerialIoHandlerPosixTest, NoErrorReadTwiceBytesReadOneAndTwo) {
+ for (int buffer_len = 2; buffer_len <= 20; ++buffer_len) {
+ set_error_detect_state(NO_ERROR);
+ set_parity_check_enabled(true);
+ set_num_chars_ignored(0);
+ char buffer[buffer_len];
+
+ buffer[0] = 'a';
+ int bytes_read = 1;
+ bool break_detected = false;
+ bool parity_error_detected = false;
+ int new_bytes_read = call_CheckReceiveError(
+ buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
+ EXPECT_EQ(NO_ERROR, get_error_detect_state());
+ EXPECT_EQ(0, get_num_chars_ignored());
+ EXPECT_EQ(bytes_read, new_bytes_read);
+ EXPECT_EQ('a', buffer[0]);
+ EXPECT_EQ(break_detected, false);
+ EXPECT_EQ(parity_error_detected, false);
+
+ buffer[0] = 'b';
+ buffer[1] = 'c';
+ bytes_read = 2;
+ break_detected = false;
+ parity_error_detected = false;
+ new_bytes_read = call_CheckReceiveError(
+ buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
+ EXPECT_EQ(NO_ERROR, get_error_detect_state());
+ EXPECT_EQ(0, get_num_chars_ignored());
+ EXPECT_EQ(2, new_bytes_read);
+ EXPECT_EQ('b', buffer[0]);
+ EXPECT_EQ('c', buffer[1]);
+ EXPECT_EQ(break_detected, false);
+ EXPECT_EQ(parity_error_detected, false);
+ }
+}
+
+// 'a'
+// 'b'
+// 'c'
+TEST_F(SerialIoHandlerPosixTest, NoErrorReadThreeTimes) {
+ for (int buffer_len = 1; buffer_len <= 20; ++buffer_len) {
+ set_error_detect_state(NO_ERROR);
+ set_parity_check_enabled(true);
+ set_num_chars_ignored(0);
+ char buffer[buffer_len];
+
+ buffer[0] = 'a';
+ int bytes_read = 1;
+ bool break_detected = false;
+ bool parity_error_detected = false;
+ int new_bytes_read = call_CheckReceiveError(
+ buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
+ EXPECT_EQ(NO_ERROR, get_error_detect_state());
+ EXPECT_EQ(0, get_num_chars_ignored());
+ EXPECT_EQ(1, new_bytes_read);
+ EXPECT_EQ('a', buffer[0]);
+ EXPECT_EQ(break_detected, false);
+ EXPECT_EQ(parity_error_detected, false);
+
+ buffer[0] = 'b';
+ bytes_read = 1;
+ break_detected = false;
+ parity_error_detected = false;
+ new_bytes_read = call_CheckReceiveError(
+ buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
+ EXPECT_EQ(NO_ERROR, get_error_detect_state());
+ EXPECT_EQ(0, get_num_chars_ignored());
+ EXPECT_EQ(1, new_bytes_read);
+ EXPECT_EQ('b', buffer[0]);
+ EXPECT_EQ(break_detected, false);
+ EXPECT_EQ(parity_error_detected, false);
+
+ buffer[0] = 'c';
+ bytes_read = 1;
+ break_detected = false;
+ parity_error_detected = false;
+ new_bytes_read = call_CheckReceiveError(
+ buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
+ EXPECT_EQ(NO_ERROR, get_error_detect_state());
+ EXPECT_EQ(0, get_num_chars_ignored());
+ EXPECT_EQ(1, new_bytes_read);
+ EXPECT_EQ('c', buffer[0]);
+ EXPECT_EQ(break_detected, false);
+ EXPECT_EQ(parity_error_detected, false);
+ }
+}
+
+// '\377' '\0' '\0'
+TEST_F(SerialIoHandlerPosixTest, BreakReadOnce) {
+ for (int buffer_len = 3; buffer_len <= 20; ++buffer_len) {
+ set_error_detect_state(NO_ERROR);
+ set_parity_check_enabled(true);
+ set_num_chars_ignored(0);
+ char buffer[buffer_len];
+
+ buffer[0] = '\377';
+ buffer[1] = '\0';
+ buffer[2] = '\0';
+ int bytes_read = 3;
+ bool break_detected = false;
+ bool parity_error_detected = false;
+ int new_bytes_read = call_CheckReceiveError(
+ buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
+ EXPECT_EQ(NO_ERROR, get_error_detect_state());
+ EXPECT_EQ(0, get_num_chars_ignored());
+ EXPECT_EQ(0, new_bytes_read);
+ EXPECT_EQ(break_detected, true);
+ EXPECT_EQ(parity_error_detected, false);
+ }
+}
+
+// 'a' 'b' '\377' '\0' '\0' 'c' 'd' 'e'
+TEST_F(SerialIoHandlerPosixTest, BreakReadOnceHasBytesBeforeAndAfterBreak) {
+ for (int buffer_len = 8; buffer_len <= 20; ++buffer_len) {
+ set_error_detect_state(NO_ERROR);
+ set_parity_check_enabled(true);
+ set_num_chars_ignored(0);
+ char buffer[buffer_len];
+
+ buffer[0] = 'a';
+ buffer[1] = 'b';
+ buffer[2] = '\377';
+ buffer[3] = '\0';
+ buffer[4] = '\0';
+ buffer[5] = 'c';
+ buffer[6] = 'd';
+ buffer[7] = 'e';
+ int bytes_read = 8;
+ bool break_detected = false;
+ bool parity_error_detected = false;
+ int new_bytes_read = call_CheckReceiveError(
+ buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
+ EXPECT_EQ(NO_ERROR, get_error_detect_state());
+ EXPECT_EQ(0, get_num_chars_ignored());
+ EXPECT_EQ(5, new_bytes_read);
+ EXPECT_EQ('a', buffer[0]);
+ EXPECT_EQ('b', buffer[1]);
+ EXPECT_EQ('c', buffer[2]);
+ EXPECT_EQ('d', buffer[3]);
+ EXPECT_EQ('e', buffer[4]);
+ EXPECT_EQ(break_detected, true);
+ EXPECT_EQ(parity_error_detected, false);
+ }
+}
+
+// '\377' '\0'
+// '\0'
+TEST_F(SerialIoHandlerPosixTest, BreakReadTwiceBytesReadTwoAndOne) {
+ for (int buffer_len = 2; buffer_len <= 20; ++buffer_len) {
+ set_error_detect_state(NO_ERROR);
+ set_parity_check_enabled(true);
+ set_num_chars_ignored(0);
+ char buffer[buffer_len];
+
+ buffer[0] = '\377';
+ buffer[1] = '\0';
+ int bytes_read = 2;
+ bool break_detected = false;
+ bool parity_error_detected = false;
+ int new_bytes_read = call_CheckReceiveError(
+ buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
+ EXPECT_EQ(MARK_0_SEEN, get_error_detect_state());
+ EXPECT_EQ(2, get_num_chars_ignored());
+ EXPECT_EQ('\377', get_chars_ignored(0));
+ EXPECT_EQ('\0', get_chars_ignored(1));
+ EXPECT_EQ(0, new_bytes_read);
+ EXPECT_EQ(break_detected, false);
+ EXPECT_EQ(parity_error_detected, false);
+
+ buffer[0] = '\0';
+ bytes_read = 1;
+ break_detected = false;
+ parity_error_detected = false;
+ new_bytes_read = call_CheckReceiveError(
+ buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
+ EXPECT_EQ(NO_ERROR, get_error_detect_state());
+ EXPECT_EQ(0, get_num_chars_ignored());
+ EXPECT_EQ(0, new_bytes_read);
+ EXPECT_EQ(break_detected, true);
+ EXPECT_EQ(parity_error_detected, false);
+ }
+}
+
+// 'a' 'b' 'c' \377' '\0'
+// '\0' 'd' 'e'
+TEST_F(SerialIoHandlerPosixTest,
+ BreakReadTwiceBytesReadTwoAndOneHasBytesBeforeAndAfterBreak) {
+ for (int buffer_len = 5; buffer_len <= 20; ++buffer_len) {
+ set_error_detect_state(NO_ERROR);
+ set_parity_check_enabled(true);
+ set_num_chars_ignored(0);
+ char buffer[buffer_len];
+
+ buffer[0] = 'a';
+ buffer[1] = 'b';
+ buffer[2] = 'c';
+ buffer[3] = '\377';
+ buffer[4] = '\0';
+ int bytes_read = 5;
+ bool break_detected = false;
+ bool parity_error_detected = false;
+ int new_bytes_read = call_CheckReceiveError(
+ buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
+ EXPECT_EQ(MARK_0_SEEN, get_error_detect_state());
+ EXPECT_EQ(2, get_num_chars_ignored());
+ EXPECT_EQ('\377', get_chars_ignored(0));
+ EXPECT_EQ('\0', get_chars_ignored(1));
+ EXPECT_EQ(3, new_bytes_read);
+ EXPECT_EQ('a', buffer[0]);
+ EXPECT_EQ('b', buffer[1]);
+ EXPECT_EQ('c', buffer[2]);
+ EXPECT_EQ(break_detected, false);
+ EXPECT_EQ(parity_error_detected, false);
+
+ buffer[0] = '\0';
+ buffer[1] = 'd';
+ buffer[2] = 'e';
+ bytes_read = 3;
+ break_detected = false;
+ parity_error_detected = false;
+ new_bytes_read = call_CheckReceiveError(
+ buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
+ EXPECT_EQ(NO_ERROR, get_error_detect_state());
+ EXPECT_EQ(0, get_num_chars_ignored());
+ EXPECT_EQ(2, new_bytes_read);
+ EXPECT_EQ('d', buffer[0]);
+ EXPECT_EQ('e', buffer[1]);
+ EXPECT_EQ(break_detected, true);
+ EXPECT_EQ(parity_error_detected, false);
+ }
+}
+
+// '\377'
+// '\0' '\0'
+TEST_F(SerialIoHandlerPosixTest, BreakReadTwiceBytesReadOneAndTwo) {
+ for (int buffer_len = 2; buffer_len <= 20; ++buffer_len) {
+ set_error_detect_state(NO_ERROR);
+ set_parity_check_enabled(true);
+ set_num_chars_ignored(0);
+ char buffer[buffer_len];
+
+ buffer[0] = '\377';
+ int bytes_read = 1;
+ bool break_detected = false;
+ bool parity_error_detected = false;
+ int new_bytes_read = call_CheckReceiveError(
+ buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
+ EXPECT_EQ(MARK_377_SEEN, get_error_detect_state());
+ EXPECT_EQ(1, get_num_chars_ignored());
+ EXPECT_EQ('\377', get_chars_ignored(0));
+ EXPECT_EQ(0, new_bytes_read);
+ EXPECT_EQ(break_detected, false);
+ EXPECT_EQ(parity_error_detected, false);
+
+ buffer[0] = '\0';
+ buffer[1] = '\0';
+ bytes_read = 2;
+ break_detected = false;
+ parity_error_detected = false;
+ new_bytes_read = call_CheckReceiveError(
+ buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
+ EXPECT_EQ(NO_ERROR, get_error_detect_state());
+ EXPECT_EQ(0, get_num_chars_ignored());
+ EXPECT_EQ(0, new_bytes_read);
+ EXPECT_EQ(break_detected, true);
+ EXPECT_EQ(parity_error_detected, false);
+ }
+}
+
+// 'a' 'b' \377'
+// '\0' '\0' 'c'
+TEST_F(SerialIoHandlerPosixTest,
+ BreakReadTwiceBytesReadOneAndTwoHasBytesBeforeAndAfterBreak) {
+ for (int buffer_len = 3; buffer_len <= 20; ++buffer_len) {
+ set_error_detect_state(NO_ERROR);
+ set_parity_check_enabled(true);
+ set_num_chars_ignored(0);
+ char buffer[buffer_len];
+
+ buffer[0] = 'a';
+ buffer[1] = 'b';
+ buffer[2] = '\377';
+ int bytes_read = 3;
+ bool break_detected = false;
+ bool parity_error_detected = false;
+ int new_bytes_read = call_CheckReceiveError(
+ buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
+ EXPECT_EQ(MARK_377_SEEN, get_error_detect_state());
+ EXPECT_EQ(1, get_num_chars_ignored());
+ EXPECT_EQ('\377', get_chars_ignored(0));
+ EXPECT_EQ(2, new_bytes_read);
+ EXPECT_EQ('a', buffer[0]);
+ EXPECT_EQ('b', buffer[1]);
+ EXPECT_EQ(break_detected, false);
+ EXPECT_EQ(parity_error_detected, false);
+
+ buffer[0] = '\0';
+ buffer[1] = '\0';
+ buffer[2] = 'c';
+ bytes_read = 3;
+ break_detected = false;
+ parity_error_detected = false;
+ new_bytes_read = call_CheckReceiveError(
+ buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
+ EXPECT_EQ(NO_ERROR, get_error_detect_state());
+ EXPECT_EQ(0, get_num_chars_ignored());
+ EXPECT_EQ(1, new_bytes_read);
+ EXPECT_EQ('c', buffer[0]);
+ EXPECT_EQ(break_detected, true);
+ EXPECT_EQ(parity_error_detected, false);
+ }
+}
+
+// '\377'
+// '\0'
+// '\0'
+TEST_F(SerialIoHandlerPosixTest, BreakReadThreeTimes) {
+ for (int buffer_len = 1; buffer_len <= 20; ++buffer_len) {
+ set_error_detect_state(NO_ERROR);
+ set_parity_check_enabled(true);
+ set_num_chars_ignored(0);
+ char buffer[buffer_len];
+
+ buffer[0] = '\377';
+ int bytes_read = 1;
+ bool break_detected = false;
+ bool parity_error_detected = false;
+ int new_bytes_read = call_CheckReceiveError(
+ buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
+ EXPECT_EQ(MARK_377_SEEN, get_error_detect_state());
+ EXPECT_EQ(1, get_num_chars_ignored());
+ EXPECT_EQ('\377', get_chars_ignored(0));
+ EXPECT_EQ(0, new_bytes_read);
+ EXPECT_EQ(break_detected, false);
+ EXPECT_EQ(parity_error_detected, false);
+
+ buffer[0] = '\0';
+ bytes_read = 1;
+ break_detected = false;
+ parity_error_detected = false;
+ new_bytes_read = call_CheckReceiveError(
+ buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
+ EXPECT_EQ(MARK_0_SEEN, get_error_detect_state());
+ EXPECT_EQ(2, get_num_chars_ignored());
+ EXPECT_EQ('\377', get_chars_ignored(0));
+ EXPECT_EQ('\0', get_chars_ignored(1));
+ EXPECT_EQ(0, new_bytes_read);
+ EXPECT_EQ(break_detected, false);
+ EXPECT_EQ(parity_error_detected, false);
+
+ buffer[0] = '\0';
+ bytes_read = 1;
+ break_detected = false;
+ parity_error_detected = false;
+ new_bytes_read = call_CheckReceiveError(
+ buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
+ EXPECT_EQ(NO_ERROR, get_error_detect_state());
+ EXPECT_EQ(0, get_num_chars_ignored());
+ EXPECT_EQ(0, new_bytes_read);
+ EXPECT_EQ(break_detected, true);
+ EXPECT_EQ(parity_error_detected, false);
+ }
+}
+
+// 'a' \377'
+// '\0'
+// '\0' 'b'
+TEST_F(SerialIoHandlerPosixTest,
+ BreakReadThreeTimesHasBytesBeforeAndAfterBreak) {
+ for (int buffer_len = 2; buffer_len <= 20; ++buffer_len) {
+ set_error_detect_state(NO_ERROR);
+ set_parity_check_enabled(true);
+ set_num_chars_ignored(0);
+ char buffer[buffer_len];
+
+ buffer[0] = 'a';
+ buffer[1] = '\377';
+ int bytes_read = 2;
+ bool break_detected = false;
+ bool parity_error_detected = false;
+ int new_bytes_read = call_CheckReceiveError(
+ buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
+ EXPECT_EQ(MARK_377_SEEN, get_error_detect_state());
+ EXPECT_EQ(1, get_num_chars_ignored());
+ EXPECT_EQ('\377', get_chars_ignored(0));
+ EXPECT_EQ(1, new_bytes_read);
+ EXPECT_EQ('a', buffer[0]);
+ EXPECT_EQ(break_detected, false);
+ EXPECT_EQ(parity_error_detected, false);
+
+ buffer[0] = '\0';
+ bytes_read = 1;
+ break_detected = false;
+ parity_error_detected = false;
+ new_bytes_read = call_CheckReceiveError(
+ buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
+ EXPECT_EQ(MARK_0_SEEN, get_error_detect_state());
+ EXPECT_EQ(2, get_num_chars_ignored());
+ EXPECT_EQ('\377', get_chars_ignored(0));
+ EXPECT_EQ('\0', get_chars_ignored(1));
+ EXPECT_EQ(0, new_bytes_read);
+ EXPECT_EQ(break_detected, false);
+ EXPECT_EQ(parity_error_detected, false);
+
+ buffer[0] = '\0';
+ buffer[1] = 'b';
+ bytes_read = 2;
+ break_detected = false;
+ parity_error_detected = false;
+ new_bytes_read = call_CheckReceiveError(
+ buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
+ EXPECT_EQ(NO_ERROR, get_error_detect_state());
+ EXPECT_EQ(0, get_num_chars_ignored());
+ EXPECT_EQ(1, new_bytes_read);
+ EXPECT_EQ('b', buffer[0]);
+ EXPECT_EQ(break_detected, true);
+ EXPECT_EQ(parity_error_detected, false);
+ }
+}
+
+// '\377' '\0' 'a'
+TEST_F(SerialIoHandlerPosixTest, ParityErrorReadOnce) {
+ for (int buffer_len = 3; buffer_len <= 20; ++buffer_len) {
+ set_error_detect_state(NO_ERROR);
+ set_parity_check_enabled(true);
+ set_num_chars_ignored(0);
+ char buffer[buffer_len];
+
+ buffer[0] = '\377';
+ buffer[1] = '\0';
+ buffer[2] = 'a';
+ int bytes_read = 3;
+ bool break_detected = false;
+ bool parity_error_detected = false;
+ int new_bytes_read = call_CheckReceiveError(
+ buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
+ EXPECT_EQ(NO_ERROR, get_error_detect_state());
+ EXPECT_EQ(0, get_num_chars_ignored());
+ EXPECT_EQ(0, new_bytes_read);
+ EXPECT_EQ(break_detected, false);
+ EXPECT_EQ(parity_error_detected, true);
+ }
+}
+
+// 'b' 'c' \377' '\0' 'a' 'd'
+TEST_F(SerialIoHandlerPosixTest,
+ ParityErrorReadOnceHasBytesBeforeAndAfterParityError) {
+ for (int buffer_len = 6; buffer_len <= 20; ++buffer_len) {
+ set_error_detect_state(NO_ERROR);
+ set_parity_check_enabled(true);
+ set_num_chars_ignored(0);
+ char buffer[buffer_len];
+
+ buffer[0] = 'b';
+ buffer[1] = 'c';
+ buffer[2] = '\377';
+ buffer[3] = '\0';
+ buffer[4] = 'a';
+ buffer[5] = 'd';
+ int bytes_read = 6;
+ bool break_detected = false;
+ bool parity_error_detected = false;
+ int new_bytes_read = call_CheckReceiveError(
+ buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
+ EXPECT_EQ(NO_ERROR, get_error_detect_state());
+ EXPECT_EQ(0, get_num_chars_ignored());
+ EXPECT_EQ(3, new_bytes_read);
+ EXPECT_EQ('b', buffer[0]);
+ EXPECT_EQ('c', buffer[1]);
+ EXPECT_EQ('d', buffer[2]);
+ EXPECT_EQ(break_detected, false);
+ EXPECT_EQ(parity_error_detected, true);
+ }
+}
+
+// '\377' '\0'
+// 'a'
+TEST_F(SerialIoHandlerPosixTest, ParityErrorReadTwiceBytesReadTwoAndOne) {
+ for (int buffer_len = 2; buffer_len <= 20; ++buffer_len) {
+ set_error_detect_state(NO_ERROR);
+ set_parity_check_enabled(true);
+ set_num_chars_ignored(0);
+ char buffer[buffer_len];
+
+ buffer[0] = '\377';
+ buffer[1] = '\0';
+ int bytes_read = 2;
+ bool break_detected = false;
+ bool parity_error_detected = false;
+ int new_bytes_read = call_CheckReceiveError(
+ buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
+ EXPECT_EQ(MARK_0_SEEN, get_error_detect_state());
+ EXPECT_EQ(2, get_num_chars_ignored());
+ EXPECT_EQ('\377', get_chars_ignored(0));
+ EXPECT_EQ('\0', get_chars_ignored(1));
+ EXPECT_EQ(0, new_bytes_read);
+ EXPECT_EQ(break_detected, false);
+ EXPECT_EQ(parity_error_detected, false);
+
+ buffer[0] = 'a';
+ bytes_read = 1;
+ break_detected = false;
+ parity_error_detected = false;
+ new_bytes_read = call_CheckReceiveError(
+ buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
+ EXPECT_EQ(NO_ERROR, get_error_detect_state());
+ EXPECT_EQ(0, get_num_chars_ignored());
+ EXPECT_EQ(0, new_bytes_read);
+ EXPECT_EQ(break_detected, false);
+ EXPECT_EQ(parity_error_detected, true);
+ }
+}
+
+// 'b' \377' '\0'
+// 'a' 'c' 'd'
+TEST_F(
+ SerialIoHandlerPosixTest,
+ ParityErrorReadTwiceBytesReadTwoAndOneHasBytesBeforeAndAfterParityError) {
+ for (int buffer_len = 3; buffer_len <= 20; ++buffer_len) {
+ set_error_detect_state(NO_ERROR);
+ set_parity_check_enabled(true);
+ set_num_chars_ignored(0);
+ char buffer[buffer_len];
+
+ buffer[0] = 'b';
+ buffer[1] = '\377';
+ buffer[2] = '\0';
+ int bytes_read = 3;
+ bool break_detected = false;
+ bool parity_error_detected = false;
+ int new_bytes_read = call_CheckReceiveError(
+ buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
+ EXPECT_EQ(MARK_0_SEEN, get_error_detect_state());
+ EXPECT_EQ(2, get_num_chars_ignored());
+ EXPECT_EQ('\377', get_chars_ignored(0));
+ EXPECT_EQ('\0', get_chars_ignored(1));
+ EXPECT_EQ(1, new_bytes_read);
+ EXPECT_EQ('b', buffer[0]);
+ EXPECT_EQ(break_detected, false);
+ EXPECT_EQ(parity_error_detected, false);
+
+ buffer[0] = 'a';
+ buffer[1] = 'c';
+ buffer[2] = 'd';
+ bytes_read = 3;
+ break_detected = false;
+ parity_error_detected = false;
+ new_bytes_read = call_CheckReceiveError(
+ buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
+ EXPECT_EQ(NO_ERROR, get_error_detect_state());
+ EXPECT_EQ(0, get_num_chars_ignored());
+ EXPECT_EQ(2, new_bytes_read);
+ EXPECT_EQ('c', buffer[0]);
+ EXPECT_EQ('d', buffer[1]);
+ EXPECT_EQ(break_detected, false);
+ EXPECT_EQ(parity_error_detected, true);
+ }
+}
+
+// '\377'
+// '\0' 'a'
+TEST_F(SerialIoHandlerPosixTest, ParityErrorReadTwiceBytesReadOneAndTwo) {
+ for (int buffer_len = 2; buffer_len <= 20; ++buffer_len) {
+ set_error_detect_state(NO_ERROR);
+ set_parity_check_enabled(true);
+ set_num_chars_ignored(0);
+ char buffer[buffer_len];
+
+ buffer[0] = '\377';
+ int bytes_read = 1;
+ bool break_detected = false;
+ bool parity_error_detected = false;
+ int new_bytes_read = call_CheckReceiveError(
+ buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
+ EXPECT_EQ(MARK_377_SEEN, get_error_detect_state());
+ EXPECT_EQ(1, get_num_chars_ignored());
+ EXPECT_EQ('\377', get_chars_ignored(0));
+ EXPECT_EQ(0, new_bytes_read);
+ EXPECT_EQ(break_detected, false);
+ EXPECT_EQ(parity_error_detected, false);
+
+ buffer[0] = '\0';
+ buffer[1] = 'a';
+ bytes_read = 2;
+ break_detected = false;
+ parity_error_detected = false;
+ new_bytes_read = call_CheckReceiveError(
+ buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
+ EXPECT_EQ(NO_ERROR, get_error_detect_state());
+ EXPECT_EQ(0, get_num_chars_ignored());
+ EXPECT_EQ(0, new_bytes_read);
+ EXPECT_EQ(break_detected, false);
+ EXPECT_EQ(parity_error_detected, true);
+ }
+}
+
+// 'b' 'c' \377'
+// '\0' 'a' 'd'
+TEST_F(
+ SerialIoHandlerPosixTest,
+ ParityErrorReadTwiceBytesReadOneAndTwoHasBytesBeforeAndAfterParityError) {
+ for (int buffer_len = 3; buffer_len <= 20; ++buffer_len) {
+ set_error_detect_state(NO_ERROR);
+ set_parity_check_enabled(true);
+ set_num_chars_ignored(0);
+ char buffer[buffer_len];
+
+ buffer[0] = 'b';
+ buffer[1] = 'c';
+ buffer[2] = '\377';
+ int bytes_read = 3;
+ bool break_detected = false;
+ bool parity_error_detected = false;
+ int new_bytes_read = call_CheckReceiveError(
+ buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
+ EXPECT_EQ(MARK_377_SEEN, get_error_detect_state());
+ EXPECT_EQ(1, get_num_chars_ignored());
+ EXPECT_EQ('\377', get_chars_ignored(0));
+ EXPECT_EQ(2, new_bytes_read);
+ EXPECT_EQ('b', buffer[0]);
+ EXPECT_EQ('c', buffer[1]);
+ EXPECT_EQ(break_detected, false);
+ EXPECT_EQ(parity_error_detected, false);
+
+ buffer[0] = '\0';
+ buffer[1] = 'a';
+ buffer[2] = 'd';
+ bytes_read = 3;
+ break_detected = false;
+ parity_error_detected = false;
+ new_bytes_read = call_CheckReceiveError(
+ buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
+ EXPECT_EQ(NO_ERROR, get_error_detect_state());
+ EXPECT_EQ(0, get_num_chars_ignored());
+ EXPECT_EQ(1, new_bytes_read);
+ EXPECT_EQ('d', buffer[0]);
+ EXPECT_EQ(break_detected, false);
+ EXPECT_EQ(parity_error_detected, true);
+ }
+}
+
+// '\377'
+// '\0'
+// 'a'
+TEST_F(SerialIoHandlerPosixTest, ParityErrorReadThreeTimes) {
+ for (int buffer_len = 1; buffer_len <= 20; ++buffer_len) {
+ set_error_detect_state(NO_ERROR);
+ set_parity_check_enabled(true);
+ set_num_chars_ignored(0);
+ char buffer[buffer_len];
+
+ buffer[0] = '\377';
+ int bytes_read = 1;
+ bool break_detected = false;
+ bool parity_error_detected = false;
+ int new_bytes_read = call_CheckReceiveError(
+ buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
+ EXPECT_EQ(MARK_377_SEEN, get_error_detect_state());
+ EXPECT_EQ(1, get_num_chars_ignored());
+ EXPECT_EQ('\377', get_chars_ignored(0));
+ EXPECT_EQ(0, new_bytes_read);
+ EXPECT_EQ(break_detected, false);
+ EXPECT_EQ(parity_error_detected, false);
+
+ buffer[0] = '\0';
+ bytes_read = 1;
+ break_detected = false;
+ parity_error_detected = false;
+ new_bytes_read = call_CheckReceiveError(
+ buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
+ EXPECT_EQ(MARK_0_SEEN, get_error_detect_state());
+ EXPECT_EQ(2, get_num_chars_ignored());
+ EXPECT_EQ('\377', get_chars_ignored(0));
+ EXPECT_EQ('\0', get_chars_ignored(1));
+ EXPECT_EQ(0, new_bytes_read);
+ EXPECT_EQ(break_detected, false);
+ EXPECT_EQ(parity_error_detected, false);
+
+ buffer[0] = 'a';
+ bytes_read = 1;
+ break_detected = false;
+ parity_error_detected = false;
+ new_bytes_read = call_CheckReceiveError(
+ buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
+ EXPECT_EQ(NO_ERROR, get_error_detect_state());
+ EXPECT_EQ(0, get_num_chars_ignored());
+ EXPECT_EQ(0, new_bytes_read);
+ EXPECT_EQ(break_detected, false);
+ EXPECT_EQ(parity_error_detected, true);
+ }
+}
+
+// 'b' '\377'
+// '\0'
+// 'a' 'c'
+TEST_F(SerialIoHandlerPosixTest,
+ ParityErrorReadThreeTimesHasBytesBeforeAndAfterParityError) {
+ for (int buffer_len = 2; buffer_len <= 20; ++buffer_len) {
+ set_error_detect_state(NO_ERROR);
+ set_parity_check_enabled(true);
+ set_num_chars_ignored(0);
+ char buffer[buffer_len];
+
+ buffer[0] = 'b';
+ buffer[1] = '\377';
+ int bytes_read = 2;
+ bool break_detected = false;
+ bool parity_error_detected = false;
+ int new_bytes_read = call_CheckReceiveError(
+ buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
+ EXPECT_EQ(MARK_377_SEEN, get_error_detect_state());
+ EXPECT_EQ(1, get_num_chars_ignored());
+ EXPECT_EQ('\377', get_chars_ignored(0));
+ EXPECT_EQ(1, new_bytes_read);
+ EXPECT_EQ('b', buffer[0]);
+ EXPECT_EQ(break_detected, false);
+ EXPECT_EQ(parity_error_detected, false);
+
+ buffer[0] = '\0';
+ bytes_read = 1;
+ break_detected = false;
+ parity_error_detected = false;
+ new_bytes_read = call_CheckReceiveError(
+ buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
+ EXPECT_EQ(MARK_0_SEEN, get_error_detect_state());
+ EXPECT_EQ(2, get_num_chars_ignored());
+ EXPECT_EQ('\377', get_chars_ignored(0));
+ EXPECT_EQ('\0', get_chars_ignored(1));
+ EXPECT_EQ(0, new_bytes_read);
+ EXPECT_EQ(break_detected, false);
+ EXPECT_EQ(parity_error_detected, false);
+
+ buffer[0] = 'a';
+ buffer[1] = 'c';
+ bytes_read = 2;
+ break_detected = false;
+ parity_error_detected = false;
+ new_bytes_read = call_CheckReceiveError(
+ buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
+ EXPECT_EQ(NO_ERROR, get_error_detect_state());
+ EXPECT_EQ(0, get_num_chars_ignored());
+ EXPECT_EQ(1, new_bytes_read);
+ EXPECT_EQ('c', buffer[0]);
+ EXPECT_EQ(break_detected, false);
+ EXPECT_EQ(parity_error_detected, true);
+ }
+}
+
+// '\377' '\377'
+TEST_F(SerialIoHandlerPosixTest, TwoEOFsReadOnce) {
+ for (int buffer_len = 2; buffer_len <= 20; ++buffer_len) {
+ set_error_detect_state(NO_ERROR);
+ set_parity_check_enabled(true);
+ set_num_chars_ignored(0);
+ char buffer[buffer_len];
+
+ buffer[0] = '\377';
+ buffer[1] = '\377';
+ int bytes_read = 2;
+ bool break_detected = false;
+ bool parity_error_detected = false;
+ int new_bytes_read = call_CheckReceiveError(
+ buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
+ EXPECT_EQ(NO_ERROR, get_error_detect_state());
+ EXPECT_EQ(0, get_num_chars_ignored());
+ EXPECT_EQ(1, new_bytes_read);
+ EXPECT_EQ('\377', buffer[0]);
+ EXPECT_EQ(break_detected, false);
+ EXPECT_EQ(parity_error_detected, false);
+ }
+}
+
+// 'a' \377' '\377' 'b' 'c'
+TEST_F(SerialIoHandlerPosixTest, TwoEOFsReadOnceHasBytesBeforeAndAfterEOF) {
+ for (int buffer_len = 5; buffer_len <= 20; ++buffer_len) {
+ set_error_detect_state(NO_ERROR);
+ set_parity_check_enabled(true);
+ set_num_chars_ignored(0);
+ char buffer[buffer_len];
+
+ buffer[0] = 'a';
+ buffer[1] = '\377';
+ buffer[2] = '\377';
+ buffer[3] = 'b';
+ buffer[4] = 'c';
+ int bytes_read = 5;
+ bool break_detected = false;
+ bool parity_error_detected = false;
+ int new_bytes_read = call_CheckReceiveError(
+ buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
+ EXPECT_EQ(NO_ERROR, get_error_detect_state());
+ EXPECT_EQ(0, get_num_chars_ignored());
+ EXPECT_EQ(4, new_bytes_read);
+ EXPECT_EQ('a', buffer[0]);
+ EXPECT_EQ('\377', buffer[1]);
+ EXPECT_EQ('b', buffer[2]);
+ EXPECT_EQ('c', buffer[3]);
+ EXPECT_EQ(break_detected, false);
+ EXPECT_EQ(parity_error_detected, false);
+ }
+}
+
+// '\377'
+// '\377'
+TEST_F(SerialIoHandlerPosixTest, TwoEOFsReadTwice) {
+ for (int buffer_len = 1; buffer_len <= 20; ++buffer_len) {
+ set_error_detect_state(NO_ERROR);
+ set_parity_check_enabled(true);
+ set_num_chars_ignored(0);
+ char buffer[buffer_len];
+
+ buffer[0] = '\377';
+ int bytes_read = 1;
+ bool break_detected = false;
+ bool parity_error_detected = false;
+ int new_bytes_read = call_CheckReceiveError(
+ buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
+ EXPECT_EQ(MARK_377_SEEN, get_error_detect_state());
+ EXPECT_EQ(1, get_num_chars_ignored());
+ EXPECT_EQ('\377', get_chars_ignored(0));
+ EXPECT_EQ(0, new_bytes_read);
+ EXPECT_EQ(break_detected, false);
+ EXPECT_EQ(parity_error_detected, false);
+
+ buffer[0] = '\377';
+ bytes_read = 1;
+ break_detected = false;
+ parity_error_detected = false;
+ new_bytes_read = call_CheckReceiveError(
+ buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
+ EXPECT_EQ(NO_ERROR, get_error_detect_state());
+ EXPECT_EQ(0, get_num_chars_ignored());
+ EXPECT_EQ(1, new_bytes_read);
+ EXPECT_EQ('\377', buffer[0]);
+ EXPECT_EQ(break_detected, false);
+ EXPECT_EQ(parity_error_detected, false);
+ }
+}
+
+// 'a' \377'
+// '\377' 'b'
+TEST_F(SerialIoHandlerPosixTest, TwoEOFsReadTwiceHasBytesBeforeAndAfterEOF) {
+ for (int buffer_len = 2; buffer_len <= 20; ++buffer_len) {
+ set_error_detect_state(NO_ERROR);
+ set_parity_check_enabled(true);
+ set_num_chars_ignored(0);
+ char buffer[buffer_len];
+
+ buffer[0] = 'a';
+ buffer[1] = '\377';
+ int bytes_read = 2;
+ bool break_detected = false;
+ bool parity_error_detected = false;
+ int new_bytes_read = call_CheckReceiveError(
+ buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
+ EXPECT_EQ(MARK_377_SEEN, get_error_detect_state());
+ EXPECT_EQ(1, get_num_chars_ignored());
+ EXPECT_EQ('\377', get_chars_ignored(0));
+ EXPECT_EQ(1, new_bytes_read);
+ EXPECT_EQ('a', buffer[0]);
+ EXPECT_EQ(break_detected, false);
+ EXPECT_EQ(parity_error_detected, false);
+
+ buffer[0] = '\377';
+ buffer[1] = 'b';
+ bytes_read = 2;
+ break_detected = false;
+ parity_error_detected = false;
+ new_bytes_read = call_CheckReceiveError(
+ buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
+ EXPECT_EQ(NO_ERROR, get_error_detect_state());
+ EXPECT_EQ(0, get_num_chars_ignored());
+ EXPECT_EQ(2, new_bytes_read);
+ EXPECT_EQ('\377', buffer[0]);
+ EXPECT_EQ('b', buffer[1]);
+ EXPECT_EQ(break_detected, false);
+ EXPECT_EQ(parity_error_detected, false);
+ }
+}
+
+// '\377' '\0' 'a'
+TEST_F(SerialIoHandlerPosixTest, ParityCheckDisabledReadOnce) {
+ for (int buffer_len = 3; buffer_len <= 20; ++buffer_len) {
+ set_error_detect_state(NO_ERROR);
+ set_parity_check_enabled(false);
+ set_num_chars_ignored(0);
+ char buffer[buffer_len];
+
+ buffer[0] = '\377';
+ buffer[1] = '\0';
+ buffer[2] = 'a';
+ int bytes_read = 3;
+ bool break_detected = false;
+ bool parity_error_detected = false;
+ int new_bytes_read = call_CheckReceiveError(
+ buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
+ EXPECT_EQ(NO_ERROR, get_error_detect_state());
+ EXPECT_EQ(0, get_num_chars_ignored());
+ EXPECT_EQ(3, new_bytes_read);
+ EXPECT_EQ('\377', buffer[0]);
+ EXPECT_EQ('\0', buffer[1]);
+ EXPECT_EQ('a', buffer[2]);
+ EXPECT_EQ(break_detected, false);
+ EXPECT_EQ(parity_error_detected, false);
+ }
+}
+
+// 'b' '\377' '\0' 'a' 'c'
+TEST_F(SerialIoHandlerPosixTest,
+ ParityCheckDisabledReadOnceHasBytesBeforeAndAfter) {
+ for (int buffer_len = 5; buffer_len <= 20; ++buffer_len) {
+ set_error_detect_state(NO_ERROR);
+ set_parity_check_enabled(false);
+ set_num_chars_ignored(0);
+ char buffer[buffer_len];
+
+ buffer[0] = 'b';
+ buffer[1] = '\377';
+ buffer[2] = '\0';
+ buffer[3] = 'a';
+ buffer[4] = 'c';
+ int bytes_read = 5;
+ bool break_detected = false;
+ bool parity_error_detected = false;
+ int new_bytes_read = call_CheckReceiveError(
+ buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
+ EXPECT_EQ(NO_ERROR, get_error_detect_state());
+ EXPECT_EQ(0, get_num_chars_ignored());
+ EXPECT_EQ(5, new_bytes_read);
+ EXPECT_EQ('b', buffer[0]);
+ EXPECT_EQ('\377', buffer[1]);
+ EXPECT_EQ('\0', buffer[2]);
+ EXPECT_EQ('a', buffer[3]);
+ EXPECT_EQ('c', buffer[4]);
+ EXPECT_EQ(break_detected, false);
+ EXPECT_EQ(parity_error_detected, false);
+ }
+}
+
+// '\377' '\0'
+// 'a'
+TEST_F(SerialIoHandlerPosixTest,
+ ParityCheckDisabledReadTwiceBytesReadTwoAndOne) {
+ set_error_detect_state(NO_ERROR);
+ set_parity_check_enabled(false);
+ set_num_chars_ignored(0);
+ int buffer_len = 2;
+ char buffer[buffer_len];
+
+ buffer[0] = '\377';
+ buffer[1] = '\0';
+ int bytes_read = 2;
+ bool break_detected = false;
+ bool parity_error_detected = false;
+ int new_bytes_read = call_CheckReceiveError(
+ buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
+ EXPECT_EQ(MARK_0_SEEN, get_error_detect_state());
+ EXPECT_EQ(2, get_num_chars_ignored());
+ EXPECT_EQ('\377', get_chars_ignored(0));
+ EXPECT_EQ('\0', get_chars_ignored(1));
+ EXPECT_EQ(0, new_bytes_read);
+ EXPECT_EQ(break_detected, false);
+ EXPECT_EQ(parity_error_detected, false);
+
+ buffer[0] = 'a';
+ bytes_read = 1;
+ break_detected = false;
+ parity_error_detected = false;
+ new_bytes_read = call_CheckReceiveError(
+ buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
+ EXPECT_EQ(NO_ERROR, get_error_detect_state());
+ // since the buffer_len is 2, the buffer now stores two bytes from the
+ // previous read, and the byte currently read needs to be stored into
+ // chars_ignored_[]
+ EXPECT_EQ(1, get_num_chars_ignored());
+ EXPECT_EQ('a', get_chars_ignored(0));
+ EXPECT_EQ(2, new_bytes_read);
+ EXPECT_EQ('\377', buffer[0]);
+ EXPECT_EQ('\0', buffer[1]);
+ EXPECT_EQ(break_detected, false);
+ EXPECT_EQ(parity_error_detected, false);
+}
+
+// '\377' '\0'
+// 'a' 'b'
+TEST_F(SerialIoHandlerPosixTest,
+ ParityCheckDisabledReadTwiceBytesReadTwoAndOneHasBytesAfter) {
+ set_error_detect_state(NO_ERROR);
+ set_parity_check_enabled(false);
+ set_num_chars_ignored(0);
+ int buffer_len = 2;
+ char buffer[buffer_len];
+
+ buffer[0] = '\377';
+ buffer[1] = '\0';
+ int bytes_read = 2;
+ bool break_detected = false;
+ bool parity_error_detected = false;
+ int new_bytes_read = call_CheckReceiveError(
+ buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
+ EXPECT_EQ(MARK_0_SEEN, get_error_detect_state());
+ EXPECT_EQ(2, get_num_chars_ignored());
+ EXPECT_EQ('\377', get_chars_ignored(0));
+ EXPECT_EQ('\0', get_chars_ignored(1));
+ EXPECT_EQ(0, new_bytes_read);
+ EXPECT_EQ(break_detected, false);
+ EXPECT_EQ(parity_error_detected, false);
+
+ buffer[0] = 'a';
+ buffer[1] = 'b';
+ bytes_read = 2;
+ break_detected = false;
+ parity_error_detected = false;
+ new_bytes_read = call_CheckReceiveError(
+ buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
+ EXPECT_EQ(NO_ERROR, get_error_detect_state());
+ // since the buffer_len is 2, the buffer now stores two bytes from the
+ // previous read, and the bytes currently read need to be stored into
+ // chars_ignored_[]
+ EXPECT_EQ(2, get_num_chars_ignored());
+ EXPECT_EQ('a', get_chars_ignored(0));
+ EXPECT_EQ('b', get_chars_ignored(1));
+ EXPECT_EQ(2, new_bytes_read);
+ EXPECT_EQ('\377', buffer[0]);
+ EXPECT_EQ('\0', buffer[1]);
+ EXPECT_EQ(break_detected, false);
+ EXPECT_EQ(parity_error_detected, false);
+}
+
+// '\377' '\0'
+// 'a'
+TEST_F(SerialIoHandlerPosixTest,
+ ParityCheckDisabledReadTwiceBytesReadTwoAndOneLargerBufferLen) {
+ for (int buffer_len = 3; buffer_len <= 20; ++buffer_len) {
+ set_error_detect_state(NO_ERROR);
+ set_parity_check_enabled(false);
+ set_num_chars_ignored(0);
+ char buffer[buffer_len];
+
+ buffer[0] = '\377';
+ buffer[1] = '\0';
+ int bytes_read = 2;
+ bool break_detected = false;
+ bool parity_error_detected = false;
+ int new_bytes_read = call_CheckReceiveError(
+ buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
+ EXPECT_EQ(MARK_0_SEEN, get_error_detect_state());
+ EXPECT_EQ(2, get_num_chars_ignored());
+ EXPECT_EQ('\377', get_chars_ignored(0));
+ EXPECT_EQ('\0', get_chars_ignored(1));
+ EXPECT_EQ(0, new_bytes_read);
+ EXPECT_EQ(break_detected, false);
+ EXPECT_EQ(parity_error_detected, false);
+
+ buffer[0] = 'a';
+ bytes_read = 1;
+ break_detected = false;
+ parity_error_detected = false;
+ new_bytes_read = call_CheckReceiveError(
+ buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
+ EXPECT_EQ(NO_ERROR, get_error_detect_state());
+ EXPECT_EQ(0, get_num_chars_ignored());
+ EXPECT_EQ(3, new_bytes_read);
+ EXPECT_EQ('\377', buffer[0]);
+ EXPECT_EQ('\0', buffer[1]);
+ EXPECT_EQ('a', buffer[2]);
+ EXPECT_EQ(break_detected, false);
+ EXPECT_EQ(parity_error_detected, false);
+ }
+}
+
+// 'b' '\377' '\0'
+// 'a' 'c'
+TEST_F(
+ SerialIoHandlerPosixTest,
+ ParityCheckDisabledReadTwiceBytesReadTwoAndOneBufferLenThreeHasBytesBeforeAndAfter) {
+ set_error_detect_state(NO_ERROR);
+ set_parity_check_enabled(false);
+ set_num_chars_ignored(0);
+ int buffer_len = 3;
+ char buffer[buffer_len];
+
+ buffer[0] = 'b';
+ buffer[1] = '\377';
+ buffer[2] = '\0';
+ int bytes_read = 3;
+ bool break_detected = false;
+ bool parity_error_detected = false;
+ int new_bytes_read = call_CheckReceiveError(
+ buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
+ EXPECT_EQ(MARK_0_SEEN, get_error_detect_state());
+ EXPECT_EQ(2, get_num_chars_ignored());
+ EXPECT_EQ('\377', get_chars_ignored(0));
+ EXPECT_EQ('\0', get_chars_ignored(1));
+ EXPECT_EQ(1, new_bytes_read);
+ EXPECT_EQ('b', buffer[0]);
+ EXPECT_EQ(break_detected, false);
+ EXPECT_EQ(parity_error_detected, false);
+
+ buffer[0] = 'a';
+ buffer[1] = 'c';
+ bytes_read = 2;
+ break_detected = false;
+ parity_error_detected = false;
+ new_bytes_read = call_CheckReceiveError(
+ buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
+ EXPECT_EQ(NO_ERROR, get_error_detect_state());
+ EXPECT_EQ(1, get_num_chars_ignored());
+ EXPECT_EQ('c', get_chars_ignored(0));
+ EXPECT_EQ(3, new_bytes_read);
+ EXPECT_EQ('\377', buffer[0]);
+ EXPECT_EQ('\0', buffer[1]);
+ EXPECT_EQ('a', buffer[2]);
+ EXPECT_EQ(break_detected, false);
+ EXPECT_EQ(parity_error_detected, false);
+}
+
+// 'b' '\377' '\0'
+// 'a' 'c'
+TEST_F(
+ SerialIoHandlerPosixTest,
+ ParityCheckDisabledReadTwiceBytesReadTwoAndOneLargerBufferLenHasBytesBeforeAndAfter) {
+ for (int buffer_len = 4; buffer_len <= 20; ++buffer_len) {
+ set_error_detect_state(NO_ERROR);
+ set_parity_check_enabled(false);
+ set_num_chars_ignored(0);
+ char buffer[buffer_len];
+
+ buffer[0] = 'b';
+ buffer[1] = '\377';
+ buffer[2] = '\0';
+ int bytes_read = 3;
+ bool break_detected = false;
+ bool parity_error_detected = false;
+ int new_bytes_read = call_CheckReceiveError(
+ buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
+ EXPECT_EQ(MARK_0_SEEN, get_error_detect_state());
+ EXPECT_EQ(2, get_num_chars_ignored());
+ EXPECT_EQ('\377', get_chars_ignored(0));
+ EXPECT_EQ('\0', get_chars_ignored(1));
+ EXPECT_EQ(1, new_bytes_read);
+ EXPECT_EQ('b', buffer[0]);
+ EXPECT_EQ(break_detected, false);
+ EXPECT_EQ(parity_error_detected, false);
+
+ buffer[0] = 'a';
+ buffer[1] = 'c';
+ bytes_read = 2;
+ break_detected = false;
+ parity_error_detected = false;
+ new_bytes_read = call_CheckReceiveError(
+ buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
+ EXPECT_EQ(NO_ERROR, get_error_detect_state());
+ EXPECT_EQ(0, get_num_chars_ignored());
+ EXPECT_EQ(4, new_bytes_read);
+ EXPECT_EQ('\377', buffer[0]);
+ EXPECT_EQ('\0', buffer[1]);
+ EXPECT_EQ('a', buffer[2]);
+ EXPECT_EQ('c', buffer[3]);
+ EXPECT_EQ(break_detected, false);
+ EXPECT_EQ(parity_error_detected, false);
+ }
+}
+
+// '\377'
+// '\0' 'a'
+TEST_F(SerialIoHandlerPosixTest,
+ ParityCheckDisabledReadTwiceBytesReadOneAndTwo) {
+ set_error_detect_state(NO_ERROR);
+ set_parity_check_enabled(false);
+ set_num_chars_ignored(0);
+ int buffer_len = 2;
+ char buffer[buffer_len];
+
+ buffer[0] = '\377';
+ int bytes_read = 1;
+ bool break_detected = false;
+ bool parity_error_detected = false;
+ int new_bytes_read = call_CheckReceiveError(
+ buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
+ EXPECT_EQ(MARK_377_SEEN, get_error_detect_state());
+ EXPECT_EQ(1, get_num_chars_ignored());
+ EXPECT_EQ('\377', get_chars_ignored(0));
+ EXPECT_EQ(0, new_bytes_read);
+ EXPECT_EQ(break_detected, false);
+ EXPECT_EQ(parity_error_detected, false);
+
+ buffer[0] = '\0';
+ buffer[1] = 'a';
+ bytes_read = 2;
+ break_detected = false;
+ parity_error_detected = false;
+ new_bytes_read = call_CheckReceiveError(
+ buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
+ EXPECT_EQ(NO_ERROR, get_error_detect_state());
+ EXPECT_EQ(1, get_num_chars_ignored());
+ EXPECT_EQ('a', get_chars_ignored(0));
+ EXPECT_EQ(2, new_bytes_read);
+ EXPECT_EQ('\377', buffer[0]);
+ EXPECT_EQ('\0', buffer[1]);
+ EXPECT_EQ(break_detected, false);
+ EXPECT_EQ(parity_error_detected, false);
+}
+
+// 'b' '\377'
+// '\0' 'a'
+TEST_F(SerialIoHandlerPosixTest,
+ ParityCheckDisabledReadTwiceBytesReadOneAndTwoHasBytesBefore) {
+ set_error_detect_state(NO_ERROR);
+ set_parity_check_enabled(false);
+ set_num_chars_ignored(0);
+ int buffer_len = 2;
+ char buffer[buffer_len];
+
+ buffer[0] = 'b';
+ buffer[1] = '\377';
+ int bytes_read = 2;
+ bool break_detected = false;
+ bool parity_error_detected = false;
+ int new_bytes_read = call_CheckReceiveError(
+ buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
+ EXPECT_EQ(MARK_377_SEEN, get_error_detect_state());
+ EXPECT_EQ(1, get_num_chars_ignored());
+ EXPECT_EQ('\377', get_chars_ignored(0));
+ EXPECT_EQ(1, new_bytes_read);
+ EXPECT_EQ('b', buffer[0]);
+ EXPECT_EQ(break_detected, false);
+ EXPECT_EQ(parity_error_detected, false);
+
+ buffer[0] = '\0';
+ buffer[1] = 'a';
+ bytes_read = 2;
+ break_detected = false;
+ parity_error_detected = false;
+ new_bytes_read = call_CheckReceiveError(
+ buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
+ EXPECT_EQ(NO_ERROR, get_error_detect_state());
+ EXPECT_EQ(1, get_num_chars_ignored());
+ EXPECT_EQ('a', get_chars_ignored(0));
+ EXPECT_EQ(2, new_bytes_read);
+ EXPECT_EQ('\377', buffer[0]);
+ EXPECT_EQ('\0', buffer[1]);
+ EXPECT_EQ(break_detected, false);
+ EXPECT_EQ(parity_error_detected, false);
+}
+
+// '\377'
+// '\0' 'a'
+TEST_F(SerialIoHandlerPosixTest,
+ ParityCheckDisabledReadTwiceBytesReadOneAndTwoLargerBufferLen) {
+ for (int buffer_len = 3; buffer_len <= 20; ++buffer_len) {
+ set_error_detect_state(NO_ERROR);
+ set_parity_check_enabled(false);
+ set_num_chars_ignored(0);
+ char buffer[buffer_len];
+
+ buffer[0] = '\377';
+ int bytes_read = 1;
+ bool break_detected = false;
+ bool parity_error_detected = false;
+ int new_bytes_read = call_CheckReceiveError(
+ buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
+ EXPECT_EQ(MARK_377_SEEN, get_error_detect_state());
+ EXPECT_EQ(1, get_num_chars_ignored());
+ EXPECT_EQ('\377', get_chars_ignored(0));
+ EXPECT_EQ(0, new_bytes_read);
+ EXPECT_EQ(break_detected, false);
+ EXPECT_EQ(parity_error_detected, false);
+
+ buffer[0] = '\0';
+ buffer[1] = 'a';
+ bytes_read = 2;
+ break_detected = false;
+ parity_error_detected = false;
+ new_bytes_read = call_CheckReceiveError(
+ buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
+ EXPECT_EQ(NO_ERROR, get_error_detect_state());
+ EXPECT_EQ(0, get_num_chars_ignored());
+ EXPECT_EQ(3, new_bytes_read);
+ EXPECT_EQ('\377', buffer[0]);
+ EXPECT_EQ('\0', buffer[1]);
+ EXPECT_EQ('a', buffer[2]);
+ EXPECT_EQ(break_detected, false);
+ EXPECT_EQ(parity_error_detected, false);
+ }
+}
+
+// 'b' '\377'
+// '\0' 'a' 'c'
+TEST_F(
+ SerialIoHandlerPosixTest,
+ ParityCheckDisabledReadTwiceBytesReadOneAndTwoBufferLenThreeHasBytesBeforeAndAfter) {
+ set_error_detect_state(NO_ERROR);
+ set_parity_check_enabled(false);
+ set_num_chars_ignored(0);
+ int buffer_len = 3;
+ char buffer[buffer_len];
+
+ buffer[0] = 'b';
+ buffer[1] = '\377';
+ int bytes_read = 2;
+ bool break_detected = false;
+ bool parity_error_detected = false;
+ int new_bytes_read = call_CheckReceiveError(
+ buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
+ EXPECT_EQ(MARK_377_SEEN, get_error_detect_state());
+ EXPECT_EQ(1, get_num_chars_ignored());
+ EXPECT_EQ('\377', get_chars_ignored(0));
+ EXPECT_EQ(1, new_bytes_read);
+ EXPECT_EQ('b', buffer[0]);
+ EXPECT_EQ(break_detected, false);
+ EXPECT_EQ(parity_error_detected, false);
+
+ buffer[0] = '\0';
+ buffer[1] = 'a';
+ buffer[2] = 'c';
+ bytes_read = 3;
+ break_detected = false;
+ parity_error_detected = false;
+ new_bytes_read = call_CheckReceiveError(
+ buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
+ EXPECT_EQ(NO_ERROR, get_error_detect_state());
+ EXPECT_EQ(1, get_num_chars_ignored());
+ EXPECT_EQ('c', get_chars_ignored(0));
+ EXPECT_EQ(3, new_bytes_read);
+ EXPECT_EQ('\377', buffer[0]);
+ EXPECT_EQ('\0', buffer[1]);
+ EXPECT_EQ('a', buffer[2]);
+ EXPECT_EQ(break_detected, false);
+ EXPECT_EQ(parity_error_detected, false);
+}
+
+// 'b' '\377'
+// '\0' 'a' 'c'
+TEST_F(
+ SerialIoHandlerPosixTest,
+ ParityCheckDisabledReadTwiceBytesReadOneAndTwoLargerBufferLenHasBytesBeforeAndAfter) {
+ for (int buffer_len = 4; buffer_len <= 20; ++buffer_len) {
+ set_error_detect_state(NO_ERROR);
+ set_parity_check_enabled(false);
+ set_num_chars_ignored(0);
+ char buffer[buffer_len];
+
+ buffer[0] = 'b';
+ buffer[1] = '\377';
+ int bytes_read = 2;
+ bool break_detected = false;
+ bool parity_error_detected = false;
+ int new_bytes_read = call_CheckReceiveError(
+ buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
+ EXPECT_EQ(MARK_377_SEEN, get_error_detect_state());
+ EXPECT_EQ(1, get_num_chars_ignored());
+ EXPECT_EQ('\377', get_chars_ignored(0));
+ EXPECT_EQ(1, new_bytes_read);
+ EXPECT_EQ('b', buffer[0]);
+ EXPECT_EQ(break_detected, false);
+ EXPECT_EQ(parity_error_detected, false);
+
+ buffer[0] = '\0';
+ buffer[1] = 'a';
+ buffer[2] = 'c';
+ bytes_read = 3;
+ break_detected = false;
+ parity_error_detected = false;
+ new_bytes_read = call_CheckReceiveError(
+ buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
+ EXPECT_EQ(NO_ERROR, get_error_detect_state());
+ EXPECT_EQ(0, get_num_chars_ignored());
+ EXPECT_EQ(4, new_bytes_read);
+ EXPECT_EQ('\377', buffer[0]);
+ EXPECT_EQ('\0', buffer[1]);
+ EXPECT_EQ('a', buffer[2]);
+ EXPECT_EQ('c', buffer[3]);
+ EXPECT_EQ(break_detected, false);
+ EXPECT_EQ(parity_error_detected, false);
+ }
+}
+
+// '\377'
+// '\0'
+// 'a'
+TEST_F(SerialIoHandlerPosixTest,
+ ParityCheckDisabledReadThreeTimesBufferLenOne) {
+ set_error_detect_state(NO_ERROR);
+ set_parity_check_enabled(false);
+ set_num_chars_ignored(0);
+ int buffer_len = 1;
+ char buffer[buffer_len];
+
+ buffer[0] = '\377';
+ int bytes_read = 1;
+ bool break_detected = false;
+ bool parity_error_detected = false;
+ int new_bytes_read = call_CheckReceiveError(
+ buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
+ EXPECT_EQ(MARK_377_SEEN, get_error_detect_state());
+ EXPECT_EQ(1, get_num_chars_ignored());
+ EXPECT_EQ('\377', get_chars_ignored(0));
+ EXPECT_EQ(0, new_bytes_read);
+ EXPECT_EQ(break_detected, false);
+ EXPECT_EQ(parity_error_detected, false);
+
+ buffer[0] = '\0';
+ bytes_read = 1;
+ break_detected = false;
+ parity_error_detected = false;
+ new_bytes_read = call_CheckReceiveError(
+ buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
+ EXPECT_EQ(MARK_0_SEEN, get_error_detect_state());
+ EXPECT_EQ(2, get_num_chars_ignored());
+ EXPECT_EQ('\377', get_chars_ignored(0));
+ EXPECT_EQ('\0', get_chars_ignored(1));
+ EXPECT_EQ(0, new_bytes_read);
+ EXPECT_EQ(break_detected, false);
+ EXPECT_EQ(parity_error_detected, false);
+
+ buffer[0] = 'a';
+ bytes_read = 1;
+ break_detected = false;
+ parity_error_detected = false;
+ new_bytes_read = call_CheckReceiveError(
+ buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
+ EXPECT_EQ(NO_ERROR, get_error_detect_state());
+ EXPECT_EQ(2, get_num_chars_ignored());
+ EXPECT_EQ('\0', get_chars_ignored(0));
+ EXPECT_EQ('a', get_chars_ignored(1));
+ EXPECT_EQ(1, new_bytes_read);
+ EXPECT_EQ('\377', buffer[0]);
+ EXPECT_EQ(break_detected, false);
+ EXPECT_EQ(parity_error_detected, false);
+}
+
+// '\377'
+// '\0'
+// 'a'
+TEST_F(SerialIoHandlerPosixTest,
+ ParityCheckDisabledReadThreeTimesBufferLenTwo) {
+ set_error_detect_state(NO_ERROR);
+ set_parity_check_enabled(false);
+ set_num_chars_ignored(0);
+ int buffer_len = 2;
+ char buffer[buffer_len];
+
+ buffer[0] = '\377';
+ int bytes_read = 1;
+ bool break_detected = false;
+ bool parity_error_detected = false;
+ int new_bytes_read = call_CheckReceiveError(
+ buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
+ EXPECT_EQ(MARK_377_SEEN, get_error_detect_state());
+ EXPECT_EQ(1, get_num_chars_ignored());
+ EXPECT_EQ('\377', get_chars_ignored(0));
+ EXPECT_EQ(0, new_bytes_read);
+ EXPECT_EQ(break_detected, false);
+ EXPECT_EQ(parity_error_detected, false);
+
+ buffer[0] = '\0';
+ bytes_read = 1;
+ break_detected = false;
+ parity_error_detected = false;
+ new_bytes_read = call_CheckReceiveError(
+ buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
+ EXPECT_EQ(MARK_0_SEEN, get_error_detect_state());
+ EXPECT_EQ(2, get_num_chars_ignored());
+ EXPECT_EQ('\377', get_chars_ignored(0));
+ EXPECT_EQ('\0', get_chars_ignored(1));
+ EXPECT_EQ(0, new_bytes_read);
+ EXPECT_EQ(break_detected, false);
+ EXPECT_EQ(parity_error_detected, false);
+
+ buffer[0] = 'a';
+ bytes_read = 1;
+ break_detected = false;
+ parity_error_detected = false;
+ new_bytes_read = call_CheckReceiveError(
+ buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
+ EXPECT_EQ(NO_ERROR, get_error_detect_state());
+ EXPECT_EQ(1, get_num_chars_ignored());
+ EXPECT_EQ('a', get_chars_ignored(0));
+ EXPECT_EQ(2, new_bytes_read);
+ EXPECT_EQ('\377', buffer[0]);
+ EXPECT_EQ('\0', buffer[1]);
+ EXPECT_EQ(break_detected, false);
+ EXPECT_EQ(parity_error_detected, false);
+}
+
+// '\377'
+// '\0'
+// 'a'
+TEST_F(SerialIoHandlerPosixTest,
+ ParityCheckDisabledReadThreeTimesLargerBufferLen) {
+ for (int buffer_len = 3; buffer_len <= 20; ++buffer_len) {
+ set_error_detect_state(NO_ERROR);
+ set_parity_check_enabled(false);
+ set_num_chars_ignored(0);
+ char buffer[buffer_len];
+
+ buffer[0] = '\377';
+ int bytes_read = 1;
+ bool break_detected = false;
+ bool parity_error_detected = false;
+ int new_bytes_read = call_CheckReceiveError(
+ buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
+ EXPECT_EQ(MARK_377_SEEN, get_error_detect_state());
+ EXPECT_EQ(1, get_num_chars_ignored());
+ EXPECT_EQ('\377', get_chars_ignored(0));
+ EXPECT_EQ(0, new_bytes_read);
+ EXPECT_EQ(break_detected, false);
+ EXPECT_EQ(parity_error_detected, false);
+
+ buffer[0] = '\0';
+ bytes_read = 1;
+ break_detected = false;
+ parity_error_detected = false;
+ new_bytes_read = call_CheckReceiveError(
+ buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
+ EXPECT_EQ(MARK_0_SEEN, get_error_detect_state());
+ EXPECT_EQ(2, get_num_chars_ignored());
+ EXPECT_EQ('\377', get_chars_ignored(0));
+ EXPECT_EQ('\0', get_chars_ignored(1));
+ EXPECT_EQ(0, new_bytes_read);
+ EXPECT_EQ(break_detected, false);
+ EXPECT_EQ(parity_error_detected, false);
+
+ buffer[0] = 'a';
+ bytes_read = 1;
+ break_detected = false;
+ parity_error_detected = false;
+ new_bytes_read = call_CheckReceiveError(
+ buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
+ EXPECT_EQ(NO_ERROR, get_error_detect_state());
+ EXPECT_EQ(0, get_num_chars_ignored());
+ EXPECT_EQ(3, new_bytes_read);
+ EXPECT_EQ('\377', buffer[0]);
+ EXPECT_EQ('\0', buffer[1]);
+ EXPECT_EQ('a', buffer[2]);
+ EXPECT_EQ(break_detected, false);
+ EXPECT_EQ(parity_error_detected, false);
+ }
+}
+
+// 'b' '\377'
+// '\0'
+// 'a' 'c'
+TEST_F(SerialIoHandlerPosixTest,
+ ParityCheckDisabledReadThreeTimesBufferLenThreeByteBeforeAndAfter) {
+ set_error_detect_state(NO_ERROR);
+ set_parity_check_enabled(false);
+ set_num_chars_ignored(0);
+ int buffer_len = 3;
+ char buffer[buffer_len];
+
+ buffer[0] = 'b';
+ buffer[1] = '\377';
+ int bytes_read = 2;
+ bool break_detected = false;
+ bool parity_error_detected = false;
+ int new_bytes_read = call_CheckReceiveError(
+ buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
+ EXPECT_EQ(MARK_377_SEEN, get_error_detect_state());
+ EXPECT_EQ(1, get_num_chars_ignored());
+ EXPECT_EQ('\377', get_chars_ignored(0));
+ EXPECT_EQ(1, new_bytes_read);
+ EXPECT_EQ('b', buffer[0]);
+ EXPECT_EQ(break_detected, false);
+ EXPECT_EQ(parity_error_detected, false);
+
+ buffer[0] = '\0';
+ bytes_read = 1;
+ break_detected = false;
+ parity_error_detected = false;
+ new_bytes_read = call_CheckReceiveError(
+ buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
+ EXPECT_EQ(MARK_0_SEEN, get_error_detect_state());
+ EXPECT_EQ(2, get_num_chars_ignored());
+ EXPECT_EQ('\377', get_chars_ignored(0));
+ EXPECT_EQ('\0', get_chars_ignored(1));
+ EXPECT_EQ(0, new_bytes_read);
+ EXPECT_EQ(break_detected, false);
+ EXPECT_EQ(parity_error_detected, false);
+
+ buffer[0] = 'a';
+ buffer[1] = 'c';
+ bytes_read = 2;
+ break_detected = false;
+ parity_error_detected = false;
+ new_bytes_read = call_CheckReceiveError(
+ buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
+ EXPECT_EQ(NO_ERROR, get_error_detect_state());
+ EXPECT_EQ(1, get_num_chars_ignored());
+ EXPECT_EQ('c', get_chars_ignored(0));
+ EXPECT_EQ(3, new_bytes_read);
+ EXPECT_EQ('\377', buffer[0]);
+ EXPECT_EQ('\0', buffer[1]);
+ EXPECT_EQ('a', buffer[2]);
+ EXPECT_EQ(break_detected, false);
+ EXPECT_EQ(parity_error_detected, false);
+}
+
+// 'b' '\377'
+// '\0'
+// 'a' 'c'
+TEST_F(SerialIoHandlerPosixTest,
+ ParityCheckDisabledReadThreeTimesLargerBufferLenHasBytesBeforeAndAfter) {
+ for (int buffer_len = 4; buffer_len <= 20; ++buffer_len) {
+ set_error_detect_state(NO_ERROR);
+ set_parity_check_enabled(false);
+ set_num_chars_ignored(0);
+ char buffer[buffer_len];
+
+ buffer[0] = 'b';
+ buffer[1] = '\377';
+ int bytes_read = 2;
+ bool break_detected = false;
+ bool parity_error_detected = false;
+ int new_bytes_read = call_CheckReceiveError(
+ buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
+ EXPECT_EQ(MARK_377_SEEN, get_error_detect_state());
+ EXPECT_EQ(1, get_num_chars_ignored());
+ EXPECT_EQ('\377', get_chars_ignored(0));
+ EXPECT_EQ(1, new_bytes_read);
+ EXPECT_EQ('b', buffer[0]);
+ EXPECT_EQ(break_detected, false);
+ EXPECT_EQ(parity_error_detected, false);
+
+ buffer[0] = '\0';
+ bytes_read = 1;
+ break_detected = false;
+ parity_error_detected = false;
+ new_bytes_read = call_CheckReceiveError(
+ buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
+ EXPECT_EQ(MARK_0_SEEN, get_error_detect_state());
+ EXPECT_EQ(2, get_num_chars_ignored());
+ EXPECT_EQ('\377', get_chars_ignored(0));
+ EXPECT_EQ('\0', get_chars_ignored(1));
+ EXPECT_EQ(0, new_bytes_read);
+ EXPECT_EQ(break_detected, false);
+ EXPECT_EQ(parity_error_detected, false);
+
+ buffer[0] = 'a';
+ buffer[1] = 'c';
+ bytes_read = 2;
+ break_detected = false;
+ parity_error_detected = false;
+ new_bytes_read = call_CheckReceiveError(
+ buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
+ EXPECT_EQ(NO_ERROR, get_error_detect_state());
+ EXPECT_EQ(0, get_num_chars_ignored());
+ EXPECT_EQ(4, new_bytes_read);
+ EXPECT_EQ('\377', buffer[0]);
+ EXPECT_EQ('\0', buffer[1]);
+ EXPECT_EQ('a', buffer[2]);
+ EXPECT_EQ('c', buffer[3]);
+ EXPECT_EQ(break_detected, false);
+ EXPECT_EQ(parity_error_detected, false);
+ }
+}
+
+TEST_F(SerialIoHandlerPosixTest, BytesReadZero) {
+ for (int buffer_len = 1; buffer_len <= 20; ++buffer_len) {
+ set_error_detect_state(NO_ERROR);
+ set_parity_check_enabled(true);
+ set_num_chars_ignored(0);
+ char buffer[buffer_len];
+
+ int bytes_read = 0;
+ bool break_detected = false;
+ bool parity_error_detected = false;
+ int new_bytes_read = call_CheckReceiveError(
+ buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
+ EXPECT_EQ(NO_ERROR, get_error_detect_state());
+ EXPECT_EQ(0, get_num_chars_ignored());
+ EXPECT_EQ(0, new_bytes_read);
+ EXPECT_EQ(break_detected, false);
+ EXPECT_EQ(parity_error_detected, false);
+ }
+}
+
+// '\377' 'a' 'b'
+TEST_F(SerialIoHandlerPosixTest, InvalidSequenceReadOnce) {
+ for (int buffer_len = 3; buffer_len <= 20; ++buffer_len) {
+ set_error_detect_state(NO_ERROR);
+ set_parity_check_enabled(true);
+ set_num_chars_ignored(0);
+ char buffer[buffer_len];
+
+ buffer[0] = '\377';
+ buffer[1] = 'a';
+ buffer[2] = 'b';
+ int bytes_read = 3;
+ bool break_detected = false;
+ bool parity_error_detected = false;
+ int new_bytes_read = call_CheckReceiveError(
+ buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
+ EXPECT_EQ(NO_ERROR, get_error_detect_state());
+ EXPECT_EQ(0, get_num_chars_ignored());
+ EXPECT_EQ(3, new_bytes_read);
+ EXPECT_EQ('\377', buffer[0]);
+ EXPECT_EQ('a', buffer[1]);
+ EXPECT_EQ('b', buffer[2]);
+ EXPECT_EQ(break_detected, false);
+ EXPECT_EQ(parity_error_detected, false);
+ }
+}
+
+// '\377' 'a'
+// 'b'
+TEST_F(SerialIoHandlerPosixTest, InvalidSequenceReadTwiceBytesReadTwoAndOne) {
+ for (int buffer_len = 2; buffer_len <= 20; ++buffer_len) {
+ set_error_detect_state(NO_ERROR);
+ set_parity_check_enabled(true);
+ set_num_chars_ignored(0);
+ char buffer[buffer_len];
+
+ buffer[0] = '\377';
+ buffer[1] = 'a';
+ int bytes_read = 2;
+ bool break_detected = false;
+ bool parity_error_detected = false;
+ int new_bytes_read = call_CheckReceiveError(
+ buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
+ EXPECT_EQ(NO_ERROR, get_error_detect_state());
+ EXPECT_EQ(0, get_num_chars_ignored());
+ EXPECT_EQ(2, new_bytes_read);
+ EXPECT_EQ('\377', buffer[0]);
+ EXPECT_EQ('a', buffer[1]);
+ EXPECT_EQ(break_detected, false);
+ EXPECT_EQ(parity_error_detected, false);
+
+ buffer[0] = 'b';
+ bytes_read = 1;
+ break_detected = false;
+ parity_error_detected = false;
+ new_bytes_read = call_CheckReceiveError(
+ buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
+ EXPECT_EQ(NO_ERROR, get_error_detect_state());
+ EXPECT_EQ(0, get_num_chars_ignored());
+ EXPECT_EQ(1, new_bytes_read);
+ EXPECT_EQ('b', buffer[0]);
+ EXPECT_EQ(break_detected, false);
+ EXPECT_EQ(parity_error_detected, false);
+ }
+}
+
+// '\377'
+// 'a' 'b'
+TEST_F(SerialIoHandlerPosixTest, InvalidSequenceReadTwiceBytesReadOneAndTwo) {
+ set_error_detect_state(NO_ERROR);
+ set_parity_check_enabled(true);
+ set_num_chars_ignored(0);
+ int buffer_len = 2;
+ char buffer[buffer_len];
+
+ buffer[0] = '\377';
+ int bytes_read = 1;
+ bool break_detected = false;
+ bool parity_error_detected = false;
+ int new_bytes_read = call_CheckReceiveError(
+ buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
+ EXPECT_EQ(MARK_377_SEEN, get_error_detect_state());
+ EXPECT_EQ(1, get_num_chars_ignored());
+ EXPECT_EQ('\377', get_chars_ignored(0));
+ EXPECT_EQ(0, new_bytes_read);
+ EXPECT_EQ(break_detected, false);
+ EXPECT_EQ(parity_error_detected, false);
+
+ buffer[0] = 'a';
+ buffer[1] = 'b';
+ bytes_read = 2;
+ break_detected = false;
+ parity_error_detected = false;
+ new_bytes_read = call_CheckReceiveError(
+ buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
+ EXPECT_EQ(NO_ERROR, get_error_detect_state());
+ EXPECT_EQ(1, get_num_chars_ignored());
+ EXPECT_EQ('b', get_chars_ignored(0));
+ EXPECT_EQ(2, new_bytes_read);
+ EXPECT_EQ('\377', buffer[0]);
+ EXPECT_EQ('a', buffer[1]);
+ EXPECT_EQ(break_detected, false);
+ EXPECT_EQ(parity_error_detected, false);
+}
+
+// '\377'
+// 'a' 'b'
+TEST_F(SerialIoHandlerPosixTest,
+ InvalidSequenceReadTwiceBytesReadOneAndTwoLargerBufferLen) {
+ for (int buffer_len = 3; buffer_len <= 20; ++buffer_len) {
+ set_error_detect_state(NO_ERROR);
+ set_parity_check_enabled(true);
+ set_num_chars_ignored(0);
+ char buffer[buffer_len];
+
+ buffer[0] = '\377';
+ int bytes_read = 1;
+ bool break_detected = false;
+ bool parity_error_detected = false;
+ int new_bytes_read = call_CheckReceiveError(
+ buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
+ EXPECT_EQ(MARK_377_SEEN, get_error_detect_state());
+ EXPECT_EQ(1, get_num_chars_ignored());
+ EXPECT_EQ('\377', get_chars_ignored(0));
+ EXPECT_EQ(0, new_bytes_read);
+ EXPECT_EQ(break_detected, false);
+ EXPECT_EQ(parity_error_detected, false);
+
+ buffer[0] = 'a';
+ buffer[1] = 'b';
+ bytes_read = 2;
+ break_detected = false;
+ parity_error_detected = false;
+ new_bytes_read = call_CheckReceiveError(
+ buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
+ EXPECT_EQ(NO_ERROR, get_error_detect_state());
+ EXPECT_EQ(0, get_num_chars_ignored());
+ EXPECT_EQ(3, new_bytes_read);
+ EXPECT_EQ('\377', buffer[0]);
+ EXPECT_EQ('a', buffer[1]);
+ EXPECT_EQ('b', buffer[2]);
+ EXPECT_EQ(break_detected, false);
+ EXPECT_EQ(parity_error_detected, false);
+ }
+}
+
+// '\377'
+// 'a'
+// 'b'
+TEST_F(SerialIoHandlerPosixTest, InvalidSequenceReadThreeTimes) {
+ set_error_detect_state(NO_ERROR);
+ set_parity_check_enabled(true);
+ set_num_chars_ignored(0);
+ int buffer_len = 1;
+ char buffer[buffer_len];
+
+ buffer[0] = '\377';
+ int bytes_read = 1;
+ bool break_detected = false;
+ bool parity_error_detected = false;
+ int new_bytes_read = call_CheckReceiveError(
+ buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
+ EXPECT_EQ(MARK_377_SEEN, get_error_detect_state());
+ EXPECT_EQ(1, get_num_chars_ignored());
+ EXPECT_EQ('\377', get_chars_ignored(0));
+ EXPECT_EQ(0, new_bytes_read);
+ EXPECT_EQ(break_detected, false);
+ EXPECT_EQ(parity_error_detected, false);
+
+ buffer[0] = 'a';
+ bytes_read = 1;
+ break_detected = false;
+ parity_error_detected = false;
+ new_bytes_read = call_CheckReceiveError(
+ buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
+ EXPECT_EQ(NO_ERROR, get_error_detect_state());
+ EXPECT_EQ(1, get_num_chars_ignored());
+ EXPECT_EQ('a', get_chars_ignored(0));
+ EXPECT_EQ(1, new_bytes_read);
+ EXPECT_EQ('\377', buffer[0]);
+ EXPECT_EQ(break_detected, false);
+ EXPECT_EQ(parity_error_detected, false);
+
+ buffer[0] = 'b';
+ bytes_read = 1;
+ new_bytes_read = call_CheckReceiveError(
+ buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
+ EXPECT_EQ(NO_ERROR, get_error_detect_state());
+ EXPECT_EQ(1, get_num_chars_ignored());
+ EXPECT_EQ('b', get_chars_ignored(0));
+ EXPECT_EQ(1, new_bytes_read);
+ EXPECT_EQ('a', buffer[0]);
+ EXPECT_EQ(break_detected, false);
+ EXPECT_EQ(parity_error_detected, false);
+}
+
+// '\377'
+// 'a'
+// 'b'
+TEST_F(SerialIoHandlerPosixTest, InvalidSequenceReadThreeTimesLargerBufferLen) {
+ for (int buffer_len = 2; buffer_len <= 20; ++buffer_len) {
+ set_error_detect_state(NO_ERROR);
+ set_parity_check_enabled(true);
+ set_num_chars_ignored(0);
+ char buffer[buffer_len];
+
+ buffer[0] = '\377';
+ int bytes_read = 1;
+ bool break_detected = false;
+ bool parity_error_detected = false;
+ int new_bytes_read = call_CheckReceiveError(
+ buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
+ EXPECT_EQ(MARK_377_SEEN, get_error_detect_state());
+ EXPECT_EQ(1, get_num_chars_ignored());
+ EXPECT_EQ('\377', get_chars_ignored(0));
+ EXPECT_EQ(0, new_bytes_read);
+ EXPECT_EQ(break_detected, false);
+ EXPECT_EQ(parity_error_detected, false);
+
+ buffer[0] = 'a';
+ bytes_read = 1;
+ break_detected = false;
+ parity_error_detected = false;
+ new_bytes_read = call_CheckReceiveError(
+ buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
+ EXPECT_EQ(NO_ERROR, get_error_detect_state());
+ EXPECT_EQ(0, get_num_chars_ignored());
+ EXPECT_EQ(2, new_bytes_read);
+ EXPECT_EQ('\377', buffer[0]);
+ EXPECT_EQ('a', buffer[1]);
+ EXPECT_EQ(break_detected, false);
+ EXPECT_EQ(parity_error_detected, false);
+
+ buffer[0] = 'b';
+ bytes_read = 1;
+ break_detected = false;
+ parity_error_detected = false;
+ new_bytes_read = call_CheckReceiveError(
+ buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
+ EXPECT_EQ(NO_ERROR, get_error_detect_state());
+ EXPECT_EQ(0, get_num_chars_ignored());
+ EXPECT_EQ(1, new_bytes_read);
+ EXPECT_EQ('b', buffer[0]);
+ EXPECT_EQ(break_detected, false);
+ EXPECT_EQ(parity_error_detected, false);
+ }
+}
+
+// 'a' 'b' 'c' '\377'
+TEST_F(SerialIoHandlerPosixTest, CharsIgnoredPreset) {
+ set_error_detect_state(NO_ERROR);
+ set_parity_check_enabled(true);
+ set_num_chars_ignored(2);
+ set_chars_ignored(0, 'a');
+ set_chars_ignored(1, 'b');
+ int buffer_len = 2;
+ char buffer[buffer_len];
+
+ buffer[0] = 'c';
+ buffer[1] = '\377';
+ int bytes_read = 2;
+ bool break_detected = false;
+ bool parity_error_detected = false;
+ int new_bytes_read = call_CheckReceiveError(
+ buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
+ EXPECT_EQ(MARK_377_SEEN, get_error_detect_state());
+ EXPECT_EQ(2, get_num_chars_ignored());
+ EXPECT_EQ('c', get_chars_ignored(0));
+ EXPECT_EQ('\377', get_chars_ignored(1));
+ EXPECT_EQ(2, new_bytes_read);
+ EXPECT_EQ('a', buffer[0]);
+ EXPECT_EQ('b', buffer[1]);
+ EXPECT_EQ(break_detected, false);
+ EXPECT_EQ(parity_error_detected, false);
+}
+
+// 'b' 'c' '\377' '\0' '\0' '\377' '\377' '\377' '\0' 'a' 'd' 'e'
+TEST_F(SerialIoHandlerPosixTest, BreakAndEOFAndParityError) {
+ set_error_detect_state(NO_ERROR);
+ set_parity_check_enabled(true);
+ set_num_chars_ignored(0);
+ int buffer_len = 12;
+ char buffer[buffer_len];
+
+ buffer[0] = 'b';
+ buffer[1] = 'c';
+ buffer[2] = '\377';
+ buffer[3] = '\0';
+ buffer[4] = '\0';
+ buffer[5] = '\377';
+ buffer[6] = '\377';
+ buffer[7] = '\377';
+ buffer[8] = '\0';
+ buffer[9] = 'a';
+ buffer[10] = 'd';
+ buffer[11] = 'e';
+ int bytes_read = 12;
+ bool break_detected = false;
+ bool parity_error_detected = false;
+ int new_bytes_read = call_CheckReceiveError(
+ buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
+ EXPECT_EQ(NO_ERROR, get_error_detect_state());
+ EXPECT_EQ(0, get_num_chars_ignored());
+ EXPECT_EQ(5, new_bytes_read);
+ EXPECT_EQ('b', buffer[0]);
+ EXPECT_EQ('c', buffer[1]);
+ EXPECT_EQ('\377', buffer[2]);
+ EXPECT_EQ('d', buffer[3]);
+ EXPECT_EQ('e', buffer[4]);
+ EXPECT_EQ(break_detected, true);
+ EXPECT_EQ(parity_error_detected, true);
+}
+
+// 'b' 'c' '\377' '\0' '\0' '\377'
+// '\377' '\377' '\0'
+// 'a' 'd' 'e'
+TEST_F(SerialIoHandlerPosixTest, BreakAndEOFAndParityErrorReadThreeTimes) {
+ for (int buffer_len = 6; buffer_len <= 20; ++buffer_len) {
+ set_error_detect_state(NO_ERROR);
+ set_parity_check_enabled(true);
+ set_num_chars_ignored(0);
+ char buffer[buffer_len];
+
+ buffer[0] = 'b';
+ buffer[1] = 'c';
+ buffer[2] = '\377';
+ buffer[3] = '\0';
+ buffer[4] = '\0';
+ buffer[5] = '\377';
+ int bytes_read = 6;
+ bool break_detected = false;
+ bool parity_error_detected = false;
+ int new_bytes_read = call_CheckReceiveError(
+ buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
+ EXPECT_EQ(MARK_377_SEEN, get_error_detect_state());
+ EXPECT_EQ(1, get_num_chars_ignored());
+ EXPECT_EQ('\377', get_chars_ignored(0));
+ EXPECT_EQ(2, new_bytes_read);
+ EXPECT_EQ('b', buffer[0]);
+ EXPECT_EQ('c', buffer[1]);
+ EXPECT_EQ(break_detected, true);
+ EXPECT_EQ(parity_error_detected, false);
+
+ buffer[0] = '\377';
+ buffer[1] = '\377';
+ buffer[2] = '\0';
+ bytes_read = 3;
+ break_detected = false;
+ parity_error_detected = false;
+ new_bytes_read = call_CheckReceiveError(
+ buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
+ EXPECT_EQ(MARK_0_SEEN, get_error_detect_state());
+ EXPECT_EQ(2, get_num_chars_ignored());
+ EXPECT_EQ('\377', get_chars_ignored(0));
+ EXPECT_EQ('\0', get_chars_ignored(1));
+ EXPECT_EQ(1, new_bytes_read);
+ EXPECT_EQ('\377', buffer[0]);
+ EXPECT_EQ(break_detected, false);
+ EXPECT_EQ(parity_error_detected, false);
+
+ buffer[0] = 'a';
+ buffer[1] = 'd';
+ buffer[2] = 'e';
+ bytes_read = 3;
+ break_detected = false;
+ parity_error_detected = false;
+ new_bytes_read = call_CheckReceiveError(
+ buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
+ EXPECT_EQ(NO_ERROR, get_error_detect_state());
+ EXPECT_EQ(0, get_num_chars_ignored());
+ EXPECT_EQ(2, new_bytes_read);
+ EXPECT_EQ('d', buffer[0]);
+ EXPECT_EQ('e', buffer[1]);
+ EXPECT_EQ(break_detected, false);
+ EXPECT_EQ(parity_error_detected, true);
+ }
+}
+
+} // namespace device
« device/serial/serial_io_handler_posix.h ('K') | « device/serial/serial_io_handler_posix.cc ('k') | no next file » | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698