Index: net/http2/tools/random_decoder_test.h |
diff --git a/net/http2/tools/random_decoder_test.h b/net/http2/tools/random_decoder_test.h |
deleted file mode 100644 |
index f3ab829d8067c64dddd2fe5a507b9ea90b661b95..0000000000000000000000000000000000000000 |
--- a/net/http2/tools/random_decoder_test.h |
+++ /dev/null |
@@ -1,264 +0,0 @@ |
-// Copyright 2016 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. |
- |
-#ifndef NET_HTTP2_TOOLS_RANDOM_DECODER_TEST_H_ |
-#define NET_HTTP2_TOOLS_RANDOM_DECODER_TEST_H_ |
- |
-// RandomDecoderTest is a base class for tests of decoding various kinds |
-// of HTTP/2 and HPACK encodings. |
- |
-// TODO(jamessynge): Move more methods into .cc file. |
- |
-#include <stddef.h> |
- |
-#include <memory> |
-#include <string> |
-#include <type_traits> |
- |
-#include "base/bind.h" |
-#include "base/callback.h" |
-#include "base/logging.h" |
-#include "base/strings/string_piece.h" |
-#include "base/template_util.h" |
-#include "net/http2/decoder/decode_buffer.h" |
-#include "net/http2/decoder/decode_status.h" |
-#include "net/http2/tools/failure.h" |
-#include "net/http2/tools/http2_random.h" |
-#include "testing/gtest/include/gtest/gtest.h" |
- |
-namespace net { |
-namespace test { |
- |
-// Some helpers. |
- |
-template <typename T, size_t N> |
-base::StringPiece ToStringPiece(T (&data)[N]) { |
- return base::StringPiece(reinterpret_cast<const char*>(data), N * sizeof(T)); |
-} |
- |
-// strings/hex_ascii_dump.h doesn't support StringPiece args for this case. |
-std::string HexEncode(base::StringPiece s); |
- |
-// Overwrite the enum with some random value, probably not a valid value for |
-// the enum type, but which fits into its storage. |
-template <typename T, |
- typename E = typename std::enable_if<std::is_enum<T>::value>::type> |
-void CorruptEnum(T* out, RandomBase* rng) { |
- // Per cppreference.com, if the destination type of a static_cast is |
- // smaller than the source type (i.e. type of r and uint32 below), the |
- // resulting value is the smallest unsigned value equal to the source value |
- // modulo 2^n, where n is the number of bits used to represent the |
- // destination type unsigned U. |
- typedef typename base::underlying_type<T>::type underlying_type_T; |
- typedef typename std::make_unsigned<underlying_type_T>::type |
- unsigned_underlying_type_T; |
- auto r = static_cast<unsigned_underlying_type_T>(rng->Rand32()); |
- *out = static_cast<T>(r); |
-} |
- |
-// Base class for tests of the ability to decode a sequence of bytes with |
-// various boundaries between the DecodeBuffers provided to the decoder. |
-class RandomDecoderTest : public ::testing::Test { |
- public: |
- // SelectSize returns the size of the next DecodeBuffer to be passed to the |
- // decoder. Note that RandomDecoderTest allows that size to be zero, though |
- // some decoders can't deal with that on the first byte, hence the |first| |
- // parameter. |
- typedef base::Callback<size_t(bool first, size_t offset, size_t remaining)> |
- SelectSize; |
- |
- // Validator returns an AssertionResult so test can do: |
- // EXPECT_THAT(DecodeAndValidate(..., validator)); |
- typedef ::testing::AssertionResult AssertionResult; |
- typedef base::Callback<AssertionResult(const DecodeBuffer& input, |
- DecodeStatus status)> |
- Validator; |
- typedef base::Callback<AssertionResult()> NoArgValidator; |
- |
- RandomDecoderTest(); |
- |
- protected: |
- // TODO(jamessynge): Modify StartDecoding, etc. to (somehow) return |
- // AssertionResult so that the VERIFY_* methods exported from |
- // gunit_helpers.h can be widely used. |
- |
- // Start decoding; call allows sub-class to Reset the decoder, or deal with |
- // the first byte if that is done in a unique fashion. Might be called with |
- // a zero byte buffer. |
- virtual DecodeStatus StartDecoding(DecodeBuffer* db) = 0; |
- |
- // Resume decoding of the input after a prior call to StartDecoding, and |
- // possibly many calls to ResumeDecoding. |
- virtual DecodeStatus ResumeDecoding(DecodeBuffer* db) = 0; |
- |
- // Return true if a decode status of kDecodeDone indicates that |
- // decoding should stop. |
- virtual bool StopDecodeOnDone(); |
- |
- // Decode buffer |original| until we run out of input, or kDecodeDone is |
- // returned by the decoder AND StopDecodeOnDone() returns true. Segments |
- // (i.e. cuts up) the original DecodeBuffer into (potentially) smaller buffers |
- // by calling |select_size| to decide how large each buffer should be. |
- // We do this to test the ability to deal with arbitrary boundaries, as might |
- // happen in transport. |
- // Returns the final DecodeStatus. |
- DecodeStatus DecodeSegments(DecodeBuffer* original, |
- const SelectSize& select_size); |
- |
- // Decode buffer |original| until we run out of input, or kDecodeDone is |
- // returned by the decoder AND StopDecodeOnDone() returns true. Segments |
- // (i.e. cuts up) the original DecodeBuffer into (potentially) smaller buffers |
- // by calling |select_size| to decide how large each buffer should be. |
- // We do this to test the ability to deal with arbitrary boundaries, as might |
- // happen in transport. |
- // Invokes |validator| with the final decode status and the original decode |
- // buffer, with the cursor advanced as far as has been consumed by the decoder |
- // and returns validator's result. |
- ::testing::AssertionResult DecodeSegmentsAndValidate( |
- DecodeBuffer* original, |
- const SelectSize& select_size, |
- const Validator& validator) { |
- DecodeStatus status = DecodeSegments(original, select_size); |
- VERIFY_AND_RETURN_SUCCESS(validator.Run(*original, status)); |
- } |
- |
- // Returns a size for fast decoding, i.e. passing all that |
- // is available to the decoder. |
- static size_t SelectRemaining(bool first, size_t offset, size_t remaining) { |
- return remaining; |
- } |
- |
- // Returns a size for decoding a single byte at a time. |
- static size_t SelectOne(bool first, size_t offset, size_t remaining) { |
- return 1; |
- } |
- |
- // Returns a size for decoding a single byte at a time, where |
- // zero byte buffers are also allowed. Alternates between zero and one. |
- static size_t SelectZeroAndOne(bool* zero_next, |
- bool first, |
- size_t offset, |
- size_t remaining); |
- |
- // Returns a size for decoding random sized segments. |
- size_t SelectRandom(bool return_non_zero_on_first, |
- bool first, |
- size_t offset, |
- size_t remaining); |
- |
- // Decode |original| multiple times, with different segmentations of the |
- // decode buffer, validating after each decode, and confirming that they |
- // each decode the same amount. Returns on the first failure, else returns |
- // success. |
- AssertionResult DecodeAndValidateSeveralWays(DecodeBuffer* original, |
- bool return_non_zero_on_first, |
- const Validator& validator); |
- |
- static AssertionResult SucceedingValidator(const DecodeBuffer& input, |
- DecodeStatus status) { |
- return ::testing::AssertionSuccess(); |
- } |
- |
- static Validator ToValidator(const Validator& validator) { return validator; } |
- |
- static AssertionResult RunNoArgValidator(const NoArgValidator& validator, |
- const DecodeBuffer& input, |
- DecodeStatus status) { |
- return validator.Run(); |
- } |
- |
- static Validator ToValidator(const NoArgValidator& validator) { |
- return base::Bind(&RunNoArgValidator, validator); |
- } |
- |
- // Wraps a validator with another validator |
- // that first checks that the DecodeStatus is kDecodeDone and |
- // that the DecodeBuffer is empty. |
- // TODO(jamessynge): Replace this overload with the next, as using this method |
- // usually means that the wrapped function doesn't need to be passed the |
- // DecodeBuffer nor the DecodeStatus. |
- static AssertionResult ValidateDoneAndEmptyImpl(const Validator& wrapped, |
- const DecodeBuffer& input, |
- DecodeStatus status) { |
- VERIFY_EQ(status, DecodeStatus::kDecodeDone); |
- VERIFY_EQ(0u, input.Remaining()) << "\nOffset=" << input.Offset(); |
- return wrapped.Run(input, status); |
- } |
- static Validator ValidateDoneAndEmpty(const Validator& wrapped) { |
- return base::Bind(&ValidateDoneAndEmptyImpl, wrapped); |
- } |
- static AssertionResult ValidateDoneAndEmptyNoArgImpl( |
- const NoArgValidator& wrapped, |
- const DecodeBuffer& input, |
- DecodeStatus status) { |
- VERIFY_EQ(status, DecodeStatus::kDecodeDone); |
- VERIFY_EQ(0u, input.Remaining()) << "\nOffset=" << input.Offset(); |
- return wrapped.Run(); |
- } |
- static Validator ValidateDoneAndEmpty(const NoArgValidator& wrapped) { |
- return base::Bind(&ValidateDoneAndEmptyNoArgImpl, wrapped); |
- } |
- static Validator ValidateDoneAndEmpty() { |
- return ValidateDoneAndEmpty(base::Bind(&SucceedingValidator)); |
- } |
- |
- // Wraps a validator with another validator |
- // that first checks that the DecodeStatus is kDecodeDone and |
- // that the DecodeBuffer has the expected offset. |
- // TODO(jamessynge): Replace this overload with the next, as using this method |
- // usually means that the wrapped function doesn't need to be passed the |
- // DecodeBuffer nor the DecodeStatus. |
- static AssertionResult ValidateDoneAndOffsetImpl(uint32_t offset, |
- const Validator& wrapped, |
- const DecodeBuffer& input, |
- DecodeStatus status) { |
- VERIFY_EQ(status, DecodeStatus::kDecodeDone); |
- VERIFY_EQ(offset, input.Offset()) << "\nRemaining=" << input.Remaining(); |
- return wrapped.Run(input, status); |
- } |
- static Validator ValidateDoneAndOffset(uint32_t offset, |
- const Validator& wrapped) { |
- // Make a copy of |wrapped| (by not using base::ConstRef) to avoid lifetime |
- // issues if this method is called with a temporary Validator. |
- return base::Bind(&ValidateDoneAndOffsetImpl, offset, wrapped); |
- } |
- static AssertionResult ValidateDoneAndOffsetNoArgImpl( |
- uint32_t offset, |
- const NoArgValidator& wrapped, |
- const DecodeBuffer& input, |
- DecodeStatus status) { |
- VERIFY_EQ(status, DecodeStatus::kDecodeDone); |
- VERIFY_EQ(offset, input.Offset()) << "\nRemaining=" << input.Remaining(); |
- return wrapped.Run(); |
- } |
- static Validator ValidateDoneAndOffset(uint32_t offset, |
- const NoArgValidator& wrapped) { |
- // Make a copy of |wrapped| (by not using base::ConstRef) to avoid lifetime |
- // issues if this method is called with a temporary Validator. |
- return base::Bind(&ValidateDoneAndOffsetNoArgImpl, offset, wrapped); |
- } |
- static Validator ValidateDoneAndOffset(uint32_t offset) { |
- // Make a copy of |wrapped| (by not using base::ConstRef) to avoid lifetime |
- // issues if this method is called with a temporary Validator. |
- return ValidateDoneAndOffset(offset, base::Bind(&SucceedingValidator)); |
- } |
- |
- // Expose |random_| as RandomBase so callers do not have to care about which |
- // sub-class of RandomBase is used, nor can they rely on the specific |
- // sub-class that RandomDecoderTest uses. |
- RandomBase& Random() { return random_; } |
- RandomBase* RandomPtr() { return &random_; } |
- |
- uint32_t RandStreamId(); |
- |
- bool stop_decode_on_done_ = true; |
- |
- private: |
- Http2Random random_; |
-}; |
- |
-} // namespace test |
-} // namespace net |
- |
-#endif // NET_HTTP2_TOOLS_RANDOM_DECODER_TEST_H_ |