| 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_decoder_string_buffer.h" | |
| 6 | |
| 7 // Tests of HpackDecoderStringBuffer. | |
| 8 | |
| 9 #include <initializer_list> | |
| 10 #include <sstream> | |
| 11 #include <string> | |
| 12 | |
| 13 #include "base/logging.h" | |
| 14 #include "base/strings/string_piece.h" | |
| 15 #include "net/http2/tools/failure.h" | |
| 16 #include "net/spdy/spdy_test_utils.h" | |
| 17 #include "testing/gmock/include/gmock/gmock.h" | |
| 18 #include "testing/gtest/include/gtest/gtest.h" | |
| 19 | |
| 20 using ::testing::AssertionResult; | |
| 21 using ::testing::AssertionSuccess; | |
| 22 using ::testing::HasSubstr; | |
| 23 using base::StringPiece; | |
| 24 using std::string; | |
| 25 | |
| 26 namespace net { | |
| 27 namespace test { | |
| 28 namespace { | |
| 29 | |
| 30 class HpackDecoderStringBufferTest : public ::testing::Test { | |
| 31 protected: | |
| 32 typedef HpackDecoderStringBuffer::State State; | |
| 33 typedef HpackDecoderStringBuffer::Backing Backing; | |
| 34 | |
| 35 State state() const { return buf_.state_for_testing(); } | |
| 36 Backing backing() const { return buf_.backing_for_testing(); } | |
| 37 | |
| 38 // We want to know that LOG(x) << buf_ will work in production should that | |
| 39 // be needed, so we test that it outputs the expected values. | |
| 40 AssertionResult VerifyLogHasSubstrs(std::initializer_list<string> strs) { | |
| 41 VLOG(1) << buf_; | |
| 42 std::ostringstream ss; | |
| 43 buf_.OutputDebugStringTo(ss); | |
| 44 string dbg_str(ss.str()); | |
| 45 for (const auto& expected : strs) { | |
| 46 VERIFY_THAT(dbg_str, HasSubstr(expected)); | |
| 47 } | |
| 48 return AssertionSuccess(); | |
| 49 } | |
| 50 | |
| 51 HpackDecoderStringBuffer buf_; | |
| 52 }; | |
| 53 | |
| 54 TEST_F(HpackDecoderStringBufferTest, SetStatic) { | |
| 55 StringPiece data("static string"); | |
| 56 | |
| 57 EXPECT_EQ(state(), State::RESET); | |
| 58 EXPECT_TRUE(VerifyLogHasSubstrs({"state=RESET"})); | |
| 59 | |
| 60 buf_.Set(data, /*is_static*/ true); | |
| 61 LOG(INFO) << buf_; | |
| 62 EXPECT_EQ(state(), State::COMPLETE); | |
| 63 EXPECT_EQ(backing(), Backing::STATIC); | |
| 64 EXPECT_EQ(data, buf_.str()); | |
| 65 EXPECT_EQ(data.data(), buf_.str().data()); | |
| 66 EXPECT_TRUE(VerifyLogHasSubstrs( | |
| 67 {"state=COMPLETE", "backing=STATIC", "value: static string"})); | |
| 68 | |
| 69 // The string is static, so BufferStringIfUnbuffered won't change anything. | |
| 70 buf_.BufferStringIfUnbuffered(); | |
| 71 EXPECT_EQ(state(), State::COMPLETE); | |
| 72 EXPECT_EQ(backing(), Backing::STATIC); | |
| 73 EXPECT_EQ(data, buf_.str()); | |
| 74 EXPECT_EQ(data.data(), buf_.str().data()); | |
| 75 EXPECT_TRUE(VerifyLogHasSubstrs( | |
| 76 {"state=COMPLETE", "backing=STATIC", "value: static string"})); | |
| 77 } | |
| 78 | |
| 79 TEST_F(HpackDecoderStringBufferTest, PlainWhole) { | |
| 80 StringPiece data("some text."); | |
| 81 | |
| 82 LOG(INFO) << buf_; | |
| 83 EXPECT_EQ(state(), State::RESET); | |
| 84 | |
| 85 buf_.OnStart(/*huffman_encoded*/ false, data.size()); | |
| 86 EXPECT_EQ(state(), State::COLLECTING); | |
| 87 EXPECT_EQ(backing(), Backing::RESET); | |
| 88 LOG(INFO) << buf_; | |
| 89 | |
| 90 EXPECT_TRUE(buf_.OnData(data.data(), data.size())); | |
| 91 EXPECT_EQ(state(), State::COLLECTING); | |
| 92 EXPECT_EQ(backing(), Backing::UNBUFFERED); | |
| 93 | |
| 94 EXPECT_TRUE(buf_.OnEnd()); | |
| 95 EXPECT_EQ(state(), State::COMPLETE); | |
| 96 EXPECT_EQ(backing(), Backing::UNBUFFERED); | |
| 97 EXPECT_EQ(0u, buf_.BufferedLength()); | |
| 98 EXPECT_TRUE(VerifyLogHasSubstrs( | |
| 99 {"state=COMPLETE", "backing=UNBUFFERED", "value: some text."})); | |
| 100 | |
| 101 // We expect that the string buffer points to the passed in StringPiece's | |
| 102 // backing store. | |
| 103 EXPECT_EQ(data.data(), buf_.str().data()); | |
| 104 | |
| 105 // Now force it to buffer the string, after which it will still have the same | |
| 106 // string value, but the backing store will be different. | |
| 107 buf_.BufferStringIfUnbuffered(); | |
| 108 LOG(INFO) << buf_; | |
| 109 EXPECT_EQ(backing(), Backing::BUFFERED); | |
| 110 EXPECT_EQ(buf_.BufferedLength(), data.size()); | |
| 111 EXPECT_EQ(data, buf_.str()); | |
| 112 EXPECT_NE(data.data(), buf_.str().data()); | |
| 113 EXPECT_TRUE(VerifyLogHasSubstrs( | |
| 114 {"state=COMPLETE", "backing=BUFFERED", "buffer: some text."})); | |
| 115 } | |
| 116 | |
| 117 TEST_F(HpackDecoderStringBufferTest, PlainSplit) { | |
| 118 StringPiece data("some text."); | |
| 119 StringPiece part1 = data.substr(0, 1); | |
| 120 StringPiece part2 = data.substr(1); | |
| 121 | |
| 122 EXPECT_EQ(state(), State::RESET); | |
| 123 buf_.OnStart(/*huffman_encoded*/ false, data.size()); | |
| 124 EXPECT_EQ(state(), State::COLLECTING); | |
| 125 EXPECT_EQ(backing(), Backing::RESET); | |
| 126 | |
| 127 // OnData with only a part of the data, not the whole, so buf_ will buffer | |
| 128 // the data. | |
| 129 EXPECT_TRUE(buf_.OnData(part1.data(), part1.size())); | |
| 130 EXPECT_EQ(state(), State::COLLECTING); | |
| 131 EXPECT_EQ(backing(), Backing::BUFFERED); | |
| 132 EXPECT_EQ(buf_.BufferedLength(), part1.size()); | |
| 133 LOG(INFO) << buf_; | |
| 134 | |
| 135 EXPECT_TRUE(buf_.OnData(part2.data(), part2.size())); | |
| 136 EXPECT_EQ(state(), State::COLLECTING); | |
| 137 EXPECT_EQ(backing(), Backing::BUFFERED); | |
| 138 EXPECT_EQ(buf_.BufferedLength(), data.size()); | |
| 139 | |
| 140 EXPECT_TRUE(buf_.OnEnd()); | |
| 141 EXPECT_EQ(state(), State::COMPLETE); | |
| 142 EXPECT_EQ(backing(), Backing::BUFFERED); | |
| 143 EXPECT_EQ(buf_.BufferedLength(), data.size()); | |
| 144 LOG(INFO) << buf_; | |
| 145 | |
| 146 StringPiece buffered = buf_.str(); | |
| 147 EXPECT_EQ(data, buffered); | |
| 148 EXPECT_NE(data.data(), buffered.data()); | |
| 149 | |
| 150 // The string is already buffered, so BufferStringIfUnbuffered should not make | |
| 151 // any change. | |
| 152 buf_.BufferStringIfUnbuffered(); | |
| 153 EXPECT_EQ(backing(), Backing::BUFFERED); | |
| 154 EXPECT_EQ(buf_.BufferedLength(), data.size()); | |
| 155 EXPECT_EQ(buffered, buf_.str()); | |
| 156 EXPECT_EQ(buffered.data(), buf_.str().data()); | |
| 157 } | |
| 158 | |
| 159 TEST_F(HpackDecoderStringBufferTest, HuffmanWhole) { | |
| 160 string encoded = a2b_hex("f1e3c2e5f23a6ba0ab90f4ff"); | |
| 161 StringPiece decoded("www.example.com"); | |
| 162 | |
| 163 EXPECT_EQ(state(), State::RESET); | |
| 164 buf_.OnStart(/*huffman_encoded*/ true, encoded.size()); | |
| 165 EXPECT_EQ(state(), State::COLLECTING); | |
| 166 | |
| 167 EXPECT_TRUE(buf_.OnData(encoded.data(), encoded.size())); | |
| 168 EXPECT_EQ(state(), State::COLLECTING); | |
| 169 EXPECT_EQ(backing(), Backing::BUFFERED); | |
| 170 | |
| 171 EXPECT_TRUE(buf_.OnEnd()); | |
| 172 EXPECT_EQ(state(), State::COMPLETE); | |
| 173 EXPECT_EQ(backing(), Backing::BUFFERED); | |
| 174 EXPECT_EQ(buf_.BufferedLength(), decoded.size()); | |
| 175 EXPECT_EQ(decoded, buf_.str()); | |
| 176 EXPECT_TRUE(VerifyLogHasSubstrs( | |
| 177 {"{state=COMPLETE", "backing=BUFFERED", "buffer: www.example.com}"})); | |
| 178 } | |
| 179 | |
| 180 TEST_F(HpackDecoderStringBufferTest, HuffmanSplit) { | |
| 181 string encoded = a2b_hex("f1e3c2e5f23a6ba0ab90f4ff"); | |
| 182 string part1 = encoded.substr(0, 5); | |
| 183 string part2 = encoded.substr(5); | |
| 184 StringPiece decoded("www.example.com"); | |
| 185 | |
| 186 EXPECT_EQ(state(), State::RESET); | |
| 187 buf_.OnStart(/*huffman_encoded*/ true, encoded.size()); | |
| 188 EXPECT_EQ(state(), State::COLLECTING); | |
| 189 EXPECT_EQ(backing(), Backing::BUFFERED); | |
| 190 EXPECT_EQ(0u, buf_.BufferedLength()); | |
| 191 LOG(INFO) << buf_; | |
| 192 | |
| 193 EXPECT_TRUE(buf_.OnData(part1.data(), part1.size())); | |
| 194 EXPECT_EQ(state(), State::COLLECTING); | |
| 195 EXPECT_EQ(backing(), Backing::BUFFERED); | |
| 196 EXPECT_GT(buf_.BufferedLength(), 0u); | |
| 197 EXPECT_LT(buf_.BufferedLength(), decoded.size()); | |
| 198 LOG(INFO) << buf_; | |
| 199 | |
| 200 EXPECT_TRUE(buf_.OnData(part2.data(), part2.size())); | |
| 201 EXPECT_EQ(state(), State::COLLECTING); | |
| 202 EXPECT_EQ(backing(), Backing::BUFFERED); | |
| 203 EXPECT_EQ(buf_.BufferedLength(), decoded.size()); | |
| 204 LOG(INFO) << buf_; | |
| 205 | |
| 206 EXPECT_TRUE(buf_.OnEnd()); | |
| 207 EXPECT_EQ(state(), State::COMPLETE); | |
| 208 EXPECT_EQ(backing(), Backing::BUFFERED); | |
| 209 EXPECT_EQ(buf_.BufferedLength(), decoded.size()); | |
| 210 EXPECT_EQ(decoded, buf_.str()); | |
| 211 LOG(INFO) << buf_; | |
| 212 } | |
| 213 | |
| 214 TEST_F(HpackDecoderStringBufferTest, InvalidHuffmanOnData) { | |
| 215 // Explicitly encode the End-of-String symbol, a no-no. | |
| 216 string encoded = a2b_hex("ffffffff"); | |
| 217 | |
| 218 buf_.OnStart(/*huffman_encoded*/ true, encoded.size()); | |
| 219 EXPECT_EQ(state(), State::COLLECTING); | |
| 220 | |
| 221 EXPECT_FALSE(buf_.OnData(encoded.data(), encoded.size())); | |
| 222 EXPECT_EQ(state(), State::COLLECTING); | |
| 223 EXPECT_EQ(backing(), Backing::BUFFERED); | |
| 224 | |
| 225 LOG(INFO) << buf_; | |
| 226 } | |
| 227 | |
| 228 TEST_F(HpackDecoderStringBufferTest, InvalidHuffmanOnEnd) { | |
| 229 // Last byte of string doesn't end with prefix of End-of-String symbol. | |
| 230 string encoded = a2b_hex("00"); | |
| 231 | |
| 232 buf_.OnStart(/*huffman_encoded*/ true, encoded.size()); | |
| 233 EXPECT_EQ(state(), State::COLLECTING); | |
| 234 | |
| 235 EXPECT_TRUE(buf_.OnData(encoded.data(), encoded.size())); | |
| 236 EXPECT_EQ(state(), State::COLLECTING); | |
| 237 EXPECT_EQ(backing(), Backing::BUFFERED); | |
| 238 | |
| 239 EXPECT_FALSE(buf_.OnEnd()); | |
| 240 LOG(INFO) << buf_; | |
| 241 } | |
| 242 | |
| 243 } // namespace | |
| 244 } // namespace test | |
| 245 } // namespace net | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 2554683003:
Revert of Add new HTTP/2 and HPACK decoder in net/http2/. (Closed)
