Chromium Code Reviews Chromium Code Reviews
Issue 1249933004:
Add code to detect new added ReceiveError on Linux (Closed)
Base URL: https://chromium.googlesource.com/chromium/src.git@master| OLD | NEW |
|---|---|
| (Empty) | |
| 1 // Copyright 2015 The Chromium Authors. All rights reserved. | |
| 2 // Use of this source code is governed by a BSD-style license that can be | |
| 3 // found in the LICENSE file. | |
| 4 | |
| 5 #include "device/serial/serial_io_handler_posix.h" | |
| 6 #include "testing/gtest/include/gtest/gtest.h" | |
| 7 | |
| 8 namespace device { | |
| 9 | |
| 10 class SerialIoHandlerPosixTest : public testing::Test { | |
| 11 public: | |
| 12 SerialIoHandlerPosixTest() {} | |
| 13 | |
| 14 void SetUp() override { | |
| 15 serial_io_handler_posix_ = new SerialIoHandlerPosix(nullptr, nullptr); | |
| 16 } | |
| 17 | |
| 18 void set_error_detect_state(ErrorDetectState state) { | |
| 19 serial_io_handler_posix_->error_detect_state_ = state; | |
| 20 } | |
| 21 | |
| 22 ErrorDetectState get_error_detect_state() { | |
| 23 return serial_io_handler_posix_->error_detect_state_; | |
| 24 } | |
| 25 | |
| 26 void set_parity_check_enabled(bool enabled) { | |
| 27 serial_io_handler_posix_->parity_check_enabled_ = enabled; | |
| 28 } | |
| 29 | |
| 30 void set_num_chars_ignored(int n) { | |
| 31 serial_io_handler_posix_->num_chars_ignored_ = n; | |
| 32 } | |
| 33 | |
| 34 int num_chars_ignored() { | |
| 35 return serial_io_handler_posix_->num_chars_ignored_; | |
| 36 } | |
| 37 | |
| 38 void set_chars_ignored(int index, char ch) { | |
| 39 serial_io_handler_posix_->chars_ignored_[index] = ch; | |
| 40 } | |
| 41 | |
| 42 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.
| |
| 43 return serial_io_handler_posix_->chars_ignored_[index]; | |
| 44 } | |
| 45 | |
| 46 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.
| |
| 47 bool parity_check_enabled, | |
| 48 const char* chars_ignored, | |
| 49 int num_chars_ignored) { | |
| 50 set_error_detect_state(error_detect_state); | |
| 51 set_parity_check_enabled(parity_check_enabled); | |
| 52 set_num_chars_ignored(num_chars_ignored); | |
| 53 for (int i = 0; i < num_chars_ignored; ++i) { | |
| 54 set_chars_ignored(i, chars_ignored[i]); | |
| 55 } | |
| 56 } | |
| 57 | |
| 58 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.
| |
| 59 int buffer_len, | |
| 60 int bytes_read, | |
| 61 ErrorDetectState error_detect_state_expected, | |
| 62 const char* chars_ignored_expected, | |
| 63 int num_chars_ignored_expected, | |
| 64 const char* buffer_expected, | |
| 65 int new_bytes_read_expected, | |
| 66 bool break_detected_expected, | |
| 67 bool parity_error_detected_expected) { | |
| 68 bool break_detected = false; | |
| 69 bool parity_error_detected = false; | |
| 70 int new_bytes_read = serial_io_handler_posix_->CheckReceiveError( | |
| 71 buffer, buffer_len, bytes_read, break_detected, parity_error_detected); | |
| 72 | |
| 73 EXPECT_EQ(error_detect_state_expected, get_error_detect_state()); | |
| 74 EXPECT_EQ(num_chars_ignored_expected, num_chars_ignored()); | |
| 75 for (int i = 0; i < num_chars_ignored_expected; ++i) { | |
| 76 EXPECT_EQ(chars_ignored_expected[i], get_chars_ignored(i)); | |
| 77 } | |
| 78 EXPECT_EQ(new_bytes_read_expected, new_bytes_read); | |
| 79 for (int i = 0; i < new_bytes_read_expected; ++i) { | |
| 80 EXPECT_EQ(buffer_expected[i], buffer[i]); | |
| 81 } | |
| 82 EXPECT_EQ(break_detected_expected, break_detected); | |
| 83 EXPECT_EQ(parity_error_detected_expected, parity_error_detected); | |
| 84 } | |
| 85 | |
| 86 protected: | |
| 87 scoped_refptr<SerialIoHandlerPosix> serial_io_handler_posix_; | |
| 88 | |
| 89 private: | |
| 90 DISALLOW_COPY_AND_ASSIGN(SerialIoHandlerPosixTest); | |
| 91 }; | |
| 92 | |
| 93 // 'a' 'b' 'c' | |
| 94 TEST_F(SerialIoHandlerPosixTest, NoErrorReadOnce) { | |
| 95 char buffer[30]; | |
| 96 for (int buffer_len = 3; buffer_len <= 20; ++buffer_len) { | |
| 97 initialize(ErrorDetectState::NO_ERROR, true, "", 0); | |
| 98 | |
| 99 int bytes_read = 3; | |
| 100 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.
| |
| 101 test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "", | |
| 102 0, "abc", 3, false, false); | |
| 103 } | |
| 104 } | |
| 105 | |
| 106 // 'a' 'b' | |
| 107 // 'c' | |
| 108 TEST_F(SerialIoHandlerPosixTest, NoErrorReadTwiceBytesReadTwoAndOne) { | |
| 109 char buffer[30]; | |
| 110 for (int buffer_len = 2; buffer_len <= 20; ++buffer_len) { | |
| 111 initialize(ErrorDetectState::NO_ERROR, true, "", 0); | |
| 112 | |
| 113 int bytes_read = 2; | |
| 114 memcpy(buffer, "ab", bytes_read); | |
| 115 test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "", | |
| 116 0, "ab", 2, false, false); | |
| 117 | |
| 118 bytes_read = 1; | |
| 119 memcpy(buffer, "c", bytes_read); | |
| 120 test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "", | |
| 121 0, "c", 1, false, false); | |
| 122 } | |
| 123 } | |
| 124 | |
| 125 // 'a' | |
| 126 // 'b' c' | |
| 127 TEST_F(SerialIoHandlerPosixTest, NoErrorReadTwiceBytesReadOneAndTwo) { | |
| 128 char buffer[30]; | |
| 129 for (int buffer_len = 2; buffer_len <= 20; ++buffer_len) { | |
| 130 initialize(ErrorDetectState::NO_ERROR, true, "", 0); | |
| 131 | |
| 132 int bytes_read = 1; | |
| 133 memcpy(buffer, "a", bytes_read); | |
| 134 test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "", | |
| 135 0, "a", 1, false, false); | |
| 136 | |
| 137 bytes_read = 2; | |
| 138 memcpy(buffer, "bc", bytes_read); | |
| 139 test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "", | |
| 140 0, "bc", 2, false, false); | |
| 141 } | |
| 142 } | |
| 143 | |
| 144 // 'a' | |
| 145 // 'b' | |
| 146 // 'c' | |
| 147 TEST_F(SerialIoHandlerPosixTest, NoErrorReadThreeTimes) { | |
| 148 char buffer[30]; | |
| 149 for (int buffer_len = 1; buffer_len <= 20; ++buffer_len) { | |
| 150 initialize(ErrorDetectState::NO_ERROR, true, "", 0); | |
| 151 | |
| 152 int bytes_read = 1; | |
| 153 memcpy(buffer, "a", bytes_read); | |
| 154 test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "", | |
| 155 0, "a", 1, false, false); | |
| 156 | |
| 157 bytes_read = 1; | |
| 158 memcpy(buffer, "b", bytes_read); | |
| 159 test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "", | |
| 160 0, "b", 1, false, false); | |
| 161 | |
| 162 bytes_read = 1; | |
| 163 memcpy(buffer, "c", bytes_read); | |
| 164 test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "", | |
| 165 0, "c", 1, false, false); | |
| 166 } | |
| 167 } | |
| 168 | |
| 169 // '\377' '\0' '\0' | |
| 170 TEST_F(SerialIoHandlerPosixTest, BreakReadOnce) { | |
| 171 char buffer[30]; | |
| 172 for (int buffer_len = 3; buffer_len <= 20; ++buffer_len) { | |
| 173 initialize(ErrorDetectState::NO_ERROR, true, "", 0); | |
| 174 | |
| 175 int bytes_read = 3; | |
| 176 memcpy(buffer, "\377\0\0", bytes_read); | |
| 177 test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "", | |
| 178 0, "", 0, true, false); | |
| 179 } | |
| 180 } | |
| 181 | |
| 182 // 'a' 'b' '\377' '\0' '\0' 'c' 'd' 'e' | |
| 183 TEST_F(SerialIoHandlerPosixTest, BreakReadOnceHasBytesBeforeAndAfterBreak) { | |
| 184 char buffer[30]; | |
| 185 for (int buffer_len = 8; buffer_len <= 20; ++buffer_len) { | |
| 186 initialize(ErrorDetectState::NO_ERROR, true, "", 0); | |
| 187 | |
| 188 int bytes_read = 8; | |
| 189 memcpy(buffer, "ab\377\0\000cde", bytes_read); | |
| 190 test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "", | |
| 191 0, "abcde", 5, true, false); | |
| 192 } | |
| 193 } | |
| 194 | |
| 195 // '\377' '\0' | |
| 196 // '\0' | |
| 197 TEST_F(SerialIoHandlerPosixTest, BreakReadTwiceBytesReadTwoAndOne) { | |
| 198 char buffer[30]; | |
| 199 for (int buffer_len = 2; buffer_len <= 20; ++buffer_len) { | |
| 200 initialize(ErrorDetectState::NO_ERROR, true, "", 0); | |
| 201 | |
| 202 int bytes_read = 2; | |
| 203 memcpy(buffer, "\377\0", bytes_read); | |
| 204 test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::MARK_0_SEEN, | |
| 205 "\377\0", 2, "", 0, false, false); | |
| 206 | |
| 207 bytes_read = 1; | |
| 208 memcpy(buffer, "\0", bytes_read); | |
| 209 test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "", | |
| 210 0, "", 0, true, false); | |
| 211 } | |
| 212 } | |
| 213 | |
| 214 // 'a' 'b' 'c' \377' '\0' | |
| 215 // '\0' 'd' 'e' | |
| 216 TEST_F(SerialIoHandlerPosixTest, | |
| 217 BreakReadTwiceBytesReadTwoAndOneHasBytesBeforeAndAfterBreak) { | |
| 218 char buffer[30]; | |
| 219 for (int buffer_len = 5; buffer_len <= 20; ++buffer_len) { | |
| 220 initialize(ErrorDetectState::NO_ERROR, true, "", 0); | |
| 221 | |
| 222 int bytes_read = 5; | |
| 223 memcpy(buffer, "abc\377\0", bytes_read); | |
| 224 test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::MARK_0_SEEN, | |
| 225 "\377\0", 2, "abc", 3, false, false); | |
| 226 | |
| 227 bytes_read = 3; | |
| 228 memcpy(buffer, "\000de", bytes_read); | |
| 229 test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "", | |
| 230 0, "de", 2, true, false); | |
| 231 } | |
| 232 } | |
| 233 | |
| 234 // '\377' | |
| 235 // '\0' '\0' | |
| 236 TEST_F(SerialIoHandlerPosixTest, BreakReadTwiceBytesReadOneAndTwo) { | |
| 237 char buffer[30]; | |
| 238 for (int buffer_len = 2; buffer_len <= 20; ++buffer_len) { | |
| 239 initialize(ErrorDetectState::NO_ERROR, true, "", 0); | |
| 240 | |
| 241 int bytes_read = 1; | |
| 242 memcpy(buffer, "\377", bytes_read); | |
| 243 test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::MARK_377_SEEN, | |
| 244 "\377", 1, "", 0, false, false); | |
| 245 | |
| 246 bytes_read = 2; | |
| 247 memcpy(buffer, "\0\0", bytes_read); | |
| 248 test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "", | |
| 249 0, "", 0, true, false); | |
| 250 } | |
| 251 } | |
| 252 | |
| 253 // 'a' 'b' \377' | |
| 254 // '\0' '\0' 'c' | |
| 255 TEST_F(SerialIoHandlerPosixTest, | |
| 256 BreakReadTwiceBytesReadOneAndTwoHasBytesBeforeAndAfterBreak) { | |
| 257 char buffer[30]; | |
| 258 for (int buffer_len = 3; buffer_len <= 20; ++buffer_len) { | |
| 259 initialize(ErrorDetectState::NO_ERROR, true, "", 0); | |
| 260 | |
| 261 int bytes_read = 3; | |
| 262 memcpy(buffer, "ab\377", bytes_read); | |
| 263 test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::MARK_377_SEEN, | |
| 264 "\377", 1, "ab", 2, false, false); | |
| 265 | |
| 266 bytes_read = 3; | |
| 267 memcpy(buffer, "\0\000c", bytes_read); | |
| 268 test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "", | |
| 269 0, "c", 1, true, false); | |
| 270 } | |
| 271 } | |
| 272 | |
| 273 // '\377' | |
| 274 // '\0' | |
| 275 // '\0' | |
| 276 TEST_F(SerialIoHandlerPosixTest, BreakReadThreeTimes) { | |
| 277 char buffer[30]; | |
| 278 for (int buffer_len = 1; buffer_len <= 20; ++buffer_len) { | |
| 279 initialize(ErrorDetectState::NO_ERROR, true, "", 0); | |
| 280 | |
| 281 int bytes_read = 1; | |
| 282 memcpy(buffer, "\377", bytes_read); | |
| 283 test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::MARK_377_SEEN, | |
| 284 "\377", 1, "", 0, false, false); | |
| 285 | |
| 286 bytes_read = 1; | |
| 287 memcpy(buffer, "\0", bytes_read); | |
| 288 test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::MARK_0_SEEN, | |
| 289 "\377\0", 2, "", 0, false, false); | |
| 290 | |
| 291 bytes_read = 1; | |
| 292 memcpy(buffer, "\0", bytes_read); | |
| 293 test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "", | |
| 294 0, "", 0, true, false); | |
| 295 } | |
| 296 } | |
| 297 | |
| 298 // 'a' \377' | |
| 299 // '\0' | |
| 300 // '\0' 'b' | |
| 301 TEST_F(SerialIoHandlerPosixTest, | |
| 302 BreakReadThreeTimesHasBytesBeforeAndAfterBreak) { | |
| 303 char buffer[30]; | |
| 304 for (int buffer_len = 2; buffer_len <= 20; ++buffer_len) { | |
| 305 initialize(ErrorDetectState::NO_ERROR, true, "", 0); | |
| 306 | |
| 307 int bytes_read = 2; | |
| 308 memcpy(buffer, "a\377", bytes_read); | |
| 309 test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::MARK_377_SEEN, | |
| 310 "\377", 1, "a", 1, false, false); | |
| 311 | |
| 312 bytes_read = 1; | |
| 313 memcpy(buffer, "\0", bytes_read); | |
| 314 test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::MARK_0_SEEN, | |
| 315 "\377\0", 2, "", 0, false, false); | |
| 316 | |
| 317 bytes_read = 2; | |
| 318 memcpy(buffer, "\000b", bytes_read); | |
| 319 test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "", | |
| 320 0, "b", 1, true, false); | |
| 321 } | |
| 322 } | |
| 323 | |
| 324 // '\377' '\0' 'a' | |
| 325 TEST_F(SerialIoHandlerPosixTest, ParityErrorReadOnce) { | |
| 326 char buffer[30]; | |
| 327 for (int buffer_len = 3; buffer_len <= 20; ++buffer_len) { | |
| 328 initialize(ErrorDetectState::NO_ERROR, true, "", 0); | |
| 329 | |
| 330 int bytes_read = 3; | |
| 331 memcpy(buffer, "\377\000a", bytes_read); | |
| 332 test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "", | |
| 333 0, "", 0, false, true); | |
| 334 } | |
| 335 } | |
| 336 | |
| 337 // 'b' 'c' \377' '\0' 'a' 'd' | |
| 338 TEST_F(SerialIoHandlerPosixTest, | |
| 339 ParityErrorReadOnceHasBytesBeforeAndAfterParityError) { | |
| 340 char buffer[30]; | |
| 341 for (int buffer_len = 6; buffer_len <= 20; ++buffer_len) { | |
| 342 initialize(ErrorDetectState::NO_ERROR, true, "", 0); | |
| 343 | |
| 344 int bytes_read = 6; | |
| 345 memcpy(buffer, "bc\377\000ad", bytes_read); | |
| 346 test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "", | |
| 347 0, "bcd", 3, false, true); | |
| 348 } | |
| 349 } | |
| 350 | |
| 351 // '\377' '\0' | |
| 352 // 'a' | |
| 353 TEST_F(SerialIoHandlerPosixTest, ParityErrorReadTwiceBytesReadTwoAndOne) { | |
| 354 char buffer[30]; | |
| 355 for (int buffer_len = 2; buffer_len <= 20; ++buffer_len) { | |
| 356 initialize(ErrorDetectState::NO_ERROR, true, "", 0); | |
| 357 | |
| 358 int bytes_read = 2; | |
| 359 memcpy(buffer, "\377\0", bytes_read); | |
| 360 test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::MARK_0_SEEN, | |
| 361 "\377\0", 2, "", 0, false, false); | |
| 362 | |
| 363 bytes_read = 1; | |
| 364 memcpy(buffer, "a", bytes_read); | |
| 365 test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "", | |
| 366 0, "", 0, false, true); | |
| 367 } | |
| 368 } | |
| 369 | |
| 370 // 'b' \377' '\0' | |
| 371 // 'a' 'c' 'd' | |
| 372 TEST_F( | |
| 373 SerialIoHandlerPosixTest, | |
| 374 ParityErrorReadTwiceBytesReadTwoAndOneHasBytesBeforeAndAfterParityError) { | |
| 375 char buffer[30]; | |
| 376 for (int buffer_len = 3; buffer_len <= 20; ++buffer_len) { | |
| 377 initialize(ErrorDetectState::NO_ERROR, true, "", 0); | |
| 378 | |
| 379 int bytes_read = 3; | |
| 380 memcpy(buffer, "b\377\0", bytes_read); | |
| 381 test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::MARK_0_SEEN, | |
| 382 "\377\0", 2, "b", 1, false, false); | |
| 383 | |
| 384 bytes_read = 3; | |
| 385 memcpy(buffer, "acd", bytes_read); | |
| 386 test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "", | |
| 387 0, "cd", 2, false, true); | |
| 388 } | |
| 389 } | |
| 390 | |
| 391 // '\377' | |
| 392 // '\0' 'a' | |
| 393 TEST_F(SerialIoHandlerPosixTest, ParityErrorReadTwiceBytesReadOneAndTwo) { | |
| 394 char buffer[30]; | |
| 395 for (int buffer_len = 2; buffer_len <= 20; ++buffer_len) { | |
| 396 initialize(ErrorDetectState::NO_ERROR, true, "", 0); | |
| 397 | |
| 398 int bytes_read = 1; | |
| 399 memcpy(buffer, "\377", bytes_read); | |
| 400 test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::MARK_377_SEEN, | |
| 401 "\377", 1, "", 0, false, false); | |
| 402 | |
| 403 bytes_read = 2; | |
| 404 memcpy(buffer, "\00a", bytes_read); | |
| 405 test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "", | |
| 406 0, "", 0, false, true); | |
| 407 } | |
| 408 } | |
| 409 | |
| 410 // 'b' 'c' \377' | |
| 411 // '\0' 'a' 'd' | |
| 412 TEST_F( | |
| 413 SerialIoHandlerPosixTest, | |
| 414 ParityErrorReadTwiceBytesReadOneAndTwoHasBytesBeforeAndAfterParityError) { | |
| 415 char buffer[30]; | |
| 416 for (int buffer_len = 3; buffer_len <= 20; ++buffer_len) { | |
| 417 initialize(ErrorDetectState::NO_ERROR, true, "", 0); | |
| 418 | |
| 419 int bytes_read = 3; | |
| 420 memcpy(buffer, "bc\377", bytes_read); | |
| 421 test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::MARK_377_SEEN, | |
| 422 "\377", 1, "bc", 2, false, false); | |
| 423 | |
| 424 bytes_read = 3; | |
| 425 memcpy(buffer, "\000ad", bytes_read); | |
| 426 test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "", | |
| 427 0, "d", 1, false, true); | |
| 428 } | |
| 429 } | |
| 430 | |
| 431 // '\377' | |
| 432 // '\0' | |
| 433 // 'a' | |
| 434 TEST_F(SerialIoHandlerPosixTest, ParityErrorReadThreeTimes) { | |
| 435 char buffer[30]; | |
| 436 for (int buffer_len = 1; buffer_len <= 20; ++buffer_len) { | |
| 437 initialize(ErrorDetectState::NO_ERROR, true, "", 0); | |
| 438 | |
| 439 int bytes_read = 1; | |
| 440 memcpy(buffer, "\377", bytes_read); | |
| 441 test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::MARK_377_SEEN, | |
| 442 "\377", 1, "", 0, false, false); | |
| 443 | |
| 444 bytes_read = 1; | |
| 445 memcpy(buffer, "\0", bytes_read); | |
| 446 test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::MARK_0_SEEN, | |
| 447 "\377\0", 2, "", 0, false, false); | |
| 448 | |
| 449 bytes_read = 1; | |
| 450 memcpy(buffer, "a", bytes_read); | |
| 451 test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "", | |
| 452 0, "", 0, false, true); | |
| 453 } | |
| 454 } | |
| 455 | |
| 456 // 'b' '\377' | |
| 457 // '\0' | |
| 458 // 'a' 'c' | |
| 459 TEST_F(SerialIoHandlerPosixTest, | |
| 460 ParityErrorReadThreeTimesHasBytesBeforeAndAfterParityError) { | |
| 461 char buffer[30]; | |
| 462 for (int buffer_len = 2; buffer_len <= 20; ++buffer_len) { | |
| 463 initialize(ErrorDetectState::NO_ERROR, true, "", 0); | |
| 464 | |
| 465 int bytes_read = 2; | |
| 466 memcpy(buffer, "b\377", bytes_read); | |
| 467 test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::MARK_377_SEEN, | |
| 468 "\377", 1, "b", 1, false, false); | |
| 469 | |
| 470 bytes_read = 1; | |
| 471 memcpy(buffer, "\0", bytes_read); | |
| 472 test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::MARK_0_SEEN, | |
| 473 "\377\0", 2, "", 0, false, false); | |
| 474 | |
| 475 bytes_read = 2; | |
| 476 memcpy(buffer, "ac", bytes_read); | |
| 477 test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "", | |
| 478 0, "c", 1, false, true); | |
| 479 } | |
| 480 } | |
| 481 | |
| 482 // '\377' '\377' | |
| 483 TEST_F(SerialIoHandlerPosixTest, TwoEOFsReadOnce) { | |
| 484 char buffer[30]; | |
| 485 for (int buffer_len = 2; buffer_len <= 20; ++buffer_len) { | |
| 486 initialize(ErrorDetectState::NO_ERROR, true, "", 0); | |
| 487 | |
| 488 int bytes_read = 2; | |
| 489 memcpy(buffer, "\377\377", bytes_read); | |
| 490 test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "", | |
| 491 0, "\377", 1, false, false); | |
| 492 } | |
| 493 } | |
| 494 | |
| 495 // 'a' \377' '\377' 'b' 'c' | |
| 496 TEST_F(SerialIoHandlerPosixTest, TwoEOFsReadOnceHasBytesBeforeAndAfterEOF) { | |
| 497 char buffer[30]; | |
| 498 for (int buffer_len = 5; buffer_len <= 20; ++buffer_len) { | |
| 499 initialize(ErrorDetectState::NO_ERROR, true, "", 0); | |
| 500 | |
| 501 int bytes_read = 5; | |
| 502 memcpy(buffer, "a\377\377bc", bytes_read); | |
| 503 test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "", | |
| 504 0, "a\377bc", 4, false, false); | |
| 505 } | |
| 506 } | |
| 507 | |
| 508 // '\377' | |
| 509 // '\377' | |
| 510 TEST_F(SerialIoHandlerPosixTest, TwoEOFsReadTwice) { | |
| 511 char buffer[30]; | |
| 512 for (int buffer_len = 1; buffer_len <= 20; ++buffer_len) { | |
| 513 initialize(ErrorDetectState::NO_ERROR, true, "", 0); | |
| 514 | |
| 515 int bytes_read = 1; | |
| 516 memcpy(buffer, "\377", bytes_read); | |
| 517 test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::MARK_377_SEEN, | |
| 518 "\377", 1, "", 0, false, false); | |
| 519 | |
| 520 bytes_read = 1; | |
| 521 memcpy(buffer, "\377", bytes_read); | |
| 522 test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "", | |
| 523 0, "\377", 1, false, false); | |
| 524 } | |
| 525 } | |
| 526 | |
| 527 // 'a' \377' | |
| 528 // '\377' 'b' | |
| 529 TEST_F(SerialIoHandlerPosixTest, TwoEOFsReadTwiceHasBytesBeforeAndAfterEOF) { | |
| 530 char buffer[30]; | |
| 531 for (int buffer_len = 2; buffer_len <= 20; ++buffer_len) { | |
| 532 initialize(ErrorDetectState::NO_ERROR, true, "", 0); | |
| 533 | |
| 534 int bytes_read = 2; | |
| 535 memcpy(buffer, "a\377", bytes_read); | |
| 536 test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::MARK_377_SEEN, | |
| 537 "\377", 1, "a", 1, false, false); | |
| 538 | |
| 539 bytes_read = 2; | |
| 540 memcpy(buffer, "\377b", bytes_read); | |
| 541 test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "", | |
| 542 0, "\377b", 2, false, false); | |
| 543 } | |
| 544 } | |
| 545 | |
| 546 // '\377' '\0' 'a' | |
| 547 TEST_F(SerialIoHandlerPosixTest, ParityCheckDisabledReadOnce) { | |
| 548 char buffer[30]; | |
| 549 for (int buffer_len = 3; buffer_len <= 20; ++buffer_len) { | |
| 550 initialize(ErrorDetectState::NO_ERROR, false, "", 0); | |
| 551 | |
| 552 int bytes_read = 3; | |
| 553 memcpy(buffer, "\377\000a", bytes_read); | |
| 554 test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "", | |
| 555 0, "\377\000a", 3, false, false); | |
| 556 } | |
| 557 } | |
| 558 | |
| 559 // 'b' '\377' '\0' 'a' 'c' | |
| 560 TEST_F(SerialIoHandlerPosixTest, | |
| 561 ParityCheckDisabledReadOnceHasBytesBeforeAndAfter) { | |
| 562 char buffer[30]; | |
| 563 for (int buffer_len = 5; buffer_len <= 20; ++buffer_len) { | |
| 564 initialize(ErrorDetectState::NO_ERROR, false, "", 0); | |
| 565 | |
| 566 int bytes_read = 5; | |
| 567 memcpy(buffer, "b\377\000ac", bytes_read); | |
| 568 test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "", | |
| 569 0, "b\377\000ac", 5, false, false); | |
| 570 } | |
| 571 } | |
| 572 | |
| 573 // '\377' '\0' | |
| 574 // 'a' | |
| 575 TEST_F(SerialIoHandlerPosixTest, | |
| 576 ParityCheckDisabledReadTwiceBytesReadTwoAndOne) { | |
| 577 char buffer[30]; | |
| 578 int buffer_len = 2; | |
| 579 initialize(ErrorDetectState::NO_ERROR, false, "", 0); | |
| 580 | |
| 581 int bytes_read = 2; | |
| 582 memcpy(buffer, "\377\0", bytes_read); | |
| 583 test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::MARK_0_SEEN, | |
| 584 "\377\0", 2, "", 0, false, false); | |
| 585 | |
| 586 bytes_read = 1; | |
| 587 memcpy(buffer, "a", bytes_read); | |
| 588 test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "a", | |
| 589 1, "\377\0", 2, false, false); | |
| 590 } | |
| 591 | |
| 592 // '\377' '\0' | |
| 593 // 'a' 'b' | |
| 594 TEST_F(SerialIoHandlerPosixTest, | |
| 595 ParityCheckDisabledReadTwiceBytesReadTwoAndOneHasBytesAfter) { | |
| 596 char buffer[30]; | |
| 597 int buffer_len = 2; | |
| 598 initialize(ErrorDetectState::NO_ERROR, false, "", 0); | |
| 599 | |
| 600 int bytes_read = 2; | |
| 601 memcpy(buffer, "\377\0", bytes_read); | |
| 602 test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::MARK_0_SEEN, | |
| 603 "\377\0", 2, "", 0, false, false); | |
| 604 | |
| 605 bytes_read = 2; | |
| 606 memcpy(buffer, "ab", bytes_read); | |
| 607 test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "ab", | |
| 608 2, "\377\0", 2, false, false); | |
| 609 } | |
| 610 | |
| 611 // '\377' '\0' | |
| 612 // 'a' | |
| 613 TEST_F(SerialIoHandlerPosixTest, | |
| 614 ParityCheckDisabledReadTwiceBytesReadTwoAndOneLargerBufferLen) { | |
| 615 char buffer[30]; | |
| 616 for (int buffer_len = 3; buffer_len <= 20; ++buffer_len) { | |
| 617 initialize(ErrorDetectState::NO_ERROR, false, "", 0); | |
| 618 | |
| 619 int bytes_read = 2; | |
| 620 memcpy(buffer, "\377\0", bytes_read); | |
| 621 test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::MARK_0_SEEN, | |
| 622 "\377\0", 2, "", 0, false, false); | |
| 623 | |
| 624 bytes_read = 1; | |
| 625 memcpy(buffer, "a", bytes_read); | |
| 626 test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "", | |
| 627 0, "\377\000a", 3, false, false); | |
| 628 } | |
| 629 } | |
| 630 | |
| 631 // 'b' '\377' '\0' | |
| 632 // 'a' 'c' | |
| 633 TEST_F( | |
| 634 SerialIoHandlerPosixTest, | |
| 635 ParityCheckDisabledReadTwiceBytesReadTwoAndOneBufferLenThreeHasBytesBeforeAn dAfter) { | |
| 636 char buffer[30]; | |
| 637 int buffer_len = 3; | |
| 638 initialize(ErrorDetectState::NO_ERROR, false, "", 0); | |
| 639 | |
| 640 int bytes_read = 3; | |
| 641 memcpy(buffer, "b\377\0", bytes_read); | |
| 642 test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::MARK_0_SEEN, | |
| 643 "\377\0", 2, "b", 1, false, false); | |
| 644 | |
| 645 bytes_read = 2; | |
| 646 memcpy(buffer, "ac", bytes_read); | |
| 647 test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "c", | |
| 648 1, "\377\000a", 3, false, false); | |
| 649 } | |
| 650 | |
| 651 // 'b' '\377' '\0' | |
| 652 // 'a' 'c' | |
| 653 TEST_F( | |
| 654 SerialIoHandlerPosixTest, | |
| 655 ParityCheckDisabledReadTwiceBytesReadTwoAndOneLargerBufferLenHasBytesBeforeA ndAfter) { | |
| 656 char buffer[30]; | |
| 657 for (int buffer_len = 4; buffer_len <= 20; ++buffer_len) { | |
| 658 initialize(ErrorDetectState::NO_ERROR, false, "", 0); | |
| 659 | |
| 660 int bytes_read = 3; | |
| 661 memcpy(buffer, "b\377\0", bytes_read); | |
| 662 test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::MARK_0_SEEN, | |
| 663 "\377\0", 2, "b", 1, false, false); | |
| 664 | |
| 665 bytes_read = 2; | |
| 666 memcpy(buffer, "ac", bytes_read); | |
| 667 test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "", | |
| 668 0, "\377\000ac", 4, false, false); | |
| 669 } | |
| 670 } | |
| 671 | |
| 672 // '\377' | |
| 673 // '\0' 'a' | |
| 674 TEST_F(SerialIoHandlerPosixTest, | |
| 675 ParityCheckDisabledReadTwiceBytesReadOneAndTwo) { | |
| 676 char buffer[30]; | |
| 677 int buffer_len = 2; | |
| 678 initialize(ErrorDetectState::NO_ERROR, false, "", 0); | |
| 679 | |
| 680 int bytes_read = 1; | |
| 681 memcpy(buffer, "\377", bytes_read); | |
| 682 test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::MARK_377_SEEN, | |
| 683 "\377", 1, "", 0, false, false); | |
| 684 | |
| 685 bytes_read = 2; | |
| 686 memcpy(buffer, "\000a", bytes_read); | |
| 687 test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "a", | |
| 688 1, "\377\0", 2, false, false); | |
| 689 } | |
| 690 | |
| 691 // 'b' '\377' | |
| 692 // '\0' 'a' | |
| 693 TEST_F(SerialIoHandlerPosixTest, | |
| 694 ParityCheckDisabledReadTwiceBytesReadOneAndTwoHasBytesBefore) { | |
| 695 char buffer[30]; | |
| 696 int buffer_len = 2; | |
| 697 initialize(ErrorDetectState::NO_ERROR, false, "", 0); | |
| 698 | |
| 699 int bytes_read = 2; | |
| 700 memcpy(buffer, "b\377", bytes_read); | |
| 701 test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::MARK_377_SEEN, | |
| 702 "\377", 1, "b", 1, false, false); | |
| 703 | |
| 704 bytes_read = 2; | |
| 705 memcpy(buffer, "\000a", bytes_read); | |
| 706 test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "a", | |
| 707 1, "\377\0", 2, false, false); | |
| 708 } | |
| 709 | |
| 710 // '\377' | |
| 711 // '\0' 'a' | |
| 712 TEST_F(SerialIoHandlerPosixTest, | |
| 713 ParityCheckDisabledReadTwiceBytesReadOneAndTwoLargerBufferLen) { | |
| 714 char buffer[30]; | |
| 715 for (int buffer_len = 3; buffer_len <= 20; ++buffer_len) { | |
| 716 initialize(ErrorDetectState::NO_ERROR, false, "", 0); | |
| 717 | |
| 718 int bytes_read = 1; | |
| 719 memcpy(buffer, "\377", bytes_read); | |
| 720 test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::MARK_377_SEEN, | |
| 721 "\377", 1, "", 0, false, false); | |
| 722 | |
| 723 bytes_read = 2; | |
| 724 memcpy(buffer, "\000a", bytes_read); | |
| 725 test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "", | |
| 726 0, "\377\000a", 3, false, false); | |
| 727 } | |
| 728 } | |
| 729 | |
| 730 // 'b' '\377' | |
| 731 // '\0' 'a' 'c' | |
| 732 TEST_F( | |
| 733 SerialIoHandlerPosixTest, | |
| 734 ParityCheckDisabledReadTwiceBytesReadOneAndTwoBufferLenThreeHasBytesBeforeAn dAfter) { | |
| 735 char buffer[30]; | |
| 736 int buffer_len = 3; | |
| 737 | |
| 738 initialize(ErrorDetectState::NO_ERROR, false, "", 0); | |
| 739 | |
| 740 int bytes_read = 2; | |
| 741 memcpy(buffer, "b\377", bytes_read); | |
| 742 test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::MARK_377_SEEN, | |
| 743 "\377", 1, "b", 1, false, false); | |
| 744 | |
| 745 bytes_read = 3; | |
| 746 memcpy(buffer, "\000ac", bytes_read); | |
| 747 test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "c", | |
| 748 1, "\377\000a", 3, false, false); | |
| 749 } | |
| 750 | |
| 751 // 'b' '\377' | |
| 752 // '\0' 'a' 'c' | |
| 753 TEST_F( | |
| 754 SerialIoHandlerPosixTest, | |
| 755 ParityCheckDisabledReadTwiceBytesReadOneAndTwoLargerBufferLenHasBytesBeforeA ndAfter) { | |
| 756 char buffer[30]; | |
| 757 for (int buffer_len = 4; buffer_len <= 20; ++buffer_len) { | |
| 758 initialize(ErrorDetectState::NO_ERROR, false, "", 0); | |
| 759 | |
| 760 int bytes_read = 2; | |
| 761 memcpy(buffer, "b\377", bytes_read); | |
| 762 test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::MARK_377_SEEN, | |
| 763 "\377", 1, "b", 1, false, false); | |
| 764 | |
| 765 bytes_read = 3; | |
| 766 memcpy(buffer, "\000ac", bytes_read); | |
| 767 test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "", | |
| 768 0, "\377\000ac", 4, false, false); | |
| 769 } | |
| 770 } | |
| 771 | |
| 772 // '\377' | |
| 773 // '\0' | |
| 774 // 'a' | |
| 775 TEST_F(SerialIoHandlerPosixTest, | |
| 776 ParityCheckDisabledReadThreeTimesBufferLenOne) { | |
| 777 char buffer[30]; | |
| 778 int buffer_len = 1; | |
| 779 | |
| 780 initialize(ErrorDetectState::NO_ERROR, false, "", 0); | |
| 781 | |
| 782 int bytes_read = 1; | |
| 783 memcpy(buffer, "\377", bytes_read); | |
| 784 test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::MARK_377_SEEN, | |
| 785 "\377", 1, "", 0, false, false); | |
| 786 | |
| 787 bytes_read = 1; | |
| 788 memcpy(buffer, "\0", bytes_read); | |
| 789 test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::MARK_0_SEEN, | |
| 790 "\377\0", 2, "", 0, false, false); | |
| 791 | |
| 792 bytes_read = 1; | |
| 793 memcpy(buffer, "a", bytes_read); | |
| 794 test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, | |
| 795 "\000a", 2, "\377", 1, false, false); | |
| 796 } | |
| 797 | |
| 798 // '\377' | |
| 799 // '\0' | |
| 800 // 'a' | |
| 801 TEST_F(SerialIoHandlerPosixTest, | |
| 802 ParityCheckDisabledReadThreeTimesBufferLenTwo) { | |
| 803 char buffer[30]; | |
| 804 int buffer_len = 2; | |
| 805 | |
| 806 initialize(ErrorDetectState::NO_ERROR, false, "", 0); | |
| 807 | |
| 808 int bytes_read = 1; | |
| 809 memcpy(buffer, "\377", bytes_read); | |
| 810 test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::MARK_377_SEEN, | |
| 811 "\377", 1, "", 0, false, false); | |
| 812 | |
| 813 bytes_read = 1; | |
| 814 memcpy(buffer, "\0", bytes_read); | |
| 815 test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::MARK_0_SEEN, | |
| 816 "\377\0", 2, "", 0, false, false); | |
| 817 | |
| 818 bytes_read = 1; | |
| 819 memcpy(buffer, "a", bytes_read); | |
| 820 test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "a", | |
| 821 1, "\377\0", 2, false, false); | |
| 822 } | |
| 823 | |
| 824 // '\377' | |
| 825 // '\0' | |
| 826 // 'a' | |
| 827 TEST_F(SerialIoHandlerPosixTest, | |
| 828 ParityCheckDisabledReadThreeTimesLargerBufferLen) { | |
| 829 char buffer[30]; | |
| 830 for (int buffer_len = 3; buffer_len <= 20; ++buffer_len) { | |
| 831 initialize(ErrorDetectState::NO_ERROR, false, "", 0); | |
| 832 | |
| 833 int bytes_read = 1; | |
| 834 memcpy(buffer, "\377", bytes_read); | |
| 835 test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::MARK_377_SEEN, | |
| 836 "\377", 1, "", 0, false, false); | |
| 837 | |
| 838 bytes_read = 1; | |
| 839 memcpy(buffer, "\0", bytes_read); | |
| 840 test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::MARK_0_SEEN, | |
| 841 "\377\0", 2, "", 0, false, false); | |
| 842 | |
| 843 bytes_read = 1; | |
| 844 memcpy(buffer, "a", bytes_read); | |
| 845 test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "", | |
| 846 0, "\377\000a", 3, false, false); | |
| 847 } | |
| 848 } | |
| 849 | |
| 850 // 'b' '\377' | |
| 851 // '\0' | |
| 852 // 'a' 'c' | |
| 853 TEST_F(SerialIoHandlerPosixTest, | |
| 854 ParityCheckDisabledReadThreeTimesBufferLenThreeByteBeforeAndAfter) { | |
| 855 char buffer[30]; | |
| 856 int buffer_len = 3; | |
| 857 initialize(ErrorDetectState::NO_ERROR, false, "", 0); | |
| 858 | |
| 859 int bytes_read = 2; | |
| 860 memcpy(buffer, "b\377", bytes_read); | |
| 861 test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::MARK_377_SEEN, | |
| 862 "\377", 1, "b", 1, false, false); | |
| 863 | |
| 864 bytes_read = 1; | |
| 865 memcpy(buffer, "\0", bytes_read); | |
| 866 test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::MARK_0_SEEN, | |
| 867 "\377\0", 2, "", 0, false, false); | |
| 868 | |
| 869 bytes_read = 2; | |
| 870 memcpy(buffer, "ac", bytes_read); | |
| 871 test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "c", | |
| 872 1, "\377\000a", 3, false, false); | |
| 873 } | |
| 874 | |
| 875 // 'b' '\377' | |
| 876 // '\0' | |
| 877 // 'a' 'c' | |
| 878 TEST_F(SerialIoHandlerPosixTest, | |
| 879 ParityCheckDisabledReadThreeTimesLargerBufferLenHasBytesBeforeAndAfter) { | |
| 880 char buffer[30]; | |
| 881 for (int buffer_len = 4; buffer_len <= 20; ++buffer_len) { | |
| 882 initialize(ErrorDetectState::NO_ERROR, false, "", 0); | |
| 883 | |
| 884 int bytes_read = 2; | |
| 885 memcpy(buffer, "b\377", bytes_read); | |
| 886 test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::MARK_377_SEEN, | |
| 887 "\377", 1, "b", 1, false, false); | |
| 888 | |
| 889 bytes_read = 1; | |
| 890 memcpy(buffer, "\0", bytes_read); | |
| 891 test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::MARK_0_SEEN, | |
| 892 "\377\0", 2, "", 0, false, false); | |
| 893 | |
| 894 bytes_read = 2; | |
| 895 memcpy(buffer, "ac", bytes_read); | |
| 896 test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "", | |
| 897 0, "\377\000ac", 4, false, false); | |
| 898 } | |
| 899 } | |
| 900 | |
| 901 TEST_F(SerialIoHandlerPosixTest, BytesReadZero) { | |
| 902 char buffer[30]; | |
| 903 for (int buffer_len = 1; buffer_len <= 20; ++buffer_len) { | |
| 904 initialize(ErrorDetectState::NO_ERROR, true, "", 0); | |
| 905 | |
| 906 int bytes_read = 0; | |
| 907 test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "", | |
| 908 0, "", 0, false, false); | |
| 909 } | |
| 910 } | |
| 911 | |
| 912 // '\377' 'a' 'b' | |
| 913 TEST_F(SerialIoHandlerPosixTest, InvalidSequenceReadOnce) { | |
| 914 char buffer[30]; | |
| 915 for (int buffer_len = 3; buffer_len <= 20; ++buffer_len) { | |
| 916 initialize(ErrorDetectState::NO_ERROR, true, "", 0); | |
| 917 | |
| 918 int bytes_read = 3; | |
| 919 memcpy(buffer, "\377ab", bytes_read); | |
| 920 test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "", | |
| 921 0, "\377ab", 3, false, false); | |
| 922 } | |
| 923 } | |
| 924 | |
| 925 // '\377' 'a' | |
| 926 // 'b' | |
| 927 TEST_F(SerialIoHandlerPosixTest, InvalidSequenceReadTwiceBytesReadTwoAndOne) { | |
| 928 char buffer[30]; | |
| 929 for (int buffer_len = 2; buffer_len <= 20; ++buffer_len) { | |
| 930 initialize(ErrorDetectState::NO_ERROR, true, "", 0); | |
| 931 | |
| 932 int bytes_read = 2; | |
| 933 memcpy(buffer, "\377a", bytes_read); | |
| 934 test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "", | |
| 935 0, "\377a", 2, false, false); | |
| 936 | |
| 937 bytes_read = 1; | |
| 938 memcpy(buffer, "b", bytes_read); | |
| 939 test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "", | |
| 940 0, "b", 1, false, false); | |
| 941 } | |
| 942 } | |
| 943 | |
| 944 // '\377' | |
| 945 // 'a' 'b' | |
| 946 TEST_F(SerialIoHandlerPosixTest, InvalidSequenceReadTwiceBytesReadOneAndTwo) { | |
| 947 char buffer[30]; | |
| 948 int buffer_len = 2; | |
| 949 initialize(ErrorDetectState::NO_ERROR, true, "", 0); | |
| 950 | |
| 951 int bytes_read = 1; | |
| 952 memcpy(buffer, "\377", bytes_read); | |
| 953 test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::MARK_377_SEEN, | |
| 954 "\377", 1, "", 0, false, false); | |
| 955 | |
| 956 bytes_read = 2; | |
| 957 memcpy(buffer, "ab", bytes_read); | |
| 958 test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "b", | |
| 959 1, "\377a", 2, false, false); | |
| 960 } | |
| 961 | |
| 962 // '\377' | |
| 963 // 'a' 'b' | |
| 964 TEST_F(SerialIoHandlerPosixTest, | |
| 965 InvalidSequenceReadTwiceBytesReadOneAndTwoLargerBufferLen) { | |
| 966 char buffer[30]; | |
| 967 for (int buffer_len = 3; buffer_len <= 20; ++buffer_len) { | |
| 968 initialize(ErrorDetectState::NO_ERROR, true, "", 0); | |
| 969 | |
| 970 int bytes_read = 1; | |
| 971 memcpy(buffer, "\377", bytes_read); | |
| 972 test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::MARK_377_SEEN, | |
| 973 "\377", 1, "", 0, false, false); | |
| 974 | |
| 975 bytes_read = 2; | |
| 976 memcpy(buffer, "ab", bytes_read); | |
| 977 test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "", | |
| 978 0, "\377ab", 3, false, false); | |
| 979 } | |
| 980 } | |
| 981 | |
| 982 // '\377' | |
| 983 // 'a' | |
| 984 // 'b' | |
| 985 TEST_F(SerialIoHandlerPosixTest, InvalidSequenceReadThreeTimes) { | |
| 986 char buffer[30]; | |
| 987 int buffer_len = 1; | |
| 988 initialize(ErrorDetectState::NO_ERROR, true, "", 0); | |
| 989 | |
| 990 int bytes_read = 1; | |
| 991 memcpy(buffer, "\377", bytes_read); | |
| 992 test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::MARK_377_SEEN, | |
| 993 "\377", 1, "", 0, false, false); | |
| 994 | |
| 995 bytes_read = 1; | |
| 996 memcpy(buffer, "a", bytes_read); | |
| 997 test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "a", | |
| 998 1, "\377", 1, false, false); | |
| 999 | |
| 1000 bytes_read = 1; | |
| 1001 memcpy(buffer, "b", bytes_read); | |
| 1002 test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "b", | |
| 1003 1, "a", 1, false, false); | |
| 1004 } | |
| 1005 | |
| 1006 // '\377' | |
| 1007 // 'a' | |
| 1008 // 'b' | |
| 1009 TEST_F(SerialIoHandlerPosixTest, InvalidSequenceReadThreeTimesLargerBufferLen) { | |
| 1010 char buffer[30]; | |
| 1011 for (int buffer_len = 2; buffer_len <= 20; ++buffer_len) { | |
| 1012 initialize(ErrorDetectState::NO_ERROR, true, "", 0); | |
| 1013 | |
| 1014 int bytes_read = 1; | |
| 1015 memcpy(buffer, "\377", bytes_read); | |
| 1016 test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::MARK_377_SEEN, | |
| 1017 "\377", 1, "", 0, false, false); | |
| 1018 | |
| 1019 bytes_read = 1; | |
| 1020 memcpy(buffer, "a", bytes_read); | |
| 1021 test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "", | |
| 1022 0, "\377a", 2, false, false); | |
| 1023 | |
| 1024 bytes_read = 1; | |
| 1025 memcpy(buffer, "b", bytes_read); | |
| 1026 test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "", | |
| 1027 0, "b", 1, false, false); | |
| 1028 } | |
| 1029 } | |
| 1030 | |
| 1031 // 'a' 'b' 'c' '\377' | |
| 1032 TEST_F(SerialIoHandlerPosixTest, CharsIgnoredPreset) { | |
| 1033 char buffer[30]; | |
| 1034 int buffer_len = 2; | |
| 1035 initialize(ErrorDetectState::NO_ERROR, true, "ab", 2); | |
| 1036 | |
| 1037 int bytes_read = 2; | |
| 1038 memcpy(buffer, "c\377", bytes_read); | |
| 1039 test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::MARK_377_SEEN, | |
| 1040 "c\377", 2, "ab", 2, false, false); | |
| 1041 } | |
| 1042 | |
| 1043 // 'b' 'c' '\377' '\0' '\0' '\377' '\377' '\377' '\0' 'a' 'd' 'e' | |
| 1044 TEST_F(SerialIoHandlerPosixTest, BreakAndEOFAndParityError) { | |
| 1045 char buffer[30]; | |
| 1046 int buffer_len = 12; | |
| 1047 initialize(ErrorDetectState::NO_ERROR, true, "", 0); | |
| 1048 | |
| 1049 int bytes_read = 12; | |
| 1050 memcpy(buffer, "bc\377\0\0\377\377\377\000ade", bytes_read); | |
| 1051 test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "", 0, | |
| 1052 "bc\377de", 5, true, true); | |
| 1053 } | |
| 1054 | |
| 1055 // 'b' 'c' '\377' '\0' '\0' '\377' | |
| 1056 // '\377' '\377' '\0' | |
| 1057 // 'a' 'd' 'e' | |
| 1058 TEST_F(SerialIoHandlerPosixTest, BreakAndEOFAndParityErrorReadThreeTimes) { | |
| 1059 char buffer[30]; | |
| 1060 for (int buffer_len = 6; buffer_len <= 20; ++buffer_len) { | |
| 1061 initialize(ErrorDetectState::NO_ERROR, true, "", 0); | |
| 1062 | |
| 1063 int bytes_read = 6; | |
| 1064 memcpy(buffer, "bc\377\0\0\377", bytes_read); | |
| 1065 test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::MARK_377_SEEN, | |
| 1066 "\377", 1, "bc", 2, true, false); | |
| 1067 | |
| 1068 bytes_read = 3; | |
| 1069 memcpy(buffer, "\377\377\0", bytes_read); | |
| 1070 test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::MARK_0_SEEN, | |
| 1071 "\377\0", 2, "\377", 1, false, false); | |
| 1072 | |
| 1073 bytes_read = 3; | |
| 1074 memcpy(buffer, "ade", bytes_read); | |
| 1075 test_helper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "", | |
| 1076 0, "de", 2, false, true); | |
| 1077 } | |
| 1078 } | |
| 1079 | |
| 1080 } // namespace device | |
| OLD | NEW |
