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 #ifndef NET_HTTP2_TOOLS_RANDOM_DECODER_TEST_H_ | |
6 #define NET_HTTP2_TOOLS_RANDOM_DECODER_TEST_H_ | |
7 | |
8 // RandomDecoderTest is a base class for tests of decoding various kinds | |
9 // of HTTP/2 and HPACK encodings. | |
10 | |
11 // TODO(jamessynge): Move more methods into .cc file. | |
12 | |
13 #include <stddef.h> | |
14 | |
15 #include <memory> | |
16 #include <string> | |
17 #include <type_traits> | |
18 | |
19 #include "base/bind.h" | |
20 #include "base/callback.h" | |
21 #include "base/logging.h" | |
22 #include "base/strings/string_piece.h" | |
23 #include "base/template_util.h" | |
24 #include "net/http2/decoder/decode_buffer.h" | |
25 #include "net/http2/decoder/decode_status.h" | |
26 #include "net/http2/tools/failure.h" | |
27 #include "net/http2/tools/http2_random.h" | |
28 #include "testing/gtest/include/gtest/gtest.h" | |
29 | |
30 namespace net { | |
31 namespace test { | |
32 | |
33 // Some helpers. | |
34 | |
35 template <typename T, size_t N> | |
36 base::StringPiece ToStringPiece(T (&data)[N]) { | |
37 return base::StringPiece(reinterpret_cast<const char*>(data), N * sizeof(T)); | |
38 } | |
39 | |
40 // strings/hex_ascii_dump.h doesn't support StringPiece args for this case. | |
41 std::string HexEncode(base::StringPiece s); | |
42 | |
43 // Overwrite the enum with some random value, probably not a valid value for | |
44 // the enum type, but which fits into its storage. | |
45 template <typename T, | |
46 typename E = typename std::enable_if<std::is_enum<T>::value>::type> | |
47 void CorruptEnum(T* out, RandomBase* rng) { | |
48 // Per cppreference.com, if the destination type of a static_cast is | |
49 // smaller than the source type (i.e. type of r and uint32 below), the | |
50 // resulting value is the smallest unsigned value equal to the source value | |
51 // modulo 2^n, where n is the number of bits used to represent the | |
52 // destination type unsigned U. | |
53 typedef typename base::underlying_type<T>::type underlying_type_T; | |
54 typedef typename std::make_unsigned<underlying_type_T>::type | |
55 unsigned_underlying_type_T; | |
56 auto r = static_cast<unsigned_underlying_type_T>(rng->Rand32()); | |
57 *out = static_cast<T>(r); | |
58 } | |
59 | |
60 // Base class for tests of the ability to decode a sequence of bytes with | |
61 // various boundaries between the DecodeBuffers provided to the decoder. | |
62 class RandomDecoderTest : public ::testing::Test { | |
63 public: | |
64 // SelectSize returns the size of the next DecodeBuffer to be passed to the | |
65 // decoder. Note that RandomDecoderTest allows that size to be zero, though | |
66 // some decoders can't deal with that on the first byte, hence the |first| | |
67 // parameter. | |
68 typedef base::Callback<size_t(bool first, size_t offset, size_t remaining)> | |
69 SelectSize; | |
70 | |
71 // Validator returns an AssertionResult so test can do: | |
72 // EXPECT_THAT(DecodeAndValidate(..., validator)); | |
73 typedef ::testing::AssertionResult AssertionResult; | |
74 typedef base::Callback<AssertionResult(const DecodeBuffer& input, | |
75 DecodeStatus status)> | |
76 Validator; | |
77 typedef base::Callback<AssertionResult()> NoArgValidator; | |
78 | |
79 RandomDecoderTest(); | |
80 | |
81 protected: | |
82 // TODO(jamessynge): Modify StartDecoding, etc. to (somehow) return | |
83 // AssertionResult so that the VERIFY_* methods exported from | |
84 // gunit_helpers.h can be widely used. | |
85 | |
86 // Start decoding; call allows sub-class to Reset the decoder, or deal with | |
87 // the first byte if that is done in a unique fashion. Might be called with | |
88 // a zero byte buffer. | |
89 virtual DecodeStatus StartDecoding(DecodeBuffer* db) = 0; | |
90 | |
91 // Resume decoding of the input after a prior call to StartDecoding, and | |
92 // possibly many calls to ResumeDecoding. | |
93 virtual DecodeStatus ResumeDecoding(DecodeBuffer* db) = 0; | |
94 | |
95 // Return true if a decode status of kDecodeDone indicates that | |
96 // decoding should stop. | |
97 virtual bool StopDecodeOnDone(); | |
98 | |
99 // Decode buffer |original| until we run out of input, or kDecodeDone is | |
100 // returned by the decoder AND StopDecodeOnDone() returns true. Segments | |
101 // (i.e. cuts up) the original DecodeBuffer into (potentially) smaller buffers | |
102 // by calling |select_size| to decide how large each buffer should be. | |
103 // We do this to test the ability to deal with arbitrary boundaries, as might | |
104 // happen in transport. | |
105 // Returns the final DecodeStatus. | |
106 DecodeStatus DecodeSegments(DecodeBuffer* original, | |
107 const SelectSize& select_size); | |
108 | |
109 // Decode buffer |original| until we run out of input, or kDecodeDone is | |
110 // returned by the decoder AND StopDecodeOnDone() returns true. Segments | |
111 // (i.e. cuts up) the original DecodeBuffer into (potentially) smaller buffers | |
112 // by calling |select_size| to decide how large each buffer should be. | |
113 // We do this to test the ability to deal with arbitrary boundaries, as might | |
114 // happen in transport. | |
115 // Invokes |validator| with the final decode status and the original decode | |
116 // buffer, with the cursor advanced as far as has been consumed by the decoder | |
117 // and returns validator's result. | |
118 ::testing::AssertionResult DecodeSegmentsAndValidate( | |
119 DecodeBuffer* original, | |
120 const SelectSize& select_size, | |
121 const Validator& validator) { | |
122 DecodeStatus status = DecodeSegments(original, select_size); | |
123 VERIFY_AND_RETURN_SUCCESS(validator.Run(*original, status)); | |
124 } | |
125 | |
126 // Returns a size for fast decoding, i.e. passing all that | |
127 // is available to the decoder. | |
128 static size_t SelectRemaining(bool first, size_t offset, size_t remaining) { | |
129 return remaining; | |
130 } | |
131 | |
132 // Returns a size for decoding a single byte at a time. | |
133 static size_t SelectOne(bool first, size_t offset, size_t remaining) { | |
134 return 1; | |
135 } | |
136 | |
137 // Returns a size for decoding a single byte at a time, where | |
138 // zero byte buffers are also allowed. Alternates between zero and one. | |
139 static size_t SelectZeroAndOne(bool* zero_next, | |
140 bool first, | |
141 size_t offset, | |
142 size_t remaining); | |
143 | |
144 // Returns a size for decoding random sized segments. | |
145 size_t SelectRandom(bool return_non_zero_on_first, | |
146 bool first, | |
147 size_t offset, | |
148 size_t remaining); | |
149 | |
150 // Decode |original| multiple times, with different segmentations of the | |
151 // decode buffer, validating after each decode, and confirming that they | |
152 // each decode the same amount. Returns on the first failure, else returns | |
153 // success. | |
154 AssertionResult DecodeAndValidateSeveralWays(DecodeBuffer* original, | |
155 bool return_non_zero_on_first, | |
156 const Validator& validator); | |
157 | |
158 static AssertionResult SucceedingValidator(const DecodeBuffer& input, | |
159 DecodeStatus status) { | |
160 return ::testing::AssertionSuccess(); | |
161 } | |
162 | |
163 static Validator ToValidator(const Validator& validator) { return validator; } | |
164 | |
165 static AssertionResult RunNoArgValidator(const NoArgValidator& validator, | |
166 const DecodeBuffer& input, | |
167 DecodeStatus status) { | |
168 return validator.Run(); | |
169 } | |
170 | |
171 static Validator ToValidator(const NoArgValidator& validator) { | |
172 return base::Bind(&RunNoArgValidator, validator); | |
173 } | |
174 | |
175 // Wraps a validator with another validator | |
176 // that first checks that the DecodeStatus is kDecodeDone and | |
177 // that the DecodeBuffer is empty. | |
178 // TODO(jamessynge): Replace this overload with the next, as using this method | |
179 // usually means that the wrapped function doesn't need to be passed the | |
180 // DecodeBuffer nor the DecodeStatus. | |
181 static AssertionResult ValidateDoneAndEmptyImpl(const Validator& wrapped, | |
182 const DecodeBuffer& input, | |
183 DecodeStatus status) { | |
184 VERIFY_EQ(status, DecodeStatus::kDecodeDone); | |
185 VERIFY_EQ(0u, input.Remaining()) << "\nOffset=" << input.Offset(); | |
186 return wrapped.Run(input, status); | |
187 } | |
188 static Validator ValidateDoneAndEmpty(const Validator& wrapped) { | |
189 return base::Bind(&ValidateDoneAndEmptyImpl, wrapped); | |
190 } | |
191 static AssertionResult ValidateDoneAndEmptyNoArgImpl( | |
192 const NoArgValidator& wrapped, | |
193 const DecodeBuffer& input, | |
194 DecodeStatus status) { | |
195 VERIFY_EQ(status, DecodeStatus::kDecodeDone); | |
196 VERIFY_EQ(0u, input.Remaining()) << "\nOffset=" << input.Offset(); | |
197 return wrapped.Run(); | |
198 } | |
199 static Validator ValidateDoneAndEmpty(const NoArgValidator& wrapped) { | |
200 return base::Bind(&ValidateDoneAndEmptyNoArgImpl, wrapped); | |
201 } | |
202 static Validator ValidateDoneAndEmpty() { | |
203 return ValidateDoneAndEmpty(base::Bind(&SucceedingValidator)); | |
204 } | |
205 | |
206 // Wraps a validator with another validator | |
207 // that first checks that the DecodeStatus is kDecodeDone and | |
208 // that the DecodeBuffer has the expected offset. | |
209 // TODO(jamessynge): Replace this overload with the next, as using this method | |
210 // usually means that the wrapped function doesn't need to be passed the | |
211 // DecodeBuffer nor the DecodeStatus. | |
212 static AssertionResult ValidateDoneAndOffsetImpl(uint32_t offset, | |
213 const Validator& wrapped, | |
214 const DecodeBuffer& input, | |
215 DecodeStatus status) { | |
216 VERIFY_EQ(status, DecodeStatus::kDecodeDone); | |
217 VERIFY_EQ(offset, input.Offset()) << "\nRemaining=" << input.Remaining(); | |
218 return wrapped.Run(input, status); | |
219 } | |
220 static Validator ValidateDoneAndOffset(uint32_t offset, | |
221 const Validator& wrapped) { | |
222 // Make a copy of |wrapped| (by not using base::ConstRef) to avoid lifetime | |
223 // issues if this method is called with a temporary Validator. | |
224 return base::Bind(&ValidateDoneAndOffsetImpl, offset, wrapped); | |
225 } | |
226 static AssertionResult ValidateDoneAndOffsetNoArgImpl( | |
227 uint32_t offset, | |
228 const NoArgValidator& wrapped, | |
229 const DecodeBuffer& input, | |
230 DecodeStatus status) { | |
231 VERIFY_EQ(status, DecodeStatus::kDecodeDone); | |
232 VERIFY_EQ(offset, input.Offset()) << "\nRemaining=" << input.Remaining(); | |
233 return wrapped.Run(); | |
234 } | |
235 static Validator ValidateDoneAndOffset(uint32_t offset, | |
236 const NoArgValidator& wrapped) { | |
237 // Make a copy of |wrapped| (by not using base::ConstRef) to avoid lifetime | |
238 // issues if this method is called with a temporary Validator. | |
239 return base::Bind(&ValidateDoneAndOffsetNoArgImpl, offset, wrapped); | |
240 } | |
241 static Validator ValidateDoneAndOffset(uint32_t offset) { | |
242 // Make a copy of |wrapped| (by not using base::ConstRef) to avoid lifetime | |
243 // issues if this method is called with a temporary Validator. | |
244 return ValidateDoneAndOffset(offset, base::Bind(&SucceedingValidator)); | |
245 } | |
246 | |
247 // Expose |random_| as RandomBase so callers do not have to care about which | |
248 // sub-class of RandomBase is used, nor can they rely on the specific | |
249 // sub-class that RandomDecoderTest uses. | |
250 RandomBase& Random() { return random_; } | |
251 RandomBase* RandomPtr() { return &random_; } | |
252 | |
253 uint32_t RandStreamId(); | |
254 | |
255 bool stop_decode_on_done_ = true; | |
256 | |
257 private: | |
258 Http2Random random_; | |
259 }; | |
260 | |
261 } // namespace test | |
262 } // namespace net | |
263 | |
264 #endif // NET_HTTP2_TOOLS_RANDOM_DECODER_TEST_H_ | |
OLD | NEW |