OLD | NEW |
---|---|
(Empty) | |
1 // Copyright 2015 The Chromium Authors. All rights reserved. | |
2 // Use of this source code is governed by a BSD-style license that can be | |
3 // found in the LICENSE file. | |
4 | |
5 #include "device/serial/serial_io_handler_posix.h" | |
6 #include "testing/gtest/include/gtest/gtest.h" | |
7 | |
8 namespace device { | |
9 | |
10 class SerialIoHandlerPosixTest : public testing::Test { | |
11 public: | |
12 SerialIoHandlerPosixTest() {} | |
13 | |
14 void SetUp() override { | |
15 serial_io_handler_posix_ = new SerialIoHandlerPosix(nullptr, nullptr); | |
16 } | |
17 | |
18 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 | |
OLD | NEW |