| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright (c) 2012 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/quic/quic_reliable_client_stream.h" | |
| 6 | |
| 7 #include "net/base/net_errors.h" | |
| 8 #include "net/base/test_completion_callback.h" | |
| 9 #include "net/quic/quic_client_session.h" | |
| 10 #include "net/quic/quic_utils.h" | |
| 11 #include "net/quic/spdy_utils.h" | |
| 12 #include "net/quic/test_tools/quic_test_utils.h" | |
| 13 #include "testing/gmock/include/gmock/gmock.h" | |
| 14 | |
| 15 using testing::AnyNumber; | |
| 16 using testing::Return; | |
| 17 using testing::StrEq; | |
| 18 using testing::_; | |
| 19 | |
| 20 namespace net { | |
| 21 namespace test { | |
| 22 namespace { | |
| 23 | |
| 24 const QuicConnectionId kStreamId = 3; | |
| 25 | |
| 26 class MockDelegate : public QuicReliableClientStream::Delegate { | |
| 27 public: | |
| 28 MockDelegate() {} | |
| 29 | |
| 30 MOCK_METHOD0(OnSendData, int()); | |
| 31 MOCK_METHOD2(OnSendDataComplete, int(int, bool*)); | |
| 32 MOCK_METHOD2(OnDataReceived, int(const char*, int)); | |
| 33 MOCK_METHOD1(OnClose, void(QuicErrorCode)); | |
| 34 MOCK_METHOD1(OnError, void(int)); | |
| 35 MOCK_METHOD0(HasSendHeadersComplete, bool()); | |
| 36 | |
| 37 private: | |
| 38 DISALLOW_COPY_AND_ASSIGN(MockDelegate); | |
| 39 }; | |
| 40 | |
| 41 class QuicReliableClientStreamTest | |
| 42 : public ::testing::TestWithParam<QuicVersion> { | |
| 43 public: | |
| 44 QuicReliableClientStreamTest() | |
| 45 : session_(new MockConnection(false, SupportedVersions(GetParam()))) { | |
| 46 stream_ = new QuicReliableClientStream(kStreamId, &session_, BoundNetLog()); | |
| 47 session_.ActivateStream(stream_); | |
| 48 stream_->SetDelegate(&delegate_); | |
| 49 } | |
| 50 | |
| 51 void InitializeHeaders() { | |
| 52 headers_[":host"] = "www.google.com"; | |
| 53 headers_[":path"] = "/index.hml"; | |
| 54 headers_[":scheme"] = "https"; | |
| 55 headers_["cookie"] = | |
| 56 "__utma=208381060.1228362404.1372200928.1372200928.1372200928.1; " | |
| 57 "__utmc=160408618; " | |
| 58 "GX=DQAAAOEAAACWJYdewdE9rIrW6qw3PtVi2-d729qaa-74KqOsM1NVQblK4VhX" | |
| 59 "hoALMsy6HOdDad2Sz0flUByv7etmo3mLMidGrBoljqO9hSVA40SLqpG_iuKKSHX" | |
| 60 "RW3Np4bq0F0SDGDNsW0DSmTS9ufMRrlpARJDS7qAI6M3bghqJp4eABKZiRqebHT" | |
| 61 "pMU-RXvTI5D5oCF1vYxYofH_l1Kviuiy3oQ1kS1enqWgbhJ2t61_SNdv-1XJIS0" | |
| 62 "O3YeHLmVCs62O6zp89QwakfAWK9d3IDQvVSJzCQsvxvNIvaZFa567MawWlXg0Rh" | |
| 63 "1zFMi5vzcns38-8_Sns; " | |
| 64 "GA=v*2%2Fmem*57968640*47239936%2Fmem*57968640*47114716%2Fno-nm-" | |
| 65 "yj*15%2Fno-cc-yj*5%2Fpc-ch*133685%2Fpc-s-cr*133947%2Fpc-s-t*1339" | |
| 66 "47%2Fno-nm-yj*4%2Fno-cc-yj*1%2Fceft-as*1%2Fceft-nqas*0%2Fad-ra-c" | |
| 67 "v_p%2Fad-nr-cv_p-f*1%2Fad-v-cv_p*859%2Fad-ns-cv_p-f*1%2Ffn-v-ad%" | |
| 68 "2Fpc-t*250%2Fpc-cm*461%2Fpc-s-cr*722%2Fpc-s-t*722%2Fau_p*4" | |
| 69 "SICAID=AJKiYcHdKgxum7KMXG0ei2t1-W4OD1uW-ecNsCqC0wDuAXiDGIcT_HA2o1" | |
| 70 "3Rs1UKCuBAF9g8rWNOFbxt8PSNSHFuIhOo2t6bJAVpCsMU5Laa6lewuTMYI8MzdQP" | |
| 71 "ARHKyW-koxuhMZHUnGBJAM1gJODe0cATO_KGoX4pbbFxxJ5IicRxOrWK_5rU3cdy6" | |
| 72 "edlR9FsEdH6iujMcHkbE5l18ehJDwTWmBKBzVD87naobhMMrF6VvnDGxQVGp9Ir_b" | |
| 73 "Rgj3RWUoPumQVCxtSOBdX0GlJOEcDTNCzQIm9BSfetog_eP_TfYubKudt5eMsXmN6" | |
| 74 "QnyXHeGeK2UINUzJ-D30AFcpqYgH9_1BvYSpi7fc7_ydBU8TaD8ZRxvtnzXqj0RfG" | |
| 75 "tuHghmv3aD-uzSYJ75XDdzKdizZ86IG6Fbn1XFhYZM-fbHhm3mVEXnyRW4ZuNOLFk" | |
| 76 "Fas6LMcVC6Q8QLlHYbXBpdNFuGbuZGUnav5C-2I_-46lL0NGg3GewxGKGHvHEfoyn" | |
| 77 "EFFlEYHsBQ98rXImL8ySDycdLEFvBPdtctPmWCfTxwmoSMLHU2SCVDhbqMWU5b0yr" | |
| 78 "JBCScs_ejbKaqBDoB7ZGxTvqlrB__2ZmnHHjCr8RgMRtKNtIeuZAo "; | |
| 79 } | |
| 80 | |
| 81 testing::StrictMock<MockDelegate> delegate_; | |
| 82 MockSession session_; | |
| 83 QuicReliableClientStream* stream_; | |
| 84 QuicCryptoClientConfig crypto_config_; | |
| 85 SpdyHeaderBlock headers_; | |
| 86 }; | |
| 87 | |
| 88 INSTANTIATE_TEST_CASE_P(Version, QuicReliableClientStreamTest, | |
| 89 ::testing::ValuesIn(QuicSupportedVersions())); | |
| 90 | |
| 91 TEST_P(QuicReliableClientStreamTest, OnFinRead) { | |
| 92 InitializeHeaders(); | |
| 93 std::string uncompressed_headers = | |
| 94 SpdyUtils::SerializeUncompressedHeaders(headers_); | |
| 95 EXPECT_CALL(delegate_, OnDataReceived(StrEq(uncompressed_headers.data()), | |
| 96 uncompressed_headers.size())); | |
| 97 QuicStreamOffset offset = 0; | |
| 98 stream_->OnStreamHeaders(uncompressed_headers); | |
| 99 stream_->OnStreamHeadersComplete(false, uncompressed_headers.length()); | |
| 100 | |
| 101 IOVector iov; | |
| 102 QuicStreamFrame frame2(kStreamId, true, offset, iov); | |
| 103 EXPECT_CALL(delegate_, OnClose(QUIC_NO_ERROR)); | |
| 104 stream_->OnStreamFrame(frame2); | |
| 105 } | |
| 106 | |
| 107 TEST_P(QuicReliableClientStreamTest, ProcessData) { | |
| 108 const char data[] = "hello world!"; | |
| 109 EXPECT_CALL(delegate_, OnDataReceived(StrEq(data), arraysize(data))); | |
| 110 EXPECT_CALL(delegate_, OnClose(QUIC_NO_ERROR)); | |
| 111 | |
| 112 EXPECT_EQ(arraysize(data), stream_->ProcessData(data, arraysize(data))); | |
| 113 } | |
| 114 | |
| 115 TEST_P(QuicReliableClientStreamTest, ProcessDataWithError) { | |
| 116 const char data[] = "hello world!"; | |
| 117 EXPECT_CALL(delegate_, | |
| 118 OnDataReceived(StrEq(data), | |
| 119 arraysize(data))).WillOnce(Return(ERR_UNEXPECTED)); | |
| 120 EXPECT_CALL(delegate_, OnClose(QUIC_NO_ERROR)); | |
| 121 | |
| 122 | |
| 123 EXPECT_EQ(0u, stream_->ProcessData(data, arraysize(data))); | |
| 124 } | |
| 125 | |
| 126 TEST_P(QuicReliableClientStreamTest, OnError) { | |
| 127 EXPECT_CALL(delegate_, OnError(ERR_INTERNET_DISCONNECTED)); | |
| 128 | |
| 129 stream_->OnError(ERR_INTERNET_DISCONNECTED); | |
| 130 EXPECT_FALSE(stream_->GetDelegate()); | |
| 131 } | |
| 132 | |
| 133 TEST_P(QuicReliableClientStreamTest, WriteStreamData) { | |
| 134 EXPECT_CALL(delegate_, OnClose(QUIC_NO_ERROR)); | |
| 135 | |
| 136 const char kData1[] = "hello world"; | |
| 137 const size_t kDataLen = arraysize(kData1); | |
| 138 | |
| 139 // All data written. | |
| 140 EXPECT_CALL(session_, WritevData(stream_->id(), _, _, _, _, _)).WillOnce( | |
| 141 Return(QuicConsumedData(kDataLen, true))); | |
| 142 TestCompletionCallback callback; | |
| 143 EXPECT_EQ(OK, stream_->WriteStreamData(base::StringPiece(kData1, kDataLen), | |
| 144 true, callback.callback())); | |
| 145 } | |
| 146 | |
| 147 TEST_P(QuicReliableClientStreamTest, WriteStreamDataAsync) { | |
| 148 EXPECT_CALL(delegate_, HasSendHeadersComplete()).Times(AnyNumber()); | |
| 149 EXPECT_CALL(delegate_, OnClose(QUIC_NO_ERROR)); | |
| 150 | |
| 151 const char kData1[] = "hello world"; | |
| 152 const size_t kDataLen = arraysize(kData1); | |
| 153 | |
| 154 // No data written. | |
| 155 EXPECT_CALL(session_, WritevData(stream_->id(), _, _, _, _, _)).WillOnce( | |
| 156 Return(QuicConsumedData(0, false))); | |
| 157 TestCompletionCallback callback; | |
| 158 EXPECT_EQ(ERR_IO_PENDING, | |
| 159 stream_->WriteStreamData(base::StringPiece(kData1, kDataLen), | |
| 160 true, callback.callback())); | |
| 161 ASSERT_FALSE(callback.have_result()); | |
| 162 | |
| 163 // All data written. | |
| 164 EXPECT_CALL(session_, WritevData(stream_->id(), _, _, _, _, _)).WillOnce( | |
| 165 Return(QuicConsumedData(kDataLen, true))); | |
| 166 stream_->OnCanWrite(); | |
| 167 ASSERT_TRUE(callback.have_result()); | |
| 168 EXPECT_EQ(OK, callback.WaitForResult()); | |
| 169 } | |
| 170 | |
| 171 } // namespace | |
| 172 } // namespace test | |
| 173 } // namespace net | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 992733002:
Remove //net (except for Android test stuff) and sdch (Closed)
Base URL: git@github.com:domokit/mojo.git@master