http_connection_unittest.cc 15 KB

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