Add test for SpdyReadQueue::Clear().

net/spdy/spdy_read_queue_unittest.cc

 // Copyright (c) 2013 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/spdy/spdy_read_queue.h"
 
 #include <algorithm>
 #include <cstddef>
 #include <memory>
 #include <string>
 
+#include "base/bind.h"
+#include "base/memory/ptr_util.h"
 #include "base/stl_util.h"
 #include "net/spdy/spdy_buffer.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace net {
-
+namespace test {

[davidben, 2016/10/04 18:41:49]

(Huh, is that the usual pattern? I've seen unnamespaced, net::,
net::<anonymous>, but this is the first I've seen of net::test. *shrug* I'll
defer to you because I don't actually know the styles these days.)

[Bence, 2016/10/04 18:49:53]

Yes, I see this pattern quite often, see
https://cs.chromium.org/search/?q=file:%5Esrc/net.*test.cc$++%22namespace+tes....

 namespace {
 
 const char kData[] = "SPDY read queue test data.\0Some more data.";
 const size_t kDataSize = arraysize(kData);
 
 // Enqueues |data| onto |queue| in chunks of at most |max_buffer_size|
 // bytes.
 void EnqueueString(const std::string& data,
                    size_t max_buffer_size,
                    SpdyReadQueue* queue) {
@@ skipping 49 matching lines @@
 void RunEnqueueDequeueTest(size_t enqueue_max_buffer_size,
                            size_t dequeue_max_buffer_size) {
   std::string data(kData, kDataSize);
   SpdyReadQueue read_queue;
   EnqueueString(data, enqueue_max_buffer_size, &read_queue);
   const std::string& drained_data =
       DrainToString(dequeue_max_buffer_size, &read_queue);
   EXPECT_EQ(data, drained_data);
 }
 
+void OnBufferDiscarded(bool* discarded,
+                       size_t* discarded_bytes,
+                       size_t delta,
+                       SpdyBuffer::ConsumeSource consume_source) {
+  EXPECT_EQ(SpdyBuffer::DISCARD, consume_source);
+  *discarded = true;
+  *discarded_bytes = delta;
+}
+
+}  // namespace
+
 class SpdyReadQueueTest : public ::testing::Test {};
 
 // Call RunEnqueueDequeueTest() with various buffer size combinatinos.
 
 TEST_F(SpdyReadQueueTest, LargeEnqueueAndDequeueBuffers) {
   RunEnqueueDequeueTest(2 * kDataSize, 2 * kDataSize);
 }
 
 TEST_F(SpdyReadQueueTest, OneByteEnqueueAndDequeueBuffers) {
   RunEnqueueDequeueTest(1, 1);
 }
 
 TEST_F(SpdyReadQueueTest, CoprimeBufferSizes) {
   RunEnqueueDequeueTest(2, 3);
   RunEnqueueDequeueTest(3, 2);
 }
 
-}  // namespace
+TEST_F(SpdyReadQueueTest, Clear) {
+  auto buffer = base::MakeUnique<SpdyBuffer>(kData, kDataSize);
+  bool discarded = false;
+  size_t discarded_bytes = 0;
+  buffer->AddConsumeCallback(
+      base::Bind(&OnBufferDiscarded, &discarded, &discarded_bytes));
 
+  SpdyReadQueue read_queue;
+  read_queue.Enqueue(std::move(buffer));
+
+  EXPECT_FALSE(discarded);
+  EXPECT_EQ(0u, discarded_bytes);
+  EXPECT_FALSE(read_queue.IsEmpty());
+
+  read_queue.Clear();
+
+  EXPECT_TRUE(discarded);
+  EXPECT_EQ(kDataSize, discarded_bytes);
+  EXPECT_TRUE(read_queue.IsEmpty());
+}
+
+}  // namespace test
 }  // namespace net