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

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: updated code to handle byte sequence is split across multiple calls to read(), added unit tests 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..4dc5d1fcbab6f217626b94d589340ca71e7ed78b
--- /dev/null
+++ b/device/serial/serial_io_handler_posix_unittest.cc
@@ -0,0 +1,1134 @@
+// 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 "base/gtest_prod_util.h"
+#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);
+ }
+
+ 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) {
+ serial_io_handler_posix_->byte_read_state_ = BYTEREAD_REGULAR;
+ serial_io_handler_posix_->parity_check_enabled_ = true;
+ serial_io_handler_posix_->num_chars_ignored_ = 0;
+ char buffer[buffer_len];
+
+ buffer[0] = 'a';
+ buffer[1] = 'b';
+ buffer[2] = 'c';
+ int bytes_read = 3;
+ 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(BYTEREAD_REGULAR, serial_io_handler_posix_->byte_read_state_);
+ EXPECT_EQ(0, serial_io_handler_posix_->num_chars_ignored_);
+ EXPECT_EQ(bytes_read, 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) {
+ serial_io_handler_posix_->byte_read_state_ = BYTEREAD_REGULAR;
+ serial_io_handler_posix_->parity_check_enabled_ = true;
+ serial_io_handler_posix_->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 = serial_io_handler_posix_->CheckReceiveError(
+ buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
+ EXPECT_EQ(BYTEREAD_REGULAR, serial_io_handler_posix_->byte_read_state_);
+ EXPECT_EQ(0, serial_io_handler_posix_->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;
+ new_bytes_read = serial_io_handler_posix_->CheckReceiveError(
+ buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
+ EXPECT_EQ(BYTEREAD_REGULAR, serial_io_handler_posix_->byte_read_state_);
+ EXPECT_EQ(0, serial_io_handler_posix_->num_chars_ignored_);
+ EXPECT_EQ(bytes_read, 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) {
+ serial_io_handler_posix_->byte_read_state_ = BYTEREAD_REGULAR;
+ serial_io_handler_posix_->parity_check_enabled_ = true;
+ serial_io_handler_posix_->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 = serial_io_handler_posix_->CheckReceiveError(
+ buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
+ EXPECT_EQ(BYTEREAD_REGULAR, serial_io_handler_posix_->byte_read_state_);
+ EXPECT_EQ(0, serial_io_handler_posix_->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;
+ new_bytes_read = serial_io_handler_posix_->CheckReceiveError(
+ buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
+ EXPECT_EQ(BYTEREAD_REGULAR, serial_io_handler_posix_->byte_read_state_);
+ EXPECT_EQ(0, serial_io_handler_posix_->num_chars_ignored_);
+ EXPECT_EQ(bytes_read, 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) {
+ serial_io_handler_posix_->byte_read_state_ = BYTEREAD_REGULAR;
+ serial_io_handler_posix_->parity_check_enabled_ = true;
+ serial_io_handler_posix_->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 = serial_io_handler_posix_->CheckReceiveError(
+ buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
+ EXPECT_EQ(BYTEREAD_REGULAR, serial_io_handler_posix_->byte_read_state_);
+ EXPECT_EQ(0, serial_io_handler_posix_->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';
+ new_bytes_read = serial_io_handler_posix_->CheckReceiveError(
+ buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
+ EXPECT_EQ(BYTEREAD_REGULAR, serial_io_handler_posix_->byte_read_state_);
+ EXPECT_EQ(0, serial_io_handler_posix_->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';
+ new_bytes_read = serial_io_handler_posix_->CheckReceiveError(
+ buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
+ EXPECT_EQ(BYTEREAD_REGULAR, serial_io_handler_posix_->byte_read_state_);
+ EXPECT_EQ(0, serial_io_handler_posix_->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) {
+ serial_io_handler_posix_->byte_read_state_ = BYTEREAD_REGULAR;
+ serial_io_handler_posix_->parity_check_enabled_ = true;
+ serial_io_handler_posix_->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 = serial_io_handler_posix_->CheckReceiveError(
+ buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
+ EXPECT_EQ(BYTEREAD_REGULAR, serial_io_handler_posix_->byte_read_state_);
+ EXPECT_EQ(0, serial_io_handler_posix_->num_chars_ignored_);
+ EXPECT_EQ(0, new_bytes_read);
+ 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) {
+ serial_io_handler_posix_->byte_read_state_ = BYTEREAD_REGULAR;
+ serial_io_handler_posix_->parity_check_enabled_ = true;
+ serial_io_handler_posix_->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 = serial_io_handler_posix_->CheckReceiveError(
+ buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
+ EXPECT_EQ(BYTEREAD_ALL_ZERO, serial_io_handler_posix_->byte_read_state_);
+ EXPECT_EQ(2, serial_io_handler_posix_->num_chars_ignored_);
+ EXPECT_EQ('\377', serial_io_handler_posix_->chars_ignored_[0]);
+ EXPECT_EQ('\0', serial_io_handler_posix_->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;
+ new_bytes_read = serial_io_handler_posix_->CheckReceiveError(
+ buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
+ EXPECT_EQ(BYTEREAD_REGULAR, serial_io_handler_posix_->byte_read_state_);
+ EXPECT_EQ(0, serial_io_handler_posix_->num_chars_ignored_);
+ EXPECT_EQ(0, new_bytes_read);
+ 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) {
+ serial_io_handler_posix_->byte_read_state_ = BYTEREAD_REGULAR;
+ serial_io_handler_posix_->parity_check_enabled_ = true;
+ serial_io_handler_posix_->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 = serial_io_handler_posix_->CheckReceiveError(
+ buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
+ EXPECT_EQ(BYTEREAD_ALL_ONE, serial_io_handler_posix_->byte_read_state_);
+ EXPECT_EQ(1, serial_io_handler_posix_->num_chars_ignored_);
+ EXPECT_EQ('\377', serial_io_handler_posix_->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;
+ new_bytes_read = serial_io_handler_posix_->CheckReceiveError(
+ buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
+ EXPECT_EQ(BYTEREAD_REGULAR, serial_io_handler_posix_->byte_read_state_);
+ EXPECT_EQ(0, serial_io_handler_posix_->num_chars_ignored_);
+ EXPECT_EQ(0, new_bytes_read);
+ 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) {
+ serial_io_handler_posix_->byte_read_state_ = BYTEREAD_REGULAR;
+ serial_io_handler_posix_->parity_check_enabled_ = true;
+ serial_io_handler_posix_->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 = serial_io_handler_posix_->CheckReceiveError(
+ buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
+ EXPECT_EQ(BYTEREAD_ALL_ONE, serial_io_handler_posix_->byte_read_state_);
+ EXPECT_EQ(1, serial_io_handler_posix_->num_chars_ignored_);
+ EXPECT_EQ('\377', serial_io_handler_posix_->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;
+ new_bytes_read = serial_io_handler_posix_->CheckReceiveError(
+ buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
+ EXPECT_EQ(BYTEREAD_ALL_ZERO, serial_io_handler_posix_->byte_read_state_);
+ EXPECT_EQ(2, serial_io_handler_posix_->num_chars_ignored_);
+ EXPECT_EQ('\377', serial_io_handler_posix_->chars_ignored_[0]);
+ EXPECT_EQ('\0', serial_io_handler_posix_->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;
+ new_bytes_read = serial_io_handler_posix_->CheckReceiveError(
+ buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
+ EXPECT_EQ(BYTEREAD_REGULAR, serial_io_handler_posix_->byte_read_state_);
+ EXPECT_EQ(0, serial_io_handler_posix_->num_chars_ignored_);
+ EXPECT_EQ(0, new_bytes_read);
+ 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) {
+ serial_io_handler_posix_->byte_read_state_ = BYTEREAD_REGULAR;
+ serial_io_handler_posix_->parity_check_enabled_ = true;
+ serial_io_handler_posix_->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 = serial_io_handler_posix_->CheckReceiveError(
+ buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
+ EXPECT_EQ(BYTEREAD_REGULAR, serial_io_handler_posix_->byte_read_state_);
+ EXPECT_EQ(0, serial_io_handler_posix_->num_chars_ignored_);
+ EXPECT_EQ(0, new_bytes_read);
+ 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) {
+ serial_io_handler_posix_->byte_read_state_ = BYTEREAD_REGULAR;
+ serial_io_handler_posix_->parity_check_enabled_ = true;
+ serial_io_handler_posix_->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 = serial_io_handler_posix_->CheckReceiveError(
+ buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
+ EXPECT_EQ(BYTEREAD_ALL_ZERO, serial_io_handler_posix_->byte_read_state_);
+ EXPECT_EQ(2, serial_io_handler_posix_->num_chars_ignored_);
+ EXPECT_EQ('\377', serial_io_handler_posix_->chars_ignored_[0]);
+ EXPECT_EQ('\0', serial_io_handler_posix_->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;
+ new_bytes_read = serial_io_handler_posix_->CheckReceiveError(
+ buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
+ EXPECT_EQ(BYTEREAD_REGULAR, serial_io_handler_posix_->byte_read_state_);
+ EXPECT_EQ(0, serial_io_handler_posix_->num_chars_ignored_);
+ EXPECT_EQ(0, new_bytes_read);
+ 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) {
+ serial_io_handler_posix_->byte_read_state_ = BYTEREAD_REGULAR;
+ serial_io_handler_posix_->parity_check_enabled_ = true;
+ serial_io_handler_posix_->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 = serial_io_handler_posix_->CheckReceiveError(
+ buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
+ EXPECT_EQ(BYTEREAD_ALL_ONE, serial_io_handler_posix_->byte_read_state_);
+ EXPECT_EQ(1, serial_io_handler_posix_->num_chars_ignored_);
+ EXPECT_EQ('\377', serial_io_handler_posix_->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;
+ new_bytes_read = serial_io_handler_posix_->CheckReceiveError(
+ buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
+ EXPECT_EQ(BYTEREAD_REGULAR, serial_io_handler_posix_->byte_read_state_);
+ EXPECT_EQ(0, serial_io_handler_posix_->num_chars_ignored_);
+ EXPECT_EQ(0, new_bytes_read);
+ 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) {
+ serial_io_handler_posix_->byte_read_state_ = BYTEREAD_REGULAR;
+ serial_io_handler_posix_->parity_check_enabled_ = true;
+ serial_io_handler_posix_->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 = serial_io_handler_posix_->CheckReceiveError(
+ buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
+ EXPECT_EQ(BYTEREAD_ALL_ONE, serial_io_handler_posix_->byte_read_state_);
+ EXPECT_EQ(1, serial_io_handler_posix_->num_chars_ignored_);
+ EXPECT_EQ('\377', serial_io_handler_posix_->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;
+ new_bytes_read = serial_io_handler_posix_->CheckReceiveError(
+ buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
+ EXPECT_EQ(BYTEREAD_ALL_ZERO, serial_io_handler_posix_->byte_read_state_);
+ EXPECT_EQ(2, serial_io_handler_posix_->num_chars_ignored_);
+ EXPECT_EQ('\377', serial_io_handler_posix_->chars_ignored_[0]);
+ EXPECT_EQ('\0', serial_io_handler_posix_->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;
+ new_bytes_read = serial_io_handler_posix_->CheckReceiveError(
+ buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
+ EXPECT_EQ(BYTEREAD_REGULAR, serial_io_handler_posix_->byte_read_state_);
+ EXPECT_EQ(0, serial_io_handler_posix_->num_chars_ignored_);
+ EXPECT_EQ(0, new_bytes_read);
+ 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) {
+ serial_io_handler_posix_->byte_read_state_ = BYTEREAD_REGULAR;
+ serial_io_handler_posix_->parity_check_enabled_ = true;
+ serial_io_handler_posix_->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 = serial_io_handler_posix_->CheckReceiveError(
+ buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
+ EXPECT_EQ(BYTEREAD_REGULAR, serial_io_handler_posix_->byte_read_state_);
+ EXPECT_EQ(0, serial_io_handler_posix_->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);
+ }
+}
+
+// '\377'
+// '\377'
+TEST_F(SerialIoHandlerPosixTest, TwoEOFsReadTwice) {
+ for (int buffer_len = 1; buffer_len <= 20; ++buffer_len) {
+ serial_io_handler_posix_->byte_read_state_ = BYTEREAD_REGULAR;
+ serial_io_handler_posix_->parity_check_enabled_ = true;
+ serial_io_handler_posix_->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 = serial_io_handler_posix_->CheckReceiveError(
+ buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
+ EXPECT_EQ(BYTEREAD_ALL_ONE, serial_io_handler_posix_->byte_read_state_);
+ EXPECT_EQ(1, serial_io_handler_posix_->num_chars_ignored_);
+ EXPECT_EQ('\377', serial_io_handler_posix_->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;
+ new_bytes_read = serial_io_handler_posix_->CheckReceiveError(
+ buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
+ EXPECT_EQ(BYTEREAD_REGULAR, serial_io_handler_posix_->byte_read_state_);
+ EXPECT_EQ(0, serial_io_handler_posix_->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);
+ }
+}
+
+// '\377' '\0' 'a'
+TEST_F(SerialIoHandlerPosixTest, ParityCheckDisabledReadOnce) {
+ for (int buffer_len = 3; buffer_len <= 20; ++buffer_len) {
+ serial_io_handler_posix_->byte_read_state_ = BYTEREAD_REGULAR;
+ serial_io_handler_posix_->parity_check_enabled_ = false;
+ serial_io_handler_posix_->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 = serial_io_handler_posix_->CheckReceiveError(
+ buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
+ EXPECT_EQ(BYTEREAD_REGULAR, serial_io_handler_posix_->byte_read_state_);
+ EXPECT_EQ(0, serial_io_handler_posix_->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);
+ }
+}
+
+// '\377' '\0'
+// 'a'
+TEST_F(SerialIoHandlerPosixTest,
+ ParityCheckDisabledReadTwiceBytesReadTwoAndOne) {
+ serial_io_handler_posix_->byte_read_state_ = BYTEREAD_REGULAR;
+ serial_io_handler_posix_->parity_check_enabled_ = false;
+ serial_io_handler_posix_->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 = serial_io_handler_posix_->CheckReceiveError(
+ buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
+ EXPECT_EQ(BYTEREAD_ALL_ZERO, serial_io_handler_posix_->byte_read_state_);
+ EXPECT_EQ(2, serial_io_handler_posix_->num_chars_ignored_);
+ EXPECT_EQ('\377', serial_io_handler_posix_->chars_ignored_[0]);
+ EXPECT_EQ('\0', serial_io_handler_posix_->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;
+ new_bytes_read = serial_io_handler_posix_->CheckReceiveError(
+ buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
+ EXPECT_EQ(BYTEREAD_REGULAR, serial_io_handler_posix_->byte_read_state_);
+ EXPECT_EQ(1, serial_io_handler_posix_->num_chars_ignored_);
+ EXPECT_EQ('a', serial_io_handler_posix_->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,
+ ParityCheckDisabledReadTwiceBytesReadTwoAndOneLargerBufferLen) {
+ for (int buffer_len = 3; buffer_len <= 20; ++buffer_len) {
+ serial_io_handler_posix_->byte_read_state_ = BYTEREAD_REGULAR;
+ serial_io_handler_posix_->parity_check_enabled_ = false;
+ serial_io_handler_posix_->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 = serial_io_handler_posix_->CheckReceiveError(
+ buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
+ EXPECT_EQ(BYTEREAD_ALL_ZERO, serial_io_handler_posix_->byte_read_state_);
+ EXPECT_EQ(2, serial_io_handler_posix_->num_chars_ignored_);
+ EXPECT_EQ('\377', serial_io_handler_posix_->chars_ignored_[0]);
+ EXPECT_EQ('\0', serial_io_handler_posix_->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;
+ new_bytes_read = serial_io_handler_posix_->CheckReceiveError(
+ buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
+ EXPECT_EQ(BYTEREAD_REGULAR, serial_io_handler_posix_->byte_read_state_);
+ EXPECT_EQ(0, serial_io_handler_posix_->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);
+ }
+}
+
+// '\377'
+// '\0' 'a'
+TEST_F(SerialIoHandlerPosixTest,
+ ParityCheckDisabledReadTwiceBytesReadOneAndTwo) {
+ serial_io_handler_posix_->byte_read_state_ = BYTEREAD_REGULAR;
+ serial_io_handler_posix_->parity_check_enabled_ = false;
+ serial_io_handler_posix_->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 = serial_io_handler_posix_->CheckReceiveError(
+ buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
+ EXPECT_EQ(BYTEREAD_ALL_ONE, serial_io_handler_posix_->byte_read_state_);
+ EXPECT_EQ(1, serial_io_handler_posix_->num_chars_ignored_);
+ EXPECT_EQ('\377', serial_io_handler_posix_->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;
+ new_bytes_read = serial_io_handler_posix_->CheckReceiveError(
+ buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
+ EXPECT_EQ(BYTEREAD_REGULAR, serial_io_handler_posix_->byte_read_state_);
+ EXPECT_EQ(1, serial_io_handler_posix_->num_chars_ignored_);
+ EXPECT_EQ('a', serial_io_handler_posix_->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) {
+ serial_io_handler_posix_->byte_read_state_ = BYTEREAD_REGULAR;
+ serial_io_handler_posix_->parity_check_enabled_ = false;
+ serial_io_handler_posix_->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 = serial_io_handler_posix_->CheckReceiveError(
+ buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
+ EXPECT_EQ(BYTEREAD_ALL_ONE, serial_io_handler_posix_->byte_read_state_);
+ EXPECT_EQ(1, serial_io_handler_posix_->num_chars_ignored_);
+ EXPECT_EQ('\377', serial_io_handler_posix_->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;
+ new_bytes_read = serial_io_handler_posix_->CheckReceiveError(
+ buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
+ EXPECT_EQ(BYTEREAD_REGULAR, serial_io_handler_posix_->byte_read_state_);
+ EXPECT_EQ(0, serial_io_handler_posix_->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);
+ }
+}
+
+// '\377'
+// '\0'
+// 'a'
+TEST_F(SerialIoHandlerPosixTest,
+ ParityCheckDisabledReadThreeTimesBufferLenOne) {
+ serial_io_handler_posix_->byte_read_state_ = BYTEREAD_REGULAR;
+ serial_io_handler_posix_->parity_check_enabled_ = false;
+ serial_io_handler_posix_->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 = serial_io_handler_posix_->CheckReceiveError(
+ buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
+ EXPECT_EQ(BYTEREAD_ALL_ONE, serial_io_handler_posix_->byte_read_state_);
+ EXPECT_EQ(1, serial_io_handler_posix_->num_chars_ignored_);
+ EXPECT_EQ('\377', serial_io_handler_posix_->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;
+ new_bytes_read = serial_io_handler_posix_->CheckReceiveError(
+ buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
+ EXPECT_EQ(BYTEREAD_ALL_ZERO, serial_io_handler_posix_->byte_read_state_);
+ EXPECT_EQ(2, serial_io_handler_posix_->num_chars_ignored_);
+ EXPECT_EQ('\377', serial_io_handler_posix_->chars_ignored_[0]);
+ EXPECT_EQ('\0', serial_io_handler_posix_->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;
+ new_bytes_read = serial_io_handler_posix_->CheckReceiveError(
+ buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
+ EXPECT_EQ(BYTEREAD_REGULAR, serial_io_handler_posix_->byte_read_state_);
+ EXPECT_EQ(2, serial_io_handler_posix_->num_chars_ignored_);
+ EXPECT_EQ('\0', serial_io_handler_posix_->chars_ignored_[0]);
+ EXPECT_EQ('a', serial_io_handler_posix_->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) {
+ serial_io_handler_posix_->byte_read_state_ = BYTEREAD_REGULAR;
+ serial_io_handler_posix_->parity_check_enabled_ = false;
+ serial_io_handler_posix_->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 = serial_io_handler_posix_->CheckReceiveError(
+ buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
+ EXPECT_EQ(BYTEREAD_ALL_ONE, serial_io_handler_posix_->byte_read_state_);
+ EXPECT_EQ(1, serial_io_handler_posix_->num_chars_ignored_);
+ EXPECT_EQ('\377', serial_io_handler_posix_->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;
+ new_bytes_read = serial_io_handler_posix_->CheckReceiveError(
+ buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
+ EXPECT_EQ(BYTEREAD_ALL_ZERO, serial_io_handler_posix_->byte_read_state_);
+ EXPECT_EQ(2, serial_io_handler_posix_->num_chars_ignored_);
+ EXPECT_EQ('\377', serial_io_handler_posix_->chars_ignored_[0]);
+ EXPECT_EQ('\0', serial_io_handler_posix_->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;
+ new_bytes_read = serial_io_handler_posix_->CheckReceiveError(
+ buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
+ EXPECT_EQ(BYTEREAD_REGULAR, serial_io_handler_posix_->byte_read_state_);
+ EXPECT_EQ(1, serial_io_handler_posix_->num_chars_ignored_);
+ EXPECT_EQ('a', serial_io_handler_posix_->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) {
+ serial_io_handler_posix_->byte_read_state_ = BYTEREAD_REGULAR;
+ serial_io_handler_posix_->parity_check_enabled_ = false;
+ serial_io_handler_posix_->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 = serial_io_handler_posix_->CheckReceiveError(
+ buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
+ EXPECT_EQ(BYTEREAD_ALL_ONE, serial_io_handler_posix_->byte_read_state_);
+ EXPECT_EQ(1, serial_io_handler_posix_->num_chars_ignored_);
+ EXPECT_EQ('\377', serial_io_handler_posix_->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;
+ new_bytes_read = serial_io_handler_posix_->CheckReceiveError(
+ buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
+ EXPECT_EQ(BYTEREAD_ALL_ZERO, serial_io_handler_posix_->byte_read_state_);
+ EXPECT_EQ(2, serial_io_handler_posix_->num_chars_ignored_);
+ EXPECT_EQ('\377', serial_io_handler_posix_->chars_ignored_[0]);
+ EXPECT_EQ('\0', serial_io_handler_posix_->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;
+ new_bytes_read = serial_io_handler_posix_->CheckReceiveError(
+ buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
+ EXPECT_EQ(BYTEREAD_REGULAR, serial_io_handler_posix_->byte_read_state_);
+ EXPECT_EQ(0, serial_io_handler_posix_->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);
+ }
+}
+
+TEST_F(SerialIoHandlerPosixTest, BytesReadZero) {
+ for (int buffer_len = 1; buffer_len <= 20; ++buffer_len) {
+ serial_io_handler_posix_->byte_read_state_ = BYTEREAD_REGULAR;
+ serial_io_handler_posix_->parity_check_enabled_ = true;
+ serial_io_handler_posix_->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 = serial_io_handler_posix_->CheckReceiveError(
+ buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
+ EXPECT_EQ(BYTEREAD_REGULAR, serial_io_handler_posix_->byte_read_state_);
+ EXPECT_EQ(0, serial_io_handler_posix_->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) {
+ serial_io_handler_posix_->byte_read_state_ = BYTEREAD_REGULAR;
+ serial_io_handler_posix_->parity_check_enabled_ = true;
+ serial_io_handler_posix_->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 = serial_io_handler_posix_->CheckReceiveError(
+ buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
+ EXPECT_EQ(BYTEREAD_REGULAR, serial_io_handler_posix_->byte_read_state_);
+ EXPECT_EQ(0, serial_io_handler_posix_->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) {
+ serial_io_handler_posix_->byte_read_state_ = BYTEREAD_REGULAR;
+ serial_io_handler_posix_->parity_check_enabled_ = true;
+ serial_io_handler_posix_->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 = serial_io_handler_posix_->CheckReceiveError(
+ buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
+ EXPECT_EQ(BYTEREAD_REGULAR, serial_io_handler_posix_->byte_read_state_);
+ EXPECT_EQ(0, serial_io_handler_posix_->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;
+ new_bytes_read = serial_io_handler_posix_->CheckReceiveError(
+ buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
+ EXPECT_EQ(BYTEREAD_REGULAR, serial_io_handler_posix_->byte_read_state_);
+ EXPECT_EQ(0, serial_io_handler_posix_->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) {
+ serial_io_handler_posix_->byte_read_state_ = BYTEREAD_REGULAR;
+ serial_io_handler_posix_->parity_check_enabled_ = true;
+ serial_io_handler_posix_->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 = serial_io_handler_posix_->CheckReceiveError(
+ buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
+ EXPECT_EQ(BYTEREAD_ALL_ONE, serial_io_handler_posix_->byte_read_state_);
+ EXPECT_EQ(1, serial_io_handler_posix_->num_chars_ignored_);
+ EXPECT_EQ('\377', serial_io_handler_posix_->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;
+ new_bytes_read = serial_io_handler_posix_->CheckReceiveError(
+ buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
+ EXPECT_EQ(BYTEREAD_REGULAR, serial_io_handler_posix_->byte_read_state_);
+ EXPECT_EQ(1, serial_io_handler_posix_->num_chars_ignored_);
+ EXPECT_EQ('b', serial_io_handler_posix_->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) {
+ serial_io_handler_posix_->byte_read_state_ = BYTEREAD_REGULAR;
+ serial_io_handler_posix_->parity_check_enabled_ = true;
+ serial_io_handler_posix_->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 = serial_io_handler_posix_->CheckReceiveError(
+ buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
+ EXPECT_EQ(BYTEREAD_ALL_ONE, serial_io_handler_posix_->byte_read_state_);
+ EXPECT_EQ(1, serial_io_handler_posix_->num_chars_ignored_);
+ EXPECT_EQ('\377', serial_io_handler_posix_->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;
+ new_bytes_read = serial_io_handler_posix_->CheckReceiveError(
+ buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
+ EXPECT_EQ(BYTEREAD_REGULAR, serial_io_handler_posix_->byte_read_state_);
+ EXPECT_EQ(0, serial_io_handler_posix_->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) {
+ serial_io_handler_posix_->byte_read_state_ = BYTEREAD_REGULAR;
+ serial_io_handler_posix_->parity_check_enabled_ = true;
+ serial_io_handler_posix_->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 = serial_io_handler_posix_->CheckReceiveError(
+ buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
+ EXPECT_EQ(BYTEREAD_ALL_ONE, serial_io_handler_posix_->byte_read_state_);
+ EXPECT_EQ(1, serial_io_handler_posix_->num_chars_ignored_);
+ EXPECT_EQ('\377', serial_io_handler_posix_->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;
+ new_bytes_read = serial_io_handler_posix_->CheckReceiveError(
+ buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
+ EXPECT_EQ(BYTEREAD_REGULAR, serial_io_handler_posix_->byte_read_state_);
+ EXPECT_EQ(1, serial_io_handler_posix_->num_chars_ignored_);
+ EXPECT_EQ('a', serial_io_handler_posix_->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 = serial_io_handler_posix_->CheckReceiveError(
+ buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
+ EXPECT_EQ(BYTEREAD_REGULAR, serial_io_handler_posix_->byte_read_state_);
+ EXPECT_EQ(1, serial_io_handler_posix_->num_chars_ignored_);
+ EXPECT_EQ('b', serial_io_handler_posix_->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) {
+ serial_io_handler_posix_->byte_read_state_ = BYTEREAD_REGULAR;
+ serial_io_handler_posix_->parity_check_enabled_ = true;
+ serial_io_handler_posix_->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 = serial_io_handler_posix_->CheckReceiveError(
+ buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
+ EXPECT_EQ(BYTEREAD_ALL_ONE, serial_io_handler_posix_->byte_read_state_);
+ EXPECT_EQ(1, serial_io_handler_posix_->num_chars_ignored_);
+ EXPECT_EQ('\377', serial_io_handler_posix_->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;
+ new_bytes_read = serial_io_handler_posix_->CheckReceiveError(
+ buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
+ EXPECT_EQ(BYTEREAD_REGULAR, serial_io_handler_posix_->byte_read_state_);
+ EXPECT_EQ(0, serial_io_handler_posix_->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;
+ new_bytes_read = serial_io_handler_posix_->CheckReceiveError(
+ buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
+ EXPECT_EQ(BYTEREAD_REGULAR, serial_io_handler_posix_->byte_read_state_);
+ EXPECT_EQ(0, serial_io_handler_posix_->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) {
+ serial_io_handler_posix_->byte_read_state_ = BYTEREAD_REGULAR;
+ serial_io_handler_posix_->parity_check_enabled_ = true;
+ serial_io_handler_posix_->num_chars_ignored_ = 0;
+ serial_io_handler_posix_->num_chars_ignored_ = 2;
+ serial_io_handler_posix_->chars_ignored_[0] = 'a';
+ serial_io_handler_posix_->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 = serial_io_handler_posix_->CheckReceiveError(
+ buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
+ EXPECT_EQ(BYTEREAD_ALL_ONE, serial_io_handler_posix_->byte_read_state_);
+ EXPECT_EQ(2, serial_io_handler_posix_->num_chars_ignored_);
+ EXPECT_EQ('c', serial_io_handler_posix_->chars_ignored_[0]);
+ EXPECT_EQ('\377', serial_io_handler_posix_->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);
+}
+
+} // 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