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