Modify DeterministicSocketData to verify that the sequence number of reads and writes start at zero…

net/spdy/spdy_network_transaction_spdy3_unittest.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "net/http/http_network_transaction.h"
 
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 5518 matching lines @@
 
   scoped_ptr<SpdyFrame>
       stream1_reply(ConstructSpdyGetSynReply(NULL, 0, 1));
   MockRead reads[] = {
     CreateMockRead(*stream1_reply, 1),
     CreateMockRead(*stream2_syn, 2),
     CreateMockRead(*stream1_body, 3),
     CreateMockRead(*stream2_headers, 4),
     MockRead(ASYNC, reinterpret_cast<const char*>(kPushBodyFrame),
              arraysize(kPushBodyFrame), 5),
-    MockRead(ASYNC, 0, 5),  // EOF
+    MockRead(ASYNC, 0, 6),  // EOF
   };
 
   HttpResponseInfo response;
   HttpResponseInfo response2;
   std::string expected_push_result("pushed");
   scoped_ptr<DeterministicSocketData> data(
       new DeterministicSocketData(reads, arraysize(reads),
                                   writes, arraysize(writes)));
 
   NormalSpdyTransactionHelper helper(CreateGetRequest(),
@@ skipping 28 matching lines @@
   data->RunFor(3);
   MessageLoop::current()->RunAllPending();
 
   // Read the server push body.
   std::string result2;
   ReadResult(trans2.get(), data.get(), &result2);
   // Read the response body.
   std::string result;
   ReadResult(trans, data.get(), &result);
 
-  // Verify that we consumed all test data.
-  EXPECT_TRUE(data->at_read_eof());
-  EXPECT_TRUE(data->at_write_eof());
-
   // Verify that the received push data is same as the expected push data.
   EXPECT_EQ(result2.compare(expected_push_result), 0)
       << "Received data: "
       << result2
       << "||||| Expected data: "
       << expected_push_result;
 
   // Verify the SYN_REPLY.
   // Copy the response info, because trans goes away.
   response = *trans->GetResponseInfo();
   response2 = *trans2->GetResponseInfo();
 
   VerifyStreamsClosed(helper);
 
   // Verify the SYN_REPLY.
   EXPECT_TRUE(response.headers != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response.headers->GetStatusLine());
 
   // Verify the pushed stream.
   EXPECT_TRUE(response2.headers != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response2.headers->GetStatusLine());
+
+  // Read the final EOF (which will close the session)
+  data->RunFor(1);
+
+  // Verify that we consumed all test data.
+  EXPECT_TRUE(data->at_read_eof());
+  EXPECT_TRUE(data->at_write_eof());
 }
 
 TEST_P(SpdyNetworkTransactionSpdy3Test, ServerPushWithTwoHeaderFrames) {
   // We push a stream and attempt to claim it before the headers come down.
   static const unsigned char kPushBodyFrame[] = {
     0x00, 0x00, 0x00, 0x02,                                      // header, ID
     0x01, 0x00, 0x00, 0x06,                                      // FIN, length
     'p', 'u', 's', 'h', 'e', 'd'                                 // "pushed"
   };
   scoped_ptr<SpdyFrame>
@@ skipping 56 matching lines @@
   scoped_ptr<SpdyFrame>
       stream1_reply(ConstructSpdyGetSynReply(NULL, 0, 1));
   MockRead reads[] = {
     CreateMockRead(*stream1_reply, 1),
     CreateMockRead(*stream2_syn, 2),
     CreateMockRead(*stream1_body, 3),
     CreateMockRead(*stream2_headers1, 4),
     CreateMockRead(*stream2_headers2, 5),
     MockRead(ASYNC, reinterpret_cast<const char*>(kPushBodyFrame),
              arraysize(kPushBodyFrame), 6),
-    MockRead(ASYNC, 0, 6),  // EOF
+    MockRead(ASYNC, 0, 7),  // EOF
   };
 
   HttpResponseInfo response;
   HttpResponseInfo response2;
   std::string expected_push_result("pushed");
   scoped_ptr<DeterministicSocketData> data(
       new DeterministicSocketData(reads, arraysize(reads),
                                   writes, arraysize(writes)));
 
   NormalSpdyTransactionHelper helper(CreateGetRequest(),
@@ skipping 28 matching lines @@
   data->RunFor(3);
   MessageLoop::current()->RunAllPending();
 
   // Read the server push body.
   std::string result2;
   ReadResult(trans2.get(), data.get(), &result2);
   // Read the response body.
   std::string result;
   ReadResult(trans, data.get(), &result);
 
-  // Verify that we consumed all test data.
-  EXPECT_TRUE(data->at_read_eof());
-  EXPECT_TRUE(data->at_write_eof());
-
   // Verify that the received push data is same as the expected push data.
   EXPECT_EQ(result2.compare(expected_push_result), 0)
       << "Received data: "
       << result2
       << "||||| Expected data: "
       << expected_push_result;
 
   // Verify the SYN_REPLY.
   // Copy the response info, because trans goes away.
   response = *trans->GetResponseInfo();
@@ skipping 12 matching lines @@
   // Verify we got all the headers
   EXPECT_TRUE(response2.headers->HasHeaderValue(
       "scheme", "http"));
   EXPECT_TRUE(response2.headers->HasHeaderValue(
       "host", "www.google.com"));
   EXPECT_TRUE(response2.headers->HasHeaderValue(
       "path", "/foo.dat"));
   EXPECT_TRUE(response2.headers->HasHeaderValue("hello", "bye"));
   EXPECT_TRUE(response2.headers->HasHeaderValue("status", "200"));
   EXPECT_TRUE(response2.headers->HasHeaderValue("version", "HTTP/1.1"));
+
+  // Read the final EOF (which will close the session)
+  data->RunFor(1);
+
+  // Verify that we consumed all test data.
+  EXPECT_TRUE(data->at_read_eof());
+  EXPECT_TRUE(data->at_write_eof());
 }
 
 TEST_P(SpdyNetworkTransactionSpdy3Test, SynReplyWithHeaders) {
   scoped_ptr<SpdyFrame> req(ConstructSpdyGet(NULL, 0, false, 1, LOWEST));
   MockWrite writes[] = { CreateMockWrite(*req) };
 
   static const char* const kInitialHeaders[] = {
     ":status",
     "200 OK",
     ":version",
@@ skipping 413 matching lines @@
   // And now we can allow everything else to run to completion.
   data->SetStop(10);
   data->Run();
   EXPECT_EQ(OK, callback2.WaitForResult());
   EXPECT_EQ(OK, callback3.WaitForResult());
 
   helper.VerifyDataConsumed();
 }
 
 }  // namespace net