1 // Copyright 2013 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 "net/tools/balsa/balsa_frame.h" 6 7 #include <iterator> 8 9 #include "base/memory/scoped_ptr.h" 10 #include "base/strings/string_piece.h" 11 #include "net/tools/balsa/balsa_enums.h" 12 #include "net/tools/balsa/balsa_headers.h" 13 #include "testing/gmock/include/gmock/gmock.h" 14 #include "testing/gtest/include/gtest/gtest.h" 15 16 namespace net { 17 18 namespace { 19 20 using ::base::StringPiece; 21 using ::testing::_; 22 using ::testing::InSequence; 23 using ::testing::SaveArg; 24 25 class Visitor : public BalsaVisitorInterface { 26 public: 27 virtual ~Visitor() {} 28 MOCK_METHOD2(ProcessBodyInput, void(const char*, size_t)); 29 MOCK_METHOD2(ProcessBodyData, void(const char*, size_t)); 30 MOCK_METHOD2(ProcessHeaderInput, void(const char*, size_t)); 31 MOCK_METHOD2(ProcessTrailerInput, void(const char*, size_t)); 32 MOCK_METHOD1(ProcessHeaders, void(const BalsaHeaders&)); 33 MOCK_METHOD8(ProcessRequestFirstLine, void(const char*, 34 size_t, 35 const char*, 36 size_t, 37 const char*, 38 size_t, 39 const char*, 40 size_t)); 41 MOCK_METHOD8(ProcessResponseFirstLine, void(const char*, 42 size_t, 43 const char*, 44 size_t, 45 const char*, 46 size_t, 47 const char*, 48 size_t)); 49 MOCK_METHOD2(ProcessChunkExtensions, void(const char*, size_t)); 50 MOCK_METHOD1(ProcessChunkLength, void(size_t)); 51 MOCK_METHOD0(HeaderDone, void()); 52 MOCK_METHOD0(MessageDone, void()); 53 MOCK_METHOD1(HandleHeaderError, void(BalsaFrame*)); 54 MOCK_METHOD1(HandleHeaderWarning, void(BalsaFrame*)); 55 MOCK_METHOD1(HandleChunkingError, void(BalsaFrame*)); 56 MOCK_METHOD1(HandleBodyError, void(BalsaFrame*)); 57 }; 58 59 class BalsaFrameTest : public ::testing::Test { 60 public: 61 virtual void SetUp() OVERRIDE { 62 frame_.reset(new BalsaFrame); 63 frame_headers_.reset(new BalsaHeaders); 64 visitor_.reset(new Visitor); 65 frame_->set_balsa_visitor(visitor_.get()); 66 }; 67 68 protected: 69 scoped_ptr<BalsaFrame> frame_; 70 scoped_ptr<BalsaHeaders> frame_headers_; 71 scoped_ptr<Visitor> visitor_; 72 }; 73 74 TEST_F(BalsaFrameTest, EmptyFrame) { 75 ASSERT_EQ(BalsaFrameEnums::READING_HEADER_AND_FIRSTLINE, 76 frame_->ParseState()); 77 ASSERT_FALSE(frame_->MessageFullyRead()); 78 ASSERT_FALSE(frame_->Error()); 79 ASSERT_EQ(NULL, frame_->const_balsa_headers()); 80 ASSERT_EQ(NULL, frame_->balsa_headers()); 81 ASSERT_EQ(NULL, frame_->headers()); 82 ASSERT_EQ(NULL, frame_->mutable_headers()); 83 ASSERT_EQ(0u, frame_->BytesSafeToSplice()); 84 ASSERT_TRUE(frame_->is_request()); 85 ASSERT_FALSE(frame_->request_was_head()); 86 } 87 88 TEST_F(BalsaFrameTest, EmptyRequest) { 89 const char input[] = "\r\n"; 90 frame_->set_balsa_headers(frame_headers_.get()); 91 92 { 93 InSequence s; 94 // No visitor callback should be called. 95 } 96 size_t read = frame_->ProcessInput(input, strlen(input)); 97 EXPECT_EQ(2u, read); 98 ASSERT_EQ(BalsaFrameEnums::READING_HEADER_AND_FIRSTLINE, 99 frame_->ParseState()); 100 ASSERT_FALSE(frame_->Error()); 101 ASSERT_EQ(BalsaFrameEnums::NO_ERROR, frame_->ErrorCode()); 102 ASSERT_EQ(0u, frame_->BytesSafeToSplice()); 103 } 104 105 TEST_F(BalsaFrameTest, GetRequest) { 106 const char input[] = "GET / HTTP/1.0\r\nkey1: value1\r\n\r\n"; 107 const char* line = NULL; 108 size_t line_length = 0; 109 const char* method = NULL; 110 size_t method_length = 0; 111 const char* request_uri = NULL; 112 size_t request_uri_length = 0; 113 const char* version = NULL; 114 size_t version_length = 0; 115 const char* header = NULL; 116 size_t header_length = 0; 117 118 { 119 InSequence s; 120 EXPECT_CALL(*visitor_, ProcessRequestFirstLine(_, _, _, _, _, _, _, _)) 121 .WillOnce(DoAll(SaveArg<0>(&line), 122 SaveArg<1>(&line_length), 123 SaveArg<2>(&method), 124 SaveArg<3>(&method_length), 125 SaveArg<4>(&request_uri), 126 SaveArg<5>(&request_uri_length), 127 SaveArg<6>(&version), 128 SaveArg<7>(&version_length))); 129 EXPECT_CALL(*visitor_, ProcessHeaderInput(_, _)) 130 .WillOnce(DoAll(SaveArg<0>(&header), SaveArg<1>(&header_length))); 131 EXPECT_CALL(*visitor_, ProcessHeaders(_)); 132 EXPECT_CALL(*visitor_, HeaderDone()); 133 EXPECT_CALL(*visitor_, MessageDone()); 134 } 135 136 frame_->set_balsa_headers(frame_headers_.get()); 137 ASSERT_EQ(frame_headers_.get(), frame_->const_balsa_headers()); 138 ASSERT_EQ(frame_headers_.get(), frame_->balsa_headers()); 139 ASSERT_EQ(frame_headers_.get(), frame_->headers()); 140 ASSERT_EQ(frame_headers_.get(), frame_->mutable_headers()); 141 142 size_t read = frame_->ProcessInput(input, strlen(input)); 143 ASSERT_EQ(strlen(input), read); 144 ASSERT_EQ(BalsaFrameEnums::MESSAGE_FULLY_READ, frame_->ParseState()); 145 ASSERT_TRUE(frame_->MessageFullyRead()); 146 ASSERT_FALSE(frame_->Error()); 147 ASSERT_EQ(0u, frame_->BytesSafeToSplice()); 148 ASSERT_EQ("GET / HTTP/1.0", StringPiece(line, line_length)); 149 ASSERT_EQ("GET", StringPiece(method, method_length)); 150 ASSERT_EQ("/", StringPiece(request_uri, request_uri_length)); 151 ASSERT_EQ("HTTP/1.0", StringPiece(version, version_length)); 152 ASSERT_EQ(input, StringPiece(header, header_length)); 153 } 154 155 TEST_F(BalsaFrameTest, HeadResponse) { 156 const char input[] = "HTTP/1.1 200 OK\r\n" 157 "Content-type: text/plain\r\n" 158 "Content-Length: 14\r\n\r\n"; 159 const char* line = NULL; 160 size_t line_length = 0; 161 const char* version = NULL; 162 size_t version_length = 0; 163 const char* status = NULL; 164 size_t status_length = 0; 165 const char* reason = NULL; 166 size_t reason_length = 0; 167 const char* header = NULL; 168 size_t header_length = 0; 169 170 frame_->set_balsa_headers(frame_headers_.get()); 171 frame_->set_is_request(false); 172 frame_->set_request_was_head(true); 173 174 { 175 InSequence s; 176 EXPECT_CALL(*visitor_, ProcessResponseFirstLine(_, _, _, _, _, _, _, _)) 177 .WillOnce(DoAll(SaveArg<0>(&line), 178 SaveArg<1>(&line_length), 179 SaveArg<2>(&version), 180 SaveArg<3>(&version_length), 181 SaveArg<4>(&status), 182 SaveArg<5>(&status_length), 183 SaveArg<6>(&reason), 184 SaveArg<7>(&reason_length))); 185 EXPECT_CALL(*visitor_, ProcessHeaderInput(_, _)) 186 .WillOnce(DoAll(SaveArg<0>(&header), SaveArg<1>(&header_length))); 187 EXPECT_CALL(*visitor_, ProcessHeaders(_)); 188 EXPECT_CALL(*visitor_, HeaderDone()); 189 EXPECT_CALL(*visitor_, MessageDone()); 190 } 191 192 size_t read = frame_->ProcessInput(input, strlen(input)); 193 ASSERT_EQ(strlen(input), read); 194 ASSERT_EQ(BalsaFrameEnums::MESSAGE_FULLY_READ, frame_->ParseState()); 195 ASSERT_TRUE(frame_->MessageFullyRead()); 196 ASSERT_FALSE(frame_->Error()); 197 ASSERT_EQ(0u, frame_->BytesSafeToSplice()); 198 199 ASSERT_EQ("HTTP/1.1 200 OK", StringPiece(line, line_length)); 200 ASSERT_EQ("HTTP/1.1", StringPiece(version, version_length)); 201 ASSERT_EQ("200", StringPiece(status, status_length)); 202 ASSERT_EQ("OK", StringPiece(reason, reason_length)); 203 ASSERT_EQ("HTTP/1.1 200 OK\r\n" 204 "Content-type: text/plain\r\n" 205 "Content-Length: 14\r\n\r\n", 206 StringPiece(header, header_length)); 207 } 208 209 TEST_F(BalsaFrameTest, GetResponse) { 210 const char input[] = "HTTP/1.1 200 OK\r\n" 211 "Content-type: text/plain\r\n" 212 "Content-Length: 14\r\n\r\n" 213 "hello, world\r\n"; 214 const char* line = NULL; 215 size_t line_length = 0; 216 const char* version = NULL; 217 size_t version_length = 0; 218 const char* status = NULL; 219 size_t status_length = 0; 220 const char* reason = NULL; 221 size_t reason_length = 0; 222 const char* header = NULL; 223 size_t header_length = 0; 224 const char* body = NULL; 225 size_t body_length = 0; 226 const char* body_data = NULL; 227 size_t body_data_length = 0; 228 testing::MockFunction<void(int)> checkpoint; 229 230 frame_->set_balsa_headers(frame_headers_.get()); 231 frame_->set_is_request(false); 232 233 { 234 InSequence s; 235 EXPECT_CALL(*visitor_, ProcessResponseFirstLine(_, _, _, _, _, _, _, _)) 236 .WillOnce(DoAll(SaveArg<0>(&line), 237 SaveArg<1>(&line_length), 238 SaveArg<2>(&version), 239 SaveArg<3>(&version_length), 240 SaveArg<4>(&status), 241 SaveArg<5>(&status_length), 242 SaveArg<6>(&reason), 243 SaveArg<7>(&reason_length))); 244 EXPECT_CALL(*visitor_, ProcessHeaderInput(_, _)) 245 .WillOnce(DoAll(SaveArg<0>(&header), SaveArg<1>(&header_length))); 246 EXPECT_CALL(*visitor_, ProcessHeaders(_)); 247 EXPECT_CALL(*visitor_, HeaderDone()); 248 EXPECT_CALL(checkpoint, Call(0)); 249 EXPECT_CALL(*visitor_, ProcessBodyInput(_, _)) 250 .WillOnce(DoAll(SaveArg<0>(&body), SaveArg<1>(&body_length))); 251 EXPECT_CALL(*visitor_, ProcessBodyData(_, _)) 252 .WillOnce(DoAll(SaveArg<0>(&body_data), SaveArg<1>(&body_data_length))); 253 EXPECT_CALL(*visitor_, MessageDone()); 254 } 255 256 size_t read = frame_->ProcessInput(input, strlen(input)); 257 ASSERT_EQ(65u, read); 258 ASSERT_EQ(BalsaFrameEnums::READING_CONTENT, frame_->ParseState()); 259 checkpoint.Call(0); 260 read += frame_->ProcessInput(&input[read], strlen(input) - read); 261 ASSERT_EQ(strlen(input), read); 262 ASSERT_EQ(BalsaFrameEnums::MESSAGE_FULLY_READ, frame_->ParseState()); 263 ASSERT_TRUE(frame_->MessageFullyRead()); 264 ASSERT_FALSE(frame_->Error()); 265 ASSERT_EQ(0u, frame_->BytesSafeToSplice()); 266 267 ASSERT_EQ("HTTP/1.1 200 OK", StringPiece(line, line_length)); 268 ASSERT_EQ("HTTP/1.1", StringPiece(version, version_length)); 269 ASSERT_EQ("200", StringPiece(status, status_length)); 270 ASSERT_EQ("OK", StringPiece(reason, reason_length)); 271 ASSERT_EQ("HTTP/1.1 200 OK\r\n" 272 "Content-type: text/plain\r\n" 273 "Content-Length: 14\r\n\r\n", 274 StringPiece(header, header_length)); 275 ASSERT_EQ("hello, world\r\n", StringPiece(body, body_length)); 276 ASSERT_EQ("hello, world\r\n", StringPiece(body_data, body_data_length)); 277 } 278 279 TEST_F(BalsaFrameTest, Reset) { 280 const char input[] = "GET / HTTP/1.0\r\nkey1: value1\r\n\r\n"; 281 282 { 283 InSequence s; 284 EXPECT_CALL(*visitor_, ProcessRequestFirstLine(_, _, _, _, _, _, _, _)); 285 EXPECT_CALL(*visitor_, ProcessHeaderInput(_, _)); 286 EXPECT_CALL(*visitor_, ProcessHeaders(_)); 287 EXPECT_CALL(*visitor_, HeaderDone()); 288 EXPECT_CALL(*visitor_, MessageDone()); 289 } 290 291 frame_->set_balsa_headers(frame_headers_.get()); 292 293 size_t read = frame_->ProcessInput(input, strlen(input)); 294 ASSERT_EQ(strlen(input), read); 295 ASSERT_EQ(BalsaFrameEnums::MESSAGE_FULLY_READ, frame_->ParseState()); 296 ASSERT_TRUE(frame_->MessageFullyRead()); 297 ASSERT_FALSE(frame_->Error()); 298 299 frame_->Reset(); 300 ASSERT_EQ(BalsaFrameEnums::READING_HEADER_AND_FIRSTLINE, 301 frame_->ParseState()); 302 ASSERT_FALSE(frame_->MessageFullyRead()); 303 ASSERT_FALSE(frame_->Error()); 304 } 305 306 TEST_F(BalsaFrameTest, InvalidStatusCode) { 307 const char input[] = "HTTP/1.1 InvalidStatusCode OK\r\n" 308 "Content-type: text/plain\r\n" 309 "Content-Length: 14\r\n\r\n" 310 "hello, world\r\n"; 311 312 frame_->set_balsa_headers(frame_headers_.get()); 313 frame_->set_is_request(false); 314 315 { 316 InSequence s; 317 EXPECT_CALL(*visitor_, HandleHeaderError(frame_.get())); 318 } 319 320 size_t read = frame_->ProcessInput(input, strlen(input)); 321 ASSERT_EQ(30u, read); 322 ASSERT_EQ(BalsaFrameEnums::PARSE_ERROR, frame_->ParseState()); 323 ASSERT_EQ(BalsaFrameEnums::FAILED_CONVERTING_STATUS_CODE_TO_INT, 324 frame_->ErrorCode()); 325 ASSERT_FALSE(frame_->MessageFullyRead()); 326 ASSERT_TRUE(frame_->Error()); 327 ASSERT_EQ(0u, frame_->BytesSafeToSplice()); 328 } 329 330 TEST_F(BalsaFrameTest, ResetError) { 331 const char input[] = "HTTP/1.1 InvalidStatusCode OK\r\n" 332 "Content-type: text/plain\r\n" 333 "Content-Length: 14\r\n\r\n" 334 "hello, world\r\n"; 335 336 frame_->set_balsa_headers(frame_headers_.get()); 337 frame_->set_is_request(false); 338 339 { 340 InSequence s; 341 EXPECT_CALL(*visitor_, HandleHeaderError(frame_.get())); 342 } 343 344 size_t read = frame_->ProcessInput(input, strlen(input)); 345 ASSERT_EQ(30u, read); 346 ASSERT_EQ(BalsaFrameEnums::PARSE_ERROR, frame_->ParseState()); 347 ASSERT_EQ(BalsaFrameEnums::FAILED_CONVERTING_STATUS_CODE_TO_INT, 348 frame_->ErrorCode()); 349 ASSERT_FALSE(frame_->MessageFullyRead()); 350 ASSERT_TRUE(frame_->Error()); 351 ASSERT_EQ(0u, frame_->BytesSafeToSplice()); 352 353 frame_->Reset(); 354 ASSERT_EQ(BalsaFrameEnums::READING_HEADER_AND_FIRSTLINE, 355 frame_->ParseState()); 356 ASSERT_FALSE(frame_->MessageFullyRead()); 357 ASSERT_FALSE(frame_->Error()); 358 } 359 360 TEST_F(BalsaFrameTest, RequestURITooLong) { 361 const char input[] = "GET / HTTP/1.0\r\n\r\n"; 362 363 frame_->set_balsa_headers(frame_headers_.get()); 364 frame_->set_max_request_uri_length(0); 365 366 { 367 InSequence s; 368 EXPECT_CALL(*visitor_, HandleHeaderError(frame_.get())); 369 } 370 371 size_t read = frame_->ProcessInput(input, strlen(input)); 372 ASSERT_EQ(15u, read); 373 ASSERT_EQ(BalsaFrameEnums::PARSE_ERROR, frame_->ParseState()); 374 ASSERT_EQ(BalsaFrameEnums::REQUEST_URI_TOO_LONG, frame_->ErrorCode()); 375 ASSERT_FALSE(frame_->MessageFullyRead()); 376 ASSERT_TRUE(frame_->Error()); 377 ASSERT_EQ(0u, frame_->BytesSafeToSplice()); 378 } 379 380 TEST_F(BalsaFrameTest, HeadersTooLong) { 381 const char input[] = "GET / HTTP/1.0\r\n\r\n"; 382 383 frame_->set_balsa_headers(frame_headers_.get()); 384 frame_->set_max_header_length(0); 385 386 { 387 InSequence s; 388 EXPECT_CALL(*visitor_, HandleHeaderError(frame_.get())); 389 } 390 391 size_t read = frame_->ProcessInput(input, strlen(input)); 392 ASSERT_EQ(0u, read); 393 ASSERT_EQ(BalsaFrameEnums::PARSE_ERROR, frame_->ParseState()); 394 ASSERT_EQ(BalsaFrameEnums::HEADERS_TOO_LONG, frame_->ErrorCode()); 395 ASSERT_FALSE(frame_->MessageFullyRead()); 396 ASSERT_TRUE(frame_->Error()); 397 ASSERT_EQ(0u, frame_->BytesSafeToSplice()); 398 } 399 400 TEST_F(BalsaFrameTest, InvalidHeader) { 401 const char input[] = "GET / HTTP/1.0\r\n" 402 "foo bar baz\r\n" 403 "Content-Type: text/plain\r\n\r\n"; 404 const char* line = NULL; 405 size_t line_length = 0; 406 const char* method = NULL; 407 size_t method_length = 0; 408 const char* request_uri = NULL; 409 size_t request_uri_length = 0; 410 const char* version = NULL; 411 size_t version_length = 0; 412 413 frame_->set_balsa_headers(frame_headers_.get()); 414 415 { 416 InSequence s; 417 EXPECT_CALL(*visitor_, ProcessRequestFirstLine(_, _, _, _, _, _, _, _)) 418 .WillOnce(DoAll(SaveArg<0>(&line), 419 SaveArg<1>(&line_length), 420 SaveArg<2>(&method), 421 SaveArg<3>(&method_length), 422 SaveArg<4>(&request_uri), 423 SaveArg<5>(&request_uri_length), 424 SaveArg<6>(&version), 425 SaveArg<7>(&version_length))); 426 EXPECT_CALL(*visitor_, ProcessHeaderInput(_, _)); 427 EXPECT_CALL(*visitor_, HandleHeaderWarning(frame_.get())); 428 EXPECT_CALL(*visitor_, ProcessHeaders(_)); 429 EXPECT_CALL(*visitor_, HeaderDone()); 430 EXPECT_CALL(*visitor_, MessageDone()); 431 } 432 433 size_t read = frame_->ProcessInput(input, strlen(input)); 434 ASSERT_EQ(strlen(input), read); 435 ASSERT_EQ(BalsaFrameEnums::MESSAGE_FULLY_READ, frame_->ParseState()); 436 ASSERT_EQ(BalsaFrameEnums::HEADER_MISSING_COLON, frame_->ErrorCode()); 437 ASSERT_TRUE(frame_->MessageFullyRead()); 438 ASSERT_FALSE(frame_->Error()); 439 ASSERT_EQ(0u, frame_->BytesSafeToSplice()); 440 ASSERT_EQ("GET / HTTP/1.0", StringPiece(line, line_length)); 441 ASSERT_EQ("GET", StringPiece(method, method_length)); 442 ASSERT_EQ("/", StringPiece(request_uri, request_uri_length)); 443 ASSERT_EQ("HTTP/1.0", StringPiece(version, version_length)); 444 ASSERT_EQ(2, std::distance(frame_headers_->header_lines_begin(), 445 frame_headers_->header_lines_end())); 446 } 447 448 TEST_F(BalsaFrameTest, GetResponseSplit) { 449 const char input[] = "HTTP/1.1 200 OK\r\n" 450 "Content-type: text/plain\r\n" 451 "Content-Length: 14\r\n\r\n" 452 "hello"; 453 const char input2[] = ", world\r\n"; 454 const char* body1 = NULL; 455 size_t body1_length = 0; 456 const char* body1_data = NULL; 457 size_t body1_data_length = 0; 458 const char* body2 = NULL; 459 size_t body2_length = 0; 460 const char* body2_data = NULL; 461 size_t body2_data_length = 0; 462 testing::MockFunction<void(int)> checkpoint; 463 464 frame_->set_balsa_headers(frame_headers_.get()); 465 frame_->set_is_request(false); 466 467 { 468 InSequence s; 469 EXPECT_CALL(*visitor_, ProcessResponseFirstLine(_, _, _, _, _, _, _, _)); 470 EXPECT_CALL(*visitor_, ProcessHeaderInput(_, _)); 471 EXPECT_CALL(*visitor_, ProcessHeaders(_)); 472 EXPECT_CALL(*visitor_, HeaderDone()); 473 EXPECT_CALL(checkpoint, Call(0)); 474 EXPECT_CALL(*visitor_, ProcessBodyInput(_, _)) 475 .WillOnce(DoAll(SaveArg<0>(&body1), SaveArg<1>(&body1_length))); 476 EXPECT_CALL(*visitor_, ProcessBodyData(_, _)) 477 .WillOnce(DoAll(SaveArg<0>(&body1_data), 478 SaveArg<1>(&body1_data_length))); 479 EXPECT_CALL(checkpoint, Call(1)); 480 EXPECT_CALL(*visitor_, ProcessBodyInput(_, _)) 481 .WillOnce(DoAll(SaveArg<0>(&body2), SaveArg<1>(&body2_length))); 482 EXPECT_CALL(*visitor_, ProcessBodyData(_, _)) 483 .WillOnce(DoAll(SaveArg<0>(&body2_data), 484 SaveArg<1>(&body2_data_length))); 485 EXPECT_CALL(*visitor_, MessageDone()); 486 } 487 488 size_t read = frame_->ProcessInput(input, strlen(input)); 489 ASSERT_EQ(65u, read); 490 ASSERT_EQ(BalsaFrameEnums::READING_CONTENT, frame_->ParseState()); 491 checkpoint.Call(0); 492 read += frame_->ProcessInput(&input[read], strlen(input) - read); 493 ASSERT_EQ(strlen(input), read); 494 ASSERT_EQ(BalsaFrameEnums::READING_CONTENT, frame_->ParseState()); 495 checkpoint.Call(1); 496 ASSERT_EQ(9u, frame_->BytesSafeToSplice()); 497 read = frame_->ProcessInput(input2, strlen(input2)); 498 ASSERT_EQ(strlen(input2), read); 499 500 ASSERT_EQ(BalsaFrameEnums::MESSAGE_FULLY_READ, frame_->ParseState()); 501 ASSERT_TRUE(frame_->MessageFullyRead()); 502 ASSERT_FALSE(frame_->Error()); 503 ASSERT_EQ(0u, frame_->BytesSafeToSplice()); 504 ASSERT_EQ("hello", StringPiece(body1, body1_length)); 505 ASSERT_EQ("hello", StringPiece(body1_data, body1_data_length)); 506 ASSERT_EQ(", world\r\n", StringPiece(body2, body2_length)); 507 ASSERT_EQ(", world\r\n", StringPiece(body2_data, body2_data_length)); 508 } 509 510 TEST_F(BalsaFrameTest, GetResponseBytesSpliced) { 511 const char input[] = "HTTP/1.1 200 OK\r\n" 512 "Content-type: text/plain\r\n" 513 "Content-Length: 14\r\n\r\n" 514 "hello"; 515 testing::MockFunction<void(int)> checkpoint; 516 517 frame_->set_balsa_headers(frame_headers_.get()); 518 frame_->set_is_request(false); 519 520 { 521 InSequence s; 522 EXPECT_CALL(*visitor_, ProcessResponseFirstLine(_, _, _, _, _, _, _, _)); 523 EXPECT_CALL(*visitor_, ProcessHeaderInput(_, _)); 524 EXPECT_CALL(*visitor_, ProcessHeaders(_)); 525 EXPECT_CALL(*visitor_, HeaderDone()); 526 EXPECT_CALL(checkpoint, Call(0)); 527 EXPECT_CALL(*visitor_, ProcessBodyInput(_, _)); 528 EXPECT_CALL(*visitor_, ProcessBodyData(_, _)); 529 EXPECT_CALL(checkpoint, Call(1)); 530 EXPECT_CALL(checkpoint, Call(2)); 531 EXPECT_CALL(*visitor_, MessageDone()); 532 } 533 534 size_t read = frame_->ProcessInput(input, strlen(input)); 535 ASSERT_EQ(65u, read); 536 ASSERT_EQ(BalsaFrameEnums::READING_CONTENT, frame_->ParseState()); 537 checkpoint.Call(0); 538 read += frame_->ProcessInput(&input[read], strlen(input) - read); 539 ASSERT_EQ(strlen(input), read); 540 ASSERT_EQ(BalsaFrameEnums::READING_CONTENT, frame_->ParseState()); 541 ASSERT_EQ(9u, frame_->BytesSafeToSplice()); 542 checkpoint.Call(1); 543 frame_->BytesSpliced(5); 544 ASSERT_EQ(BalsaFrameEnums::READING_CONTENT, frame_->ParseState()); 545 ASSERT_EQ(4u, frame_->BytesSafeToSplice()); 546 checkpoint.Call(2); 547 frame_->BytesSpliced(4); 548 ASSERT_EQ(BalsaFrameEnums::MESSAGE_FULLY_READ, frame_->ParseState()); 549 550 ASSERT_TRUE(frame_->MessageFullyRead()); 551 ASSERT_FALSE(frame_->Error()); 552 ASSERT_EQ(0u, frame_->BytesSafeToSplice()); 553 } 554 555 TEST_F(BalsaFrameTest, GetResponseBytesSplicedTooMany) { 556 const char input[] = "HTTP/1.1 200 OK\r\n" 557 "Content-type: text/plain\r\n" 558 "Content-Length: 14\r\n\r\n" 559 "hello"; 560 testing::MockFunction<void(int)> checkpoint; 561 562 frame_->set_balsa_headers(frame_headers_.get()); 563 frame_->set_is_request(false); 564 565 { 566 InSequence s; 567 EXPECT_CALL(*visitor_, ProcessResponseFirstLine(_, _, _, _, _, _, _, _)); 568 EXPECT_CALL(*visitor_, ProcessHeaderInput(_, _)); 569 EXPECT_CALL(*visitor_, ProcessHeaders(_)); 570 EXPECT_CALL(*visitor_, HeaderDone()); 571 EXPECT_CALL(checkpoint, Call(0)); 572 EXPECT_CALL(*visitor_, ProcessBodyInput(_, _)); 573 EXPECT_CALL(*visitor_, ProcessBodyData(_, _)); 574 EXPECT_CALL(checkpoint, Call(1)); 575 EXPECT_CALL(*visitor_, HandleBodyError(frame_.get())); 576 } 577 578 size_t read = frame_->ProcessInput(input, strlen(input)); 579 ASSERT_EQ(65u, read); 580 ASSERT_EQ(BalsaFrameEnums::READING_CONTENT, frame_->ParseState()); 581 checkpoint.Call(0); 582 read += frame_->ProcessInput(&input[read], strlen(input) - read); 583 ASSERT_EQ(strlen(input), read); 584 ASSERT_EQ(BalsaFrameEnums::READING_CONTENT, frame_->ParseState()); 585 ASSERT_EQ(9u, frame_->BytesSafeToSplice()); 586 checkpoint.Call(1); 587 frame_->BytesSpliced(99); 588 ASSERT_EQ(BalsaFrameEnums::PARSE_ERROR, frame_->ParseState()); 589 ASSERT_FALSE(frame_->MessageFullyRead()); 590 ASSERT_TRUE(frame_->Error()); 591 ASSERT_EQ( 592 BalsaFrameEnums::CALLED_BYTES_SPLICED_AND_EXCEEDED_SAFE_SPLICE_AMOUNT, 593 frame_->ErrorCode()); 594 ASSERT_EQ(0u, frame_->BytesSafeToSplice()); 595 } 596 597 } // namespace 598 599 } // namespace net 600
