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