OLD | NEW |
| (Empty) |
1 // Copyright 2016 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/http2/hpack/decoder/hpack_block_collector.h" | |
6 | |
7 #include <algorithm> | |
8 #include <memory> | |
9 | |
10 #include "base/logging.h" | |
11 #include "net/http2/tools/failure.h" | |
12 #include "testing/gtest/include/gtest/gtest.h" | |
13 | |
14 using ::testing::AssertionResult; | |
15 using ::testing::AssertionSuccess; | |
16 using std::string; | |
17 | |
18 using base::StringPiece; | |
19 | |
20 namespace net { | |
21 namespace test { | |
22 | |
23 HpackBlockCollector::HpackBlockCollector() {} | |
24 HpackBlockCollector::HpackBlockCollector(const HpackBlockCollector& other) | |
25 : pending_entry_(other.pending_entry_), entries_(other.entries_) {} | |
26 HpackBlockCollector::~HpackBlockCollector() {} | |
27 | |
28 void HpackBlockCollector::OnIndexedHeader(size_t index) { | |
29 pending_entry_.OnIndexedHeader(index); | |
30 PushPendingEntry(); | |
31 } | |
32 void HpackBlockCollector::OnDynamicTableSizeUpdate(size_t size) { | |
33 pending_entry_.OnDynamicTableSizeUpdate(size); | |
34 PushPendingEntry(); | |
35 } | |
36 void HpackBlockCollector::OnStartLiteralHeader(HpackEntryType header_type, | |
37 size_t maybe_name_index) { | |
38 pending_entry_.OnStartLiteralHeader(header_type, maybe_name_index); | |
39 } | |
40 void HpackBlockCollector::OnNameStart(bool huffman_encoded, size_t len) { | |
41 pending_entry_.OnNameStart(huffman_encoded, len); | |
42 } | |
43 void HpackBlockCollector::OnNameData(const char* data, size_t len) { | |
44 pending_entry_.OnNameData(data, len); | |
45 } | |
46 void HpackBlockCollector::OnNameEnd() { | |
47 pending_entry_.OnNameEnd(); | |
48 } | |
49 void HpackBlockCollector::OnValueStart(bool huffman_encoded, size_t len) { | |
50 pending_entry_.OnValueStart(huffman_encoded, len); | |
51 } | |
52 void HpackBlockCollector::OnValueData(const char* data, size_t len) { | |
53 pending_entry_.OnValueData(data, len); | |
54 } | |
55 void HpackBlockCollector::OnValueEnd() { | |
56 pending_entry_.OnValueEnd(); | |
57 PushPendingEntry(); | |
58 } | |
59 | |
60 void HpackBlockCollector::PushPendingEntry() { | |
61 EXPECT_TRUE(pending_entry_.IsComplete()); | |
62 DVLOG(2) << "PushPendingEntry: " << pending_entry_; | |
63 entries_.push_back(pending_entry_); | |
64 EXPECT_TRUE(entries_.back().IsComplete()); | |
65 pending_entry_.Clear(); | |
66 } | |
67 void HpackBlockCollector::Clear() { | |
68 pending_entry_.Clear(); | |
69 entries_.clear(); | |
70 } | |
71 | |
72 void HpackBlockCollector::ExpectIndexedHeader(size_t index) { | |
73 entries_.push_back( | |
74 HpackEntryCollector(HpackEntryType::kIndexedHeader, index)); | |
75 } | |
76 void HpackBlockCollector::ExpectDynamicTableSizeUpdate(size_t size) { | |
77 entries_.push_back( | |
78 HpackEntryCollector(HpackEntryType::kDynamicTableSizeUpdate, size)); | |
79 } | |
80 void HpackBlockCollector::ExpectNameIndexAndLiteralValue(HpackEntryType type, | |
81 size_t index, | |
82 bool value_huffman, | |
83 const string& value) { | |
84 entries_.push_back(HpackEntryCollector(type, index, value_huffman, value)); | |
85 } | |
86 void HpackBlockCollector::ExpectLiteralNameAndValue(HpackEntryType type, | |
87 bool name_huffman, | |
88 const string& name, | |
89 bool value_huffman, | |
90 const string& value) { | |
91 entries_.push_back( | |
92 HpackEntryCollector(type, name_huffman, name, value_huffman, value)); | |
93 } | |
94 | |
95 void HpackBlockCollector::ShuffleEntries(RandomBase* rng) { | |
96 std::random_shuffle(entries_.begin(), entries_.end()); | |
97 } | |
98 | |
99 void HpackBlockCollector::AppendToHpackBlockBuilder( | |
100 HpackBlockBuilder* hbb) const { | |
101 CHECK(IsNotPending()); | |
102 for (const auto& entry : entries_) { | |
103 entry.AppendToHpackBlockBuilder(hbb); | |
104 } | |
105 } | |
106 | |
107 AssertionResult HpackBlockCollector::ValidateSoleIndexedHeader( | |
108 size_t ndx) const { | |
109 VERIFY_TRUE(pending_entry_.IsClear()); | |
110 VERIFY_EQ(1u, entries_.size()); | |
111 VERIFY_TRUE(entries_.front().ValidateIndexedHeader(ndx)); | |
112 return AssertionSuccess(); | |
113 } | |
114 AssertionResult HpackBlockCollector::ValidateSoleLiteralValueHeader( | |
115 HpackEntryType expected_type, | |
116 size_t expected_index, | |
117 bool expected_value_huffman, | |
118 StringPiece expected_value) const { | |
119 VERIFY_TRUE(pending_entry_.IsClear()); | |
120 VERIFY_EQ(1u, entries_.size()); | |
121 VERIFY_TRUE(entries_.front().ValidateLiteralValueHeader( | |
122 expected_type, expected_index, expected_value_huffman, expected_value)); | |
123 return AssertionSuccess(); | |
124 } | |
125 AssertionResult HpackBlockCollector::ValidateSoleLiteralNameValueHeader( | |
126 HpackEntryType expected_type, | |
127 bool expected_name_huffman, | |
128 StringPiece expected_name, | |
129 bool expected_value_huffman, | |
130 StringPiece expected_value) const { | |
131 VERIFY_TRUE(pending_entry_.IsClear()); | |
132 VERIFY_EQ(1u, entries_.size()); | |
133 VERIFY_TRUE(entries_.front().ValidateLiteralNameValueHeader( | |
134 expected_type, expected_name_huffman, expected_name, | |
135 expected_value_huffman, expected_value)); | |
136 return AssertionSuccess(); | |
137 } | |
138 AssertionResult HpackBlockCollector::ValidateSoleDynamicTableSizeUpdate( | |
139 size_t size) const { | |
140 VERIFY_TRUE(pending_entry_.IsClear()); | |
141 VERIFY_EQ(1u, entries_.size()); | |
142 VERIFY_TRUE(entries_.front().ValidateDynamicTableSizeUpdate(size)); | |
143 return AssertionSuccess(); | |
144 } | |
145 | |
146 AssertionResult HpackBlockCollector::VerifyEq( | |
147 const HpackBlockCollector& that) const { | |
148 VERIFY_EQ(pending_entry_, that.pending_entry_); | |
149 VERIFY_EQ(entries_, that.entries_); | |
150 return AssertionSuccess(); | |
151 } | |
152 | |
153 } // namespace test | |
154 } // namespace net | |
OLD | NEW |