OLD | NEW |
| (Empty) |
1 // Copyright (c) 2013 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/spdy/spdy_read_queue.h" | |
6 | |
7 #include <algorithm> | |
8 #include <cstddef> | |
9 #include <memory> | |
10 #include <utility> | |
11 | |
12 #include "base/bind.h" | |
13 #include "base/memory/ptr_util.h" | |
14 #include "base/stl_util.h" | |
15 #include "net/spdy/platform/api/spdy_string.h" | |
16 #include "net/spdy/spdy_buffer.h" | |
17 #include "testing/gtest/include/gtest/gtest.h" | |
18 | |
19 namespace net { | |
20 namespace test { | |
21 namespace { | |
22 | |
23 const char kData[] = "SPDY read queue test data.\0Some more data."; | |
24 const size_t kDataSize = arraysize(kData); | |
25 | |
26 // Enqueues |data| onto |queue| in chunks of at most |max_buffer_size| | |
27 // bytes. | |
28 void EnqueueString(const SpdyString& data, | |
29 size_t max_buffer_size, | |
30 SpdyReadQueue* queue) { | |
31 ASSERT_GT(data.size(), 0u); | |
32 ASSERT_GT(max_buffer_size, 0u); | |
33 size_t old_total_size = queue->GetTotalSize(); | |
34 for (size_t i = 0; i < data.size();) { | |
35 size_t buffer_size = std::min(data.size() - i, max_buffer_size); | |
36 queue->Enqueue(std::unique_ptr<SpdyBuffer>( | |
37 new SpdyBuffer(data.data() + i, buffer_size))); | |
38 i += buffer_size; | |
39 EXPECT_FALSE(queue->IsEmpty()); | |
40 EXPECT_EQ(old_total_size + i, queue->GetTotalSize()); | |
41 } | |
42 } | |
43 | |
44 // Dequeues all bytes in |queue| in chunks of at most | |
45 // |max_buffer_size| bytes and returns the data as a string. | |
46 SpdyString DrainToString(size_t max_buffer_size, SpdyReadQueue* queue) { | |
47 SpdyString data; | |
48 | |
49 // Pad the buffer so we can detect out-of-bound writes. | |
50 size_t padding = std::max(static_cast<size_t>(4096), queue->GetTotalSize()); | |
51 size_t buffer_size_with_padding = padding + max_buffer_size + padding; | |
52 std::unique_ptr<char[]> buffer(new char[buffer_size_with_padding]); | |
53 std::memset(buffer.get(), 0, buffer_size_with_padding); | |
54 char* buffer_data = buffer.get() + padding; | |
55 | |
56 while (!queue->IsEmpty()) { | |
57 size_t old_total_size = queue->GetTotalSize(); | |
58 EXPECT_GT(old_total_size, 0u); | |
59 size_t dequeued_bytes = queue->Dequeue(buffer_data, max_buffer_size); | |
60 | |
61 // Make sure |queue| doesn't write past either end of its given | |
62 // boundaries. | |
63 for (int i = 1; i <= static_cast<int>(padding); ++i) { | |
64 EXPECT_EQ('\0', buffer_data[-i]) << -i; | |
65 } | |
66 for (size_t i = 0; i < padding; ++i) { | |
67 EXPECT_EQ('\0', buffer_data[max_buffer_size + i]) << i; | |
68 } | |
69 | |
70 data.append(buffer_data, dequeued_bytes); | |
71 EXPECT_EQ(dequeued_bytes, std::min(max_buffer_size, dequeued_bytes)); | |
72 EXPECT_EQ(queue->GetTotalSize(), old_total_size - dequeued_bytes); | |
73 } | |
74 EXPECT_TRUE(queue->IsEmpty()); | |
75 return data; | |
76 } | |
77 | |
78 // Enqueue a test string with the given enqueue/dequeue max buffer | |
79 // sizes. | |
80 void RunEnqueueDequeueTest(size_t enqueue_max_buffer_size, | |
81 size_t dequeue_max_buffer_size) { | |
82 SpdyString data(kData, kDataSize); | |
83 SpdyReadQueue read_queue; | |
84 EnqueueString(data, enqueue_max_buffer_size, &read_queue); | |
85 const SpdyString& drained_data = | |
86 DrainToString(dequeue_max_buffer_size, &read_queue); | |
87 EXPECT_EQ(data, drained_data); | |
88 } | |
89 | |
90 void OnBufferDiscarded(bool* discarded, | |
91 size_t* discarded_bytes, | |
92 size_t delta, | |
93 SpdyBuffer::ConsumeSource consume_source) { | |
94 EXPECT_EQ(SpdyBuffer::DISCARD, consume_source); | |
95 *discarded = true; | |
96 *discarded_bytes = delta; | |
97 } | |
98 | |
99 } // namespace | |
100 | |
101 class SpdyReadQueueTest : public ::testing::Test {}; | |
102 | |
103 // Call RunEnqueueDequeueTest() with various buffer size combinatinos. | |
104 | |
105 TEST_F(SpdyReadQueueTest, LargeEnqueueAndDequeueBuffers) { | |
106 RunEnqueueDequeueTest(2 * kDataSize, 2 * kDataSize); | |
107 } | |
108 | |
109 TEST_F(SpdyReadQueueTest, OneByteEnqueueAndDequeueBuffers) { | |
110 RunEnqueueDequeueTest(1, 1); | |
111 } | |
112 | |
113 TEST_F(SpdyReadQueueTest, CoprimeBufferSizes) { | |
114 RunEnqueueDequeueTest(2, 3); | |
115 RunEnqueueDequeueTest(3, 2); | |
116 } | |
117 | |
118 TEST_F(SpdyReadQueueTest, Clear) { | |
119 auto buffer = base::MakeUnique<SpdyBuffer>(kData, kDataSize); | |
120 bool discarded = false; | |
121 size_t discarded_bytes = 0; | |
122 buffer->AddConsumeCallback( | |
123 base::Bind(&OnBufferDiscarded, &discarded, &discarded_bytes)); | |
124 | |
125 SpdyReadQueue read_queue; | |
126 read_queue.Enqueue(std::move(buffer)); | |
127 | |
128 EXPECT_FALSE(discarded); | |
129 EXPECT_EQ(0u, discarded_bytes); | |
130 EXPECT_FALSE(read_queue.IsEmpty()); | |
131 | |
132 read_queue.Clear(); | |
133 | |
134 EXPECT_TRUE(discarded); | |
135 EXPECT_EQ(kDataSize, discarded_bytes); | |
136 EXPECT_TRUE(read_queue.IsEmpty()); | |
137 } | |
138 | |
139 } // namespace test | |
140 } // namespace net | |
OLD | NEW |