Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(514)

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: net/quic/quic_data_stream_test.cc

Issue 266243004: Clang format slam. Base URL: svn://svn.chromium.org/chrome/trunk/src
Patch Set: Created 6 years, 7 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 side-by-side diff with in-line comments
Download patch
« net/base/mime_util_unittest.cc ('K') | « net/quic/quic_data_stream.cc ('k') | net/quic/quic_data_writer.h » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: net/quic/quic_data_stream_test.cc
diff --git a/net/quic/quic_data_stream_test.cc b/net/quic/quic_data_stream_test.cc
index ca6d99b84d2cf6f8b253bb7737fbf983f2b3a15f..b68ca615f6dd62908a8b7eb1332c69a8ea8ae10b 100644
--- a/net/quic/quic_data_stream_test.cc
+++ b/net/quic/quic_data_stream_test.cc
@@ -36,9 +36,7 @@ const bool kShouldProcessData = true;
class TestStream : public QuicDataStream {
public:
- TestStream(QuicStreamId id,
- QuicSession* session,
- bool should_process_data)
+ TestStream(QuicStreamId id, QuicSession* session, bool should_process_data)
: QuicDataStream(id, session),
should_process_data_(should_process_data) {}
@@ -96,10 +94,10 @@ class QuicDataStreamTest : public ::testing::TestWithParam<QuicVersion> {
connection_ = new testing::StrictMock<MockConnection>(
kIsServer, SupportedVersions(GetParam()));
session_.reset(new testing::StrictMock<MockSession>(connection_));
- stream_.reset(new TestStream(kStreamId, session_.get(),
- stream_should_process_data));
- stream2_.reset(new TestStream(kStreamId + 2, session_.get(),
- stream_should_process_data));
+ stream_.reset(
+ new TestStream(kStreamId, session_.get(), stream_should_process_data));
+ stream2_.reset(new TestStream(
+ kStreamId + 2, session_.get(), stream_should_process_data));
write_blocked_list_ =
QuicSessionPeer::GetWriteblockedStreams(session_.get());
}
@@ -113,7 +111,8 @@ class QuicDataStreamTest : public ::testing::TestWithParam<QuicVersion> {
QuicWriteBlockedList* write_blocked_list_;
};
-INSTANTIATE_TEST_CASE_P(Tests, QuicDataStreamTest,
+INSTANTIATE_TEST_CASE_P(Tests,
+ QuicDataStreamTest,
::testing::ValuesIn(QuicSupportedVersions()));
TEST_P(QuicDataStreamTest, ProcessHeaders) {
@@ -148,11 +147,9 @@ TEST_P(QuicDataStreamTest, ProcessHeadersAndBodyFragments) {
string headers = SpdyUtils::SerializeUncompressedHeaders(headers_);
string body = "this is the body";
- for (size_t fragment_size = 1; fragment_size < body.size();
- ++fragment_size) {
+ for (size_t fragment_size = 1; fragment_size < body.size(); ++fragment_size) {
Initialize(kShouldProcessData);
- for (size_t offset = 0; offset < headers.size();
- offset += fragment_size) {
+ for (size_t offset = 0; offset < headers.size(); offset += fragment_size) {
size_t remaining_data = headers.size() - offset;
StringPiece fragment(headers.data() + offset,
min(fragment_size, remaining_data));
@@ -166,8 +163,8 @@ TEST_P(QuicDataStreamTest, ProcessHeadersAndBodyFragments) {
QuicStreamFrame frame(kStreamId, false, offset, MakeIOVector(fragment));
stream_->OnStreamFrame(frame);
}
- ASSERT_EQ(headers + body,
- stream_->data()) << "fragment_size: " << fragment_size;
+ ASSERT_EQ(headers + body, stream_->data())
+ << "fragment_size: " << fragment_size;
}
}
@@ -189,14 +186,13 @@ TEST_P(QuicDataStreamTest, ProcessHeadersAndBodyFragmentsSplit) {
QuicStreamFrame frame1(kStreamId, false, 0, MakeIOVector(fragment1));
stream_->OnStreamFrame(frame1);
- StringPiece fragment2(body.data() + split_point,
- body.size() - split_point);
+ StringPiece fragment2(body.data() + split_point, body.size() - split_point);
QuicStreamFrame frame2(
kStreamId, false, split_point, MakeIOVector(fragment2));
stream_->OnStreamFrame(frame2);
- ASSERT_EQ(headers + body,
- stream_->data()) << "split_point: " << split_point;
+ ASSERT_EQ(headers + body, stream_->data())
+ << "split_point: " << split_point;
}
}
@@ -238,7 +234,6 @@ TEST_P(QuicDataStreamTest, ProcessHeadersAndBodyIncrementalReadv) {
QuicStreamFrame frame(kStreamId, false, 0, MakeIOVector(body));
stream_->OnStreamFrame(frame);
-
char buffer[1];
struct iovec vec;
vec.iov_base = buffer;
@@ -263,7 +258,6 @@ TEST_P(QuicDataStreamTest, ProcessHeadersUsingReadvWithMultipleIovecs) {
QuicStreamFrame frame(kStreamId, false, 0, MakeIOVector(body));
stream_->OnStreamFrame(frame);
-
char buffer1[1];
char buffer2[1];
struct iovec vec[2];
@@ -294,8 +288,9 @@ TEST_P(QuicDataStreamTest, StreamFlowControlBlocked) {
const uint64 kWindow = 36;
QuicFlowControllerPeer::SetSendWindowOffset(stream_->flow_controller(),
kWindow);
- EXPECT_EQ(kWindow, QuicFlowControllerPeer::SendWindowOffset(
- stream_->flow_controller()));
+ EXPECT_EQ(
+ kWindow,
+ QuicFlowControllerPeer::SendWindowOffset(stream_->flow_controller()));
// Try to send more data than the flow control limit allows.
string headers = SpdyUtils::SerializeUncompressedHeaders(headers_);
@@ -304,8 +299,8 @@ TEST_P(QuicDataStreamTest, StreamFlowControlBlocked) {
GenerateBody(&body, kWindow + kOverflow);
EXPECT_CALL(*connection_, SendBlocked(kStreamId));
- EXPECT_CALL(*session_, WritevData(kStreamId, _, _, _, _)).WillOnce(
- Return(QuicConsumedData(kWindow, true)));
+ EXPECT_CALL(*session_, WritevData(kStreamId, _, _, _, _))
+ .WillOnce(Return(QuicConsumedData(kWindow, true)));
stream_->WriteOrBufferData(body, false, NULL);
// Should have sent as much as possible, resulting in no send window left.
@@ -313,8 +308,7 @@ TEST_P(QuicDataStreamTest, StreamFlowControlBlocked) {
QuicFlowControllerPeer::SendWindowSize(stream_->flow_controller()));
// And we should have queued the overflowed data.
- EXPECT_EQ(kOverflow,
- ReliableQuicStreamPeer::SizeOfQueuedData(stream_.get()));
+ EXPECT_EQ(kOverflow, ReliableQuicStreamPeer::SizeOfQueuedData(stream_.get()));
}
TEST_P(QuicDataStreamTest, StreamFlowControlNoWindowUpdateIfNotConsumed) {
@@ -339,8 +333,9 @@ TEST_P(QuicDataStreamTest, StreamFlowControlNoWindowUpdateIfNotConsumed) {
kWindow);
QuicFlowControllerPeer::SetMaxReceiveWindow(stream_->flow_controller(),
kWindow);
- EXPECT_EQ(kWindow, QuicFlowControllerPeer::ReceiveWindowOffset(
- stream_->flow_controller()));
+ EXPECT_EQ(
+ kWindow,
+ QuicFlowControllerPeer::ReceiveWindowOffset(stream_->flow_controller()));
// Stream receives enough data to fill a fraction of the receive window.
string headers = SpdyUtils::SerializeUncompressedHeaders(headers_);
@@ -352,8 +347,9 @@ TEST_P(QuicDataStreamTest, StreamFlowControlNoWindowUpdateIfNotConsumed) {
QuicStreamFrame frame1(kStreamId, false, 0, MakeIOVector(body));
stream_->OnStreamFrame(frame1);
- EXPECT_EQ(kWindow - (kWindow / 3), QuicFlowControllerPeer::ReceiveWindowSize(
- stream_->flow_controller()));
+ EXPECT_EQ(
+ kWindow - (kWindow / 3),
+ QuicFlowControllerPeer::ReceiveWindowSize(stream_->flow_controller()));
// Now receive another frame which results in the receive window being over
// half full. This should all be buffered, decreasing the receive window but
@@ -382,8 +378,9 @@ TEST_P(QuicDataStreamTest, StreamFlowControlWindowUpdate) {
kWindow);
QuicFlowControllerPeer::SetMaxReceiveWindow(stream_->flow_controller(),
kWindow);
- EXPECT_EQ(kWindow, QuicFlowControllerPeer::ReceiveWindowOffset(
- stream_->flow_controller()));
+ EXPECT_EQ(
+ kWindow,
+ QuicFlowControllerPeer::ReceiveWindowOffset(stream_->flow_controller()));
// Stream receives enough data to fill a fraction of the receive window.
string headers = SpdyUtils::SerializeUncompressedHeaders(headers_);
@@ -395,22 +392,24 @@ TEST_P(QuicDataStreamTest, StreamFlowControlWindowUpdate) {
QuicStreamFrame frame1(kStreamId, false, 0, MakeIOVector(body));
stream_->OnStreamFrame(frame1);
- EXPECT_EQ(kWindow - (kWindow / 3), QuicFlowControllerPeer::ReceiveWindowSize(
- stream_->flow_controller()));
+ EXPECT_EQ(
+ kWindow - (kWindow / 3),
+ QuicFlowControllerPeer::ReceiveWindowSize(stream_->flow_controller()));
// Now receive another frame which results in the receive window being over
// half full. This will trigger the stream to increase its receive window
// offset and send a WINDOW_UPDATE. The result will be again an available
// window of kWindow bytes.
QuicStreamFrame frame2(kStreamId, false, kWindow / 3, MakeIOVector(body));
- EXPECT_CALL(
- *connection_,
- SendWindowUpdate(kStreamId, QuicFlowControllerPeer::ReceiveWindowOffset(
- stream_->flow_controller()) +
- 2 * kWindow / 3));
+ EXPECT_CALL(*connection_,
+ SendWindowUpdate(kStreamId,
+ QuicFlowControllerPeer::ReceiveWindowOffset(
+ stream_->flow_controller()) +
+ 2 * kWindow / 3));
stream_->OnStreamFrame(frame2);
- EXPECT_EQ(kWindow, QuicFlowControllerPeer::ReceiveWindowSize(
- stream_->flow_controller()));
+ EXPECT_EQ(
+ kWindow,
+ QuicFlowControllerPeer::ReceiveWindowSize(stream_->flow_controller()));
}
TEST_P(QuicDataStreamTest, StreamFlowControlViolation) {
@@ -455,16 +454,17 @@ TEST_P(QuicDataStreamTest, StreamFlowControlFinNotBlocked) {
// Set a flow control limit of zero.
QuicFlowControllerPeer::SetReceiveWindowOffset(stream_->flow_controller(), 0);
- EXPECT_EQ(0u, QuicFlowControllerPeer::ReceiveWindowOffset(
- stream_->flow_controller()));
+ EXPECT_EQ(
+ 0u,
+ QuicFlowControllerPeer::ReceiveWindowOffset(stream_->flow_controller()));
// Send a frame with a FIN but no data. This should not be blocked.
string body = "";
bool fin = true;
EXPECT_CALL(*connection_, SendBlocked(kStreamId)).Times(0);
- EXPECT_CALL(*session_, WritevData(kStreamId, _, _, _, _)).WillOnce(
- Return(QuicConsumedData(0, fin)));
+ EXPECT_CALL(*session_, WritevData(kStreamId, _, _, _, _))
+ .WillOnce(Return(QuicConsumedData(0, fin)));
stream_->WriteOrBufferData(body, fin, NULL);
}
« net/base/mime_util_unittest.cc ('K') | « net/quic/quic_data_stream.cc ('k') | net/quic/quic_data_writer.h » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698