| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright 2014 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/server/http_connection.h" | |
| 6 | |
| 7 #include <string> | |
| 8 | |
| 9 #include "base/memory/ref_counted.h" | |
| 10 #include "base/strings/string_piece.h" | |
| 11 #include "testing/gtest/include/gtest/gtest.h" | |
| 12 | |
| 13 namespace net { | |
| 14 namespace { | |
| 15 | |
| 16 std::string GetTestString(int size) { | |
| 17 std::string test_string; | |
| 18 for (int i = 0; i < size; ++i) { | |
| 19 test_string.push_back('A' + (i % 26)); | |
| 20 } | |
| 21 return test_string; | |
| 22 } | |
| 23 | |
| 24 TEST(HttpConnectionTest, ReadIOBuffer_SetCapacity) { | |
| 25 scoped_refptr<HttpConnection::ReadIOBuffer> buffer( | |
| 26 new HttpConnection::ReadIOBuffer); | |
| 27 EXPECT_EQ(HttpConnection::ReadIOBuffer::kInitialBufSize + 0, | |
| 28 buffer->GetCapacity()); | |
| 29 EXPECT_EQ(HttpConnection::ReadIOBuffer::kInitialBufSize + 0, | |
| 30 buffer->RemainingCapacity()); | |
| 31 EXPECT_EQ(0, buffer->GetSize()); | |
| 32 | |
| 33 const int kNewCapacity = HttpConnection::ReadIOBuffer::kInitialBufSize + 128; | |
| 34 buffer->SetCapacity(kNewCapacity); | |
| 35 EXPECT_EQ(kNewCapacity, buffer->GetCapacity()); | |
| 36 EXPECT_EQ(kNewCapacity, buffer->RemainingCapacity()); | |
| 37 EXPECT_EQ(0, buffer->GetSize()); | |
| 38 } | |
| 39 | |
| 40 TEST(HttpConnectionTest, ReadIOBuffer_SetCapacity_WithData) { | |
| 41 scoped_refptr<HttpConnection::ReadIOBuffer> buffer( | |
| 42 new HttpConnection::ReadIOBuffer); | |
| 43 EXPECT_EQ(HttpConnection::ReadIOBuffer::kInitialBufSize + 0, | |
| 44 buffer->GetCapacity()); | |
| 45 EXPECT_EQ(HttpConnection::ReadIOBuffer::kInitialBufSize + 0, | |
| 46 buffer->RemainingCapacity()); | |
| 47 | |
| 48 // Write arbitrary data up to kInitialBufSize. | |
| 49 const std::string kReadData( | |
| 50 GetTestString(HttpConnection::ReadIOBuffer::kInitialBufSize)); | |
| 51 memcpy(buffer->data(), kReadData.data(), kReadData.size()); | |
| 52 buffer->DidRead(kReadData.size()); | |
| 53 EXPECT_EQ(HttpConnection::ReadIOBuffer::kInitialBufSize + 0, | |
| 54 buffer->GetCapacity()); | |
| 55 EXPECT_EQ(HttpConnection::ReadIOBuffer::kInitialBufSize - | |
| 56 static_cast<int>(kReadData.size()), | |
| 57 buffer->RemainingCapacity()); | |
| 58 EXPECT_EQ(static_cast<int>(kReadData.size()), buffer->GetSize()); | |
| 59 EXPECT_EQ(kReadData, | |
| 60 base::StringPiece(buffer->StartOfBuffer(), buffer->GetSize())); | |
| 61 | |
| 62 // Check if read data in the buffer is same after SetCapacity(). | |
| 63 const int kNewCapacity = HttpConnection::ReadIOBuffer::kInitialBufSize + 128; | |
| 64 buffer->SetCapacity(kNewCapacity); | |
| 65 EXPECT_EQ(kNewCapacity, buffer->GetCapacity()); | |
| 66 EXPECT_EQ(kNewCapacity - static_cast<int>(kReadData.size()), | |
| 67 buffer->RemainingCapacity()); | |
| 68 EXPECT_EQ(static_cast<int>(kReadData.size()), buffer->GetSize()); | |
| 69 EXPECT_EQ(kReadData, | |
| 70 base::StringPiece(buffer->StartOfBuffer(), buffer->GetSize())); | |
| 71 } | |
| 72 | |
| 73 TEST(HttpConnectionTest, ReadIOBuffer_IncreaseCapacity) { | |
| 74 scoped_refptr<HttpConnection::ReadIOBuffer> buffer( | |
| 75 new HttpConnection::ReadIOBuffer); | |
| 76 EXPECT_TRUE(buffer->IncreaseCapacity()); | |
| 77 const int kExpectedInitialBufSize = | |
| 78 HttpConnection::ReadIOBuffer::kInitialBufSize * | |
| 79 HttpConnection::ReadIOBuffer::kCapacityIncreaseFactor; | |
| 80 EXPECT_EQ(kExpectedInitialBufSize, buffer->GetCapacity()); | |
| 81 EXPECT_EQ(kExpectedInitialBufSize, buffer->RemainingCapacity()); | |
| 82 EXPECT_EQ(0, buffer->GetSize()); | |
| 83 | |
| 84 // Increase capacity until it fails. | |
| 85 while (buffer->IncreaseCapacity()); | |
| 86 EXPECT_FALSE(buffer->IncreaseCapacity()); | |
| 87 EXPECT_EQ(HttpConnection::ReadIOBuffer::kDefaultMaxBufferSize + 0, | |
| 88 buffer->max_buffer_size()); | |
| 89 EXPECT_EQ(HttpConnection::ReadIOBuffer::kDefaultMaxBufferSize + 0, | |
| 90 buffer->GetCapacity()); | |
| 91 | |
| 92 // Enlarge capacity limit. | |
| 93 buffer->set_max_buffer_size(buffer->max_buffer_size() * 2); | |
| 94 EXPECT_TRUE(buffer->IncreaseCapacity()); | |
| 95 EXPECT_EQ(HttpConnection::ReadIOBuffer::kDefaultMaxBufferSize * | |
| 96 HttpConnection::ReadIOBuffer::kCapacityIncreaseFactor, | |
| 97 buffer->GetCapacity()); | |
| 98 | |
| 99 // Shrink capacity limit. It doesn't change capacity itself. | |
| 100 buffer->set_max_buffer_size( | |
| 101 HttpConnection::ReadIOBuffer::kDefaultMaxBufferSize / 2); | |
| 102 EXPECT_FALSE(buffer->IncreaseCapacity()); | |
| 103 EXPECT_EQ(HttpConnection::ReadIOBuffer::kDefaultMaxBufferSize * | |
| 104 HttpConnection::ReadIOBuffer::kCapacityIncreaseFactor, | |
| 105 buffer->GetCapacity()); | |
| 106 } | |
| 107 | |
| 108 TEST(HttpConnectionTest, ReadIOBuffer_IncreaseCapacity_WithData) { | |
| 109 scoped_refptr<HttpConnection::ReadIOBuffer> buffer( | |
| 110 new HttpConnection::ReadIOBuffer); | |
| 111 EXPECT_TRUE(buffer->IncreaseCapacity()); | |
| 112 const int kExpectedInitialBufSize = | |
| 113 HttpConnection::ReadIOBuffer::kInitialBufSize * | |
| 114 HttpConnection::ReadIOBuffer::kCapacityIncreaseFactor; | |
| 115 EXPECT_EQ(kExpectedInitialBufSize, buffer->GetCapacity()); | |
| 116 EXPECT_EQ(kExpectedInitialBufSize, buffer->RemainingCapacity()); | |
| 117 EXPECT_EQ(0, buffer->GetSize()); | |
| 118 | |
| 119 // Write arbitrary data up to kExpectedInitialBufSize. | |
| 120 std::string kReadData(GetTestString(kExpectedInitialBufSize)); | |
| 121 memcpy(buffer->data(), kReadData.data(), kReadData.size()); | |
| 122 buffer->DidRead(kReadData.size()); | |
| 123 EXPECT_EQ(kExpectedInitialBufSize, buffer->GetCapacity()); | |
| 124 EXPECT_EQ(kExpectedInitialBufSize - static_cast<int>(kReadData.size()), | |
| 125 buffer->RemainingCapacity()); | |
| 126 EXPECT_EQ(static_cast<int>(kReadData.size()), buffer->GetSize()); | |
| 127 EXPECT_EQ(kReadData, | |
| 128 base::StringPiece(buffer->StartOfBuffer(), buffer->GetSize())); | |
| 129 | |
| 130 // Increase capacity until it fails and check if read data in the buffer is | |
| 131 // same. | |
| 132 while (buffer->IncreaseCapacity()); | |
| 133 EXPECT_FALSE(buffer->IncreaseCapacity()); | |
| 134 EXPECT_EQ(HttpConnection::ReadIOBuffer::kDefaultMaxBufferSize + 0, | |
| 135 buffer->max_buffer_size()); | |
| 136 EXPECT_EQ(HttpConnection::ReadIOBuffer::kDefaultMaxBufferSize + 0, | |
| 137 buffer->GetCapacity()); | |
| 138 EXPECT_EQ(HttpConnection::ReadIOBuffer::kDefaultMaxBufferSize - | |
| 139 static_cast<int>(kReadData.size()), | |
| 140 buffer->RemainingCapacity()); | |
| 141 EXPECT_EQ(static_cast<int>(kReadData.size()), buffer->GetSize()); | |
| 142 EXPECT_EQ(kReadData, | |
| 143 base::StringPiece(buffer->StartOfBuffer(), buffer->GetSize())); | |
| 144 } | |
| 145 | |
| 146 TEST(HttpConnectionTest, ReadIOBuffer_DidRead_DidConsume) { | |
| 147 scoped_refptr<HttpConnection::ReadIOBuffer> buffer( | |
| 148 new HttpConnection::ReadIOBuffer); | |
| 149 const char* start_of_buffer = buffer->StartOfBuffer(); | |
| 150 EXPECT_EQ(start_of_buffer, buffer->data()); | |
| 151 | |
| 152 // Read data. | |
| 153 const int kReadLength = 128; | |
| 154 const std::string kReadData(GetTestString(kReadLength)); | |
| 155 memcpy(buffer->data(), kReadData.data(), kReadLength); | |
| 156 buffer->DidRead(kReadLength); | |
| 157 // No change in total capacity. | |
| 158 EXPECT_EQ(HttpConnection::ReadIOBuffer::kInitialBufSize + 0, | |
| 159 buffer->GetCapacity()); | |
| 160 // Change in unused capacity because of read data. | |
| 161 EXPECT_EQ(HttpConnection::ReadIOBuffer::kInitialBufSize - kReadLength, | |
| 162 buffer->RemainingCapacity()); | |
| 163 EXPECT_EQ(kReadLength, buffer->GetSize()); | |
| 164 // No change in start pointers of read data. | |
| 165 EXPECT_EQ(start_of_buffer, buffer->StartOfBuffer()); | |
| 166 // Change in start pointer of unused buffer. | |
| 167 EXPECT_EQ(start_of_buffer + kReadLength, buffer->data()); | |
| 168 // Test read data. | |
| 169 EXPECT_EQ(kReadData, std::string(buffer->StartOfBuffer(), buffer->GetSize())); | |
| 170 | |
| 171 // Consume data partially. | |
| 172 const int kConsumedLength = 32; | |
| 173 ASSERT_LT(kConsumedLength, kReadLength); | |
| 174 buffer->DidConsume(kConsumedLength); | |
| 175 // Capacity reduced because read data was too small comparing to capacity. | |
| 176 EXPECT_EQ(HttpConnection::ReadIOBuffer::kInitialBufSize / | |
| 177 HttpConnection::ReadIOBuffer::kCapacityIncreaseFactor, | |
| 178 buffer->GetCapacity()); | |
| 179 // Change in unused capacity because of read data. | |
| 180 EXPECT_EQ(HttpConnection::ReadIOBuffer::kInitialBufSize / | |
| 181 HttpConnection::ReadIOBuffer::kCapacityIncreaseFactor - | |
| 182 kReadLength + kConsumedLength, | |
| 183 buffer->RemainingCapacity()); | |
| 184 // Change in read size. | |
| 185 EXPECT_EQ(kReadLength - kConsumedLength, buffer->GetSize()); | |
| 186 // Start data could be changed even when capacity is reduced. | |
| 187 start_of_buffer = buffer->StartOfBuffer(); | |
| 188 // Change in start pointer of unused buffer. | |
| 189 EXPECT_EQ(start_of_buffer + kReadLength - kConsumedLength, buffer->data()); | |
| 190 // Change in read data. | |
| 191 EXPECT_EQ(kReadData.substr(kConsumedLength), | |
| 192 std::string(buffer->StartOfBuffer(), buffer->GetSize())); | |
| 193 | |
| 194 // Read more data. | |
| 195 const int kReadLength2 = 64; | |
| 196 buffer->DidRead(kReadLength2); | |
| 197 // No change in total capacity. | |
| 198 EXPECT_EQ(HttpConnection::ReadIOBuffer::kInitialBufSize / | |
| 199 HttpConnection::ReadIOBuffer::kCapacityIncreaseFactor, | |
| 200 buffer->GetCapacity()); | |
| 201 // Change in unused capacity because of read data. | |
| 202 EXPECT_EQ(HttpConnection::ReadIOBuffer::kInitialBufSize / | |
| 203 HttpConnection::ReadIOBuffer::kCapacityIncreaseFactor - | |
| 204 kReadLength + kConsumedLength - kReadLength2, | |
| 205 buffer->RemainingCapacity()); | |
| 206 // Change in read size | |
| 207 EXPECT_EQ(kReadLength - kConsumedLength + kReadLength2, buffer->GetSize()); | |
| 208 // No change in start pointer of read part. | |
| 209 EXPECT_EQ(start_of_buffer, buffer->StartOfBuffer()); | |
| 210 // Change in start pointer of unused buffer. | |
| 211 EXPECT_EQ(start_of_buffer + kReadLength - kConsumedLength + kReadLength2, | |
| 212 buffer->data()); | |
| 213 | |
| 214 // Consume data fully. | |
| 215 buffer->DidConsume(kReadLength - kConsumedLength + kReadLength2); | |
| 216 // Capacity reduced again because read data was too small. | |
| 217 EXPECT_EQ(HttpConnection::ReadIOBuffer::kInitialBufSize / | |
| 218 HttpConnection::ReadIOBuffer::kCapacityIncreaseFactor / | |
| 219 HttpConnection::ReadIOBuffer::kCapacityIncreaseFactor, | |
| 220 buffer->GetCapacity()); | |
| 221 EXPECT_EQ(HttpConnection::ReadIOBuffer::kInitialBufSize / | |
| 222 HttpConnection::ReadIOBuffer::kCapacityIncreaseFactor / | |
| 223 HttpConnection::ReadIOBuffer::kCapacityIncreaseFactor, | |
| 224 buffer->RemainingCapacity()); | |
| 225 // All reverts to initial because no data is left. | |
| 226 EXPECT_EQ(0, buffer->GetSize()); | |
| 227 // Start data could be changed even when capacity is reduced. | |
| 228 start_of_buffer = buffer->StartOfBuffer(); | |
| 229 EXPECT_EQ(start_of_buffer, buffer->data()); | |
| 230 } | |
| 231 | |
| 232 TEST(HttpConnectionTest, QueuedWriteIOBuffer_Append_DidConsume) { | |
| 233 scoped_refptr<HttpConnection::QueuedWriteIOBuffer> buffer( | |
| 234 new HttpConnection::QueuedWriteIOBuffer()); | |
| 235 EXPECT_TRUE(buffer->IsEmpty()); | |
| 236 EXPECT_EQ(0, buffer->GetSizeToWrite()); | |
| 237 EXPECT_EQ(0, buffer->total_size()); | |
| 238 | |
| 239 const std::string kData("data to write"); | |
| 240 EXPECT_TRUE(buffer->Append(kData)); | |
| 241 EXPECT_FALSE(buffer->IsEmpty()); | |
| 242 EXPECT_EQ(static_cast<int>(kData.size()), buffer->GetSizeToWrite()); | |
| 243 EXPECT_EQ(static_cast<int>(kData.size()), buffer->total_size()); | |
| 244 // First data to write is same to kData. | |
| 245 EXPECT_EQ(kData, base::StringPiece(buffer->data(), buffer->GetSizeToWrite())); | |
| 246 | |
| 247 const std::string kData2("more data to write"); | |
| 248 EXPECT_TRUE(buffer->Append(kData2)); | |
| 249 EXPECT_FALSE(buffer->IsEmpty()); | |
| 250 // No change in size to write. | |
| 251 EXPECT_EQ(static_cast<int>(kData.size()), buffer->GetSizeToWrite()); | |
| 252 // Change in total size. | |
| 253 EXPECT_EQ(static_cast<int>(kData.size() + kData2.size()), | |
| 254 buffer->total_size()); | |
| 255 // First data to write has not been changed. Same to kData. | |
| 256 EXPECT_EQ(kData, base::StringPiece(buffer->data(), buffer->GetSizeToWrite())); | |
| 257 | |
| 258 // Consume data partially. | |
| 259 const int kConsumedLength = kData.length() - 1; | |
| 260 buffer->DidConsume(kConsumedLength); | |
| 261 EXPECT_FALSE(buffer->IsEmpty()); | |
| 262 // Change in size to write. | |
| 263 EXPECT_EQ(static_cast<int>(kData.size()) - kConsumedLength, | |
| 264 buffer->GetSizeToWrite()); | |
| 265 // Change in total size. | |
| 266 EXPECT_EQ(static_cast<int>(kData.size() + kData2.size()) - kConsumedLength, | |
| 267 buffer->total_size()); | |
| 268 // First data to write has shrinked. | |
| 269 EXPECT_EQ(kData.substr(kConsumedLength), | |
| 270 base::StringPiece(buffer->data(), buffer->GetSizeToWrite())); | |
| 271 | |
| 272 // Consume first data fully. | |
| 273 buffer->DidConsume(kData.size() - kConsumedLength); | |
| 274 EXPECT_FALSE(buffer->IsEmpty()); | |
| 275 // Now, size to write is size of data added second. | |
| 276 EXPECT_EQ(static_cast<int>(kData2.size()), buffer->GetSizeToWrite()); | |
| 277 // Change in total size. | |
| 278 EXPECT_EQ(static_cast<int>(kData2.size()), buffer->total_size()); | |
| 279 // First data to write has changed to kData2. | |
| 280 EXPECT_EQ(kData2, | |
| 281 base::StringPiece(buffer->data(), buffer->GetSizeToWrite())); | |
| 282 | |
| 283 // Consume second data fully. | |
| 284 buffer->DidConsume(kData2.size()); | |
| 285 EXPECT_TRUE(buffer->IsEmpty()); | |
| 286 EXPECT_EQ(0, buffer->GetSizeToWrite()); | |
| 287 EXPECT_EQ(0, buffer->total_size()); | |
| 288 } | |
| 289 | |
| 290 TEST(HttpConnectionTest, QueuedWriteIOBuffer_TotalSizeLimit) { | |
| 291 scoped_refptr<HttpConnection::QueuedWriteIOBuffer> buffer( | |
| 292 new HttpConnection::QueuedWriteIOBuffer()); | |
| 293 EXPECT_EQ(HttpConnection::QueuedWriteIOBuffer::kDefaultMaxBufferSize + 0, | |
| 294 buffer->max_buffer_size()); | |
| 295 | |
| 296 // Set total size limit very small. | |
| 297 buffer->set_max_buffer_size(10); | |
| 298 | |
| 299 const int kDataLength = 4; | |
| 300 const std::string kData(kDataLength, 'd'); | |
| 301 EXPECT_TRUE(buffer->Append(kData)); | |
| 302 EXPECT_EQ(kDataLength, buffer->total_size()); | |
| 303 EXPECT_TRUE(buffer->Append(kData)); | |
| 304 EXPECT_EQ(kDataLength * 2, buffer->total_size()); | |
| 305 | |
| 306 // Cannot append more data because it exceeds the limit. | |
| 307 EXPECT_FALSE(buffer->Append(kData)); | |
| 308 EXPECT_EQ(kDataLength * 2, buffer->total_size()); | |
| 309 | |
| 310 // Consume data partially. | |
| 311 const int kConsumedLength = 2; | |
| 312 buffer->DidConsume(kConsumedLength); | |
| 313 EXPECT_EQ(kDataLength * 2 - kConsumedLength, buffer->total_size()); | |
| 314 | |
| 315 // Can add more data. | |
| 316 EXPECT_TRUE(buffer->Append(kData)); | |
| 317 EXPECT_EQ(kDataLength * 3 - kConsumedLength, buffer->total_size()); | |
| 318 | |
| 319 // Cannot append more data because it exceeds the limit. | |
| 320 EXPECT_FALSE(buffer->Append(kData)); | |
| 321 EXPECT_EQ(kDataLength * 3 - kConsumedLength, buffer->total_size()); | |
| 322 | |
| 323 // Enlarge limit. | |
| 324 buffer->set_max_buffer_size(20); | |
| 325 // Can add more data. | |
| 326 EXPECT_TRUE(buffer->Append(kData)); | |
| 327 EXPECT_EQ(kDataLength * 4 - kConsumedLength, buffer->total_size()); | |
| 328 } | |
| 329 | |
| 330 } // namespace | |
| 331 } // namespace net | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 497223003:
Revert of Replace StreamListenSocket with StreamSocket in HttpServer. (Closed)
Base URL: https://chromium.googlesource.com/chromium/src.git@master