Index: device/serial/serial_io_handler_posix_unittest.cc |
diff --git a/device/serial/serial_io_handler_posix_unittest.cc b/device/serial/serial_io_handler_posix_unittest.cc |
new file mode 100644 |
index 0000000000000000000000000000000000000000..208396575881d97cbf19531d6bdfa748e9ea39e5 |
--- /dev/null |
+++ b/device/serial/serial_io_handler_posix_unittest.cc |
@@ -0,0 +1,1080 @@ |
+// Copyright 2015 The Chromium Authors. All rights reserved. |
+// Use of this source code is governed by a BSD-style license that can be |
+// found in the LICENSE file. |
+ |
+#include "device/serial/serial_io_handler_posix.h" |
+#include "testing/gtest/include/gtest/gtest.h" |
+ |
+namespace device { |
+ |
+class SerialIoHandlerPosixTest : public testing::Test { |
+ public: |
+ SerialIoHandlerPosixTest() {} |
+ |
+ void SetUp() override { |
+ serial_io_handler_posix_ = new SerialIoHandlerPosix(nullptr, nullptr); |
+ } |
+ |
+ void set_error_detect_state(ErrorDetectState state) { |
+ serial_io_handler_posix_->error_detect_state_ = state; |
+ } |
+ |
+ ErrorDetectState get_error_detect_state() { |
+ return serial_io_handler_posix_->error_detect_state_; |
+ } |
+ |
+ void set_parity_check_enabled(bool enabled) { |
+ serial_io_handler_posix_->parity_check_enabled_ = enabled; |
+ } |
+ |
+ void set_num_chars_ignored(int n) { |
+ serial_io_handler_posix_->num_chars_ignored_ = n; |
+ } |
+ |
+ int num_chars_ignored() { |
+ return serial_io_handler_posix_->num_chars_ignored_; |
+ } |
+ |
+ void set_chars_ignored(int index, char ch) { |
+ serial_io_handler_posix_->chars_ignored_[index] = ch; |
+ } |
+ |
+ char get_chars_ignored(int index) { |
Reilly Grant (use Gerrit)
2015/07/30 00:00:41
You don't need these wrappers anymore.
juncai
2015/07/30 16:04:37
Done.
|
+ return serial_io_handler_posix_->chars_ignored_[index]; |
+ } |
+ |
+ void initialize(ErrorDetectState error_detect_state, |
Reilly Grant (use Gerrit)
2015/07/30 00:00:41
initialize -> Initialize
juncai
2015/07/30 16:04:37
Done.
|
+ bool parity_check_enabled, |
+ const char* chars_ignored, |
+ int num_chars_ignored) { |
+ set_error_detect_state(error_detect_state); |
+ set_parity_check_enabled(parity_check_enabled); |
+ set_num_chars_ignored(num_chars_ignored); |
+ for (int i = 0; i < num_chars_ignored; ++i) { |
+ set_chars_ignored(i, chars_ignored[i]); |
+ } |
+ } |
+ |
+ void test_helper(char* buffer, |
Reilly Grant (use Gerrit)
2015/07/30 00:00:41
test_helper -> TestHelper
juncai
2015/07/30 16:04:36
Done.
|
+ int buffer_len, |
+ int bytes_read, |
+ ErrorDetectState error_detect_state_expected, |
+ const char* chars_ignored_expected, |
+ int num_chars_ignored_expected, |
+ const char* buffer_expected, |
+ int new_bytes_read_expected, |
+ bool break_detected_expected, |
+ bool parity_error_detected_expected) { |
+ bool break_detected = false; |
+ bool parity_error_detected = false; |
+ int new_bytes_read = serial_io_handler_posix_->CheckReceiveError( |
+ buffer, buffer_len, bytes_read, break_detected, parity_error_detected); |
+ |
+ EXPECT_EQ(error_detect_state_expected, get_error_detect_state()); |
+ EXPECT_EQ(num_chars_ignored_expected, num_chars_ignored()); |
+ for (int i = 0; i < num_chars_ignored_expected; ++i) { |
+ EXPECT_EQ(chars_ignored_expected[i], get_chars_ignored(i)); |
+ } |
+ EXPECT_EQ(new_bytes_read_expected, new_bytes_read); |
+ for (int i = 0; i < new_bytes_read_expected; ++i) { |
+ EXPECT_EQ(buffer_expected[i], buffer[i]); |
+ } |
+ EXPECT_EQ(break_detected_expected, break_detected); |
+ EXPECT_EQ(parity_error_detected_expected, parity_error_detected); |
+ } |
+ |
+ protected: |
+ scoped_refptr<SerialIoHandlerPosix> serial_io_handler_posix_; |
+ |
+ private: |
+ DISALLOW_COPY_AND_ASSIGN(SerialIoHandlerPosixTest); |
+}; |
+ |
+// 'a' 'b' 'c' |
+TEST_F(SerialIoHandlerPosixTest, NoErrorReadOnce) { |
+ char buffer[30]; |
+ for (int buffer_len = 3; buffer_len <= 20; ++buffer_len) { |
+ initialize(ErrorDetectState::NO_ERROR, true, "", 0); |
+ |
+ int bytes_read = 3; |
+ memcpy(buffer, "abc", bytes_read); |
Reilly Grant (use Gerrit)
2015/07/30 00:00:41
Use an array literal instead of memcpy:
char buff
juncai
2015/07/30 16:04:36
Done.
|
+ test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "", |
+ 0, "abc", 3, false, false); |
+ } |
+} |
+ |
+// 'a' 'b' |
+// 'c' |
+TEST_F(SerialIoHandlerPosixTest, NoErrorReadTwiceBytesReadTwoAndOne) { |
+ char buffer[30]; |
+ for (int buffer_len = 2; buffer_len <= 20; ++buffer_len) { |
+ initialize(ErrorDetectState::NO_ERROR, true, "", 0); |
+ |
+ int bytes_read = 2; |
+ memcpy(buffer, "ab", bytes_read); |
+ test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "", |
+ 0, "ab", 2, false, false); |
+ |
+ bytes_read = 1; |
+ memcpy(buffer, "c", bytes_read); |
+ test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "", |
+ 0, "c", 1, false, false); |
+ } |
+} |
+ |
+// 'a' |
+// 'b' c' |
+TEST_F(SerialIoHandlerPosixTest, NoErrorReadTwiceBytesReadOneAndTwo) { |
+ char buffer[30]; |
+ for (int buffer_len = 2; buffer_len <= 20; ++buffer_len) { |
+ initialize(ErrorDetectState::NO_ERROR, true, "", 0); |
+ |
+ int bytes_read = 1; |
+ memcpy(buffer, "a", bytes_read); |
+ test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "", |
+ 0, "a", 1, false, false); |
+ |
+ bytes_read = 2; |
+ memcpy(buffer, "bc", bytes_read); |
+ test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "", |
+ 0, "bc", 2, false, false); |
+ } |
+} |
+ |
+// 'a' |
+// 'b' |
+// 'c' |
+TEST_F(SerialIoHandlerPosixTest, NoErrorReadThreeTimes) { |
+ char buffer[30]; |
+ for (int buffer_len = 1; buffer_len <= 20; ++buffer_len) { |
+ initialize(ErrorDetectState::NO_ERROR, true, "", 0); |
+ |
+ int bytes_read = 1; |
+ memcpy(buffer, "a", bytes_read); |
+ test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "", |
+ 0, "a", 1, false, false); |
+ |
+ bytes_read = 1; |
+ memcpy(buffer, "b", bytes_read); |
+ test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "", |
+ 0, "b", 1, false, false); |
+ |
+ bytes_read = 1; |
+ memcpy(buffer, "c", bytes_read); |
+ test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "", |
+ 0, "c", 1, false, false); |
+ } |
+} |
+ |
+// '\377' '\0' '\0' |
+TEST_F(SerialIoHandlerPosixTest, BreakReadOnce) { |
+ char buffer[30]; |
+ for (int buffer_len = 3; buffer_len <= 20; ++buffer_len) { |
+ initialize(ErrorDetectState::NO_ERROR, true, "", 0); |
+ |
+ int bytes_read = 3; |
+ memcpy(buffer, "\377\0\0", bytes_read); |
+ test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "", |
+ 0, "", 0, true, false); |
+ } |
+} |
+ |
+// 'a' 'b' '\377' '\0' '\0' 'c' 'd' 'e' |
+TEST_F(SerialIoHandlerPosixTest, BreakReadOnceHasBytesBeforeAndAfterBreak) { |
+ char buffer[30]; |
+ for (int buffer_len = 8; buffer_len <= 20; ++buffer_len) { |
+ initialize(ErrorDetectState::NO_ERROR, true, "", 0); |
+ |
+ int bytes_read = 8; |
+ memcpy(buffer, "ab\377\0\000cde", bytes_read); |
+ test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "", |
+ 0, "abcde", 5, true, false); |
+ } |
+} |
+ |
+// '\377' '\0' |
+// '\0' |
+TEST_F(SerialIoHandlerPosixTest, BreakReadTwiceBytesReadTwoAndOne) { |
+ char buffer[30]; |
+ for (int buffer_len = 2; buffer_len <= 20; ++buffer_len) { |
+ initialize(ErrorDetectState::NO_ERROR, true, "", 0); |
+ |
+ int bytes_read = 2; |
+ memcpy(buffer, "\377\0", bytes_read); |
+ test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::MARK_0_SEEN, |
+ "\377\0", 2, "", 0, false, false); |
+ |
+ bytes_read = 1; |
+ memcpy(buffer, "\0", bytes_read); |
+ test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "", |
+ 0, "", 0, true, false); |
+ } |
+} |
+ |
+// 'a' 'b' 'c' \377' '\0' |
+// '\0' 'd' 'e' |
+TEST_F(SerialIoHandlerPosixTest, |
+ BreakReadTwiceBytesReadTwoAndOneHasBytesBeforeAndAfterBreak) { |
+ char buffer[30]; |
+ for (int buffer_len = 5; buffer_len <= 20; ++buffer_len) { |
+ initialize(ErrorDetectState::NO_ERROR, true, "", 0); |
+ |
+ int bytes_read = 5; |
+ memcpy(buffer, "abc\377\0", bytes_read); |
+ test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::MARK_0_SEEN, |
+ "\377\0", 2, "abc", 3, false, false); |
+ |
+ bytes_read = 3; |
+ memcpy(buffer, "\000de", bytes_read); |
+ test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "", |
+ 0, "de", 2, true, false); |
+ } |
+} |
+ |
+// '\377' |
+// '\0' '\0' |
+TEST_F(SerialIoHandlerPosixTest, BreakReadTwiceBytesReadOneAndTwo) { |
+ char buffer[30]; |
+ for (int buffer_len = 2; buffer_len <= 20; ++buffer_len) { |
+ initialize(ErrorDetectState::NO_ERROR, true, "", 0); |
+ |
+ int bytes_read = 1; |
+ memcpy(buffer, "\377", bytes_read); |
+ test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::MARK_377_SEEN, |
+ "\377", 1, "", 0, false, false); |
+ |
+ bytes_read = 2; |
+ memcpy(buffer, "\0\0", bytes_read); |
+ test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "", |
+ 0, "", 0, true, false); |
+ } |
+} |
+ |
+// 'a' 'b' \377' |
+// '\0' '\0' 'c' |
+TEST_F(SerialIoHandlerPosixTest, |
+ BreakReadTwiceBytesReadOneAndTwoHasBytesBeforeAndAfterBreak) { |
+ char buffer[30]; |
+ for (int buffer_len = 3; buffer_len <= 20; ++buffer_len) { |
+ initialize(ErrorDetectState::NO_ERROR, true, "", 0); |
+ |
+ int bytes_read = 3; |
+ memcpy(buffer, "ab\377", bytes_read); |
+ test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::MARK_377_SEEN, |
+ "\377", 1, "ab", 2, false, false); |
+ |
+ bytes_read = 3; |
+ memcpy(buffer, "\0\000c", bytes_read); |
+ test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "", |
+ 0, "c", 1, true, false); |
+ } |
+} |
+ |
+// '\377' |
+// '\0' |
+// '\0' |
+TEST_F(SerialIoHandlerPosixTest, BreakReadThreeTimes) { |
+ char buffer[30]; |
+ for (int buffer_len = 1; buffer_len <= 20; ++buffer_len) { |
+ initialize(ErrorDetectState::NO_ERROR, true, "", 0); |
+ |
+ int bytes_read = 1; |
+ memcpy(buffer, "\377", bytes_read); |
+ test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::MARK_377_SEEN, |
+ "\377", 1, "", 0, false, false); |
+ |
+ bytes_read = 1; |
+ memcpy(buffer, "\0", bytes_read); |
+ test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::MARK_0_SEEN, |
+ "\377\0", 2, "", 0, false, false); |
+ |
+ bytes_read = 1; |
+ memcpy(buffer, "\0", bytes_read); |
+ test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "", |
+ 0, "", 0, true, false); |
+ } |
+} |
+ |
+// 'a' \377' |
+// '\0' |
+// '\0' 'b' |
+TEST_F(SerialIoHandlerPosixTest, |
+ BreakReadThreeTimesHasBytesBeforeAndAfterBreak) { |
+ char buffer[30]; |
+ for (int buffer_len = 2; buffer_len <= 20; ++buffer_len) { |
+ initialize(ErrorDetectState::NO_ERROR, true, "", 0); |
+ |
+ int bytes_read = 2; |
+ memcpy(buffer, "a\377", bytes_read); |
+ test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::MARK_377_SEEN, |
+ "\377", 1, "a", 1, false, false); |
+ |
+ bytes_read = 1; |
+ memcpy(buffer, "\0", bytes_read); |
+ test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::MARK_0_SEEN, |
+ "\377\0", 2, "", 0, false, false); |
+ |
+ bytes_read = 2; |
+ memcpy(buffer, "\000b", bytes_read); |
+ test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "", |
+ 0, "b", 1, true, false); |
+ } |
+} |
+ |
+// '\377' '\0' 'a' |
+TEST_F(SerialIoHandlerPosixTest, ParityErrorReadOnce) { |
+ char buffer[30]; |
+ for (int buffer_len = 3; buffer_len <= 20; ++buffer_len) { |
+ initialize(ErrorDetectState::NO_ERROR, true, "", 0); |
+ |
+ int bytes_read = 3; |
+ memcpy(buffer, "\377\000a", bytes_read); |
+ test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "", |
+ 0, "", 0, false, true); |
+ } |
+} |
+ |
+// 'b' 'c' \377' '\0' 'a' 'd' |
+TEST_F(SerialIoHandlerPosixTest, |
+ ParityErrorReadOnceHasBytesBeforeAndAfterParityError) { |
+ char buffer[30]; |
+ for (int buffer_len = 6; buffer_len <= 20; ++buffer_len) { |
+ initialize(ErrorDetectState::NO_ERROR, true, "", 0); |
+ |
+ int bytes_read = 6; |
+ memcpy(buffer, "bc\377\000ad", bytes_read); |
+ test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "", |
+ 0, "bcd", 3, false, true); |
+ } |
+} |
+ |
+// '\377' '\0' |
+// 'a' |
+TEST_F(SerialIoHandlerPosixTest, ParityErrorReadTwiceBytesReadTwoAndOne) { |
+ char buffer[30]; |
+ for (int buffer_len = 2; buffer_len <= 20; ++buffer_len) { |
+ initialize(ErrorDetectState::NO_ERROR, true, "", 0); |
+ |
+ int bytes_read = 2; |
+ memcpy(buffer, "\377\0", bytes_read); |
+ test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::MARK_0_SEEN, |
+ "\377\0", 2, "", 0, false, false); |
+ |
+ bytes_read = 1; |
+ memcpy(buffer, "a", bytes_read); |
+ test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "", |
+ 0, "", 0, false, true); |
+ } |
+} |
+ |
+// 'b' \377' '\0' |
+// 'a' 'c' 'd' |
+TEST_F( |
+ SerialIoHandlerPosixTest, |
+ ParityErrorReadTwiceBytesReadTwoAndOneHasBytesBeforeAndAfterParityError) { |
+ char buffer[30]; |
+ for (int buffer_len = 3; buffer_len <= 20; ++buffer_len) { |
+ initialize(ErrorDetectState::NO_ERROR, true, "", 0); |
+ |
+ int bytes_read = 3; |
+ memcpy(buffer, "b\377\0", bytes_read); |
+ test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::MARK_0_SEEN, |
+ "\377\0", 2, "b", 1, false, false); |
+ |
+ bytes_read = 3; |
+ memcpy(buffer, "acd", bytes_read); |
+ test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "", |
+ 0, "cd", 2, false, true); |
+ } |
+} |
+ |
+// '\377' |
+// '\0' 'a' |
+TEST_F(SerialIoHandlerPosixTest, ParityErrorReadTwiceBytesReadOneAndTwo) { |
+ char buffer[30]; |
+ for (int buffer_len = 2; buffer_len <= 20; ++buffer_len) { |
+ initialize(ErrorDetectState::NO_ERROR, true, "", 0); |
+ |
+ int bytes_read = 1; |
+ memcpy(buffer, "\377", bytes_read); |
+ test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::MARK_377_SEEN, |
+ "\377", 1, "", 0, false, false); |
+ |
+ bytes_read = 2; |
+ memcpy(buffer, "\00a", bytes_read); |
+ test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "", |
+ 0, "", 0, false, true); |
+ } |
+} |
+ |
+// 'b' 'c' \377' |
+// '\0' 'a' 'd' |
+TEST_F( |
+ SerialIoHandlerPosixTest, |
+ ParityErrorReadTwiceBytesReadOneAndTwoHasBytesBeforeAndAfterParityError) { |
+ char buffer[30]; |
+ for (int buffer_len = 3; buffer_len <= 20; ++buffer_len) { |
+ initialize(ErrorDetectState::NO_ERROR, true, "", 0); |
+ |
+ int bytes_read = 3; |
+ memcpy(buffer, "bc\377", bytes_read); |
+ test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::MARK_377_SEEN, |
+ "\377", 1, "bc", 2, false, false); |
+ |
+ bytes_read = 3; |
+ memcpy(buffer, "\000ad", bytes_read); |
+ test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "", |
+ 0, "d", 1, false, true); |
+ } |
+} |
+ |
+// '\377' |
+// '\0' |
+// 'a' |
+TEST_F(SerialIoHandlerPosixTest, ParityErrorReadThreeTimes) { |
+ char buffer[30]; |
+ for (int buffer_len = 1; buffer_len <= 20; ++buffer_len) { |
+ initialize(ErrorDetectState::NO_ERROR, true, "", 0); |
+ |
+ int bytes_read = 1; |
+ memcpy(buffer, "\377", bytes_read); |
+ test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::MARK_377_SEEN, |
+ "\377", 1, "", 0, false, false); |
+ |
+ bytes_read = 1; |
+ memcpy(buffer, "\0", bytes_read); |
+ test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::MARK_0_SEEN, |
+ "\377\0", 2, "", 0, false, false); |
+ |
+ bytes_read = 1; |
+ memcpy(buffer, "a", bytes_read); |
+ test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "", |
+ 0, "", 0, false, true); |
+ } |
+} |
+ |
+// 'b' '\377' |
+// '\0' |
+// 'a' 'c' |
+TEST_F(SerialIoHandlerPosixTest, |
+ ParityErrorReadThreeTimesHasBytesBeforeAndAfterParityError) { |
+ char buffer[30]; |
+ for (int buffer_len = 2; buffer_len <= 20; ++buffer_len) { |
+ initialize(ErrorDetectState::NO_ERROR, true, "", 0); |
+ |
+ int bytes_read = 2; |
+ memcpy(buffer, "b\377", bytes_read); |
+ test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::MARK_377_SEEN, |
+ "\377", 1, "b", 1, false, false); |
+ |
+ bytes_read = 1; |
+ memcpy(buffer, "\0", bytes_read); |
+ test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::MARK_0_SEEN, |
+ "\377\0", 2, "", 0, false, false); |
+ |
+ bytes_read = 2; |
+ memcpy(buffer, "ac", bytes_read); |
+ test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "", |
+ 0, "c", 1, false, true); |
+ } |
+} |
+ |
+// '\377' '\377' |
+TEST_F(SerialIoHandlerPosixTest, TwoEOFsReadOnce) { |
+ char buffer[30]; |
+ for (int buffer_len = 2; buffer_len <= 20; ++buffer_len) { |
+ initialize(ErrorDetectState::NO_ERROR, true, "", 0); |
+ |
+ int bytes_read = 2; |
+ memcpy(buffer, "\377\377", bytes_read); |
+ test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "", |
+ 0, "\377", 1, false, false); |
+ } |
+} |
+ |
+// 'a' \377' '\377' 'b' 'c' |
+TEST_F(SerialIoHandlerPosixTest, TwoEOFsReadOnceHasBytesBeforeAndAfterEOF) { |
+ char buffer[30]; |
+ for (int buffer_len = 5; buffer_len <= 20; ++buffer_len) { |
+ initialize(ErrorDetectState::NO_ERROR, true, "", 0); |
+ |
+ int bytes_read = 5; |
+ memcpy(buffer, "a\377\377bc", bytes_read); |
+ test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "", |
+ 0, "a\377bc", 4, false, false); |
+ } |
+} |
+ |
+// '\377' |
+// '\377' |
+TEST_F(SerialIoHandlerPosixTest, TwoEOFsReadTwice) { |
+ char buffer[30]; |
+ for (int buffer_len = 1; buffer_len <= 20; ++buffer_len) { |
+ initialize(ErrorDetectState::NO_ERROR, true, "", 0); |
+ |
+ int bytes_read = 1; |
+ memcpy(buffer, "\377", bytes_read); |
+ test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::MARK_377_SEEN, |
+ "\377", 1, "", 0, false, false); |
+ |
+ bytes_read = 1; |
+ memcpy(buffer, "\377", bytes_read); |
+ test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "", |
+ 0, "\377", 1, false, false); |
+ } |
+} |
+ |
+// 'a' \377' |
+// '\377' 'b' |
+TEST_F(SerialIoHandlerPosixTest, TwoEOFsReadTwiceHasBytesBeforeAndAfterEOF) { |
+ char buffer[30]; |
+ for (int buffer_len = 2; buffer_len <= 20; ++buffer_len) { |
+ initialize(ErrorDetectState::NO_ERROR, true, "", 0); |
+ |
+ int bytes_read = 2; |
+ memcpy(buffer, "a\377", bytes_read); |
+ test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::MARK_377_SEEN, |
+ "\377", 1, "a", 1, false, false); |
+ |
+ bytes_read = 2; |
+ memcpy(buffer, "\377b", bytes_read); |
+ test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "", |
+ 0, "\377b", 2, false, false); |
+ } |
+} |
+ |
+// '\377' '\0' 'a' |
+TEST_F(SerialIoHandlerPosixTest, ParityCheckDisabledReadOnce) { |
+ char buffer[30]; |
+ for (int buffer_len = 3; buffer_len <= 20; ++buffer_len) { |
+ initialize(ErrorDetectState::NO_ERROR, false, "", 0); |
+ |
+ int bytes_read = 3; |
+ memcpy(buffer, "\377\000a", bytes_read); |
+ test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "", |
+ 0, "\377\000a", 3, false, false); |
+ } |
+} |
+ |
+// 'b' '\377' '\0' 'a' 'c' |
+TEST_F(SerialIoHandlerPosixTest, |
+ ParityCheckDisabledReadOnceHasBytesBeforeAndAfter) { |
+ char buffer[30]; |
+ for (int buffer_len = 5; buffer_len <= 20; ++buffer_len) { |
+ initialize(ErrorDetectState::NO_ERROR, false, "", 0); |
+ |
+ int bytes_read = 5; |
+ memcpy(buffer, "b\377\000ac", bytes_read); |
+ test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "", |
+ 0, "b\377\000ac", 5, false, false); |
+ } |
+} |
+ |
+// '\377' '\0' |
+// 'a' |
+TEST_F(SerialIoHandlerPosixTest, |
+ ParityCheckDisabledReadTwiceBytesReadTwoAndOne) { |
+ char buffer[30]; |
+ int buffer_len = 2; |
+ initialize(ErrorDetectState::NO_ERROR, false, "", 0); |
+ |
+ int bytes_read = 2; |
+ memcpy(buffer, "\377\0", bytes_read); |
+ test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::MARK_0_SEEN, |
+ "\377\0", 2, "", 0, false, false); |
+ |
+ bytes_read = 1; |
+ memcpy(buffer, "a", bytes_read); |
+ test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "a", |
+ 1, "\377\0", 2, false, false); |
+} |
+ |
+// '\377' '\0' |
+// 'a' 'b' |
+TEST_F(SerialIoHandlerPosixTest, |
+ ParityCheckDisabledReadTwiceBytesReadTwoAndOneHasBytesAfter) { |
+ char buffer[30]; |
+ int buffer_len = 2; |
+ initialize(ErrorDetectState::NO_ERROR, false, "", 0); |
+ |
+ int bytes_read = 2; |
+ memcpy(buffer, "\377\0", bytes_read); |
+ test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::MARK_0_SEEN, |
+ "\377\0", 2, "", 0, false, false); |
+ |
+ bytes_read = 2; |
+ memcpy(buffer, "ab", bytes_read); |
+ test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "ab", |
+ 2, "\377\0", 2, false, false); |
+} |
+ |
+// '\377' '\0' |
+// 'a' |
+TEST_F(SerialIoHandlerPosixTest, |
+ ParityCheckDisabledReadTwiceBytesReadTwoAndOneLargerBufferLen) { |
+ char buffer[30]; |
+ for (int buffer_len = 3; buffer_len <= 20; ++buffer_len) { |
+ initialize(ErrorDetectState::NO_ERROR, false, "", 0); |
+ |
+ int bytes_read = 2; |
+ memcpy(buffer, "\377\0", bytes_read); |
+ test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::MARK_0_SEEN, |
+ "\377\0", 2, "", 0, false, false); |
+ |
+ bytes_read = 1; |
+ memcpy(buffer, "a", bytes_read); |
+ test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "", |
+ 0, "\377\000a", 3, false, false); |
+ } |
+} |
+ |
+// 'b' '\377' '\0' |
+// 'a' 'c' |
+TEST_F( |
+ SerialIoHandlerPosixTest, |
+ ParityCheckDisabledReadTwiceBytesReadTwoAndOneBufferLenThreeHasBytesBeforeAndAfter) { |
+ char buffer[30]; |
+ int buffer_len = 3; |
+ initialize(ErrorDetectState::NO_ERROR, false, "", 0); |
+ |
+ int bytes_read = 3; |
+ memcpy(buffer, "b\377\0", bytes_read); |
+ test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::MARK_0_SEEN, |
+ "\377\0", 2, "b", 1, false, false); |
+ |
+ bytes_read = 2; |
+ memcpy(buffer, "ac", bytes_read); |
+ test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "c", |
+ 1, "\377\000a", 3, false, false); |
+} |
+ |
+// 'b' '\377' '\0' |
+// 'a' 'c' |
+TEST_F( |
+ SerialIoHandlerPosixTest, |
+ ParityCheckDisabledReadTwiceBytesReadTwoAndOneLargerBufferLenHasBytesBeforeAndAfter) { |
+ char buffer[30]; |
+ for (int buffer_len = 4; buffer_len <= 20; ++buffer_len) { |
+ initialize(ErrorDetectState::NO_ERROR, false, "", 0); |
+ |
+ int bytes_read = 3; |
+ memcpy(buffer, "b\377\0", bytes_read); |
+ test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::MARK_0_SEEN, |
+ "\377\0", 2, "b", 1, false, false); |
+ |
+ bytes_read = 2; |
+ memcpy(buffer, "ac", bytes_read); |
+ test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "", |
+ 0, "\377\000ac", 4, false, false); |
+ } |
+} |
+ |
+// '\377' |
+// '\0' 'a' |
+TEST_F(SerialIoHandlerPosixTest, |
+ ParityCheckDisabledReadTwiceBytesReadOneAndTwo) { |
+ char buffer[30]; |
+ int buffer_len = 2; |
+ initialize(ErrorDetectState::NO_ERROR, false, "", 0); |
+ |
+ int bytes_read = 1; |
+ memcpy(buffer, "\377", bytes_read); |
+ test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::MARK_377_SEEN, |
+ "\377", 1, "", 0, false, false); |
+ |
+ bytes_read = 2; |
+ memcpy(buffer, "\000a", bytes_read); |
+ test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "a", |
+ 1, "\377\0", 2, false, false); |
+} |
+ |
+// 'b' '\377' |
+// '\0' 'a' |
+TEST_F(SerialIoHandlerPosixTest, |
+ ParityCheckDisabledReadTwiceBytesReadOneAndTwoHasBytesBefore) { |
+ char buffer[30]; |
+ int buffer_len = 2; |
+ initialize(ErrorDetectState::NO_ERROR, false, "", 0); |
+ |
+ int bytes_read = 2; |
+ memcpy(buffer, "b\377", bytes_read); |
+ test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::MARK_377_SEEN, |
+ "\377", 1, "b", 1, false, false); |
+ |
+ bytes_read = 2; |
+ memcpy(buffer, "\000a", bytes_read); |
+ test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "a", |
+ 1, "\377\0", 2, false, false); |
+} |
+ |
+// '\377' |
+// '\0' 'a' |
+TEST_F(SerialIoHandlerPosixTest, |
+ ParityCheckDisabledReadTwiceBytesReadOneAndTwoLargerBufferLen) { |
+ char buffer[30]; |
+ for (int buffer_len = 3; buffer_len <= 20; ++buffer_len) { |
+ initialize(ErrorDetectState::NO_ERROR, false, "", 0); |
+ |
+ int bytes_read = 1; |
+ memcpy(buffer, "\377", bytes_read); |
+ test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::MARK_377_SEEN, |
+ "\377", 1, "", 0, false, false); |
+ |
+ bytes_read = 2; |
+ memcpy(buffer, "\000a", bytes_read); |
+ test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "", |
+ 0, "\377\000a", 3, false, false); |
+ } |
+} |
+ |
+// 'b' '\377' |
+// '\0' 'a' 'c' |
+TEST_F( |
+ SerialIoHandlerPosixTest, |
+ ParityCheckDisabledReadTwiceBytesReadOneAndTwoBufferLenThreeHasBytesBeforeAndAfter) { |
+ char buffer[30]; |
+ int buffer_len = 3; |
+ |
+ initialize(ErrorDetectState::NO_ERROR, false, "", 0); |
+ |
+ int bytes_read = 2; |
+ memcpy(buffer, "b\377", bytes_read); |
+ test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::MARK_377_SEEN, |
+ "\377", 1, "b", 1, false, false); |
+ |
+ bytes_read = 3; |
+ memcpy(buffer, "\000ac", bytes_read); |
+ test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "c", |
+ 1, "\377\000a", 3, false, false); |
+} |
+ |
+// 'b' '\377' |
+// '\0' 'a' 'c' |
+TEST_F( |
+ SerialIoHandlerPosixTest, |
+ ParityCheckDisabledReadTwiceBytesReadOneAndTwoLargerBufferLenHasBytesBeforeAndAfter) { |
+ char buffer[30]; |
+ for (int buffer_len = 4; buffer_len <= 20; ++buffer_len) { |
+ initialize(ErrorDetectState::NO_ERROR, false, "", 0); |
+ |
+ int bytes_read = 2; |
+ memcpy(buffer, "b\377", bytes_read); |
+ test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::MARK_377_SEEN, |
+ "\377", 1, "b", 1, false, false); |
+ |
+ bytes_read = 3; |
+ memcpy(buffer, "\000ac", bytes_read); |
+ test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "", |
+ 0, "\377\000ac", 4, false, false); |
+ } |
+} |
+ |
+// '\377' |
+// '\0' |
+// 'a' |
+TEST_F(SerialIoHandlerPosixTest, |
+ ParityCheckDisabledReadThreeTimesBufferLenOne) { |
+ char buffer[30]; |
+ int buffer_len = 1; |
+ |
+ initialize(ErrorDetectState::NO_ERROR, false, "", 0); |
+ |
+ int bytes_read = 1; |
+ memcpy(buffer, "\377", bytes_read); |
+ test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::MARK_377_SEEN, |
+ "\377", 1, "", 0, false, false); |
+ |
+ bytes_read = 1; |
+ memcpy(buffer, "\0", bytes_read); |
+ test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::MARK_0_SEEN, |
+ "\377\0", 2, "", 0, false, false); |
+ |
+ bytes_read = 1; |
+ memcpy(buffer, "a", bytes_read); |
+ test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, |
+ "\000a", 2, "\377", 1, false, false); |
+} |
+ |
+// '\377' |
+// '\0' |
+// 'a' |
+TEST_F(SerialIoHandlerPosixTest, |
+ ParityCheckDisabledReadThreeTimesBufferLenTwo) { |
+ char buffer[30]; |
+ int buffer_len = 2; |
+ |
+ initialize(ErrorDetectState::NO_ERROR, false, "", 0); |
+ |
+ int bytes_read = 1; |
+ memcpy(buffer, "\377", bytes_read); |
+ test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::MARK_377_SEEN, |
+ "\377", 1, "", 0, false, false); |
+ |
+ bytes_read = 1; |
+ memcpy(buffer, "\0", bytes_read); |
+ test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::MARK_0_SEEN, |
+ "\377\0", 2, "", 0, false, false); |
+ |
+ bytes_read = 1; |
+ memcpy(buffer, "a", bytes_read); |
+ test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "a", |
+ 1, "\377\0", 2, false, false); |
+} |
+ |
+// '\377' |
+// '\0' |
+// 'a' |
+TEST_F(SerialIoHandlerPosixTest, |
+ ParityCheckDisabledReadThreeTimesLargerBufferLen) { |
+ char buffer[30]; |
+ for (int buffer_len = 3; buffer_len <= 20; ++buffer_len) { |
+ initialize(ErrorDetectState::NO_ERROR, false, "", 0); |
+ |
+ int bytes_read = 1; |
+ memcpy(buffer, "\377", bytes_read); |
+ test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::MARK_377_SEEN, |
+ "\377", 1, "", 0, false, false); |
+ |
+ bytes_read = 1; |
+ memcpy(buffer, "\0", bytes_read); |
+ test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::MARK_0_SEEN, |
+ "\377\0", 2, "", 0, false, false); |
+ |
+ bytes_read = 1; |
+ memcpy(buffer, "a", bytes_read); |
+ test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "", |
+ 0, "\377\000a", 3, false, false); |
+ } |
+} |
+ |
+// 'b' '\377' |
+// '\0' |
+// 'a' 'c' |
+TEST_F(SerialIoHandlerPosixTest, |
+ ParityCheckDisabledReadThreeTimesBufferLenThreeByteBeforeAndAfter) { |
+ char buffer[30]; |
+ int buffer_len = 3; |
+ initialize(ErrorDetectState::NO_ERROR, false, "", 0); |
+ |
+ int bytes_read = 2; |
+ memcpy(buffer, "b\377", bytes_read); |
+ test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::MARK_377_SEEN, |
+ "\377", 1, "b", 1, false, false); |
+ |
+ bytes_read = 1; |
+ memcpy(buffer, "\0", bytes_read); |
+ test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::MARK_0_SEEN, |
+ "\377\0", 2, "", 0, false, false); |
+ |
+ bytes_read = 2; |
+ memcpy(buffer, "ac", bytes_read); |
+ test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "c", |
+ 1, "\377\000a", 3, false, false); |
+} |
+ |
+// 'b' '\377' |
+// '\0' |
+// 'a' 'c' |
+TEST_F(SerialIoHandlerPosixTest, |
+ ParityCheckDisabledReadThreeTimesLargerBufferLenHasBytesBeforeAndAfter) { |
+ char buffer[30]; |
+ for (int buffer_len = 4; buffer_len <= 20; ++buffer_len) { |
+ initialize(ErrorDetectState::NO_ERROR, false, "", 0); |
+ |
+ int bytes_read = 2; |
+ memcpy(buffer, "b\377", bytes_read); |
+ test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::MARK_377_SEEN, |
+ "\377", 1, "b", 1, false, false); |
+ |
+ bytes_read = 1; |
+ memcpy(buffer, "\0", bytes_read); |
+ test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::MARK_0_SEEN, |
+ "\377\0", 2, "", 0, false, false); |
+ |
+ bytes_read = 2; |
+ memcpy(buffer, "ac", bytes_read); |
+ test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "", |
+ 0, "\377\000ac", 4, false, false); |
+ } |
+} |
+ |
+TEST_F(SerialIoHandlerPosixTest, BytesReadZero) { |
+ char buffer[30]; |
+ for (int buffer_len = 1; buffer_len <= 20; ++buffer_len) { |
+ initialize(ErrorDetectState::NO_ERROR, true, "", 0); |
+ |
+ int bytes_read = 0; |
+ test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "", |
+ 0, "", 0, false, false); |
+ } |
+} |
+ |
+// '\377' 'a' 'b' |
+TEST_F(SerialIoHandlerPosixTest, InvalidSequenceReadOnce) { |
+ char buffer[30]; |
+ for (int buffer_len = 3; buffer_len <= 20; ++buffer_len) { |
+ initialize(ErrorDetectState::NO_ERROR, true, "", 0); |
+ |
+ int bytes_read = 3; |
+ memcpy(buffer, "\377ab", bytes_read); |
+ test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "", |
+ 0, "\377ab", 3, false, false); |
+ } |
+} |
+ |
+// '\377' 'a' |
+// 'b' |
+TEST_F(SerialIoHandlerPosixTest, InvalidSequenceReadTwiceBytesReadTwoAndOne) { |
+ char buffer[30]; |
+ for (int buffer_len = 2; buffer_len <= 20; ++buffer_len) { |
+ initialize(ErrorDetectState::NO_ERROR, true, "", 0); |
+ |
+ int bytes_read = 2; |
+ memcpy(buffer, "\377a", bytes_read); |
+ test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "", |
+ 0, "\377a", 2, false, false); |
+ |
+ bytes_read = 1; |
+ memcpy(buffer, "b", bytes_read); |
+ test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "", |
+ 0, "b", 1, false, false); |
+ } |
+} |
+ |
+// '\377' |
+// 'a' 'b' |
+TEST_F(SerialIoHandlerPosixTest, InvalidSequenceReadTwiceBytesReadOneAndTwo) { |
+ char buffer[30]; |
+ int buffer_len = 2; |
+ initialize(ErrorDetectState::NO_ERROR, true, "", 0); |
+ |
+ int bytes_read = 1; |
+ memcpy(buffer, "\377", bytes_read); |
+ test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::MARK_377_SEEN, |
+ "\377", 1, "", 0, false, false); |
+ |
+ bytes_read = 2; |
+ memcpy(buffer, "ab", bytes_read); |
+ test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "b", |
+ 1, "\377a", 2, false, false); |
+} |
+ |
+// '\377' |
+// 'a' 'b' |
+TEST_F(SerialIoHandlerPosixTest, |
+ InvalidSequenceReadTwiceBytesReadOneAndTwoLargerBufferLen) { |
+ char buffer[30]; |
+ for (int buffer_len = 3; buffer_len <= 20; ++buffer_len) { |
+ initialize(ErrorDetectState::NO_ERROR, true, "", 0); |
+ |
+ int bytes_read = 1; |
+ memcpy(buffer, "\377", bytes_read); |
+ test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::MARK_377_SEEN, |
+ "\377", 1, "", 0, false, false); |
+ |
+ bytes_read = 2; |
+ memcpy(buffer, "ab", bytes_read); |
+ test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "", |
+ 0, "\377ab", 3, false, false); |
+ } |
+} |
+ |
+// '\377' |
+// 'a' |
+// 'b' |
+TEST_F(SerialIoHandlerPosixTest, InvalidSequenceReadThreeTimes) { |
+ char buffer[30]; |
+ int buffer_len = 1; |
+ initialize(ErrorDetectState::NO_ERROR, true, "", 0); |
+ |
+ int bytes_read = 1; |
+ memcpy(buffer, "\377", bytes_read); |
+ test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::MARK_377_SEEN, |
+ "\377", 1, "", 0, false, false); |
+ |
+ bytes_read = 1; |
+ memcpy(buffer, "a", bytes_read); |
+ test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "a", |
+ 1, "\377", 1, false, false); |
+ |
+ bytes_read = 1; |
+ memcpy(buffer, "b", bytes_read); |
+ test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "b", |
+ 1, "a", 1, false, false); |
+} |
+ |
+// '\377' |
+// 'a' |
+// 'b' |
+TEST_F(SerialIoHandlerPosixTest, InvalidSequenceReadThreeTimesLargerBufferLen) { |
+ char buffer[30]; |
+ for (int buffer_len = 2; buffer_len <= 20; ++buffer_len) { |
+ initialize(ErrorDetectState::NO_ERROR, true, "", 0); |
+ |
+ int bytes_read = 1; |
+ memcpy(buffer, "\377", bytes_read); |
+ test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::MARK_377_SEEN, |
+ "\377", 1, "", 0, false, false); |
+ |
+ bytes_read = 1; |
+ memcpy(buffer, "a", bytes_read); |
+ test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "", |
+ 0, "\377a", 2, false, false); |
+ |
+ bytes_read = 1; |
+ memcpy(buffer, "b", bytes_read); |
+ test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "", |
+ 0, "b", 1, false, false); |
+ } |
+} |
+ |
+// 'a' 'b' 'c' '\377' |
+TEST_F(SerialIoHandlerPosixTest, CharsIgnoredPreset) { |
+ char buffer[30]; |
+ int buffer_len = 2; |
+ initialize(ErrorDetectState::NO_ERROR, true, "ab", 2); |
+ |
+ int bytes_read = 2; |
+ memcpy(buffer, "c\377", bytes_read); |
+ test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::MARK_377_SEEN, |
+ "c\377", 2, "ab", 2, false, false); |
+} |
+ |
+// 'b' 'c' '\377' '\0' '\0' '\377' '\377' '\377' '\0' 'a' 'd' 'e' |
+TEST_F(SerialIoHandlerPosixTest, BreakAndEOFAndParityError) { |
+ char buffer[30]; |
+ int buffer_len = 12; |
+ initialize(ErrorDetectState::NO_ERROR, true, "", 0); |
+ |
+ int bytes_read = 12; |
+ memcpy(buffer, "bc\377\0\0\377\377\377\000ade", bytes_read); |
+ test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "", 0, |
+ "bc\377de", 5, true, true); |
+} |
+ |
+// 'b' 'c' '\377' '\0' '\0' '\377' |
+// '\377' '\377' '\0' |
+// 'a' 'd' 'e' |
+TEST_F(SerialIoHandlerPosixTest, BreakAndEOFAndParityErrorReadThreeTimes) { |
+ char buffer[30]; |
+ for (int buffer_len = 6; buffer_len <= 20; ++buffer_len) { |
+ initialize(ErrorDetectState::NO_ERROR, true, "", 0); |
+ |
+ int bytes_read = 6; |
+ memcpy(buffer, "bc\377\0\0\377", bytes_read); |
+ test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::MARK_377_SEEN, |
+ "\377", 1, "bc", 2, true, false); |
+ |
+ bytes_read = 3; |
+ memcpy(buffer, "\377\377\0", bytes_read); |
+ test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::MARK_0_SEEN, |
+ "\377\0", 2, "\377", 1, false, false); |
+ |
+ bytes_read = 3; |
+ memcpy(buffer, "ade", bytes_read); |
+ test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "", |
+ 0, "de", 2, false, true); |
+ } |
+} |
+ |
+} // namespace device |