device/serial/serial_io_handler_posix_unittest.cc - Issue 1249933004: Add code to detect new added ReceiveError on Linux

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: updated 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

OLD	NEW
(Empty)
	1 // Copyright 2015 The Chromium Authors. All rights reserved.

	2 // Use of this source code is governed by a BSD-style license that can be

	3 // found in the LICENSE file.

	4

	5 #include "device/serial/serial_io_handler_posix.h"

	6 #include "testing/gtest/include/gtest/gtest.h"

	7

	8 namespace device {

	9

	10 class SerialIoHandlerPosixTest : public testing::Test {

	11 public:

	12 SerialIoHandlerPosixTest() {}

	13

	14 void SetUp() override {

	15 serial_io_handler_posix_ = new SerialIoHandlerPosix(nullptr, nullptr);

	16 }

	17

	18 void Initialize(ErrorDetectState error_detect_state,
	Reilly Grant (use Gerrit) 2015/07/30 17:38:35 This parameter is never set to anything but NO_ERR This parameter is never set to anything but NO_ERROR so it can be removed. juncai 2015/07/30 19:51:49 Done. Show quoted text On 2015/07/30 17:38:35, reillyg wrote: > This parameter is never set to anything but NO_ERROR so it can be removed. Done.
	19 bool parity_check_enabled,

	20 const char* chars_ignored,

	21 int num_chars_ignored) {

	22 serial_io_handler_posix_->error_detect_state_ = error_detect_state;

	23 serial_io_handler_posix_->parity_check_enabled_ = parity_check_enabled;

	24 serial_io_handler_posix_->num_chars_ignored_ = num_chars_ignored;

	25 for (int i = 0; i < num_chars_ignored; ++i) {

	26 serial_io_handler_posix_->chars_ignored_[i] = chars_ignored[i];

	27 }

	28 }

	29

	30 void TestHelper(char* buffer,

	31 int buffer_len,

	32 int bytes_read,

	33 ErrorDetectState error_detect_state_expected,

	34 const char* chars_ignored_expected,

	35 int num_chars_ignored_expected,

	36 const char* buffer_expected,

	37 int new_bytes_read_expected,

	38 bool break_detected_expected,

	39 bool parity_error_detected_expected) {

	40 bool break_detected = false;

	41 bool parity_error_detected = false;

	42 int new_bytes_read = serial_io_handler_posix_->CheckReceiveError(

	43 buffer, buffer_len, bytes_read, break_detected, parity_error_detected);

	44

	45 EXPECT_EQ(error_detect_state_expected,

	46 serial_io_handler_posix_->error_detect_state_);

	47 EXPECT_EQ(num_chars_ignored_expected,

	48 serial_io_handler_posix_->num_chars_ignored_);

	49 for (int i = 0; i < num_chars_ignored_expected; ++i) {

	50 EXPECT_EQ(chars_ignored_expected[i],

	51 serial_io_handler_posix_->chars_ignored_[i]);

	52 }

	53 EXPECT_EQ(new_bytes_read_expected, new_bytes_read);

	54 for (int i = 0; i < new_bytes_read_expected; ++i) {

	55 EXPECT_EQ(buffer_expected[i], buffer[i]);

	56 }

	57 EXPECT_EQ(break_detected_expected, break_detected);

	58 EXPECT_EQ(parity_error_detected_expected, parity_error_detected);

	59 }

	60

	61 protected:

	62 scoped_refptr<SerialIoHandlerPosix> serial_io_handler_posix_;

	63

	64 private:

	65 DISALLOW_COPY_AND_ASSIGN(SerialIoHandlerPosixTest);

	66 };

	67

	68 // 'a' 'b' 'c'

	69 TEST_F(SerialIoHandlerPosixTest, NoErrorReadOnce) {

	70 for (int buffer_len = 3; buffer_len <= 20; ++buffer_len) {

	71 Initialize(ErrorDetectState::NO_ERROR, true, "", 0);

	72

	73 char buffer[30] = {'a', 'b', 'c'};

	74 int bytes_read = 3;

	75 TestHelper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "",

	76 0, "abc", 3, false, false);

	77 }

	78 }

	79

	80 // 'a' 'b'

	81 // 'c'

	82 TEST_F(SerialIoHandlerPosixTest, NoErrorReadTwiceBytesReadTwoAndOne) {

	83 for (int buffer_len = 2; buffer_len <= 20; ++buffer_len) {

	84 Initialize(ErrorDetectState::NO_ERROR, true, "", 0);

	85

	86 char buffer_1[30] = {'a', 'b'};

	87 int bytes_read = 2;

	88 TestHelper(buffer_1, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "",

	89 0, "ab", 2, false, false);

	90

	91 char buffer_2[30] = {'c'};

	92 bytes_read = 1;

	93 TestHelper(buffer_2, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "",

	94 0, "c", 1, false, false);

	95 }

	96 }

	97

	98 // 'a'

	99 // 'b' c'

	100 TEST_F(SerialIoHandlerPosixTest, NoErrorReadTwiceBytesReadOneAndTwo) {

	101 for (int buffer_len = 2; buffer_len <= 20; ++buffer_len) {

	102 Initialize(ErrorDetectState::NO_ERROR, true, "", 0);

	103

	104 char buffer_1[30] = {'a'};

	105 int bytes_read = 1;

	106 TestHelper(buffer_1, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "",

	107 0, "a", 1, false, false);

	108

	109 char buffer_2[30] = {'b', 'c'};

	110 bytes_read = 2;

	111 TestHelper(buffer_2, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "",

	112 0, "bc", 2, false, false);

	113 }

	114 }

	115

	116 // 'a'

	117 // 'b'

	118 // 'c'

	119 TEST_F(SerialIoHandlerPosixTest, NoErrorReadThreeTimes) {

	120 for (int buffer_len = 1; buffer_len <= 20; ++buffer_len) {

	121 Initialize(ErrorDetectState::NO_ERROR, true, "", 0);

	122

	123 char buffer_1[30] = {'a'};

	124 int bytes_read = 1;

	125 TestHelper(buffer_1, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "",

	126 0, "a", 1, false, false);

	127

	128 char buffer_2[30] = {'b'};

	129 bytes_read = 1;

	130 TestHelper(buffer_2, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "",

	131 0, "b", 1, false, false);

	132

	133 char buffer_3[30] = {'c'};

	134 bytes_read = 1;

	135 TestHelper(buffer_3, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "",

	136 0, "c", 1, false, false);

	137 }

	138 }

	139

	140 // '\377' '\0' '\0'

	141 TEST_F(SerialIoHandlerPosixTest, BreakReadOnce) {

	142 for (int buffer_len = 3; buffer_len <= 20; ++buffer_len) {

	143 Initialize(ErrorDetectState::NO_ERROR, true, "", 0);

	144

	145 char buffer[30] = {'\377', '\0', '\0'};

	146 int bytes_read = 3;

	147 TestHelper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "",

	148 0, "", 0, true, false);

	149 }

	150 }

	151

	152 // 'a' 'b' '\377' '\0' '\0' 'c' 'd' 'e'

	153 TEST_F(SerialIoHandlerPosixTest, BreakReadOnceHasBytesBeforeAndAfterBreak) {

	154 for (int buffer_len = 8; buffer_len <= 20; ++buffer_len) {

	155 Initialize(ErrorDetectState::NO_ERROR, true, "", 0);

	156

	157 char buffer[30] = {'a', 'b', '\377', '\0', '\0', 'c', 'd', 'e'};

	158 int bytes_read = 8;

	159 TestHelper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "",

	160 0, "abcde", 5, true, false);

	161 }

	162 }

	163

	164 // '\377' '\0'

	165 // '\0'

	166 TEST_F(SerialIoHandlerPosixTest, BreakReadTwiceBytesReadTwoAndOne) {

	167 for (int buffer_len = 2; buffer_len <= 20; ++buffer_len) {

	168 Initialize(ErrorDetectState::NO_ERROR, true, "", 0);

	169

	170 char buffer_1[30] = {'\377', '\0'};

	171 int bytes_read = 2;

	172 TestHelper(buffer_1, buffer_len, bytes_read, ErrorDetectState::MARK_0_SEEN,

	173 "\377\0", 2, "", 0, false, false);

	174

	175 char buffer_2[30] = {'\0'};

	176 bytes_read = 1;

	177 TestHelper(buffer_2, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "",

	178 0, "", 0, true, false);

	179 }

	180 }

	181

	182 // 'a' 'b' 'c' '\377' '\0'

	183 // '\0' 'd' 'e'

	184 TEST_F(SerialIoHandlerPosixTest,

	185 BreakReadTwiceBytesReadTwoAndOneHasBytesBeforeAndAfterBreak) {

	186 for (int buffer_len = 5; buffer_len <= 20; ++buffer_len) {

	187 Initialize(ErrorDetectState::NO_ERROR, true, "", 0);

	188

	189 char buffer_1[30] = {'a', 'b', 'c', '\377', '\0'};

	190 int bytes_read = 5;

	191 TestHelper(buffer_1, buffer_len, bytes_read, ErrorDetectState::MARK_0_SEEN,

	192 "\377\0", 2, "abc", 3, false, false);

	193

	194 char buffer_2[30] = {'\0', 'd', 'e'};

	195 bytes_read = 3;

	196 TestHelper(buffer_2, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "",

	197 0, "de", 2, true, false);

	198 }

	199 }

	200

	201 // '\377'

	202 // '\0' '\0'

	203 TEST_F(SerialIoHandlerPosixTest, BreakReadTwiceBytesReadOneAndTwo) {

	204 for (int buffer_len = 2; buffer_len <= 20; ++buffer_len) {

	205 Initialize(ErrorDetectState::NO_ERROR, true, "", 0);

	206

	207 char buffer_1[30] = {'\377'};

	208 int bytes_read = 1;

	209 TestHelper(buffer_1, buffer_len, bytes_read,

	210 ErrorDetectState::MARK_377_SEEN, "\377", 1, "", 0, false, false);

	211

	212 char buffer_2[30] = {'\0', '\0'};

	213 bytes_read = 2;

	214 TestHelper(buffer_2, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "",

	215 0, "", 0, true, false);

	216 }

	217 }

	218

	219 // 'a' 'b' '\377'

	220 // '\0' '\0' 'c'

	221 TEST_F(SerialIoHandlerPosixTest,

	222 BreakReadTwiceBytesReadOneAndTwoHasBytesBeforeAndAfterBreak) {

	223 for (int buffer_len = 3; buffer_len <= 20; ++buffer_len) {

	224 Initialize(ErrorDetectState::NO_ERROR, true, "", 0);

	225

	226 char buffer_1[30] = {'a', 'b', '\377'};

	227 int bytes_read = 3;

	228 TestHelper(buffer_1, buffer_len, bytes_read,

	229 ErrorDetectState::MARK_377_SEEN, "\377", 1, "ab", 2, false,

	230 false);

	231

	232 char buffer_2[30] = {'\0', '\0', 'c'};

	233 bytes_read = 3;

	234 TestHelper(buffer_2, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "",

	235 0, "c", 1, true, false);

	236 }

	237 }

	238

	239 // '\377'

	240 // '\0'

	241 // '\0'

	242 TEST_F(SerialIoHandlerPosixTest, BreakReadThreeTimes) {

	243 for (int buffer_len = 1; buffer_len <= 20; ++buffer_len) {

	244 Initialize(ErrorDetectState::NO_ERROR, true, "", 0);

	245

	246 char buffer_1[30] = {'\377'};

	247 int bytes_read = 1;

	248 TestHelper(buffer_1, buffer_len, bytes_read,

	249 ErrorDetectState::MARK_377_SEEN, "\377", 1, "", 0, false, false);

	250

	251 char buffer_2[30] = {'\0'};

	252 bytes_read = 1;

	253 TestHelper(buffer_2, buffer_len, bytes_read, ErrorDetectState::MARK_0_SEEN,

	254 "\377\0", 2, "", 0, false, false);

	255

	256 char buffer_3[30] = {'\0'};

	257 bytes_read = 1;

	258 TestHelper(buffer_3, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "",

	259 0, "", 0, true, false);

	260 }

	261 }

	262

	263 // 'a' '\377'

	264 // '\0'

	265 // '\0' 'b'

	266 TEST_F(SerialIoHandlerPosixTest,

	267 BreakReadThreeTimesHasBytesBeforeAndAfterBreak) {

	268 for (int buffer_len = 2; buffer_len <= 20; ++buffer_len) {

	269 Initialize(ErrorDetectState::NO_ERROR, true, "", 0);

	270

	271 char buffer_1[30] = {'a', '\377'};

	272 int bytes_read = 2;

	273 TestHelper(buffer_1, buffer_len, bytes_read,

	274 ErrorDetectState::MARK_377_SEEN, "\377", 1, "a", 1, false,

	275 false);

	276

	277 char buffer_2[30] = {'\0'};

	278 bytes_read = 1;

	279 TestHelper(buffer_2, buffer_len, bytes_read, ErrorDetectState::MARK_0_SEEN,

	280 "\377\0", 2, "", 0, false, false);

	281

	282 char buffer_3[30] = {'\0', 'b'};

	283 bytes_read = 2;

	284 TestHelper(buffer_3, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "",

	285 0, "b", 1, true, false);

	286 }

	287 }

	288

	289 // '\377' '\0' 'a'

	290 TEST_F(SerialIoHandlerPosixTest, ParityErrorReadOnce) {

	291 for (int buffer_len = 3; buffer_len <= 20; ++buffer_len) {

	292 Initialize(ErrorDetectState::NO_ERROR, true, "", 0);

	293

	294 char buffer[30] = {'\377', '\0', 'a'};

	295 int bytes_read = 3;

	296 TestHelper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "",

	297 0, "", 0, false, true);

	298 }

	299 }

	300

	301 // 'b' 'c' '\377' '\0' 'a' 'd'

	302 TEST_F(SerialIoHandlerPosixTest,

	303 ParityErrorReadOnceHasBytesBeforeAndAfterParityError) {

	304 for (int buffer_len = 6; buffer_len <= 20; ++buffer_len) {

	305 Initialize(ErrorDetectState::NO_ERROR, true, "", 0);

	306

	307 char buffer[30] = {'b', 'c', '\377', '\0', 'a', 'd'};

	308 int bytes_read = 6;

	309 TestHelper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "",

	310 0, "bcd", 3, false, true);

	311 }

	312 }

	313

	314 // '\377' '\0'

	315 // 'a'

	316 TEST_F(SerialIoHandlerPosixTest, ParityErrorReadTwiceBytesReadTwoAndOne) {

	317 for (int buffer_len = 2; buffer_len <= 20; ++buffer_len) {

	318 Initialize(ErrorDetectState::NO_ERROR, true, "", 0);

	319

	320 char buffer_1[30] = {'\377', '\0'};

	321 int bytes_read = 2;

	322 TestHelper(buffer_1, buffer_len, bytes_read, ErrorDetectState::MARK_0_SEEN,

	323 "\377\0", 2, "", 0, false, false);

	324

	325 char buffer_2[30] = {'a'};

	326 bytes_read = 1;

	327 TestHelper(buffer_2, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "",

	328 0, "", 0, false, true);

	329 }

	330 }

	331

	332 // 'b' '\377' '\0'

	333 // 'a' 'c' 'd'

	334 TEST_F(

	335 SerialIoHandlerPosixTest,

	336 ParityErrorReadTwiceBytesReadTwoAndOneHasBytesBeforeAndAfterParityError) {

	337 for (int buffer_len = 3; buffer_len <= 20; ++buffer_len) {

	338 Initialize(ErrorDetectState::NO_ERROR, true, "", 0);

	339

	340 char buffer_1[30] = {'b', '\377', '\0'};

	341 int bytes_read = 3;

	342 TestHelper(buffer_1, buffer_len, bytes_read, ErrorDetectState::MARK_0_SEEN,

	343 "\377\0", 2, "b", 1, false, false);

	344

	345 char buffer_2[30] = {'a', 'c', 'd'};

	346 bytes_read = 3;

	347 TestHelper(buffer_2, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "",

	348 0, "cd", 2, false, true);

	349 }

	350 }

	351

	352 // '\377'

	353 // '\0' 'a'

	354 TEST_F(SerialIoHandlerPosixTest, ParityErrorReadTwiceBytesReadOneAndTwo) {

	355 for (int buffer_len = 2; buffer_len <= 20; ++buffer_len) {

	356 Initialize(ErrorDetectState::NO_ERROR, true, "", 0);

	357

	358 char buffer_1[30] = {'\377'};

	359 int bytes_read = 1;

	360 TestHelper(buffer_1, buffer_len, bytes_read,

	361 ErrorDetectState::MARK_377_SEEN, "\377", 1, "", 0, false, false);

	362

	363 char buffer_2[30] = {'\0', 'a'};

	364 bytes_read = 2;

	365 TestHelper(buffer_2, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "",

	366 0, "", 0, false, true);

	367 }

	368 }

	369

	370 // 'b' 'c' '\377'

	371 // '\0' 'a' 'd'

	372 TEST_F(

	373 SerialIoHandlerPosixTest,

	374 ParityErrorReadTwiceBytesReadOneAndTwoHasBytesBeforeAndAfterParityError) {

	375 for (int buffer_len = 3; buffer_len <= 20; ++buffer_len) {

	376 Initialize(ErrorDetectState::NO_ERROR, true, "", 0);

	377

	378 char buffer_1[30] = {'b', 'c', '\377'};

	379 int bytes_read = 3;

	380 TestHelper(buffer_1, buffer_len, bytes_read,

	381 ErrorDetectState::MARK_377_SEEN, "\377", 1, "bc", 2, false,

	382 false);

	383

	384 char buffer_2[30] = {'\0', 'a', 'd'};

	385 bytes_read = 3;

	386 TestHelper(buffer_2, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "",

	387 0, "d", 1, false, true);

	388 }

	389 }

	390

	391 // '\377'

	392 // '\0'

	393 // 'a'

	394 TEST_F(SerialIoHandlerPosixTest, ParityErrorReadThreeTimes) {

	395 for (int buffer_len = 1; buffer_len <= 20; ++buffer_len) {

	396 Initialize(ErrorDetectState::NO_ERROR, true, "", 0);

	397

	398 char buffer_1[30] = {'\377'};

	399 int bytes_read = 1;

	400 TestHelper(buffer_1, buffer_len, bytes_read,

	401 ErrorDetectState::MARK_377_SEEN, "\377", 1, "", 0, false, false);

	402

	403 char buffer_2[30] = {'\0'};

	404 bytes_read = 1;

	405 TestHelper(buffer_2, buffer_len, bytes_read, ErrorDetectState::MARK_0_SEEN,

	406 "\377\0", 2, "", 0, false, false);

	407

	408 char buffer_3[30] = {'a'};

	409 bytes_read = 1;

	410 TestHelper(buffer_3, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "",

	411 0, "", 0, false, true);

	412 }

	413 }

	414

	415 // 'b' '\377'

	416 // '\0'

	417 // 'a' 'c'

	418 TEST_F(SerialIoHandlerPosixTest,

	419 ParityErrorReadThreeTimesHasBytesBeforeAndAfterParityError) {

	420 for (int buffer_len = 2; buffer_len <= 20; ++buffer_len) {

	421 Initialize(ErrorDetectState::NO_ERROR, true, "", 0);

	422

	423 char buffer_1[30] = {'b', '\377'};

	424 int bytes_read = 2;

	425 TestHelper(buffer_1, buffer_len, bytes_read,

	426 ErrorDetectState::MARK_377_SEEN, "\377", 1, "b", 1, false,

	427 false);

	428

	429 char buffer_2[30] = {'\0'};

	430 bytes_read = 1;

	431 TestHelper(buffer_2, buffer_len, bytes_read, ErrorDetectState::MARK_0_SEEN,

	432 "\377\0", 2, "", 0, false, false);

	433

	434 char buffer_3[30] = {'a', 'c'};

	435 bytes_read = 2;

	436 TestHelper(buffer_3, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "",

	437 0, "c", 1, false, true);

	438 }

	439 }

	440

	441 // '\377' '\377'

	442 TEST_F(SerialIoHandlerPosixTest, TwoEOFsReadOnce) {

	443 for (int buffer_len = 2; buffer_len <= 20; ++buffer_len) {

	444 Initialize(ErrorDetectState::NO_ERROR, true, "", 0);

	445

	446 char buffer[30] = {'\377', '\377'};

	447 int bytes_read = 2;

	448 TestHelper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "",

	449 0, "\377", 1, false, false);

	450 }

	451 }

	452

	453 // 'a' '\377' '\377' 'b' 'c'

	454 TEST_F(SerialIoHandlerPosixTest, TwoEOFsReadOnceHasBytesBeforeAndAfterEOF) {

	455 for (int buffer_len = 5; buffer_len <= 20; ++buffer_len) {

	456 Initialize(ErrorDetectState::NO_ERROR, true, "", 0);

	457

	458 char buffer[30] = {'a', '\377', '\377', 'b', 'c'};

	459 int bytes_read = 5;

	460 TestHelper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "",

	461 0, "a\377bc", 4, false, false);

	462 }

	463 }

	464

	465 // '\377'

	466 // '\377'

	467 TEST_F(SerialIoHandlerPosixTest, TwoEOFsReadTwice) {

	468 for (int buffer_len = 1; buffer_len <= 20; ++buffer_len) {

	469 Initialize(ErrorDetectState::NO_ERROR, true, "", 0);

	470

	471 char buffer_1[30] = {'\377'};

	472 int bytes_read = 1;

	473 TestHelper(buffer_1, buffer_len, bytes_read,

	474 ErrorDetectState::MARK_377_SEEN, "\377", 1, "", 0, false, false);

	475

	476 char buffer_2[30] = {'\377'};

	477 bytes_read = 1;

	478 TestHelper(buffer_2, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "",

	479 0, "\377", 1, false, false);

	480 }

	481 }

	482

	483 // 'a' '\377'

	484 // '\377' 'b'

	485 TEST_F(SerialIoHandlerPosixTest, TwoEOFsReadTwiceHasBytesBeforeAndAfterEOF) {

	486 for (int buffer_len = 2; buffer_len <= 20; ++buffer_len) {

	487 Initialize(ErrorDetectState::NO_ERROR, true, "", 0);

	488

	489 char buffer_1[30] = {'a', '\377'};

	490 int bytes_read = 2;

	491 TestHelper(buffer_1, buffer_len, bytes_read,

	492 ErrorDetectState::MARK_377_SEEN, "\377", 1, "a", 1, false,

	493 false);

	494

	495 char buffer_2[30] = {'\377', 'b'};

	496 bytes_read = 2;

	497 TestHelper(buffer_2, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "",

	498 0, "\377b", 2, false, false);

	499 }

	500 }

	501

	502 // '\377' '\0' 'a'

	503 TEST_F(SerialIoHandlerPosixTest, ParityCheckDisabledReadOnce) {

	504 for (int buffer_len = 3; buffer_len <= 20; ++buffer_len) {

	505 Initialize(ErrorDetectState::NO_ERROR, false, "", 0);

	506

	507 char buffer[30] = {'\377', '\0', 'a'};

	508 int bytes_read = 3;

	509 TestHelper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "",

	510 0, "\377\000a", 3, false, false);
	Reilly Grant (use Gerrit) 2015/07/30 17:38:35 \000 -> \0 \000 -> \0 juncai 2015/07/30 19:51:49 Done. Show quoted text On 2015/07/30 17:38:35, reillyg wrote: > \000 -> \0 Done.
	511 }

	512 }

	513

	514 // 'b' '\377' '\0' 'a' 'c'

	515 TEST_F(SerialIoHandlerPosixTest,

	516 ParityCheckDisabledReadOnceHasBytesBeforeAndAfter) {

	517 for (int buffer_len = 5; buffer_len <= 20; ++buffer_len) {

	518 Initialize(ErrorDetectState::NO_ERROR, false, "", 0);

	519

	520 char buffer[30] = {'b', '\377', '\0', 'a', 'c'};

	521 int bytes_read = 5;

	522 TestHelper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "",

	523 0, "b\377\000ac", 5, false, false);
	Reilly Grant (use Gerrit) 2015/07/30 17:38:34 \000 -> \0 \000 -> \0 juncai 2015/07/30 19:51:49 Done. Show quoted text On 2015/07/30 17:38:34, reillyg wrote: > \000 -> \0 Done.
	524 }

	525 }

	526

	527 // '\377' '\0'

	528 // 'a'

	529 TEST_F(SerialIoHandlerPosixTest,

	530 ParityCheckDisabledReadTwiceBytesReadTwoAndOne) {

	531 int buffer_len = 2;

	532 Initialize(ErrorDetectState::NO_ERROR, false, "", 0);

	533

	534 char buffer_1[30] = {'\377', '\0'};

	535 int bytes_read = 2;

	536 TestHelper(buffer_1, buffer_len, bytes_read, ErrorDetectState::MARK_0_SEEN,

	537 "\377\0", 2, "", 0, false, false);

	538

	539 char buffer_2[30] = {'a'};

	540 bytes_read = 1;

	541 TestHelper(buffer_2, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "a",

	542 1, "\377\0", 2, false, false);

	543 }

	544

	545 // '\377' '\0'

	546 // 'a' 'b'

	547 TEST_F(SerialIoHandlerPosixTest,

	548 ParityCheckDisabledReadTwiceBytesReadTwoAndOneHasBytesAfter) {

	549 int buffer_len = 2;

	550 Initialize(ErrorDetectState::NO_ERROR, false, "", 0);

	551

	552 char buffer_1[30] = {'\377', '\0'};

	553 int bytes_read = 2;

	554 TestHelper(buffer_1, buffer_len, bytes_read, ErrorDetectState::MARK_0_SEEN,

	555 "\377\0", 2, "", 0, false, false);

	556

	557 char buffer_2[30] = {'a', 'b'};

	558 bytes_read = 2;

	559 TestHelper(buffer_2, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "ab",

	560 2, "\377\0", 2, false, false);

	561 }

	562

	563 // '\377' '\0'

	564 // 'a'

	565 TEST_F(SerialIoHandlerPosixTest,

	566 ParityCheckDisabledReadTwiceBytesReadTwoAndOneLargerBufferLen) {

	567 for (int buffer_len = 3; buffer_len <= 20; ++buffer_len) {

	568 Initialize(ErrorDetectState::NO_ERROR, false, "", 0);

	569

	570 char buffer_1[30] = {'\377', '\0'};

	571 int bytes_read = 2;

	572 TestHelper(buffer_1, buffer_len, bytes_read, ErrorDetectState::MARK_0_SEEN,

	573 "\377\0", 2, "", 0, false, false);

	574

	575 char buffer_2[30] = {'a'};

	576 bytes_read = 1;

	577 TestHelper(buffer_2, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "",

	578 0, "\377\000a", 3, false, false);
	Reilly Grant (use Gerrit) 2015/07/30 17:38:34 \000 -> \0 \000 -> \0 juncai 2015/07/30 19:51:50 Done. Show quoted text On 2015/07/30 17:38:34, reillyg wrote: > \000 -> \0 Done.
	579 }

	580 }

	581

	582 // 'b' '\377' '\0'

	583 // 'a' 'c'

	584 TEST_F(

	585 SerialIoHandlerPosixTest,

	586 ParityCheckDisabledReadTwiceBytesReadTwoAndOneBufferLenThreeHasBytesBeforeAn dAfter) {

	587 int buffer_len = 3;

	588 Initialize(ErrorDetectState::NO_ERROR, false, "", 0);

	589

	590 char buffer_1[30] = {'b', '\377', '\0'};

	591 int bytes_read = 3;

	592 TestHelper(buffer_1, buffer_len, bytes_read, ErrorDetectState::MARK_0_SEEN,

	593 "\377\0", 2, "b", 1, false, false);

	594

	595 char buffer_2[30] = {'a', 'c'};

	596 bytes_read = 2;

	597 TestHelper(buffer_2, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "c",

	598 1, "\377\000a", 3, false, false);
	Reilly Grant (use Gerrit) 2015/07/30 17:38:35 \000 -> \0 \000 -> \0 juncai 2015/07/30 19:51:49 Done. Show quoted text On 2015/07/30 17:38:35, reillyg wrote: > \000 -> \0 Done.
	599 }

	600

	601 // 'b' '\377' '\0'

	602 // 'a' 'c'

	603 TEST_F(

	604 SerialIoHandlerPosixTest,

	605 ParityCheckDisabledReadTwiceBytesReadTwoAndOneLargerBufferLenHasBytesBeforeA ndAfter) {

	606 for (int buffer_len = 4; buffer_len <= 20; ++buffer_len) {

	607 Initialize(ErrorDetectState::NO_ERROR, false, "", 0);

	608

	609 char buffer_1[30] = {'b', '\377', '\0'};

	610 int bytes_read = 3;

	611 TestHelper(buffer_1, buffer_len, bytes_read, ErrorDetectState::MARK_0_SEEN,

	612 "\377\0", 2, "b", 1, false, false);

	613

	614 char buffer_2[30] = {'a', 'c'};

	615 bytes_read = 2;

	616 TestHelper(buffer_2, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "",

	617 0, "\377\000ac", 4, false, false);
	Reilly Grant (use Gerrit) 2015/07/30 17:38:35 \000 -> \0 \000 -> \0 juncai 2015/07/30 19:51:49 Done. Show quoted text On 2015/07/30 17:38:35, reillyg wrote: > \000 -> \0 Done.
	618 }

	619 }

	620

	621 // '\377'

	622 // '\0' 'a'

	623 TEST_F(SerialIoHandlerPosixTest,

	624 ParityCheckDisabledReadTwiceBytesReadOneAndTwo) {

	625 int buffer_len = 2;

	626 Initialize(ErrorDetectState::NO_ERROR, false, "", 0);

	627

	628 char buffer_1[30] = {'\377'};

	629 int bytes_read = 1;

	630 TestHelper(buffer_1, buffer_len, bytes_read, ErrorDetectState::MARK_377_SEEN,

	631 "\377", 1, "", 0, false, false);

	632

	633 char buffer_2[30] = {'\0', 'a'};

	634 bytes_read = 2;

	635 TestHelper(buffer_2, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "a",

	636 1, "\377\0", 2, false, false);
	Reilly Grant (use Gerrit) 2015/07/30 17:38:35 Add another call after this to check that "a" is p Add another call after this to check that "a" is produced when there's more buffer space available. juncai 2015/07/30 19:51:49 Done. Show quoted text On 2015/07/30 17:38:35, reillyg wrote: > Add another call after this to check that "a" is produced when there's more > buffer space available. Done.
	637 }

	638

	639 // 'b' '\377'

	640 // '\0' 'a'

	641 TEST_F(SerialIoHandlerPosixTest,

	642 ParityCheckDisabledReadTwiceBytesReadOneAndTwoHasBytesBefore) {

	643 int buffer_len = 2;

	644 Initialize(ErrorDetectState::NO_ERROR, false, "", 0);

	645

	646 char buffer_1[30] = {'b', '\377'};

	647 int bytes_read = 2;

	648 TestHelper(buffer_1, buffer_len, bytes_read, ErrorDetectState::MARK_377_SEEN,

	649 "\377", 1, "b", 1, false, false);

	650

	651 char buffer_2[30] = {'\0', 'a'};

	652 bytes_read = 2;

	653 TestHelper(buffer_2, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "a",

	654 1, "\377\0", 2, false, false);
	Reilly Grant (use Gerrit) 2015/07/30 17:38:35 Same here. Same here. juncai 2015/07/30 19:51:49 Done. Show quoted text On 2015/07/30 17:38:35, reillyg wrote: > Same here. Done.
	655 }

	656

	657 // '\377'

	658 // '\0' 'a'

	659 TEST_F(SerialIoHandlerPosixTest,

	660 ParityCheckDisabledReadTwiceBytesReadOneAndTwoLargerBufferLen) {

	661 for (int buffer_len = 3; buffer_len <= 20; ++buffer_len) {

	662 Initialize(ErrorDetectState::NO_ERROR, false, "", 0);

	663

	664 char buffer_1[30] = {'\377'};

	665 int bytes_read = 1;

	666 TestHelper(buffer_1, buffer_len, bytes_read,

	667 ErrorDetectState::MARK_377_SEEN, "\377", 1, "", 0, false, false);

	668

	669 char buffer_2[30] = {'\0', 'a'};

	670 bytes_read = 2;

	671 TestHelper(buffer_2, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "",

	672 0, "\377\000a", 3, false, false);
	Reilly Grant (use Gerrit) 2015/07/30 17:38:35 \000 -> \0 \000 -> \0 juncai 2015/07/30 19:51:49 Done. Show quoted text On 2015/07/30 17:38:35, reillyg wrote: > \000 -> \0 Done.
	673 }

	674 }

	675

	676 // 'b' '\377'

	677 // '\0' 'a' 'c'

	678 TEST_F(

	679 SerialIoHandlerPosixTest,

	680 ParityCheckDisabledReadTwiceBytesReadOneAndTwoBufferLenThreeHasBytesBeforeAn dAfter) {

	681 int buffer_len = 3;

	682 Initialize(ErrorDetectState::NO_ERROR, false, "", 0);

	683

	684 char buffer_1[30] = {'b', '\377'};

	685 int bytes_read = 2;

	686 TestHelper(buffer_1, buffer_len, bytes_read, ErrorDetectState::MARK_377_SEEN,

	687 "\377", 1, "b", 1, false, false);

	688

	689 char buffer_2[30] = {'\0', 'a', 'c'};

	690 bytes_read = 3;

	691 TestHelper(buffer_2, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "c",

	692 1, "\377\000a", 3, false, false);
	Reilly Grant (use Gerrit) 2015/07/30 17:38:35 \000 -> \0 \000 -> \0 juncai 2015/07/30 19:51:50 Done. Show quoted text On 2015/07/30 17:38:35, reillyg wrote: > \000 -> \0 Done.
	693 }

	694

	695 // 'b' '\377'

	696 // '\0' 'a' 'c'

	697 TEST_F(

	698 SerialIoHandlerPosixTest,

	699 ParityCheckDisabledReadTwiceBytesReadOneAndTwoLargerBufferLenHasBytesBeforeA ndAfter) {

	700 for (int buffer_len = 4; buffer_len <= 20; ++buffer_len) {

	701 Initialize(ErrorDetectState::NO_ERROR, false, "", 0);

	702

	703 char buffer_1[30] = {'b', '\377'};

	704 int bytes_read = 2;

	705 TestHelper(buffer_1, buffer_len, bytes_read,

	706 ErrorDetectState::MARK_377_SEEN, "\377", 1, "b", 1, false,

	707 false);

	708

	709 char buffer_2[30] = {'\0', 'a', 'c'};

	710 bytes_read = 3;

	711 TestHelper(buffer_2, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "",

	712 0, "\377\000ac", 4, false, false);
	Reilly Grant (use Gerrit) 2015/07/30 17:38:35 \000 -> \0 \000 -> \0 juncai 2015/07/30 19:51:50 Done. Show quoted text On 2015/07/30 17:38:35, reillyg wrote: > \000 -> \0 Done.
	713 }

	714 }

	715

	716 // '\377'

	717 // '\0'

	718 // 'a'

	719 TEST_F(SerialIoHandlerPosixTest,

	720 ParityCheckDisabledReadThreeTimesBufferLenOne) {

	721 int buffer_len = 1;

	722 Initialize(ErrorDetectState::NO_ERROR, false, "", 0);

	723

	724 char buffer_1[30] = {'\377'};

	725 int bytes_read = 1;

	726 TestHelper(buffer_1, buffer_len, bytes_read, ErrorDetectState::MARK_377_SEEN,

	727 "\377", 1, "", 0, false, false);

	728

	729 char buffer_2[30] = {'\0'};

	730 bytes_read = 1;

	731 TestHelper(buffer_2, buffer_len, bytes_read, ErrorDetectState::MARK_0_SEEN,

	732 "\377\0", 2, "", 0, false, false);

	733

	734 char buffer_3[30] = {'a'};

	735 bytes_read = 1;

	736 TestHelper(buffer_3, buffer_len, bytes_read, ErrorDetectState::NO_ERROR,

	737 "\000a", 2, "\377", 1, false, false);
	Reilly Grant (use Gerrit) 2015/07/30 17:38:35 \000 -> \0 \000 -> \0 juncai 2015/07/30 19:51:49 Done. Show quoted text On 2015/07/30 17:38:35, reillyg wrote: > \000 -> \0 Done.
	738 }

	739

	740 // '\377'

	741 // '\0'

	742 // 'a'

	743 TEST_F(SerialIoHandlerPosixTest,

	744 ParityCheckDisabledReadThreeTimesBufferLenTwo) {

	745 int buffer_len = 2;

	746 Initialize(ErrorDetectState::NO_ERROR, false, "", 0);

	747

	748 char buffer_1[30] = {'\377'};

	749 int bytes_read = 1;

	750 TestHelper(buffer_1, buffer_len, bytes_read, ErrorDetectState::MARK_377_SEEN,

	751 "\377", 1, "", 0, false, false);

	752

	753 char buffer_2[30] = {'\0'};

	754 bytes_read = 1;

	755 TestHelper(buffer_2, buffer_len, bytes_read, ErrorDetectState::MARK_0_SEEN,

	756 "\377\0", 2, "", 0, false, false);

	757

	758 char buffer_3[30] = {'a'};

	759 bytes_read = 1;

	760 TestHelper(buffer_3, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "a",

	761 1, "\377\0", 2, false, false);

	762 }

	763

	764 // '\377'

	765 // '\0'

	766 // 'a'

	767 TEST_F(SerialIoHandlerPosixTest,

	768 ParityCheckDisabledReadThreeTimesLargerBufferLen) {

	769 for (int buffer_len = 3; buffer_len <= 20; ++buffer_len) {

	770 Initialize(ErrorDetectState::NO_ERROR, false, "", 0);

	771

	772 char buffer_1[30] = {'\377'};

	773 int bytes_read = 1;

	774 TestHelper(buffer_1, buffer_len, bytes_read,

	775 ErrorDetectState::MARK_377_SEEN, "\377", 1, "", 0, false, false);

	776

	777 char buffer_2[30] = {'\0'};

	778 bytes_read = 1;

	779 TestHelper(buffer_2, buffer_len, bytes_read, ErrorDetectState::MARK_0_SEEN,

	780 "\377\0", 2, "", 0, false, false);

	781

	782 char buffer_3[30] = {'a'};

	783 bytes_read = 1;

	784 TestHelper(buffer_3, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "",

	785 0, "\377\000a", 3, false, false);
	Reilly Grant (use Gerrit) 2015/07/30 17:38:35 \000 -> \0 \000 -> \0 juncai 2015/07/30 19:51:49 Done. Show quoted text On 2015/07/30 17:38:35, reillyg wrote: > \000 -> \0 Done.
	786 }

	787 }

	788

	789 // 'b' '\377'

	790 // '\0'

	791 // 'a' 'c'

	792 TEST_F(SerialIoHandlerPosixTest,

	793 ParityCheckDisabledReadThreeTimesBufferLenThreeByteBeforeAndAfter) {

	794 int buffer_len = 3;

	795 Initialize(ErrorDetectState::NO_ERROR, false, "", 0);

	796

	797 char buffer_1[30] = {'b', '\377'};

	798 int bytes_read = 2;

	799 TestHelper(buffer_1, buffer_len, bytes_read, ErrorDetectState::MARK_377_SEEN,

	800 "\377", 1, "b", 1, false, false);

	801

	802 char buffer_2[30] = {'\0'};

	803 bytes_read = 1;

	804 TestHelper(buffer_2, buffer_len, bytes_read, ErrorDetectState::MARK_0_SEEN,

	805 "\377\0", 2, "", 0, false, false);

	806

	807 char buffer_3[30] = {'a', 'c'};

	808 bytes_read = 2;

	809 TestHelper(buffer_3, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "c",

	810 1, "\377\000a", 3, false, false);
	Reilly Grant (use Gerrit) 2015/07/30 17:38:35 \000 -> \0 \000 -> \0 juncai 2015/07/30 19:51:49 Done. Show quoted text On 2015/07/30 17:38:35, reillyg wrote: > \000 -> \0 Done.
	811 }

	812

	813 // 'b' '\377'

	814 // '\0'

	815 // 'a' 'c'

	816 TEST_F(SerialIoHandlerPosixTest,

	817 ParityCheckDisabledReadThreeTimesLargerBufferLenHasBytesBeforeAndAfter) {

	818 for (int buffer_len = 4; buffer_len <= 20; ++buffer_len) {

	819 Initialize(ErrorDetectState::NO_ERROR, false, "", 0);

	820

	821 char buffer_1[30] = {'b', '\377'};

	822 int bytes_read = 2;

	823 TestHelper(buffer_1, buffer_len, bytes_read,

	824 ErrorDetectState::MARK_377_SEEN, "\377", 1, "b", 1, false,

	825 false);

	826

	827 char buffer_2[30] = {'\0'};

	828 bytes_read = 1;

	829 TestHelper(buffer_2, buffer_len, bytes_read, ErrorDetectState::MARK_0_SEEN,

	830 "\377\0", 2, "", 0, false, false);

	831

	832 char buffer_3[30] = {'a', 'c'};

	833 bytes_read = 2;

	834 TestHelper(buffer_3, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "",

	835 0, "\377\000ac", 4, false, false);
	Reilly Grant (use Gerrit) 2015/07/30 17:38:35 \000 -> \0 \000 -> \0 juncai 2015/07/30 19:51:49 Done. Show quoted text On 2015/07/30 17:38:35, reillyg wrote: > \000 -> \0 Done.
	836 }

	837 }

	838

	839 TEST_F(SerialIoHandlerPosixTest, BytesReadZero) {

	840 for (int buffer_len = 1; buffer_len <= 20; ++buffer_len) {

	841 Initialize(ErrorDetectState::NO_ERROR, true, "", 0);

	842

	843 char buffer[30];

	844 int bytes_read = 0;

	845 TestHelper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "",

	846 0, "", 0, false, false);

	847 }

	848 }

	849

	850 // '\377' 'a' 'b'

	851 TEST_F(SerialIoHandlerPosixTest, InvalidSequenceReadOnce) {

	852 for (int buffer_len = 3; buffer_len <= 20; ++buffer_len) {

	853 Initialize(ErrorDetectState::NO_ERROR, true, "", 0);

	854

	855 char buffer[30] = {'\377', 'a', 'b'};

	856 int bytes_read = 3;

	857 TestHelper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "",

	858 0, "\377ab", 3, false, false);

	859 }

	860 }

	861

	862 // '\377' 'a'

	863 // 'b'

	864 TEST_F(SerialIoHandlerPosixTest, InvalidSequenceReadTwiceBytesReadTwoAndOne) {

	865 for (int buffer_len = 2; buffer_len <= 20; ++buffer_len) {

	866 Initialize(ErrorDetectState::NO_ERROR, true, "", 0);

	867

	868 char buffer_1[30] = {'\377', 'a'};

	869 int bytes_read = 2;

	870 TestHelper(buffer_1, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "",

	871 0, "\377a", 2, false, false);

	872

	873 char buffer_2[30] = {'b'};

	874 bytes_read = 1;

	875 TestHelper(buffer_2, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "",

	876 0, "b", 1, false, false);

	877 }

	878 }

	879

	880 // '\377'

	881 // 'a' 'b'

	882 TEST_F(SerialIoHandlerPosixTest, InvalidSequenceReadTwiceBytesReadOneAndTwo) {

	883 int buffer_len = 2;

	884 Initialize(ErrorDetectState::NO_ERROR, true, "", 0);

	885

	886 char buffer_1[30] = {'\377'};

	887 int bytes_read = 1;

	888 TestHelper(buffer_1, buffer_len, bytes_read, ErrorDetectState::MARK_377_SEEN,

	889 "\377", 1, "", 0, false, false);

	890

	891 char buffer_2[30] = {'a', 'b'};

	892 bytes_read = 2;

	893 TestHelper(buffer_2, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "b",

	894 1, "\377a", 2, false, false);

	895 }

	896

	897 // '\377'

	898 // 'a' 'b'

	899 TEST_F(SerialIoHandlerPosixTest,

	900 InvalidSequenceReadTwiceBytesReadOneAndTwoLargerBufferLen) {

	901 for (int buffer_len = 3; buffer_len <= 20; ++buffer_len) {

	902 Initialize(ErrorDetectState::NO_ERROR, true, "", 0);

	903

	904 char buffer_1[30] = {'\377'};

	905 int bytes_read = 1;

	906 TestHelper(buffer_1, buffer_len, bytes_read,

	907 ErrorDetectState::MARK_377_SEEN, "\377", 1, "", 0, false, false);

	908

	909 char buffer_2[30] = {'a', 'b'};

	910 bytes_read = 2;

	911 TestHelper(buffer_2, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "",

	912 0, "\377ab", 3, false, false);

	913 }

	914 }

	915

	916 // '\377'

	917 // 'a'

	918 // 'b'

	919 TEST_F(SerialIoHandlerPosixTest, InvalidSequenceReadThreeTimes) {

	920 int buffer_len = 1;

	921 Initialize(ErrorDetectState::NO_ERROR, true, "", 0);

	922

	923 char buffer_1[30] = {'\377'};

	924 int bytes_read = 1;

	925 TestHelper(buffer_1, buffer_len, bytes_read, ErrorDetectState::MARK_377_SEEN,

	926 "\377", 1, "", 0, false, false);

	927

	928 char buffer_2[30] = {'a'};

	929 bytes_read = 1;

	930 TestHelper(buffer_2, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "a",

	931 1, "\377", 1, false, false);

	932

	933 char buffer_3[30] = {'b'};

	934 bytes_read = 1;

	935 TestHelper(buffer_3, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "b",

	936 1, "a", 1, false, false);

	937 }

	938

	939 // '\377'

	940 // 'a'

	941 // 'b'

	942 TEST_F(SerialIoHandlerPosixTest, InvalidSequenceReadThreeTimesLargerBufferLen) {

	943 for (int buffer_len = 2; buffer_len <= 20; ++buffer_len) {

	944 Initialize(ErrorDetectState::NO_ERROR, true, "", 0);

	945

	946 char buffer_1[30] = {'\377'};

	947 int bytes_read = 1;

	948 TestHelper(buffer_1, buffer_len, bytes_read,

	949 ErrorDetectState::MARK_377_SEEN, "\377", 1, "", 0, false, false);

	950

	951 char buffer_2[30] = {'a'};

	952 bytes_read = 1;

	953 TestHelper(buffer_2, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "",

	954 0, "\377a", 2, false, false);

	955

	956 char buffer_3[30] = {'b'};

	957 bytes_read = 1;

	958 TestHelper(buffer_3, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "",

	959 0, "b", 1, false, false);

	960 }

	961 }

	962

	963 // 'a' 'b' 'c' '\377'

	964 TEST_F(SerialIoHandlerPosixTest, CharsIgnoredPreset) {

	965 int buffer_len = 2;

	966 Initialize(ErrorDetectState::NO_ERROR, true, "ab", 2);

	967

	968 char buffer[30] = {'c', '\377'};

	969 int bytes_read = 2;

	970 TestHelper(buffer, buffer_len, bytes_read, ErrorDetectState::MARK_377_SEEN,

	971 "c\377", 2, "ab", 2, false, false);

	972 }

	973

	974 // 'b' 'c' '\377' '\0' '\0' '\377' '\377' '\377' '\0' 'a' 'd' 'e'

	975 TEST_F(SerialIoHandlerPosixTest, BreakAndEOFAndParityError) {

	976 int buffer_len = 12;

	977 Initialize(ErrorDetectState::NO_ERROR, true, "", 0);

	978

	979 char buffer[30] = {'b', 'c', '\377', '\0', '\0', '\377',

	980 '\377', '\377', '\0', 'a', 'd', 'e'};

	981 int bytes_read = 12;

	982 TestHelper(buffer, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "", 0,

	983 "bc\377de", 5, true, true);

	984 }

	985

	986 // 'b' 'c' '\377' '\0' '\0' '\377'

	987 // '\377' '\377' '\0'

	988 // 'a' 'd' 'e'

	989 TEST_F(SerialIoHandlerPosixTest, BreakAndEOFAndParityErrorReadThreeTimes) {

	990 for (int buffer_len = 6; buffer_len <= 20; ++buffer_len) {

	991 Initialize(ErrorDetectState::NO_ERROR, true, "", 0);

	992

	993 char buffer_1[30] = {'b', 'c', '\377', '\0', '\0', '\377'};

	994 int bytes_read = 6;

	995 TestHelper(buffer_1, buffer_len, bytes_read,

	996 ErrorDetectState::MARK_377_SEEN, "\377", 1, "bc", 2, true,

	997 false);

	998

	999 char buffer_2[30] = {'\377', '\377', '\0'};

	1000 bytes_read = 3;

	1001 TestHelper(buffer_2, buffer_len, bytes_read, ErrorDetectState::MARK_0_SEEN,

	1002 "\377\0", 2, "\377", 1, false, false);

	1003

	1004 char buffer_3[30] = {'a', 'd', 'e'};

	1005 bytes_read = 3;

	1006 TestHelper(buffer_3, buffer_len, bytes_read, ErrorDetectState::NO_ERROR, "",

	1007 0, "de", 2, false, true);

	1008 }

	1009 }

	1010

	1011 } // namespace device

OLD	NEW

« device/serial/serial_io_handler_posix.cc ('K') | « device/serial/serial_io_handler_posix.cc ('k') | no next file » | no next file with comments »