Home | History | Annotate | Download | only in balsa 
      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