Index: net/server/http_connection_unittest.cc |
diff --git a/net/server/http_connection_unittest.cc b/net/server/http_connection_unittest.cc |
new file mode 100644 |
index 0000000000000000000000000000000000000000..16a5909808b05eec489b710b4f05d622366ba75d |
--- /dev/null |
+++ b/net/server/http_connection_unittest.cc |
@@ -0,0 +1,249 @@ |
+// Copyright 2014 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/server/http_connection.h" |
+ |
+#include "testing/gtest/include/gtest/gtest.h" |
+ |
+namespace net { |
+namespace { |
+ |
+class HttpConnectionTest : public testing::Test { |
mmenke
2014/08/14 16:36:02
This test fixture doesn't really get us anything,
byungchul
2014/08/14 18:44:03
Done.
|
+ public: |
+ static void CheckCapacity(scoped_refptr<HttpConnection::ReadIOBuffer> buffer, |
mmenke
2014/08/14 16:36:02
include ref_counted
byungchul
2014/08/14 18:44:02
Done.
|
+ int expected_capacity) { |
+ EXPECT_EQ(expected_capacity, buffer->GetCapacity()); |
+ EXPECT_EQ(expected_capacity, buffer->RemainingCapacity()); |
+ } |
+ |
+ static std::string GetTestString(int size) { |
mmenke
2014/08/14 16:36:02
include <string>
byungchul
2014/08/14 18:44:02
Done.
|
+ std::string test_string; |
+ for (int i = 0; i < size; ++i) { |
+ test_string.push_back('A' + (i % 26)); |
+ } |
+ return test_string; |
+ } |
+}; |
+ |
+TEST_F(HttpConnectionTest, ReadIOBuffer_SetCapacity) { |
+ scoped_refptr<HttpConnection::ReadIOBuffer> buffer( |
+ new HttpConnection::ReadIOBuffer); |
+ CheckCapacity(buffer, HttpConnection::ReadIOBuffer::kInitialBufSize); |
+ EXPECT_EQ(0, buffer->GetSize()); |
+ |
+ const int kNewCapacity = HttpConnection::ReadIOBuffer::kInitialBufSize + 128; |
+ buffer->SetCapacity(kNewCapacity); |
+ CheckCapacity(buffer, kNewCapacity); |
+ EXPECT_EQ(0, buffer->GetSize()); |
mmenke
2014/08/14 16:36:02
Should we write kInitialBufSize bytes to the buffe
byungchul
2014/08/14 18:44:03
Done.
|
+} |
+ |
+TEST_F(HttpConnectionTest, ReadIOBuffer_IncreaseCapacity) { |
+ scoped_refptr<HttpConnection::ReadIOBuffer> buffer( |
+ new HttpConnection::ReadIOBuffer); |
+ EXPECT_TRUE(buffer->IncreaseCapacity()); |
+ CheckCapacity(buffer, |
+ HttpConnection::ReadIOBuffer::kInitialBufSize |
+ * HttpConnection::ReadIOBuffer::kCapacityIncreaseFactor); |
+ EXPECT_EQ(0, buffer->GetSize()); |
+ |
+ // Increase capacity until it fails. |
+ while (buffer->IncreaseCapacity()); |
+ EXPECT_FALSE(buffer->IncreaseCapacity()); |
+ EXPECT_EQ(HttpConnection::ReadIOBuffer::kDefaultMaxBufferSize + 0, |
+ buffer->max_buffer_size()); |
+ EXPECT_EQ(HttpConnection::ReadIOBuffer::kDefaultMaxBufferSize + 0, |
+ buffer->GetCapacity()); |
+ |
+ // Enlarge capacity limit. |
+ buffer->set_max_buffer_size(buffer->max_buffer_size() * 2); |
+ EXPECT_TRUE(buffer->IncreaseCapacity()); |
+ EXPECT_EQ(HttpConnection::ReadIOBuffer::kDefaultMaxBufferSize |
+ * HttpConnection::ReadIOBuffer::kCapacityIncreaseFactor, |
+ buffer->GetCapacity()); |
+ |
+ // Shrink capacity limit. It doesn't change capacity itself. |
+ buffer->set_max_buffer_size( |
+ HttpConnection::ReadIOBuffer::kDefaultMaxBufferSize / 2); |
+ EXPECT_FALSE(buffer->IncreaseCapacity()); |
+ EXPECT_EQ(HttpConnection::ReadIOBuffer::kDefaultMaxBufferSize |
+ * HttpConnection::ReadIOBuffer::kCapacityIncreaseFactor, |
+ buffer->GetCapacity()); |
mmenke
2014/08/14 16:36:02
Same goes for this - should we make sure that we k
byungchul
2014/08/14 18:44:02
Done.
|
+} |
+ |
+TEST_F(HttpConnectionTest, ReadIOBuffer_DidRead_DidConsume) { |
+ scoped_refptr<HttpConnection::ReadIOBuffer> buffer( |
+ new HttpConnection::ReadIOBuffer); |
+ const char* start_of_buffer = buffer->StartOfBuffer(); |
+ EXPECT_EQ(start_of_buffer, buffer->data()); |
+ |
+ // Read data. |
+ const int kReadLength = 128; |
+ const std::string kReadData(GetTestString(kReadLength)); |
+ memcpy(buffer->data(), kReadData.data(), kReadLength); |
+ buffer->DidRead(kReadLength); |
+ // No change in total capacity. |
+ EXPECT_EQ(HttpConnection::ReadIOBuffer::kInitialBufSize + 0, |
+ buffer->GetCapacity()); |
+ // Change in unused capacity because of read data. |
+ EXPECT_EQ(HttpConnection::ReadIOBuffer::kInitialBufSize - kReadLength, |
+ buffer->RemainingCapacity()); |
+ EXPECT_EQ(kReadLength, buffer->GetSize()); |
+ // No change in start pointers of read data. |
+ EXPECT_EQ(start_of_buffer, buffer->StartOfBuffer()); |
+ // Change in start pointer of unused buffer. |
+ EXPECT_EQ(start_of_buffer + kReadLength, buffer->data()); |
+ // Test read data. |
+ EXPECT_EQ(kReadData, std::string(buffer->StartOfBuffer(), buffer->GetSize())); |
+ |
+ // Consume data partially. |
+ const int kConsumedLength = 32; |
+ ASSERT_LT(kConsumedLength, kReadLength); |
+ buffer->DidConsume(kConsumedLength); |
+ // Capacity reduced because read data was too small comparing to capacity. |
+ EXPECT_EQ(HttpConnection::ReadIOBuffer::kInitialBufSize |
+ / HttpConnection::ReadIOBuffer::kCapacityIncreaseFactor, |
+ buffer->GetCapacity()); |
+ // Change in unused capacity because of read data. |
+ EXPECT_EQ(HttpConnection::ReadIOBuffer::kInitialBufSize |
+ / HttpConnection::ReadIOBuffer::kCapacityIncreaseFactor |
+ - kReadLength + kConsumedLength, |
mmenke
2014/08/14 16:36:02
Put binary operators on previous line (Goes for th
byungchul
2014/08/14 18:44:03
Done. I knew the style but it was more readable fo
|
+ buffer->RemainingCapacity()); |
+ // Change in read size. |
+ EXPECT_EQ(kReadLength - kConsumedLength, buffer->GetSize()); |
+ // Start data could be changed even when capacity is reduced. |
+ start_of_buffer = buffer->StartOfBuffer(); |
+ // Change in start pointer of unused buffer. |
+ EXPECT_EQ(start_of_buffer + kReadLength - kConsumedLength, buffer->data()); |
+ // Change in read data. |
+ EXPECT_EQ(kReadData.substr(kConsumedLength), |
+ std::string(buffer->StartOfBuffer(), buffer->GetSize())); |
+ |
+ // Read more data. |
+ const int kReadLength2 = 64; |
+ buffer->DidRead(kReadLength2); |
+ // No change in total capacity. |
+ EXPECT_EQ(HttpConnection::ReadIOBuffer::kInitialBufSize |
+ / HttpConnection::ReadIOBuffer::kCapacityIncreaseFactor, |
+ buffer->GetCapacity()); |
+ // Change in unused capacity because of read data. |
+ EXPECT_EQ(HttpConnection::ReadIOBuffer::kInitialBufSize |
+ / HttpConnection::ReadIOBuffer::kCapacityIncreaseFactor |
+ - kReadLength + kConsumedLength - kReadLength2, |
+ buffer->RemainingCapacity()); |
+ // Change in read size |
+ EXPECT_EQ(kReadLength - kConsumedLength + kReadLength2, buffer->GetSize()); |
+ // No change in start pointer of read part. |
+ EXPECT_EQ(start_of_buffer, buffer->StartOfBuffer()); |
+ // Change in start pointer of unused buffer. |
+ EXPECT_EQ(start_of_buffer + kReadLength - kConsumedLength + kReadLength2, |
+ buffer->data()); |
+ |
+ // Consume data fully. |
+ buffer->DidConsume(kReadLength - kConsumedLength + kReadLength2); |
+ // Capacity reduced again because read data was too small. |
+ EXPECT_EQ(HttpConnection::ReadIOBuffer::kInitialBufSize |
+ / HttpConnection::ReadIOBuffer::kCapacityIncreaseFactor |
+ / HttpConnection::ReadIOBuffer::kCapacityIncreaseFactor, |
+ buffer->GetCapacity()); |
+ EXPECT_EQ(HttpConnection::ReadIOBuffer::kInitialBufSize |
+ / HttpConnection::ReadIOBuffer::kCapacityIncreaseFactor |
+ / HttpConnection::ReadIOBuffer::kCapacityIncreaseFactor, |
+ buffer->RemainingCapacity()); |
+ // All reverts to initial because no data is left. |
+ EXPECT_EQ(0, buffer->GetSize()); |
+ // Start data could be changed even when capacity is reduced. |
+ start_of_buffer = buffer->StartOfBuffer(); |
+ EXPECT_EQ(start_of_buffer, buffer->data()); |
+} |
+ |
+TEST_F(HttpConnectionTest, PendingWriteIOBuffer_Append_DidConsume) { |
+ scoped_refptr<HttpConnection::PendingWriteIOBuffer> buffer( |
+ new HttpConnection::PendingWriteIOBuffer()); |
+ EXPECT_TRUE(buffer->IsEmpty()); |
+ EXPECT_EQ(0, buffer->GetSizeToWrite()); |
+ EXPECT_EQ(0, buffer->total_size()); |
+ |
+ const std::string kData("data to write"); |
+ EXPECT_TRUE(buffer->Append(kData)); |
+ EXPECT_FALSE(buffer->IsEmpty()); |
+ EXPECT_EQ(static_cast<int>(kData.size()), buffer->GetSizeToWrite()); |
+ EXPECT_EQ(static_cast<int>(kData.size()), buffer->total_size()); |
+ |
+ const std::string kData2("more data to write"); |
+ EXPECT_TRUE(buffer->Append(kData2)); |
+ EXPECT_FALSE(buffer->IsEmpty()); |
+ // No change in size to write. |
+ EXPECT_EQ(static_cast<int>(kData.size()), buffer->GetSizeToWrite()); |
+ // Change in total size. |
+ EXPECT_EQ(static_cast<int>(kData.size() + kData2.size()), |
+ buffer->total_size()); |
+ |
+ // Consume data partially. |
+ const int kConsumedLength = kData.length() - 1; |
+ buffer->DidConsume(kConsumedLength); |
+ EXPECT_FALSE(buffer->IsEmpty()); |
+ // Change in size to write. |
+ EXPECT_EQ(static_cast<int>(kData.size()) - kConsumedLength, |
+ buffer->GetSizeToWrite()); |
+ // Change in total size. |
+ EXPECT_EQ(static_cast<int>(kData.size() + kData2.size()) - kConsumedLength, |
+ buffer->total_size()); |
mmenke
2014/08/14 16:36:02
Should have a partial read, with an EXPECT_EQ for
byungchul
2014/08/14 18:44:03
Did you mean partial consumption on ReadIOBuffer?
|
+ |
+ // Consume first data fully. |
+ buffer->DidConsume(kData.size() - kConsumedLength); |
+ EXPECT_FALSE(buffer->IsEmpty()); |
+ // Now, size to write is size of data added second. |
+ EXPECT_EQ(static_cast<int>(kData2.size()), buffer->GetSizeToWrite()); |
+ // Change in total size. |
+ EXPECT_EQ(static_cast<int>(kData2.size()), buffer->total_size()); |
+ |
+ // Consume second data fully. |
+ buffer->DidConsume(kData2.size()); |
+ EXPECT_TRUE(buffer->IsEmpty()); |
+ EXPECT_EQ(0, buffer->GetSizeToWrite()); |
+ EXPECT_EQ(0, buffer->total_size()); |
+} |
+ |
+TEST_F(HttpConnectionTest, PendingWriteIOBuffer_TotalSizeLimit) { |
+ scoped_refptr<HttpConnection::PendingWriteIOBuffer> buffer( |
+ new HttpConnection::PendingWriteIOBuffer()); |
+ EXPECT_EQ(HttpConnection::PendingWriteIOBuffer::kDefaultMaxBufferSize + 0, |
+ buffer->max_buffer_size()); |
+ |
+ // Set total size limit very small. |
+ buffer->set_max_buffer_size(10); |
+ |
+ const int kDataLength = 4; |
+ const std::string kData(kDataLength, 'd'); |
+ EXPECT_TRUE(buffer->Append(kData)); |
+ EXPECT_EQ(kDataLength, buffer->total_size()); |
+ EXPECT_TRUE(buffer->Append(kData)); |
+ EXPECT_EQ(kDataLength * 2, buffer->total_size()); |
+ |
+ // Cannot append more data because it exceeds the limit. |
+ EXPECT_FALSE(buffer->Append(kData)); |
+ EXPECT_EQ(kDataLength * 2, buffer->total_size()); |
+ |
+ // Consume data partially. |
+ const int kConsumedLength = 2; |
+ buffer->DidConsume(kConsumedLength); |
+ EXPECT_EQ(kDataLength * 2 - kConsumedLength, buffer->total_size()); |
+ |
+ // Can add more data. |
+ EXPECT_TRUE(buffer->Append(kData)); |
+ EXPECT_EQ(kDataLength * 3 - kConsumedLength, buffer->total_size()); |
+ |
+ // Cannot append more data because it exceeds the limit. |
+ EXPECT_FALSE(buffer->Append(kData)); |
+ EXPECT_EQ(kDataLength * 3 - kConsumedLength, buffer->total_size()); |
+ |
+ // Enlarge limit. |
+ buffer->set_max_buffer_size(20); |
+ // Can add more data. |
+ EXPECT_TRUE(buffer->Append(kData)); |
+ EXPECT_EQ(kDataLength * 4 - kConsumedLength, buffer->total_size()); |
+} |
+ |
+} // namespace |
+} // namespace net |