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 |