Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(299)

Issues Search
    My Issues | Starred     Open | Closed | All

Side by Side Diff: device/serial/serial_io_handler_posix_unittest.cc

Issue 1249933004: Add code to detect new added ReceiveError on Linux (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@master
Patch Set: added more test code. Created 5 years, 4 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
« device/serial/serial_io_handler_posix.h ('K') | « device/serial/serial_io_handler_posix.cc ('k') | no next file » | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
(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 int call_CheckReceiveError(char* buffer,
Reilly Grant (use Gerrit) 2015/07/29 17:34:18 Don't mix underscores and camel-case in function n
juncai 2015/07/29 23:29:36 Done.
19 int buffer_len,
20 int bytes_read,
21 bool& break_detected,
22 bool& parity_error_detected) {
23 return serial_io_handler_posix_->CheckReceiveError(
24 buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
25 }
26
27 void set_error_detect_state(ErrorDetectState state) {
28 serial_io_handler_posix_->error_detect_state_ = state;
29 }
30
31 ErrorDetectState get_error_detect_state() {
32 return serial_io_handler_posix_->error_detect_state_;
33 }
34
35 void set_parity_check_enabled(bool enabled) {
36 serial_io_handler_posix_->parity_check_enabled_ = enabled;
37 }
38
39 void set_num_chars_ignored(int n) {
40 serial_io_handler_posix_->num_chars_ignored_ = n;
41 }
42
43 int get_num_chars_ignored() {
Reilly Grant (use Gerrit) 2015/07/29 17:34:18 No need to prefix getters with "get_", "num_chars_
juncai 2015/07/29 23:29:36 Done.
44 return serial_io_handler_posix_->num_chars_ignored_;
45 }
46
47 void set_chars_ignored(int index, char ch) {
48 serial_io_handler_posix_->chars_ignored_[index] = ch;
49 }
50
51 char get_chars_ignored(int index) {
52 return serial_io_handler_posix_->chars_ignored_[index];
53 }
54
55 protected:
56 scoped_refptr<SerialIoHandlerPosix> serial_io_handler_posix_;
57
58 private:
59 DISALLOW_COPY_AND_ASSIGN(SerialIoHandlerPosixTest);
60 };
61
62 // 'a' 'b' 'c'
63 TEST_F(SerialIoHandlerPosixTest, NoErrorReadOnce) {
64 for (int buffer_len = 3; buffer_len <= 20; ++buffer_len) {
65 set_error_detect_state(NO_ERROR);
66 set_parity_check_enabled(true);
67 set_num_chars_ignored(0);
68 char buffer[buffer_len];
69
70 buffer[0] = 'a';
Reilly Grant (use Gerrit) 2015/07/29 17:34:18 This would be more readable if you built the buffe
juncai 2015/07/29 23:29:36 Done.
71 buffer[1] = 'b';
72 buffer[2] = 'c';
73 int bytes_read = 3;
74 bool break_detected = false;
75 bool parity_error_detected = false;
76 int new_bytes_read = call_CheckReceiveError(
77 buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
78 EXPECT_EQ(NO_ERROR, get_error_detect_state());
79 EXPECT_EQ(0, get_num_chars_ignored());
80 EXPECT_EQ(3, new_bytes_read);
81 EXPECT_EQ('a', buffer[0]);
82 EXPECT_EQ('b', buffer[1]);
83 EXPECT_EQ('c', buffer[2]);
84 EXPECT_EQ(break_detected, false);
85 EXPECT_EQ(parity_error_detected, false);
86 }
87 }
88
89 // 'a' 'b'
90 // 'c'
91 TEST_F(SerialIoHandlerPosixTest, NoErrorReadTwiceBytesReadTwoAndOne) {
92 for (int buffer_len = 2; buffer_len <= 20; ++buffer_len) {
93 set_error_detect_state(NO_ERROR);
94 set_parity_check_enabled(true);
95 set_num_chars_ignored(0);
96 char buffer[buffer_len];
97
98 buffer[0] = 'a';
99 buffer[1] = 'b';
100 int bytes_read = 2;
101 bool break_detected = false;
102 bool parity_error_detected = false;
103 int new_bytes_read = call_CheckReceiveError(
104 buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
105 EXPECT_EQ(NO_ERROR, get_error_detect_state());
106 EXPECT_EQ(0, get_num_chars_ignored());
107 EXPECT_EQ(bytes_read, new_bytes_read);
108 EXPECT_EQ('a', buffer[0]);
109 EXPECT_EQ('b', buffer[1]);
110 EXPECT_EQ(break_detected, false);
111 EXPECT_EQ(parity_error_detected, false);
112
113 buffer[0] = 'c';
114 bytes_read = 1;
115 break_detected = false;
116 parity_error_detected = false;
117 new_bytes_read = call_CheckReceiveError(
118 buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
119 EXPECT_EQ(NO_ERROR, get_error_detect_state());
120 EXPECT_EQ(0, get_num_chars_ignored());
121 EXPECT_EQ(1, new_bytes_read);
122 EXPECT_EQ('c', buffer[0]);
123 EXPECT_EQ(break_detected, false);
124 EXPECT_EQ(parity_error_detected, false);
125 }
126 }
127
128 // 'a'
129 // 'b' c'
130 TEST_F(SerialIoHandlerPosixTest, NoErrorReadTwiceBytesReadOneAndTwo) {
131 for (int buffer_len = 2; buffer_len <= 20; ++buffer_len) {
132 set_error_detect_state(NO_ERROR);
133 set_parity_check_enabled(true);
134 set_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 = call_CheckReceiveError(
142 buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
143 EXPECT_EQ(NO_ERROR, get_error_detect_state());
144 EXPECT_EQ(0, get_num_chars_ignored());
145 EXPECT_EQ(bytes_read, 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 buffer[1] = 'c';
152 bytes_read = 2;
153 break_detected = false;
154 parity_error_detected = false;
155 new_bytes_read = call_CheckReceiveError(
156 buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
157 EXPECT_EQ(NO_ERROR, get_error_detect_state());
158 EXPECT_EQ(0, get_num_chars_ignored());
159 EXPECT_EQ(2, new_bytes_read);
160 EXPECT_EQ('b', buffer[0]);
161 EXPECT_EQ('c', buffer[1]);
162 EXPECT_EQ(break_detected, false);
163 EXPECT_EQ(parity_error_detected, false);
164 }
165 }
166
167 // 'a'
168 // 'b'
169 // 'c'
170 TEST_F(SerialIoHandlerPosixTest, NoErrorReadThreeTimes) {
171 for (int buffer_len = 1; buffer_len <= 20; ++buffer_len) {
172 set_error_detect_state(NO_ERROR);
173 set_parity_check_enabled(true);
174 set_num_chars_ignored(0);
175 char buffer[buffer_len];
176
177 buffer[0] = 'a';
178 int bytes_read = 1;
179 bool break_detected = false;
180 bool parity_error_detected = false;
181 int new_bytes_read = call_CheckReceiveError(
182 buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
183 EXPECT_EQ(NO_ERROR, get_error_detect_state());
184 EXPECT_EQ(0, get_num_chars_ignored());
185 EXPECT_EQ(1, new_bytes_read);
186 EXPECT_EQ('a', buffer[0]);
187 EXPECT_EQ(break_detected, false);
188 EXPECT_EQ(parity_error_detected, false);
189
190 buffer[0] = 'b';
191 bytes_read = 1;
192 break_detected = false;
193 parity_error_detected = false;
194 new_bytes_read = call_CheckReceiveError(
195 buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
196 EXPECT_EQ(NO_ERROR, get_error_detect_state());
197 EXPECT_EQ(0, get_num_chars_ignored());
198 EXPECT_EQ(1, new_bytes_read);
199 EXPECT_EQ('b', buffer[0]);
200 EXPECT_EQ(break_detected, false);
201 EXPECT_EQ(parity_error_detected, false);
202
203 buffer[0] = 'c';
204 bytes_read = 1;
205 break_detected = false;
206 parity_error_detected = false;
207 new_bytes_read = call_CheckReceiveError(
208 buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
209 EXPECT_EQ(NO_ERROR, get_error_detect_state());
210 EXPECT_EQ(0, get_num_chars_ignored());
211 EXPECT_EQ(1, new_bytes_read);
212 EXPECT_EQ('c', buffer[0]);
213 EXPECT_EQ(break_detected, false);
214 EXPECT_EQ(parity_error_detected, false);
215 }
216 }
217
218 // '\377' '\0' '\0'
219 TEST_F(SerialIoHandlerPosixTest, BreakReadOnce) {
220 for (int buffer_len = 3; buffer_len <= 20; ++buffer_len) {
221 set_error_detect_state(NO_ERROR);
222 set_parity_check_enabled(true);
223 set_num_chars_ignored(0);
224 char buffer[buffer_len];
225
226 buffer[0] = '\377';
227 buffer[1] = '\0';
228 buffer[2] = '\0';
229 int bytes_read = 3;
230 bool break_detected = false;
231 bool parity_error_detected = false;
232 int new_bytes_read = call_CheckReceiveError(
233 buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
234 EXPECT_EQ(NO_ERROR, get_error_detect_state());
235 EXPECT_EQ(0, get_num_chars_ignored());
236 EXPECT_EQ(0, new_bytes_read);
237 EXPECT_EQ(break_detected, true);
238 EXPECT_EQ(parity_error_detected, false);
239 }
240 }
241
242 // 'a' 'b' '\377' '\0' '\0' 'c' 'd' 'e'
243 TEST_F(SerialIoHandlerPosixTest, BreakReadOnceHasBytesBeforeAndAfterBreak) {
244 for (int buffer_len = 8; buffer_len <= 20; ++buffer_len) {
245 set_error_detect_state(NO_ERROR);
246 set_parity_check_enabled(true);
247 set_num_chars_ignored(0);
248 char buffer[buffer_len];
249
250 buffer[0] = 'a';
251 buffer[1] = 'b';
252 buffer[2] = '\377';
253 buffer[3] = '\0';
254 buffer[4] = '\0';
255 buffer[5] = 'c';
256 buffer[6] = 'd';
257 buffer[7] = 'e';
258 int bytes_read = 8;
259 bool break_detected = false;
260 bool parity_error_detected = false;
261 int new_bytes_read = call_CheckReceiveError(
262 buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
263 EXPECT_EQ(NO_ERROR, get_error_detect_state());
264 EXPECT_EQ(0, get_num_chars_ignored());
265 EXPECT_EQ(5, new_bytes_read);
266 EXPECT_EQ('a', buffer[0]);
267 EXPECT_EQ('b', buffer[1]);
268 EXPECT_EQ('c', buffer[2]);
269 EXPECT_EQ('d', buffer[3]);
270 EXPECT_EQ('e', buffer[4]);
271 EXPECT_EQ(break_detected, true);
272 EXPECT_EQ(parity_error_detected, false);
273 }
274 }
275
276 // '\377' '\0'
277 // '\0'
278 TEST_F(SerialIoHandlerPosixTest, BreakReadTwiceBytesReadTwoAndOne) {
279 for (int buffer_len = 2; buffer_len <= 20; ++buffer_len) {
280 set_error_detect_state(NO_ERROR);
281 set_parity_check_enabled(true);
282 set_num_chars_ignored(0);
283 char buffer[buffer_len];
284
285 buffer[0] = '\377';
286 buffer[1] = '\0';
287 int bytes_read = 2;
288 bool break_detected = false;
289 bool parity_error_detected = false;
290 int new_bytes_read = call_CheckReceiveError(
291 buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
292 EXPECT_EQ(MARK_0_SEEN, get_error_detect_state());
293 EXPECT_EQ(2, get_num_chars_ignored());
294 EXPECT_EQ('\377', get_chars_ignored(0));
295 EXPECT_EQ('\0', get_chars_ignored(1));
296 EXPECT_EQ(0, new_bytes_read);
297 EXPECT_EQ(break_detected, false);
298 EXPECT_EQ(parity_error_detected, false);
299
300 buffer[0] = '\0';
301 bytes_read = 1;
302 break_detected = false;
303 parity_error_detected = false;
304 new_bytes_read = call_CheckReceiveError(
305 buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
306 EXPECT_EQ(NO_ERROR, get_error_detect_state());
307 EXPECT_EQ(0, get_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 // 'a' 'b' 'c' \377' '\0'
315 // '\0' 'd' 'e'
316 TEST_F(SerialIoHandlerPosixTest,
317 BreakReadTwiceBytesReadTwoAndOneHasBytesBeforeAndAfterBreak) {
318 for (int buffer_len = 5; buffer_len <= 20; ++buffer_len) {
319 set_error_detect_state(NO_ERROR);
320 set_parity_check_enabled(true);
321 set_num_chars_ignored(0);
322 char buffer[buffer_len];
323
324 buffer[0] = 'a';
325 buffer[1] = 'b';
326 buffer[2] = 'c';
327 buffer[3] = '\377';
328 buffer[4] = '\0';
329 int bytes_read = 5;
330 bool break_detected = false;
331 bool parity_error_detected = false;
332 int new_bytes_read = call_CheckReceiveError(
333 buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
334 EXPECT_EQ(MARK_0_SEEN, get_error_detect_state());
335 EXPECT_EQ(2, get_num_chars_ignored());
336 EXPECT_EQ('\377', get_chars_ignored(0));
337 EXPECT_EQ('\0', get_chars_ignored(1));
338 EXPECT_EQ(3, new_bytes_read);
339 EXPECT_EQ('a', buffer[0]);
340 EXPECT_EQ('b', buffer[1]);
341 EXPECT_EQ('c', buffer[2]);
342 EXPECT_EQ(break_detected, false);
343 EXPECT_EQ(parity_error_detected, false);
344
345 buffer[0] = '\0';
346 buffer[1] = 'd';
347 buffer[2] = 'e';
348 bytes_read = 3;
349 break_detected = false;
350 parity_error_detected = false;
351 new_bytes_read = call_CheckReceiveError(
352 buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
353 EXPECT_EQ(NO_ERROR, get_error_detect_state());
354 EXPECT_EQ(0, get_num_chars_ignored());
355 EXPECT_EQ(2, new_bytes_read);
356 EXPECT_EQ('d', buffer[0]);
357 EXPECT_EQ('e', buffer[1]);
358 EXPECT_EQ(break_detected, true);
359 EXPECT_EQ(parity_error_detected, false);
360 }
361 }
362
363 // '\377'
364 // '\0' '\0'
365 TEST_F(SerialIoHandlerPosixTest, BreakReadTwiceBytesReadOneAndTwo) {
366 for (int buffer_len = 2; buffer_len <= 20; ++buffer_len) {
367 set_error_detect_state(NO_ERROR);
368 set_parity_check_enabled(true);
369 set_num_chars_ignored(0);
370 char buffer[buffer_len];
371
372 buffer[0] = '\377';
373 int bytes_read = 1;
374 bool break_detected = false;
375 bool parity_error_detected = false;
376 int new_bytes_read = call_CheckReceiveError(
377 buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
378 EXPECT_EQ(MARK_377_SEEN, get_error_detect_state());
379 EXPECT_EQ(1, get_num_chars_ignored());
380 EXPECT_EQ('\377', get_chars_ignored(0));
381 EXPECT_EQ(0, new_bytes_read);
382 EXPECT_EQ(break_detected, false);
383 EXPECT_EQ(parity_error_detected, false);
384
385 buffer[0] = '\0';
386 buffer[1] = '\0';
387 bytes_read = 2;
388 break_detected = false;
389 parity_error_detected = false;
390 new_bytes_read = call_CheckReceiveError(
391 buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
392 EXPECT_EQ(NO_ERROR, get_error_detect_state());
393 EXPECT_EQ(0, get_num_chars_ignored());
394 EXPECT_EQ(0, new_bytes_read);
395 EXPECT_EQ(break_detected, true);
396 EXPECT_EQ(parity_error_detected, false);
397 }
398 }
399
400 // 'a' 'b' \377'
401 // '\0' '\0' 'c'
402 TEST_F(SerialIoHandlerPosixTest,
403 BreakReadTwiceBytesReadOneAndTwoHasBytesBeforeAndAfterBreak) {
404 for (int buffer_len = 3; buffer_len <= 20; ++buffer_len) {
405 set_error_detect_state(NO_ERROR);
406 set_parity_check_enabled(true);
407 set_num_chars_ignored(0);
408 char buffer[buffer_len];
409
410 buffer[0] = 'a';
411 buffer[1] = 'b';
412 buffer[2] = '\377';
413 int bytes_read = 3;
414 bool break_detected = false;
415 bool parity_error_detected = false;
416 int new_bytes_read = call_CheckReceiveError(
417 buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
418 EXPECT_EQ(MARK_377_SEEN, get_error_detect_state());
419 EXPECT_EQ(1, get_num_chars_ignored());
420 EXPECT_EQ('\377', get_chars_ignored(0));
421 EXPECT_EQ(2, new_bytes_read);
422 EXPECT_EQ('a', buffer[0]);
423 EXPECT_EQ('b', buffer[1]);
424 EXPECT_EQ(break_detected, false);
425 EXPECT_EQ(parity_error_detected, false);
426
427 buffer[0] = '\0';
428 buffer[1] = '\0';
429 buffer[2] = 'c';
430 bytes_read = 3;
431 break_detected = false;
432 parity_error_detected = false;
433 new_bytes_read = call_CheckReceiveError(
434 buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
435 EXPECT_EQ(NO_ERROR, get_error_detect_state());
436 EXPECT_EQ(0, get_num_chars_ignored());
437 EXPECT_EQ(1, new_bytes_read);
438 EXPECT_EQ('c', buffer[0]);
439 EXPECT_EQ(break_detected, true);
440 EXPECT_EQ(parity_error_detected, false);
441 }
442 }
443
444 // '\377'
445 // '\0'
446 // '\0'
447 TEST_F(SerialIoHandlerPosixTest, BreakReadThreeTimes) {
448 for (int buffer_len = 1; buffer_len <= 20; ++buffer_len) {
449 set_error_detect_state(NO_ERROR);
450 set_parity_check_enabled(true);
451 set_num_chars_ignored(0);
452 char buffer[buffer_len];
453
454 buffer[0] = '\377';
455 int bytes_read = 1;
456 bool break_detected = false;
457 bool parity_error_detected = false;
458 int new_bytes_read = call_CheckReceiveError(
459 buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
460 EXPECT_EQ(MARK_377_SEEN, get_error_detect_state());
461 EXPECT_EQ(1, get_num_chars_ignored());
462 EXPECT_EQ('\377', get_chars_ignored(0));
463 EXPECT_EQ(0, new_bytes_read);
464 EXPECT_EQ(break_detected, false);
465 EXPECT_EQ(parity_error_detected, false);
466
467 buffer[0] = '\0';
468 bytes_read = 1;
469 break_detected = false;
470 parity_error_detected = false;
471 new_bytes_read = call_CheckReceiveError(
472 buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
473 EXPECT_EQ(MARK_0_SEEN, get_error_detect_state());
474 EXPECT_EQ(2, get_num_chars_ignored());
475 EXPECT_EQ('\377', get_chars_ignored(0));
476 EXPECT_EQ('\0', get_chars_ignored(1));
477 EXPECT_EQ(0, new_bytes_read);
478 EXPECT_EQ(break_detected, false);
479 EXPECT_EQ(parity_error_detected, false);
480
481 buffer[0] = '\0';
482 bytes_read = 1;
483 break_detected = false;
484 parity_error_detected = false;
485 new_bytes_read = call_CheckReceiveError(
486 buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
487 EXPECT_EQ(NO_ERROR, get_error_detect_state());
488 EXPECT_EQ(0, get_num_chars_ignored());
489 EXPECT_EQ(0, new_bytes_read);
490 EXPECT_EQ(break_detected, true);
491 EXPECT_EQ(parity_error_detected, false);
492 }
493 }
494
495 // 'a' \377'
496 // '\0'
497 // '\0' 'b'
498 TEST_F(SerialIoHandlerPosixTest,
499 BreakReadThreeTimesHasBytesBeforeAndAfterBreak) {
500 for (int buffer_len = 2; buffer_len <= 20; ++buffer_len) {
501 set_error_detect_state(NO_ERROR);
502 set_parity_check_enabled(true);
503 set_num_chars_ignored(0);
504 char buffer[buffer_len];
505
506 buffer[0] = 'a';
507 buffer[1] = '\377';
508 int bytes_read = 2;
509 bool break_detected = false;
510 bool parity_error_detected = false;
511 int new_bytes_read = call_CheckReceiveError(
512 buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
513 EXPECT_EQ(MARK_377_SEEN, get_error_detect_state());
514 EXPECT_EQ(1, get_num_chars_ignored());
515 EXPECT_EQ('\377', get_chars_ignored(0));
516 EXPECT_EQ(1, new_bytes_read);
517 EXPECT_EQ('a', buffer[0]);
518 EXPECT_EQ(break_detected, false);
519 EXPECT_EQ(parity_error_detected, false);
520
521 buffer[0] = '\0';
522 bytes_read = 1;
523 break_detected = false;
524 parity_error_detected = false;
525 new_bytes_read = call_CheckReceiveError(
526 buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
527 EXPECT_EQ(MARK_0_SEEN, get_error_detect_state());
528 EXPECT_EQ(2, get_num_chars_ignored());
529 EXPECT_EQ('\377', get_chars_ignored(0));
530 EXPECT_EQ('\0', get_chars_ignored(1));
531 EXPECT_EQ(0, new_bytes_read);
532 EXPECT_EQ(break_detected, false);
533 EXPECT_EQ(parity_error_detected, false);
534
535 buffer[0] = '\0';
536 buffer[1] = 'b';
537 bytes_read = 2;
538 break_detected = false;
539 parity_error_detected = false;
540 new_bytes_read = call_CheckReceiveError(
541 buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
542 EXPECT_EQ(NO_ERROR, get_error_detect_state());
543 EXPECT_EQ(0, get_num_chars_ignored());
544 EXPECT_EQ(1, new_bytes_read);
545 EXPECT_EQ('b', buffer[0]);
546 EXPECT_EQ(break_detected, true);
547 EXPECT_EQ(parity_error_detected, false);
548 }
549 }
550
551 // '\377' '\0' 'a'
552 TEST_F(SerialIoHandlerPosixTest, ParityErrorReadOnce) {
553 for (int buffer_len = 3; buffer_len <= 20; ++buffer_len) {
554 set_error_detect_state(NO_ERROR);
555 set_parity_check_enabled(true);
556 set_num_chars_ignored(0);
557 char buffer[buffer_len];
558
559 buffer[0] = '\377';
560 buffer[1] = '\0';
561 buffer[2] = 'a';
562 int bytes_read = 3;
563 bool break_detected = false;
564 bool parity_error_detected = false;
565 int new_bytes_read = call_CheckReceiveError(
566 buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
567 EXPECT_EQ(NO_ERROR, get_error_detect_state());
568 EXPECT_EQ(0, get_num_chars_ignored());
569 EXPECT_EQ(0, new_bytes_read);
570 EXPECT_EQ(break_detected, false);
571 EXPECT_EQ(parity_error_detected, true);
572 }
573 }
574
575 // 'b' 'c' \377' '\0' 'a' 'd'
576 TEST_F(SerialIoHandlerPosixTest,
577 ParityErrorReadOnceHasBytesBeforeAndAfterParityError) {
578 for (int buffer_len = 6; buffer_len <= 20; ++buffer_len) {
579 set_error_detect_state(NO_ERROR);
580 set_parity_check_enabled(true);
581 set_num_chars_ignored(0);
582 char buffer[buffer_len];
583
584 buffer[0] = 'b';
585 buffer[1] = 'c';
586 buffer[2] = '\377';
587 buffer[3] = '\0';
588 buffer[4] = 'a';
589 buffer[5] = 'd';
590 int bytes_read = 6;
591 bool break_detected = false;
592 bool parity_error_detected = false;
593 int new_bytes_read = call_CheckReceiveError(
594 buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
595 EXPECT_EQ(NO_ERROR, get_error_detect_state());
596 EXPECT_EQ(0, get_num_chars_ignored());
597 EXPECT_EQ(3, new_bytes_read);
598 EXPECT_EQ('b', buffer[0]);
599 EXPECT_EQ('c', buffer[1]);
600 EXPECT_EQ('d', buffer[2]);
601 EXPECT_EQ(break_detected, false);
602 EXPECT_EQ(parity_error_detected, true);
603 }
604 }
605
606 // '\377' '\0'
607 // 'a'
608 TEST_F(SerialIoHandlerPosixTest, ParityErrorReadTwiceBytesReadTwoAndOne) {
609 for (int buffer_len = 2; buffer_len <= 20; ++buffer_len) {
610 set_error_detect_state(NO_ERROR);
611 set_parity_check_enabled(true);
612 set_num_chars_ignored(0);
613 char buffer[buffer_len];
614
615 buffer[0] = '\377';
616 buffer[1] = '\0';
617 int bytes_read = 2;
618 bool break_detected = false;
619 bool parity_error_detected = false;
620 int new_bytes_read = call_CheckReceiveError(
621 buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
622 EXPECT_EQ(MARK_0_SEEN, get_error_detect_state());
623 EXPECT_EQ(2, get_num_chars_ignored());
624 EXPECT_EQ('\377', get_chars_ignored(0));
625 EXPECT_EQ('\0', get_chars_ignored(1));
626 EXPECT_EQ(0, new_bytes_read);
627 EXPECT_EQ(break_detected, false);
628 EXPECT_EQ(parity_error_detected, false);
629
630 buffer[0] = 'a';
631 bytes_read = 1;
632 break_detected = false;
633 parity_error_detected = false;
634 new_bytes_read = call_CheckReceiveError(
635 buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
636 EXPECT_EQ(NO_ERROR, get_error_detect_state());
637 EXPECT_EQ(0, get_num_chars_ignored());
638 EXPECT_EQ(0, new_bytes_read);
639 EXPECT_EQ(break_detected, false);
640 EXPECT_EQ(parity_error_detected, true);
641 }
642 }
643
644 // 'b' \377' '\0'
645 // 'a' 'c' 'd'
646 TEST_F(
647 SerialIoHandlerPosixTest,
648 ParityErrorReadTwiceBytesReadTwoAndOneHasBytesBeforeAndAfterParityError) {
649 for (int buffer_len = 3; buffer_len <= 20; ++buffer_len) {
650 set_error_detect_state(NO_ERROR);
651 set_parity_check_enabled(true);
652 set_num_chars_ignored(0);
653 char buffer[buffer_len];
654
655 buffer[0] = 'b';
656 buffer[1] = '\377';
657 buffer[2] = '\0';
658 int bytes_read = 3;
659 bool break_detected = false;
660 bool parity_error_detected = false;
661 int new_bytes_read = call_CheckReceiveError(
662 buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
663 EXPECT_EQ(MARK_0_SEEN, get_error_detect_state());
664 EXPECT_EQ(2, get_num_chars_ignored());
665 EXPECT_EQ('\377', get_chars_ignored(0));
666 EXPECT_EQ('\0', get_chars_ignored(1));
667 EXPECT_EQ(1, new_bytes_read);
668 EXPECT_EQ('b', buffer[0]);
669 EXPECT_EQ(break_detected, false);
670 EXPECT_EQ(parity_error_detected, false);
671
672 buffer[0] = 'a';
673 buffer[1] = 'c';
674 buffer[2] = 'd';
675 bytes_read = 3;
676 break_detected = false;
677 parity_error_detected = false;
678 new_bytes_read = call_CheckReceiveError(
679 buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
680 EXPECT_EQ(NO_ERROR, get_error_detect_state());
681 EXPECT_EQ(0, get_num_chars_ignored());
682 EXPECT_EQ(2, new_bytes_read);
683 EXPECT_EQ('c', buffer[0]);
684 EXPECT_EQ('d', buffer[1]);
685 EXPECT_EQ(break_detected, false);
686 EXPECT_EQ(parity_error_detected, true);
687 }
688 }
689
690 // '\377'
691 // '\0' 'a'
692 TEST_F(SerialIoHandlerPosixTest, ParityErrorReadTwiceBytesReadOneAndTwo) {
693 for (int buffer_len = 2; buffer_len <= 20; ++buffer_len) {
694 set_error_detect_state(NO_ERROR);
695 set_parity_check_enabled(true);
696 set_num_chars_ignored(0);
697 char buffer[buffer_len];
698
699 buffer[0] = '\377';
700 int bytes_read = 1;
701 bool break_detected = false;
702 bool parity_error_detected = false;
703 int new_bytes_read = call_CheckReceiveError(
704 buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
705 EXPECT_EQ(MARK_377_SEEN, get_error_detect_state());
706 EXPECT_EQ(1, get_num_chars_ignored());
707 EXPECT_EQ('\377', get_chars_ignored(0));
708 EXPECT_EQ(0, new_bytes_read);
709 EXPECT_EQ(break_detected, false);
710 EXPECT_EQ(parity_error_detected, false);
711
712 buffer[0] = '\0';
713 buffer[1] = 'a';
714 bytes_read = 2;
715 break_detected = false;
716 parity_error_detected = false;
717 new_bytes_read = call_CheckReceiveError(
718 buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
719 EXPECT_EQ(NO_ERROR, get_error_detect_state());
720 EXPECT_EQ(0, get_num_chars_ignored());
721 EXPECT_EQ(0, new_bytes_read);
722 EXPECT_EQ(break_detected, false);
723 EXPECT_EQ(parity_error_detected, true);
724 }
725 }
726
727 // 'b' 'c' \377'
728 // '\0' 'a' 'd'
729 TEST_F(
730 SerialIoHandlerPosixTest,
731 ParityErrorReadTwiceBytesReadOneAndTwoHasBytesBeforeAndAfterParityError) {
732 for (int buffer_len = 3; buffer_len <= 20; ++buffer_len) {
733 set_error_detect_state(NO_ERROR);
734 set_parity_check_enabled(true);
735 set_num_chars_ignored(0);
736 char buffer[buffer_len];
737
738 buffer[0] = 'b';
739 buffer[1] = 'c';
740 buffer[2] = '\377';
741 int bytes_read = 3;
742 bool break_detected = false;
743 bool parity_error_detected = false;
744 int new_bytes_read = call_CheckReceiveError(
745 buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
746 EXPECT_EQ(MARK_377_SEEN, get_error_detect_state());
747 EXPECT_EQ(1, get_num_chars_ignored());
748 EXPECT_EQ('\377', get_chars_ignored(0));
749 EXPECT_EQ(2, new_bytes_read);
750 EXPECT_EQ('b', buffer[0]);
751 EXPECT_EQ('c', buffer[1]);
752 EXPECT_EQ(break_detected, false);
753 EXPECT_EQ(parity_error_detected, false);
754
755 buffer[0] = '\0';
756 buffer[1] = 'a';
757 buffer[2] = 'd';
758 bytes_read = 3;
759 break_detected = false;
760 parity_error_detected = false;
761 new_bytes_read = call_CheckReceiveError(
762 buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
763 EXPECT_EQ(NO_ERROR, get_error_detect_state());
764 EXPECT_EQ(0, get_num_chars_ignored());
765 EXPECT_EQ(1, new_bytes_read);
766 EXPECT_EQ('d', buffer[0]);
767 EXPECT_EQ(break_detected, false);
768 EXPECT_EQ(parity_error_detected, true);
769 }
770 }
771
772 // '\377'
773 // '\0'
774 // 'a'
775 TEST_F(SerialIoHandlerPosixTest, ParityErrorReadThreeTimes) {
776 for (int buffer_len = 1; buffer_len <= 20; ++buffer_len) {
777 set_error_detect_state(NO_ERROR);
778 set_parity_check_enabled(true);
779 set_num_chars_ignored(0);
780 char buffer[buffer_len];
781
782 buffer[0] = '\377';
783 int bytes_read = 1;
784 bool break_detected = false;
785 bool parity_error_detected = false;
786 int new_bytes_read = call_CheckReceiveError(
787 buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
788 EXPECT_EQ(MARK_377_SEEN, get_error_detect_state());
789 EXPECT_EQ(1, get_num_chars_ignored());
790 EXPECT_EQ('\377', get_chars_ignored(0));
791 EXPECT_EQ(0, new_bytes_read);
792 EXPECT_EQ(break_detected, false);
793 EXPECT_EQ(parity_error_detected, false);
794
795 buffer[0] = '\0';
796 bytes_read = 1;
797 break_detected = false;
798 parity_error_detected = false;
799 new_bytes_read = call_CheckReceiveError(
800 buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
801 EXPECT_EQ(MARK_0_SEEN, get_error_detect_state());
802 EXPECT_EQ(2, get_num_chars_ignored());
803 EXPECT_EQ('\377', get_chars_ignored(0));
804 EXPECT_EQ('\0', get_chars_ignored(1));
805 EXPECT_EQ(0, new_bytes_read);
806 EXPECT_EQ(break_detected, false);
807 EXPECT_EQ(parity_error_detected, false);
808
809 buffer[0] = 'a';
810 bytes_read = 1;
811 break_detected = false;
812 parity_error_detected = false;
813 new_bytes_read = call_CheckReceiveError(
814 buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
815 EXPECT_EQ(NO_ERROR, get_error_detect_state());
816 EXPECT_EQ(0, get_num_chars_ignored());
817 EXPECT_EQ(0, new_bytes_read);
818 EXPECT_EQ(break_detected, false);
819 EXPECT_EQ(parity_error_detected, true);
820 }
821 }
822
823 // 'b' '\377'
824 // '\0'
825 // 'a' 'c'
826 TEST_F(SerialIoHandlerPosixTest,
827 ParityErrorReadThreeTimesHasBytesBeforeAndAfterParityError) {
828 for (int buffer_len = 2; buffer_len <= 20; ++buffer_len) {
829 set_error_detect_state(NO_ERROR);
830 set_parity_check_enabled(true);
831 set_num_chars_ignored(0);
832 char buffer[buffer_len];
833
834 buffer[0] = 'b';
835 buffer[1] = '\377';
836 int bytes_read = 2;
837 bool break_detected = false;
838 bool parity_error_detected = false;
839 int new_bytes_read = call_CheckReceiveError(
840 buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
841 EXPECT_EQ(MARK_377_SEEN, get_error_detect_state());
842 EXPECT_EQ(1, get_num_chars_ignored());
843 EXPECT_EQ('\377', get_chars_ignored(0));
844 EXPECT_EQ(1, new_bytes_read);
845 EXPECT_EQ('b', buffer[0]);
846 EXPECT_EQ(break_detected, false);
847 EXPECT_EQ(parity_error_detected, false);
848
849 buffer[0] = '\0';
850 bytes_read = 1;
851 break_detected = false;
852 parity_error_detected = false;
853 new_bytes_read = call_CheckReceiveError(
854 buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
855 EXPECT_EQ(MARK_0_SEEN, get_error_detect_state());
856 EXPECT_EQ(2, get_num_chars_ignored());
857 EXPECT_EQ('\377', get_chars_ignored(0));
858 EXPECT_EQ('\0', get_chars_ignored(1));
859 EXPECT_EQ(0, new_bytes_read);
860 EXPECT_EQ(break_detected, false);
861 EXPECT_EQ(parity_error_detected, false);
862
863 buffer[0] = 'a';
864 buffer[1] = 'c';
865 bytes_read = 2;
866 break_detected = false;
867 parity_error_detected = false;
868 new_bytes_read = call_CheckReceiveError(
869 buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
870 EXPECT_EQ(NO_ERROR, get_error_detect_state());
871 EXPECT_EQ(0, get_num_chars_ignored());
872 EXPECT_EQ(1, new_bytes_read);
873 EXPECT_EQ('c', buffer[0]);
874 EXPECT_EQ(break_detected, false);
875 EXPECT_EQ(parity_error_detected, true);
876 }
877 }
878
879 // '\377' '\377'
880 TEST_F(SerialIoHandlerPosixTest, TwoEOFsReadOnce) {
881 for (int buffer_len = 2; buffer_len <= 20; ++buffer_len) {
882 set_error_detect_state(NO_ERROR);
883 set_parity_check_enabled(true);
884 set_num_chars_ignored(0);
885 char buffer[buffer_len];
886
887 buffer[0] = '\377';
888 buffer[1] = '\377';
889 int bytes_read = 2;
890 bool break_detected = false;
891 bool parity_error_detected = false;
892 int new_bytes_read = call_CheckReceiveError(
893 buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
894 EXPECT_EQ(NO_ERROR, get_error_detect_state());
895 EXPECT_EQ(0, get_num_chars_ignored());
896 EXPECT_EQ(1, new_bytes_read);
897 EXPECT_EQ('\377', buffer[0]);
898 EXPECT_EQ(break_detected, false);
899 EXPECT_EQ(parity_error_detected, false);
900 }
901 }
902
903 // 'a' \377' '\377' 'b' 'c'
904 TEST_F(SerialIoHandlerPosixTest, TwoEOFsReadOnceHasBytesBeforeAndAfterEOF) {
905 for (int buffer_len = 5; buffer_len <= 20; ++buffer_len) {
906 set_error_detect_state(NO_ERROR);
907 set_parity_check_enabled(true);
908 set_num_chars_ignored(0);
909 char buffer[buffer_len];
910
911 buffer[0] = 'a';
912 buffer[1] = '\377';
913 buffer[2] = '\377';
914 buffer[3] = 'b';
915 buffer[4] = 'c';
916 int bytes_read = 5;
917 bool break_detected = false;
918 bool parity_error_detected = false;
919 int new_bytes_read = call_CheckReceiveError(
920 buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
921 EXPECT_EQ(NO_ERROR, get_error_detect_state());
922 EXPECT_EQ(0, get_num_chars_ignored());
923 EXPECT_EQ(4, new_bytes_read);
924 EXPECT_EQ('a', buffer[0]);
925 EXPECT_EQ('\377', buffer[1]);
926 EXPECT_EQ('b', buffer[2]);
927 EXPECT_EQ('c', buffer[3]);
928 EXPECT_EQ(break_detected, false);
929 EXPECT_EQ(parity_error_detected, false);
930 }
931 }
932
933 // '\377'
934 // '\377'
935 TEST_F(SerialIoHandlerPosixTest, TwoEOFsReadTwice) {
936 for (int buffer_len = 1; buffer_len <= 20; ++buffer_len) {
937 set_error_detect_state(NO_ERROR);
938 set_parity_check_enabled(true);
939 set_num_chars_ignored(0);
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 = call_CheckReceiveError(
947 buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
948 EXPECT_EQ(MARK_377_SEEN, get_error_detect_state());
949 EXPECT_EQ(1, get_num_chars_ignored());
950 EXPECT_EQ('\377', get_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] = '\377';
956 bytes_read = 1;
957 break_detected = false;
958 parity_error_detected = false;
959 new_bytes_read = call_CheckReceiveError(
960 buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
961 EXPECT_EQ(NO_ERROR, get_error_detect_state());
962 EXPECT_EQ(0, get_num_chars_ignored());
963 EXPECT_EQ(1, new_bytes_read);
964 EXPECT_EQ('\377', buffer[0]);
965 EXPECT_EQ(break_detected, false);
966 EXPECT_EQ(parity_error_detected, false);
967 }
968 }
969
970 // 'a' \377'
971 // '\377' 'b'
972 TEST_F(SerialIoHandlerPosixTest, TwoEOFsReadTwiceHasBytesBeforeAndAfterEOF) {
973 for (int buffer_len = 2; buffer_len <= 20; ++buffer_len) {
974 set_error_detect_state(NO_ERROR);
975 set_parity_check_enabled(true);
976 set_num_chars_ignored(0);
977 char buffer[buffer_len];
978
979 buffer[0] = 'a';
980 buffer[1] = '\377';
981 int bytes_read = 2;
982 bool break_detected = false;
983 bool parity_error_detected = false;
984 int new_bytes_read = call_CheckReceiveError(
985 buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
986 EXPECT_EQ(MARK_377_SEEN, get_error_detect_state());
987 EXPECT_EQ(1, get_num_chars_ignored());
988 EXPECT_EQ('\377', get_chars_ignored(0));
989 EXPECT_EQ(1, new_bytes_read);
990 EXPECT_EQ('a', buffer[0]);
991 EXPECT_EQ(break_detected, false);
992 EXPECT_EQ(parity_error_detected, false);
993
994 buffer[0] = '\377';
995 buffer[1] = 'b';
996 bytes_read = 2;
997 break_detected = false;
998 parity_error_detected = false;
999 new_bytes_read = call_CheckReceiveError(
1000 buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
1001 EXPECT_EQ(NO_ERROR, get_error_detect_state());
1002 EXPECT_EQ(0, get_num_chars_ignored());
1003 EXPECT_EQ(2, new_bytes_read);
1004 EXPECT_EQ('\377', buffer[0]);
1005 EXPECT_EQ('b', buffer[1]);
1006 EXPECT_EQ(break_detected, false);
1007 EXPECT_EQ(parity_error_detected, false);
1008 }
1009 }
1010
1011 // '\377' '\0' 'a'
1012 TEST_F(SerialIoHandlerPosixTest, ParityCheckDisabledReadOnce) {
1013 for (int buffer_len = 3; buffer_len <= 20; ++buffer_len) {
1014 set_error_detect_state(NO_ERROR);
1015 set_parity_check_enabled(false);
1016 set_num_chars_ignored(0);
1017 char buffer[buffer_len];
1018
1019 buffer[0] = '\377';
1020 buffer[1] = '\0';
1021 buffer[2] = 'a';
1022 int bytes_read = 3;
1023 bool break_detected = false;
1024 bool parity_error_detected = false;
1025 int new_bytes_read = call_CheckReceiveError(
1026 buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
1027 EXPECT_EQ(NO_ERROR, get_error_detect_state());
1028 EXPECT_EQ(0, get_num_chars_ignored());
1029 EXPECT_EQ(3, new_bytes_read);
1030 EXPECT_EQ('\377', buffer[0]);
1031 EXPECT_EQ('\0', buffer[1]);
1032 EXPECT_EQ('a', buffer[2]);
1033 EXPECT_EQ(break_detected, false);
1034 EXPECT_EQ(parity_error_detected, false);
1035 }
1036 }
1037
1038 // 'b' '\377' '\0' 'a' 'c'
1039 TEST_F(SerialIoHandlerPosixTest,
1040 ParityCheckDisabledReadOnceHasBytesBeforeAndAfter) {
1041 for (int buffer_len = 5; buffer_len <= 20; ++buffer_len) {
1042 set_error_detect_state(NO_ERROR);
1043 set_parity_check_enabled(false);
1044 set_num_chars_ignored(0);
1045 char buffer[buffer_len];
1046
1047 buffer[0] = 'b';
1048 buffer[1] = '\377';
1049 buffer[2] = '\0';
1050 buffer[3] = 'a';
1051 buffer[4] = 'c';
1052 int bytes_read = 5;
1053 bool break_detected = false;
1054 bool parity_error_detected = false;
1055 int new_bytes_read = call_CheckReceiveError(
1056 buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
1057 EXPECT_EQ(NO_ERROR, get_error_detect_state());
1058 EXPECT_EQ(0, get_num_chars_ignored());
1059 EXPECT_EQ(5, new_bytes_read);
1060 EXPECT_EQ('b', buffer[0]);
1061 EXPECT_EQ('\377', buffer[1]);
1062 EXPECT_EQ('\0', buffer[2]);
1063 EXPECT_EQ('a', buffer[3]);
1064 EXPECT_EQ('c', buffer[4]);
1065 EXPECT_EQ(break_detected, false);
1066 EXPECT_EQ(parity_error_detected, false);
1067 }
1068 }
1069
1070 // '\377' '\0'
1071 // 'a'
1072 TEST_F(SerialIoHandlerPosixTest,
1073 ParityCheckDisabledReadTwiceBytesReadTwoAndOne) {
1074 set_error_detect_state(NO_ERROR);
1075 set_parity_check_enabled(false);
1076 set_num_chars_ignored(0);
1077 int buffer_len = 2;
1078 char buffer[buffer_len];
1079
1080 buffer[0] = '\377';
1081 buffer[1] = '\0';
1082 int bytes_read = 2;
1083 bool break_detected = false;
1084 bool parity_error_detected = false;
1085 int new_bytes_read = call_CheckReceiveError(
1086 buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
1087 EXPECT_EQ(MARK_0_SEEN, get_error_detect_state());
1088 EXPECT_EQ(2, get_num_chars_ignored());
1089 EXPECT_EQ('\377', get_chars_ignored(0));
1090 EXPECT_EQ('\0', get_chars_ignored(1));
1091 EXPECT_EQ(0, new_bytes_read);
1092 EXPECT_EQ(break_detected, false);
1093 EXPECT_EQ(parity_error_detected, false);
1094
1095 buffer[0] = 'a';
1096 bytes_read = 1;
1097 break_detected = false;
1098 parity_error_detected = false;
1099 new_bytes_read = call_CheckReceiveError(
1100 buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
1101 EXPECT_EQ(NO_ERROR, get_error_detect_state());
1102 // since the buffer_len is 2, the buffer now stores two bytes from the
1103 // previous read, and the byte currently read needs to be stored into
1104 // chars_ignored_[]
1105 EXPECT_EQ(1, get_num_chars_ignored());
1106 EXPECT_EQ('a', get_chars_ignored(0));
1107 EXPECT_EQ(2, new_bytes_read);
1108 EXPECT_EQ('\377', buffer[0]);
1109 EXPECT_EQ('\0', buffer[1]);
1110 EXPECT_EQ(break_detected, false);
1111 EXPECT_EQ(parity_error_detected, false);
1112 }
1113
1114 // '\377' '\0'
1115 // 'a' 'b'
1116 TEST_F(SerialIoHandlerPosixTest,
1117 ParityCheckDisabledReadTwiceBytesReadTwoAndOneHasBytesAfter) {
1118 set_error_detect_state(NO_ERROR);
1119 set_parity_check_enabled(false);
1120 set_num_chars_ignored(0);
1121 int buffer_len = 2;
1122 char buffer[buffer_len];
1123
1124 buffer[0] = '\377';
1125 buffer[1] = '\0';
1126 int bytes_read = 2;
1127 bool break_detected = false;
1128 bool parity_error_detected = false;
1129 int new_bytes_read = call_CheckReceiveError(
1130 buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
1131 EXPECT_EQ(MARK_0_SEEN, get_error_detect_state());
1132 EXPECT_EQ(2, get_num_chars_ignored());
1133 EXPECT_EQ('\377', get_chars_ignored(0));
1134 EXPECT_EQ('\0', get_chars_ignored(1));
1135 EXPECT_EQ(0, new_bytes_read);
1136 EXPECT_EQ(break_detected, false);
1137 EXPECT_EQ(parity_error_detected, false);
1138
1139 buffer[0] = 'a';
1140 buffer[1] = 'b';
1141 bytes_read = 2;
1142 break_detected = false;
1143 parity_error_detected = false;
1144 new_bytes_read = call_CheckReceiveError(
1145 buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
1146 EXPECT_EQ(NO_ERROR, get_error_detect_state());
1147 // since the buffer_len is 2, the buffer now stores two bytes from the
1148 // previous read, and the bytes currently read need to be stored into
1149 // chars_ignored_[]
1150 EXPECT_EQ(2, get_num_chars_ignored());
1151 EXPECT_EQ('a', get_chars_ignored(0));
1152 EXPECT_EQ('b', get_chars_ignored(1));
1153 EXPECT_EQ(2, new_bytes_read);
1154 EXPECT_EQ('\377', buffer[0]);
1155 EXPECT_EQ('\0', buffer[1]);
1156 EXPECT_EQ(break_detected, false);
1157 EXPECT_EQ(parity_error_detected, false);
1158 }
1159
1160 // '\377' '\0'
1161 // 'a'
1162 TEST_F(SerialIoHandlerPosixTest,
1163 ParityCheckDisabledReadTwiceBytesReadTwoAndOneLargerBufferLen) {
1164 for (int buffer_len = 3; buffer_len <= 20; ++buffer_len) {
1165 set_error_detect_state(NO_ERROR);
1166 set_parity_check_enabled(false);
1167 set_num_chars_ignored(0);
1168 char buffer[buffer_len];
1169
1170 buffer[0] = '\377';
1171 buffer[1] = '\0';
1172 int bytes_read = 2;
1173 bool break_detected = false;
1174 bool parity_error_detected = false;
1175 int new_bytes_read = call_CheckReceiveError(
1176 buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
1177 EXPECT_EQ(MARK_0_SEEN, get_error_detect_state());
1178 EXPECT_EQ(2, get_num_chars_ignored());
1179 EXPECT_EQ('\377', get_chars_ignored(0));
1180 EXPECT_EQ('\0', get_chars_ignored(1));
1181 EXPECT_EQ(0, new_bytes_read);
1182 EXPECT_EQ(break_detected, false);
1183 EXPECT_EQ(parity_error_detected, false);
1184
1185 buffer[0] = 'a';
1186 bytes_read = 1;
1187 break_detected = false;
1188 parity_error_detected = false;
1189 new_bytes_read = call_CheckReceiveError(
1190 buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
1191 EXPECT_EQ(NO_ERROR, get_error_detect_state());
1192 EXPECT_EQ(0, get_num_chars_ignored());
1193 EXPECT_EQ(3, new_bytes_read);
1194 EXPECT_EQ('\377', buffer[0]);
1195 EXPECT_EQ('\0', buffer[1]);
1196 EXPECT_EQ('a', buffer[2]);
1197 EXPECT_EQ(break_detected, false);
1198 EXPECT_EQ(parity_error_detected, false);
1199 }
1200 }
1201
1202 // 'b' '\377' '\0'
1203 // 'a' 'c'
1204 TEST_F(
1205 SerialIoHandlerPosixTest,
1206 ParityCheckDisabledReadTwiceBytesReadTwoAndOneBufferLenThreeHasBytesBeforeAn dAfter) {
1207 set_error_detect_state(NO_ERROR);
1208 set_parity_check_enabled(false);
1209 set_num_chars_ignored(0);
1210 int buffer_len = 3;
1211 char buffer[buffer_len];
1212
1213 buffer[0] = 'b';
1214 buffer[1] = '\377';
1215 buffer[2] = '\0';
1216 int bytes_read = 3;
1217 bool break_detected = false;
1218 bool parity_error_detected = false;
1219 int new_bytes_read = call_CheckReceiveError(
1220 buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
1221 EXPECT_EQ(MARK_0_SEEN, get_error_detect_state());
1222 EXPECT_EQ(2, get_num_chars_ignored());
1223 EXPECT_EQ('\377', get_chars_ignored(0));
1224 EXPECT_EQ('\0', get_chars_ignored(1));
1225 EXPECT_EQ(1, new_bytes_read);
1226 EXPECT_EQ('b', buffer[0]);
1227 EXPECT_EQ(break_detected, false);
1228 EXPECT_EQ(parity_error_detected, false);
1229
1230 buffer[0] = 'a';
1231 buffer[1] = 'c';
1232 bytes_read = 2;
1233 break_detected = false;
1234 parity_error_detected = false;
1235 new_bytes_read = call_CheckReceiveError(
1236 buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
1237 EXPECT_EQ(NO_ERROR, get_error_detect_state());
1238 EXPECT_EQ(1, get_num_chars_ignored());
1239 EXPECT_EQ('c', get_chars_ignored(0));
1240 EXPECT_EQ(3, new_bytes_read);
1241 EXPECT_EQ('\377', buffer[0]);
1242 EXPECT_EQ('\0', buffer[1]);
1243 EXPECT_EQ('a', buffer[2]);
1244 EXPECT_EQ(break_detected, false);
1245 EXPECT_EQ(parity_error_detected, false);
1246 }
1247
1248 // 'b' '\377' '\0'
1249 // 'a' 'c'
1250 TEST_F(
1251 SerialIoHandlerPosixTest,
1252 ParityCheckDisabledReadTwiceBytesReadTwoAndOneLargerBufferLenHasBytesBeforeA ndAfter) {
1253 for (int buffer_len = 4; buffer_len <= 20; ++buffer_len) {
1254 set_error_detect_state(NO_ERROR);
1255 set_parity_check_enabled(false);
1256 set_num_chars_ignored(0);
1257 char buffer[buffer_len];
1258
1259 buffer[0] = 'b';
1260 buffer[1] = '\377';
1261 buffer[2] = '\0';
1262 int bytes_read = 3;
1263 bool break_detected = false;
1264 bool parity_error_detected = false;
1265 int new_bytes_read = call_CheckReceiveError(
1266 buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
1267 EXPECT_EQ(MARK_0_SEEN, get_error_detect_state());
1268 EXPECT_EQ(2, get_num_chars_ignored());
1269 EXPECT_EQ('\377', get_chars_ignored(0));
1270 EXPECT_EQ('\0', get_chars_ignored(1));
1271 EXPECT_EQ(1, new_bytes_read);
1272 EXPECT_EQ('b', buffer[0]);
1273 EXPECT_EQ(break_detected, false);
1274 EXPECT_EQ(parity_error_detected, false);
1275
1276 buffer[0] = 'a';
1277 buffer[1] = 'c';
1278 bytes_read = 2;
1279 break_detected = false;
1280 parity_error_detected = false;
1281 new_bytes_read = call_CheckReceiveError(
1282 buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
1283 EXPECT_EQ(NO_ERROR, get_error_detect_state());
1284 EXPECT_EQ(0, get_num_chars_ignored());
1285 EXPECT_EQ(4, new_bytes_read);
1286 EXPECT_EQ('\377', buffer[0]);
1287 EXPECT_EQ('\0', buffer[1]);
1288 EXPECT_EQ('a', buffer[2]);
1289 EXPECT_EQ('c', buffer[3]);
1290 EXPECT_EQ(break_detected, false);
1291 EXPECT_EQ(parity_error_detected, false);
1292 }
1293 }
1294
1295 // '\377'
1296 // '\0' 'a'
1297 TEST_F(SerialIoHandlerPosixTest,
1298 ParityCheckDisabledReadTwiceBytesReadOneAndTwo) {
1299 set_error_detect_state(NO_ERROR);
1300 set_parity_check_enabled(false);
1301 set_num_chars_ignored(0);
1302 int buffer_len = 2;
1303 char buffer[buffer_len];
1304
1305 buffer[0] = '\377';
1306 int bytes_read = 1;
1307 bool break_detected = false;
1308 bool parity_error_detected = false;
1309 int new_bytes_read = call_CheckReceiveError(
1310 buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
1311 EXPECT_EQ(MARK_377_SEEN, get_error_detect_state());
1312 EXPECT_EQ(1, get_num_chars_ignored());
1313 EXPECT_EQ('\377', get_chars_ignored(0));
1314 EXPECT_EQ(0, new_bytes_read);
1315 EXPECT_EQ(break_detected, false);
1316 EXPECT_EQ(parity_error_detected, false);
1317
1318 buffer[0] = '\0';
1319 buffer[1] = 'a';
1320 bytes_read = 2;
1321 break_detected = false;
1322 parity_error_detected = false;
1323 new_bytes_read = call_CheckReceiveError(
1324 buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
1325 EXPECT_EQ(NO_ERROR, get_error_detect_state());
1326 EXPECT_EQ(1, get_num_chars_ignored());
1327 EXPECT_EQ('a', get_chars_ignored(0));
1328 EXPECT_EQ(2, new_bytes_read);
1329 EXPECT_EQ('\377', buffer[0]);
1330 EXPECT_EQ('\0', buffer[1]);
1331 EXPECT_EQ(break_detected, false);
1332 EXPECT_EQ(parity_error_detected, false);
1333 }
1334
1335 // 'b' '\377'
1336 // '\0' 'a'
1337 TEST_F(SerialIoHandlerPosixTest,
1338 ParityCheckDisabledReadTwiceBytesReadOneAndTwoHasBytesBefore) {
1339 set_error_detect_state(NO_ERROR);
1340 set_parity_check_enabled(false);
1341 set_num_chars_ignored(0);
1342 int buffer_len = 2;
1343 char buffer[buffer_len];
1344
1345 buffer[0] = 'b';
1346 buffer[1] = '\377';
1347 int bytes_read = 2;
1348 bool break_detected = false;
1349 bool parity_error_detected = false;
1350 int new_bytes_read = call_CheckReceiveError(
1351 buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
1352 EXPECT_EQ(MARK_377_SEEN, get_error_detect_state());
1353 EXPECT_EQ(1, get_num_chars_ignored());
1354 EXPECT_EQ('\377', get_chars_ignored(0));
1355 EXPECT_EQ(1, new_bytes_read);
1356 EXPECT_EQ('b', buffer[0]);
1357 EXPECT_EQ(break_detected, false);
1358 EXPECT_EQ(parity_error_detected, false);
1359
1360 buffer[0] = '\0';
1361 buffer[1] = 'a';
1362 bytes_read = 2;
1363 break_detected = false;
1364 parity_error_detected = false;
1365 new_bytes_read = call_CheckReceiveError(
1366 buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
1367 EXPECT_EQ(NO_ERROR, get_error_detect_state());
1368 EXPECT_EQ(1, get_num_chars_ignored());
1369 EXPECT_EQ('a', get_chars_ignored(0));
1370 EXPECT_EQ(2, new_bytes_read);
1371 EXPECT_EQ('\377', buffer[0]);
1372 EXPECT_EQ('\0', buffer[1]);
1373 EXPECT_EQ(break_detected, false);
1374 EXPECT_EQ(parity_error_detected, false);
1375 }
1376
1377 // '\377'
1378 // '\0' 'a'
1379 TEST_F(SerialIoHandlerPosixTest,
1380 ParityCheckDisabledReadTwiceBytesReadOneAndTwoLargerBufferLen) {
1381 for (int buffer_len = 3; buffer_len <= 20; ++buffer_len) {
1382 set_error_detect_state(NO_ERROR);
1383 set_parity_check_enabled(false);
1384 set_num_chars_ignored(0);
1385 char buffer[buffer_len];
1386
1387 buffer[0] = '\377';
1388 int bytes_read = 1;
1389 bool break_detected = false;
1390 bool parity_error_detected = false;
1391 int new_bytes_read = call_CheckReceiveError(
1392 buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
1393 EXPECT_EQ(MARK_377_SEEN, get_error_detect_state());
1394 EXPECT_EQ(1, get_num_chars_ignored());
1395 EXPECT_EQ('\377', get_chars_ignored(0));
1396 EXPECT_EQ(0, new_bytes_read);
1397 EXPECT_EQ(break_detected, false);
1398 EXPECT_EQ(parity_error_detected, false);
1399
1400 buffer[0] = '\0';
1401 buffer[1] = 'a';
1402 bytes_read = 2;
1403 break_detected = false;
1404 parity_error_detected = false;
1405 new_bytes_read = call_CheckReceiveError(
1406 buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
1407 EXPECT_EQ(NO_ERROR, get_error_detect_state());
1408 EXPECT_EQ(0, get_num_chars_ignored());
1409 EXPECT_EQ(3, new_bytes_read);
1410 EXPECT_EQ('\377', buffer[0]);
1411 EXPECT_EQ('\0', buffer[1]);
1412 EXPECT_EQ('a', buffer[2]);
1413 EXPECT_EQ(break_detected, false);
1414 EXPECT_EQ(parity_error_detected, false);
1415 }
1416 }
1417
1418 // 'b' '\377'
1419 // '\0' 'a' 'c'
1420 TEST_F(
1421 SerialIoHandlerPosixTest,
1422 ParityCheckDisabledReadTwiceBytesReadOneAndTwoBufferLenThreeHasBytesBeforeAn dAfter) {
1423 set_error_detect_state(NO_ERROR);
1424 set_parity_check_enabled(false);
1425 set_num_chars_ignored(0);
1426 int buffer_len = 3;
1427 char buffer[buffer_len];
1428
1429 buffer[0] = 'b';
1430 buffer[1] = '\377';
1431 int bytes_read = 2;
1432 bool break_detected = false;
1433 bool parity_error_detected = false;
1434 int new_bytes_read = call_CheckReceiveError(
1435 buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
1436 EXPECT_EQ(MARK_377_SEEN, get_error_detect_state());
1437 EXPECT_EQ(1, get_num_chars_ignored());
1438 EXPECT_EQ('\377', get_chars_ignored(0));
1439 EXPECT_EQ(1, new_bytes_read);
1440 EXPECT_EQ('b', buffer[0]);
1441 EXPECT_EQ(break_detected, false);
1442 EXPECT_EQ(parity_error_detected, false);
1443
1444 buffer[0] = '\0';
1445 buffer[1] = 'a';
1446 buffer[2] = 'c';
1447 bytes_read = 3;
1448 break_detected = false;
1449 parity_error_detected = false;
1450 new_bytes_read = call_CheckReceiveError(
1451 buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
1452 EXPECT_EQ(NO_ERROR, get_error_detect_state());
1453 EXPECT_EQ(1, get_num_chars_ignored());
1454 EXPECT_EQ('c', get_chars_ignored(0));
1455 EXPECT_EQ(3, new_bytes_read);
1456 EXPECT_EQ('\377', buffer[0]);
1457 EXPECT_EQ('\0', buffer[1]);
1458 EXPECT_EQ('a', buffer[2]);
1459 EXPECT_EQ(break_detected, false);
1460 EXPECT_EQ(parity_error_detected, false);
1461 }
1462
1463 // 'b' '\377'
1464 // '\0' 'a' 'c'
1465 TEST_F(
1466 SerialIoHandlerPosixTest,
1467 ParityCheckDisabledReadTwiceBytesReadOneAndTwoLargerBufferLenHasBytesBeforeA ndAfter) {
1468 for (int buffer_len = 4; buffer_len <= 20; ++buffer_len) {
1469 set_error_detect_state(NO_ERROR);
1470 set_parity_check_enabled(false);
1471 set_num_chars_ignored(0);
1472 char buffer[buffer_len];
1473
1474 buffer[0] = 'b';
1475 buffer[1] = '\377';
1476 int bytes_read = 2;
1477 bool break_detected = false;
1478 bool parity_error_detected = false;
1479 int new_bytes_read = call_CheckReceiveError(
1480 buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
1481 EXPECT_EQ(MARK_377_SEEN, get_error_detect_state());
1482 EXPECT_EQ(1, get_num_chars_ignored());
1483 EXPECT_EQ('\377', get_chars_ignored(0));
1484 EXPECT_EQ(1, new_bytes_read);
1485 EXPECT_EQ('b', buffer[0]);
1486 EXPECT_EQ(break_detected, false);
1487 EXPECT_EQ(parity_error_detected, false);
1488
1489 buffer[0] = '\0';
1490 buffer[1] = 'a';
1491 buffer[2] = 'c';
1492 bytes_read = 3;
1493 break_detected = false;
1494 parity_error_detected = false;
1495 new_bytes_read = call_CheckReceiveError(
1496 buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
1497 EXPECT_EQ(NO_ERROR, get_error_detect_state());
1498 EXPECT_EQ(0, get_num_chars_ignored());
1499 EXPECT_EQ(4, new_bytes_read);
1500 EXPECT_EQ('\377', buffer[0]);
1501 EXPECT_EQ('\0', buffer[1]);
1502 EXPECT_EQ('a', buffer[2]);
1503 EXPECT_EQ('c', buffer[3]);
1504 EXPECT_EQ(break_detected, false);
1505 EXPECT_EQ(parity_error_detected, false);
1506 }
1507 }
1508
1509 // '\377'
1510 // '\0'
1511 // 'a'
1512 TEST_F(SerialIoHandlerPosixTest,
1513 ParityCheckDisabledReadThreeTimesBufferLenOne) {
1514 set_error_detect_state(NO_ERROR);
1515 set_parity_check_enabled(false);
1516 set_num_chars_ignored(0);
1517 int buffer_len = 1;
1518 char buffer[buffer_len];
1519
1520 buffer[0] = '\377';
1521 int bytes_read = 1;
1522 bool break_detected = false;
1523 bool parity_error_detected = false;
1524 int new_bytes_read = call_CheckReceiveError(
1525 buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
1526 EXPECT_EQ(MARK_377_SEEN, get_error_detect_state());
1527 EXPECT_EQ(1, get_num_chars_ignored());
1528 EXPECT_EQ('\377', get_chars_ignored(0));
1529 EXPECT_EQ(0, new_bytes_read);
1530 EXPECT_EQ(break_detected, false);
1531 EXPECT_EQ(parity_error_detected, false);
1532
1533 buffer[0] = '\0';
1534 bytes_read = 1;
1535 break_detected = false;
1536 parity_error_detected = false;
1537 new_bytes_read = call_CheckReceiveError(
1538 buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
1539 EXPECT_EQ(MARK_0_SEEN, get_error_detect_state());
1540 EXPECT_EQ(2, get_num_chars_ignored());
1541 EXPECT_EQ('\377', get_chars_ignored(0));
1542 EXPECT_EQ('\0', get_chars_ignored(1));
1543 EXPECT_EQ(0, new_bytes_read);
1544 EXPECT_EQ(break_detected, false);
1545 EXPECT_EQ(parity_error_detected, false);
1546
1547 buffer[0] = 'a';
1548 bytes_read = 1;
1549 break_detected = false;
1550 parity_error_detected = false;
1551 new_bytes_read = call_CheckReceiveError(
1552 buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
1553 EXPECT_EQ(NO_ERROR, get_error_detect_state());
1554 EXPECT_EQ(2, get_num_chars_ignored());
1555 EXPECT_EQ('\0', get_chars_ignored(0));
1556 EXPECT_EQ('a', get_chars_ignored(1));
1557 EXPECT_EQ(1, new_bytes_read);
1558 EXPECT_EQ('\377', buffer[0]);
1559 EXPECT_EQ(break_detected, false);
1560 EXPECT_EQ(parity_error_detected, false);
1561 }
1562
1563 // '\377'
1564 // '\0'
1565 // 'a'
1566 TEST_F(SerialIoHandlerPosixTest,
1567 ParityCheckDisabledReadThreeTimesBufferLenTwo) {
1568 set_error_detect_state(NO_ERROR);
1569 set_parity_check_enabled(false);
1570 set_num_chars_ignored(0);
1571 int buffer_len = 2;
1572 char buffer[buffer_len];
1573
1574 buffer[0] = '\377';
1575 int bytes_read = 1;
1576 bool break_detected = false;
1577 bool parity_error_detected = false;
1578 int new_bytes_read = call_CheckReceiveError(
1579 buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
1580 EXPECT_EQ(MARK_377_SEEN, get_error_detect_state());
1581 EXPECT_EQ(1, get_num_chars_ignored());
1582 EXPECT_EQ('\377', get_chars_ignored(0));
1583 EXPECT_EQ(0, new_bytes_read);
1584 EXPECT_EQ(break_detected, false);
1585 EXPECT_EQ(parity_error_detected, false);
1586
1587 buffer[0] = '\0';
1588 bytes_read = 1;
1589 break_detected = false;
1590 parity_error_detected = false;
1591 new_bytes_read = call_CheckReceiveError(
1592 buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
1593 EXPECT_EQ(MARK_0_SEEN, get_error_detect_state());
1594 EXPECT_EQ(2, get_num_chars_ignored());
1595 EXPECT_EQ('\377', get_chars_ignored(0));
1596 EXPECT_EQ('\0', get_chars_ignored(1));
1597 EXPECT_EQ(0, new_bytes_read);
1598 EXPECT_EQ(break_detected, false);
1599 EXPECT_EQ(parity_error_detected, false);
1600
1601 buffer[0] = 'a';
1602 bytes_read = 1;
1603 break_detected = false;
1604 parity_error_detected = false;
1605 new_bytes_read = call_CheckReceiveError(
1606 buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
1607 EXPECT_EQ(NO_ERROR, get_error_detect_state());
1608 EXPECT_EQ(1, get_num_chars_ignored());
1609 EXPECT_EQ('a', get_chars_ignored(0));
1610 EXPECT_EQ(2, new_bytes_read);
1611 EXPECT_EQ('\377', buffer[0]);
1612 EXPECT_EQ('\0', buffer[1]);
1613 EXPECT_EQ(break_detected, false);
1614 EXPECT_EQ(parity_error_detected, false);
1615 }
1616
1617 // '\377'
1618 // '\0'
1619 // 'a'
1620 TEST_F(SerialIoHandlerPosixTest,
1621 ParityCheckDisabledReadThreeTimesLargerBufferLen) {
1622 for (int buffer_len = 3; buffer_len <= 20; ++buffer_len) {
1623 set_error_detect_state(NO_ERROR);
1624 set_parity_check_enabled(false);
1625 set_num_chars_ignored(0);
1626 char buffer[buffer_len];
1627
1628 buffer[0] = '\377';
1629 int bytes_read = 1;
1630 bool break_detected = false;
1631 bool parity_error_detected = false;
1632 int new_bytes_read = call_CheckReceiveError(
1633 buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
1634 EXPECT_EQ(MARK_377_SEEN, get_error_detect_state());
1635 EXPECT_EQ(1, get_num_chars_ignored());
1636 EXPECT_EQ('\377', get_chars_ignored(0));
1637 EXPECT_EQ(0, new_bytes_read);
1638 EXPECT_EQ(break_detected, false);
1639 EXPECT_EQ(parity_error_detected, false);
1640
1641 buffer[0] = '\0';
1642 bytes_read = 1;
1643 break_detected = false;
1644 parity_error_detected = false;
1645 new_bytes_read = call_CheckReceiveError(
1646 buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
1647 EXPECT_EQ(MARK_0_SEEN, get_error_detect_state());
1648 EXPECT_EQ(2, get_num_chars_ignored());
1649 EXPECT_EQ('\377', get_chars_ignored(0));
1650 EXPECT_EQ('\0', get_chars_ignored(1));
1651 EXPECT_EQ(0, new_bytes_read);
1652 EXPECT_EQ(break_detected, false);
1653 EXPECT_EQ(parity_error_detected, false);
1654
1655 buffer[0] = 'a';
1656 bytes_read = 1;
1657 break_detected = false;
1658 parity_error_detected = false;
1659 new_bytes_read = call_CheckReceiveError(
1660 buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
1661 EXPECT_EQ(NO_ERROR, get_error_detect_state());
1662 EXPECT_EQ(0, get_num_chars_ignored());
1663 EXPECT_EQ(3, new_bytes_read);
1664 EXPECT_EQ('\377', buffer[0]);
1665 EXPECT_EQ('\0', buffer[1]);
1666 EXPECT_EQ('a', buffer[2]);
1667 EXPECT_EQ(break_detected, false);
1668 EXPECT_EQ(parity_error_detected, false);
1669 }
1670 }
1671
1672 // 'b' '\377'
1673 // '\0'
1674 // 'a' 'c'
1675 TEST_F(SerialIoHandlerPosixTest,
1676 ParityCheckDisabledReadThreeTimesBufferLenThreeByteBeforeAndAfter) {
1677 set_error_detect_state(NO_ERROR);
1678 set_parity_check_enabled(false);
1679 set_num_chars_ignored(0);
1680 int buffer_len = 3;
1681 char buffer[buffer_len];
1682
1683 buffer[0] = 'b';
1684 buffer[1] = '\377';
1685 int bytes_read = 2;
1686 bool break_detected = false;
1687 bool parity_error_detected = false;
1688 int new_bytes_read = call_CheckReceiveError(
1689 buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
1690 EXPECT_EQ(MARK_377_SEEN, get_error_detect_state());
1691 EXPECT_EQ(1, get_num_chars_ignored());
1692 EXPECT_EQ('\377', get_chars_ignored(0));
1693 EXPECT_EQ(1, new_bytes_read);
1694 EXPECT_EQ('b', buffer[0]);
1695 EXPECT_EQ(break_detected, false);
1696 EXPECT_EQ(parity_error_detected, false);
1697
1698 buffer[0] = '\0';
1699 bytes_read = 1;
1700 break_detected = false;
1701 parity_error_detected = false;
1702 new_bytes_read = call_CheckReceiveError(
1703 buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
1704 EXPECT_EQ(MARK_0_SEEN, get_error_detect_state());
1705 EXPECT_EQ(2, get_num_chars_ignored());
1706 EXPECT_EQ('\377', get_chars_ignored(0));
1707 EXPECT_EQ('\0', get_chars_ignored(1));
1708 EXPECT_EQ(0, new_bytes_read);
1709 EXPECT_EQ(break_detected, false);
1710 EXPECT_EQ(parity_error_detected, false);
1711
1712 buffer[0] = 'a';
1713 buffer[1] = 'c';
1714 bytes_read = 2;
1715 break_detected = false;
1716 parity_error_detected = false;
1717 new_bytes_read = call_CheckReceiveError(
1718 buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
1719 EXPECT_EQ(NO_ERROR, get_error_detect_state());
1720 EXPECT_EQ(1, get_num_chars_ignored());
1721 EXPECT_EQ('c', get_chars_ignored(0));
1722 EXPECT_EQ(3, new_bytes_read);
1723 EXPECT_EQ('\377', buffer[0]);
1724 EXPECT_EQ('\0', buffer[1]);
1725 EXPECT_EQ('a', buffer[2]);
1726 EXPECT_EQ(break_detected, false);
1727 EXPECT_EQ(parity_error_detected, false);
1728 }
1729
1730 // 'b' '\377'
1731 // '\0'
1732 // 'a' 'c'
1733 TEST_F(SerialIoHandlerPosixTest,
1734 ParityCheckDisabledReadThreeTimesLargerBufferLenHasBytesBeforeAndAfter) {
1735 for (int buffer_len = 4; buffer_len <= 20; ++buffer_len) {
1736 set_error_detect_state(NO_ERROR);
1737 set_parity_check_enabled(false);
1738 set_num_chars_ignored(0);
1739 char buffer[buffer_len];
1740
1741 buffer[0] = 'b';
1742 buffer[1] = '\377';
1743 int bytes_read = 2;
1744 bool break_detected = false;
1745 bool parity_error_detected = false;
1746 int new_bytes_read = call_CheckReceiveError(
1747 buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
1748 EXPECT_EQ(MARK_377_SEEN, get_error_detect_state());
1749 EXPECT_EQ(1, get_num_chars_ignored());
1750 EXPECT_EQ('\377', get_chars_ignored(0));
1751 EXPECT_EQ(1, new_bytes_read);
1752 EXPECT_EQ('b', buffer[0]);
1753 EXPECT_EQ(break_detected, false);
1754 EXPECT_EQ(parity_error_detected, false);
1755
1756 buffer[0] = '\0';
1757 bytes_read = 1;
1758 break_detected = false;
1759 parity_error_detected = false;
1760 new_bytes_read = call_CheckReceiveError(
1761 buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
1762 EXPECT_EQ(MARK_0_SEEN, get_error_detect_state());
1763 EXPECT_EQ(2, get_num_chars_ignored());
1764 EXPECT_EQ('\377', get_chars_ignored(0));
1765 EXPECT_EQ('\0', get_chars_ignored(1));
1766 EXPECT_EQ(0, new_bytes_read);
1767 EXPECT_EQ(break_detected, false);
1768 EXPECT_EQ(parity_error_detected, false);
1769
1770 buffer[0] = 'a';
1771 buffer[1] = 'c';
1772 bytes_read = 2;
1773 break_detected = false;
1774 parity_error_detected = false;
1775 new_bytes_read = call_CheckReceiveError(
1776 buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
1777 EXPECT_EQ(NO_ERROR, get_error_detect_state());
1778 EXPECT_EQ(0, get_num_chars_ignored());
1779 EXPECT_EQ(4, new_bytes_read);
1780 EXPECT_EQ('\377', buffer[0]);
1781 EXPECT_EQ('\0', buffer[1]);
1782 EXPECT_EQ('a', buffer[2]);
1783 EXPECT_EQ('c', buffer[3]);
1784 EXPECT_EQ(break_detected, false);
1785 EXPECT_EQ(parity_error_detected, false);
1786 }
1787 }
1788
1789 TEST_F(SerialIoHandlerPosixTest, BytesReadZero) {
1790 for (int buffer_len = 1; buffer_len <= 20; ++buffer_len) {
1791 set_error_detect_state(NO_ERROR);
1792 set_parity_check_enabled(true);
1793 set_num_chars_ignored(0);
1794 char buffer[buffer_len];
1795
1796 int bytes_read = 0;
1797 bool break_detected = false;
1798 bool parity_error_detected = false;
1799 int new_bytes_read = call_CheckReceiveError(
1800 buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
1801 EXPECT_EQ(NO_ERROR, get_error_detect_state());
1802 EXPECT_EQ(0, get_num_chars_ignored());
1803 EXPECT_EQ(0, new_bytes_read);
1804 EXPECT_EQ(break_detected, false);
1805 EXPECT_EQ(parity_error_detected, false);
1806 }
1807 }
1808
1809 // '\377' 'a' 'b'
1810 TEST_F(SerialIoHandlerPosixTest, InvalidSequenceReadOnce) {
1811 for (int buffer_len = 3; buffer_len <= 20; ++buffer_len) {
1812 set_error_detect_state(NO_ERROR);
1813 set_parity_check_enabled(true);
1814 set_num_chars_ignored(0);
1815 char buffer[buffer_len];
1816
1817 buffer[0] = '\377';
1818 buffer[1] = 'a';
1819 buffer[2] = 'b';
1820 int bytes_read = 3;
1821 bool break_detected = false;
1822 bool parity_error_detected = false;
1823 int new_bytes_read = call_CheckReceiveError(
1824 buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
1825 EXPECT_EQ(NO_ERROR, get_error_detect_state());
1826 EXPECT_EQ(0, get_num_chars_ignored());
1827 EXPECT_EQ(3, new_bytes_read);
1828 EXPECT_EQ('\377', buffer[0]);
1829 EXPECT_EQ('a', buffer[1]);
1830 EXPECT_EQ('b', buffer[2]);
1831 EXPECT_EQ(break_detected, false);
1832 EXPECT_EQ(parity_error_detected, false);
1833 }
1834 }
1835
1836 // '\377' 'a'
1837 // 'b'
1838 TEST_F(SerialIoHandlerPosixTest, InvalidSequenceReadTwiceBytesReadTwoAndOne) {
1839 for (int buffer_len = 2; buffer_len <= 20; ++buffer_len) {
1840 set_error_detect_state(NO_ERROR);
1841 set_parity_check_enabled(true);
1842 set_num_chars_ignored(0);
1843 char buffer[buffer_len];
1844
1845 buffer[0] = '\377';
1846 buffer[1] = 'a';
1847 int bytes_read = 2;
1848 bool break_detected = false;
1849 bool parity_error_detected = false;
1850 int new_bytes_read = call_CheckReceiveError(
1851 buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
1852 EXPECT_EQ(NO_ERROR, get_error_detect_state());
1853 EXPECT_EQ(0, get_num_chars_ignored());
1854 EXPECT_EQ(2, new_bytes_read);
1855 EXPECT_EQ('\377', buffer[0]);
1856 EXPECT_EQ('a', buffer[1]);
1857 EXPECT_EQ(break_detected, false);
1858 EXPECT_EQ(parity_error_detected, false);
1859
1860 buffer[0] = 'b';
1861 bytes_read = 1;
1862 break_detected = false;
1863 parity_error_detected = false;
1864 new_bytes_read = call_CheckReceiveError(
1865 buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
1866 EXPECT_EQ(NO_ERROR, get_error_detect_state());
1867 EXPECT_EQ(0, get_num_chars_ignored());
1868 EXPECT_EQ(1, new_bytes_read);
1869 EXPECT_EQ('b', buffer[0]);
1870 EXPECT_EQ(break_detected, false);
1871 EXPECT_EQ(parity_error_detected, false);
1872 }
1873 }
1874
1875 // '\377'
1876 // 'a' 'b'
1877 TEST_F(SerialIoHandlerPosixTest, InvalidSequenceReadTwiceBytesReadOneAndTwo) {
1878 set_error_detect_state(NO_ERROR);
1879 set_parity_check_enabled(true);
1880 set_num_chars_ignored(0);
1881 int buffer_len = 2;
1882 char buffer[buffer_len];
1883
1884 buffer[0] = '\377';
1885 int bytes_read = 1;
1886 bool break_detected = false;
1887 bool parity_error_detected = false;
1888 int new_bytes_read = call_CheckReceiveError(
1889 buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
1890 EXPECT_EQ(MARK_377_SEEN, get_error_detect_state());
1891 EXPECT_EQ(1, get_num_chars_ignored());
1892 EXPECT_EQ('\377', get_chars_ignored(0));
1893 EXPECT_EQ(0, new_bytes_read);
1894 EXPECT_EQ(break_detected, false);
1895 EXPECT_EQ(parity_error_detected, false);
1896
1897 buffer[0] = 'a';
1898 buffer[1] = 'b';
1899 bytes_read = 2;
1900 break_detected = false;
1901 parity_error_detected = false;
1902 new_bytes_read = call_CheckReceiveError(
1903 buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
1904 EXPECT_EQ(NO_ERROR, get_error_detect_state());
1905 EXPECT_EQ(1, get_num_chars_ignored());
1906 EXPECT_EQ('b', get_chars_ignored(0));
1907 EXPECT_EQ(2, new_bytes_read);
1908 EXPECT_EQ('\377', buffer[0]);
1909 EXPECT_EQ('a', buffer[1]);
1910 EXPECT_EQ(break_detected, false);
1911 EXPECT_EQ(parity_error_detected, false);
1912 }
1913
1914 // '\377'
1915 // 'a' 'b'
1916 TEST_F(SerialIoHandlerPosixTest,
1917 InvalidSequenceReadTwiceBytesReadOneAndTwoLargerBufferLen) {
1918 for (int buffer_len = 3; buffer_len <= 20; ++buffer_len) {
1919 set_error_detect_state(NO_ERROR);
1920 set_parity_check_enabled(true);
1921 set_num_chars_ignored(0);
1922 char buffer[buffer_len];
1923
1924 buffer[0] = '\377';
1925 int bytes_read = 1;
1926 bool break_detected = false;
1927 bool parity_error_detected = false;
1928 int new_bytes_read = call_CheckReceiveError(
1929 buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
1930 EXPECT_EQ(MARK_377_SEEN, get_error_detect_state());
1931 EXPECT_EQ(1, get_num_chars_ignored());
1932 EXPECT_EQ('\377', get_chars_ignored(0));
1933 EXPECT_EQ(0, new_bytes_read);
1934 EXPECT_EQ(break_detected, false);
1935 EXPECT_EQ(parity_error_detected, false);
1936
1937 buffer[0] = 'a';
1938 buffer[1] = 'b';
1939 bytes_read = 2;
1940 break_detected = false;
1941 parity_error_detected = false;
1942 new_bytes_read = call_CheckReceiveError(
1943 buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
1944 EXPECT_EQ(NO_ERROR, get_error_detect_state());
1945 EXPECT_EQ(0, get_num_chars_ignored());
1946 EXPECT_EQ(3, new_bytes_read);
1947 EXPECT_EQ('\377', buffer[0]);
1948 EXPECT_EQ('a', buffer[1]);
1949 EXPECT_EQ('b', buffer[2]);
1950 EXPECT_EQ(break_detected, false);
1951 EXPECT_EQ(parity_error_detected, false);
1952 }
1953 }
1954
1955 // '\377'
1956 // 'a'
1957 // 'b'
1958 TEST_F(SerialIoHandlerPosixTest, InvalidSequenceReadThreeTimes) {
1959 set_error_detect_state(NO_ERROR);
1960 set_parity_check_enabled(true);
1961 set_num_chars_ignored(0);
1962 int buffer_len = 1;
1963 char buffer[buffer_len];
1964
1965 buffer[0] = '\377';
1966 int bytes_read = 1;
1967 bool break_detected = false;
1968 bool parity_error_detected = false;
1969 int new_bytes_read = call_CheckReceiveError(
1970 buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
1971 EXPECT_EQ(MARK_377_SEEN, get_error_detect_state());
1972 EXPECT_EQ(1, get_num_chars_ignored());
1973 EXPECT_EQ('\377', get_chars_ignored(0));
1974 EXPECT_EQ(0, new_bytes_read);
1975 EXPECT_EQ(break_detected, false);
1976 EXPECT_EQ(parity_error_detected, false);
1977
1978 buffer[0] = 'a';
1979 bytes_read = 1;
1980 break_detected = false;
1981 parity_error_detected = false;
1982 new_bytes_read = call_CheckReceiveError(
1983 buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
1984 EXPECT_EQ(NO_ERROR, get_error_detect_state());
1985 EXPECT_EQ(1, get_num_chars_ignored());
1986 EXPECT_EQ('a', get_chars_ignored(0));
1987 EXPECT_EQ(1, new_bytes_read);
1988 EXPECT_EQ('\377', buffer[0]);
1989 EXPECT_EQ(break_detected, false);
1990 EXPECT_EQ(parity_error_detected, false);
1991
1992 buffer[0] = 'b';
1993 bytes_read = 1;
1994 new_bytes_read = call_CheckReceiveError(
1995 buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
1996 EXPECT_EQ(NO_ERROR, get_error_detect_state());
1997 EXPECT_EQ(1, get_num_chars_ignored());
1998 EXPECT_EQ('b', get_chars_ignored(0));
1999 EXPECT_EQ(1, new_bytes_read);
2000 EXPECT_EQ('a', buffer[0]);
2001 EXPECT_EQ(break_detected, false);
2002 EXPECT_EQ(parity_error_detected, false);
2003 }
2004
2005 // '\377'
2006 // 'a'
2007 // 'b'
2008 TEST_F(SerialIoHandlerPosixTest, InvalidSequenceReadThreeTimesLargerBufferLen) {
2009 for (int buffer_len = 2; buffer_len <= 20; ++buffer_len) {
2010 set_error_detect_state(NO_ERROR);
2011 set_parity_check_enabled(true);
2012 set_num_chars_ignored(0);
2013 char buffer[buffer_len];
2014
2015 buffer[0] = '\377';
2016 int bytes_read = 1;
2017 bool break_detected = false;
2018 bool parity_error_detected = false;
2019 int new_bytes_read = call_CheckReceiveError(
2020 buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
2021 EXPECT_EQ(MARK_377_SEEN, get_error_detect_state());
2022 EXPECT_EQ(1, get_num_chars_ignored());
2023 EXPECT_EQ('\377', get_chars_ignored(0));
2024 EXPECT_EQ(0, new_bytes_read);
2025 EXPECT_EQ(break_detected, false);
2026 EXPECT_EQ(parity_error_detected, false);
2027
2028 buffer[0] = 'a';
2029 bytes_read = 1;
2030 break_detected = false;
2031 parity_error_detected = false;
2032 new_bytes_read = call_CheckReceiveError(
2033 buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
2034 EXPECT_EQ(NO_ERROR, get_error_detect_state());
2035 EXPECT_EQ(0, get_num_chars_ignored());
2036 EXPECT_EQ(2, new_bytes_read);
2037 EXPECT_EQ('\377', buffer[0]);
2038 EXPECT_EQ('a', buffer[1]);
2039 EXPECT_EQ(break_detected, false);
2040 EXPECT_EQ(parity_error_detected, false);
2041
2042 buffer[0] = 'b';
2043 bytes_read = 1;
2044 break_detected = false;
2045 parity_error_detected = false;
2046 new_bytes_read = call_CheckReceiveError(
2047 buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
2048 EXPECT_EQ(NO_ERROR, get_error_detect_state());
2049 EXPECT_EQ(0, get_num_chars_ignored());
2050 EXPECT_EQ(1, new_bytes_read);
2051 EXPECT_EQ('b', buffer[0]);
2052 EXPECT_EQ(break_detected, false);
2053 EXPECT_EQ(parity_error_detected, false);
2054 }
2055 }
2056
2057 // 'a' 'b' 'c' '\377'
2058 TEST_F(SerialIoHandlerPosixTest, CharsIgnoredPreset) {
2059 set_error_detect_state(NO_ERROR);
2060 set_parity_check_enabled(true);
2061 set_num_chars_ignored(2);
2062 set_chars_ignored(0, 'a');
2063 set_chars_ignored(1, 'b');
2064 int buffer_len = 2;
2065 char buffer[buffer_len];
2066
2067 buffer[0] = 'c';
2068 buffer[1] = '\377';
2069 int bytes_read = 2;
2070 bool break_detected = false;
2071 bool parity_error_detected = false;
2072 int new_bytes_read = call_CheckReceiveError(
2073 buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
2074 EXPECT_EQ(MARK_377_SEEN, get_error_detect_state());
2075 EXPECT_EQ(2, get_num_chars_ignored());
2076 EXPECT_EQ('c', get_chars_ignored(0));
2077 EXPECT_EQ('\377', get_chars_ignored(1));
2078 EXPECT_EQ(2, new_bytes_read);
2079 EXPECT_EQ('a', buffer[0]);
2080 EXPECT_EQ('b', buffer[1]);
2081 EXPECT_EQ(break_detected, false);
2082 EXPECT_EQ(parity_error_detected, false);
2083 }
2084
2085 // 'b' 'c' '\377' '\0' '\0' '\377' '\377' '\377' '\0' 'a' 'd' 'e'
2086 TEST_F(SerialIoHandlerPosixTest, BreakAndEOFAndParityError) {
2087 set_error_detect_state(NO_ERROR);
2088 set_parity_check_enabled(true);
2089 set_num_chars_ignored(0);
2090 int buffer_len = 12;
2091 char buffer[buffer_len];
2092
2093 buffer[0] = 'b';
2094 buffer[1] = 'c';
2095 buffer[2] = '\377';
2096 buffer[3] = '\0';
2097 buffer[4] = '\0';
2098 buffer[5] = '\377';
2099 buffer[6] = '\377';
2100 buffer[7] = '\377';
2101 buffer[8] = '\0';
2102 buffer[9] = 'a';
2103 buffer[10] = 'd';
2104 buffer[11] = 'e';
2105 int bytes_read = 12;
2106 bool break_detected = false;
2107 bool parity_error_detected = false;
2108 int new_bytes_read = call_CheckReceiveError(
2109 buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
2110 EXPECT_EQ(NO_ERROR, get_error_detect_state());
2111 EXPECT_EQ(0, get_num_chars_ignored());
2112 EXPECT_EQ(5, new_bytes_read);
2113 EXPECT_EQ('b', buffer[0]);
2114 EXPECT_EQ('c', buffer[1]);
2115 EXPECT_EQ('\377', buffer[2]);
2116 EXPECT_EQ('d', buffer[3]);
2117 EXPECT_EQ('e', buffer[4]);
2118 EXPECT_EQ(break_detected, true);
2119 EXPECT_EQ(parity_error_detected, true);
2120 }
2121
2122 // 'b' 'c' '\377' '\0' '\0' '\377'
2123 // '\377' '\377' '\0'
2124 // 'a' 'd' 'e'
2125 TEST_F(SerialIoHandlerPosixTest, BreakAndEOFAndParityErrorReadThreeTimes) {
2126 for (int buffer_len = 6; buffer_len <= 20; ++buffer_len) {
2127 set_error_detect_state(NO_ERROR);
2128 set_parity_check_enabled(true);
2129 set_num_chars_ignored(0);
2130 char buffer[buffer_len];
2131
2132 buffer[0] = 'b';
2133 buffer[1] = 'c';
2134 buffer[2] = '\377';
2135 buffer[3] = '\0';
2136 buffer[4] = '\0';
2137 buffer[5] = '\377';
2138 int bytes_read = 6;
2139 bool break_detected = false;
2140 bool parity_error_detected = false;
2141 int new_bytes_read = call_CheckReceiveError(
2142 buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
2143 EXPECT_EQ(MARK_377_SEEN, get_error_detect_state());
2144 EXPECT_EQ(1, get_num_chars_ignored());
2145 EXPECT_EQ('\377', get_chars_ignored(0));
2146 EXPECT_EQ(2, new_bytes_read);
2147 EXPECT_EQ('b', buffer[0]);
2148 EXPECT_EQ('c', buffer[1]);
2149 EXPECT_EQ(break_detected, true);
2150 EXPECT_EQ(parity_error_detected, false);
2151
2152 buffer[0] = '\377';
2153 buffer[1] = '\377';
2154 buffer[2] = '\0';
2155 bytes_read = 3;
2156 break_detected = false;
2157 parity_error_detected = false;
2158 new_bytes_read = call_CheckReceiveError(
2159 buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
2160 EXPECT_EQ(MARK_0_SEEN, get_error_detect_state());
2161 EXPECT_EQ(2, get_num_chars_ignored());
2162 EXPECT_EQ('\377', get_chars_ignored(0));
2163 EXPECT_EQ('\0', get_chars_ignored(1));
2164 EXPECT_EQ(1, new_bytes_read);
2165 EXPECT_EQ('\377', buffer[0]);
2166 EXPECT_EQ(break_detected, false);
2167 EXPECT_EQ(parity_error_detected, false);
2168
2169 buffer[0] = 'a';
2170 buffer[1] = 'd';
2171 buffer[2] = 'e';
2172 bytes_read = 3;
2173 break_detected = false;
2174 parity_error_detected = false;
2175 new_bytes_read = call_CheckReceiveError(
2176 buffer, buffer_len, bytes_read, break_detected, parity_error_detected);
2177 EXPECT_EQ(NO_ERROR, get_error_detect_state());
2178 EXPECT_EQ(0, get_num_chars_ignored());
2179 EXPECT_EQ(2, new_bytes_read);
2180 EXPECT_EQ('d', buffer[0]);
2181 EXPECT_EQ('e', buffer[1]);
2182 EXPECT_EQ(break_detected, false);
2183 EXPECT_EQ(parity_error_detected, true);
2184 }
2185 }
2186
2187 } // namespace device
OLDNEW
« device/serial/serial_io_handler_posix.h ('K') | « device/serial/serial_io_handler_posix.cc ('k') | no next file » | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698