blob: 0de00d85d30c041f83b1f01ef696b9d967810afa [file] [log] [blame]
#include "quiche/http2/adapter/nghttp2_test_utils.h"
#include "quiche/http2/adapter/nghttp2_util.h"
#include "quiche/common/quiche_endian.h"
namespace http2 {
namespace adapter {
namespace test {
namespace {
// Custom gMock matcher, used to implement HasFrameHeader().
class FrameHeaderMatcher {
public:
FrameHeaderMatcher(int32_t streamid, uint8_t type,
const testing::Matcher<int> flags)
: stream_id_(streamid), type_(type), flags_(flags) {}
bool Match(const nghttp2_frame_hd& frame,
testing::MatchResultListener* listener) const {
bool matched = true;
if (stream_id_ != frame.stream_id) {
*listener << "; expected stream " << stream_id_ << ", saw "
<< frame.stream_id;
matched = false;
}
if (type_ != frame.type) {
*listener << "; expected frame type " << type_ << ", saw "
<< static_cast<int>(frame.type);
matched = false;
}
if (!flags_.MatchAndExplain(frame.flags, listener)) {
matched = false;
}
return matched;
}
void DescribeTo(std::ostream* os) const {
*os << "contains a frame header with stream " << stream_id_ << ", type "
<< type_ << ", ";
flags_.DescribeTo(os);
}
void DescribeNegationTo(std::ostream* os) const {
*os << "does not contain a frame header with stream " << stream_id_
<< ", type " << type_ << ", ";
flags_.DescribeNegationTo(os);
}
private:
const int32_t stream_id_;
const int type_;
const testing::Matcher<int> flags_;
};
class PointerToFrameHeaderMatcher
: public FrameHeaderMatcher,
public testing::MatcherInterface<const nghttp2_frame_hd*> {
public:
PointerToFrameHeaderMatcher(int32_t streamid, uint8_t type,
const testing::Matcher<int> flags)
: FrameHeaderMatcher(streamid, type, flags) {}
bool MatchAndExplain(const nghttp2_frame_hd* frame,
testing::MatchResultListener* listener) const override {
return FrameHeaderMatcher::Match(*frame, listener);
}
void DescribeTo(std::ostream* os) const override {
FrameHeaderMatcher::DescribeTo(os);
}
void DescribeNegationTo(std::ostream* os) const override {
FrameHeaderMatcher::DescribeNegationTo(os);
}
};
class ReferenceToFrameHeaderMatcher
: public FrameHeaderMatcher,
public testing::MatcherInterface<const nghttp2_frame_hd&> {
public:
ReferenceToFrameHeaderMatcher(int32_t streamid, uint8_t type,
const testing::Matcher<int> flags)
: FrameHeaderMatcher(streamid, type, flags) {}
bool MatchAndExplain(const nghttp2_frame_hd& frame,
testing::MatchResultListener* listener) const override {
return FrameHeaderMatcher::Match(frame, listener);
}
void DescribeTo(std::ostream* os) const override {
FrameHeaderMatcher::DescribeTo(os);
}
void DescribeNegationTo(std::ostream* os) const override {
FrameHeaderMatcher::DescribeNegationTo(os);
}
};
class DataMatcher : public testing::MatcherInterface<const nghttp2_frame*> {
public:
DataMatcher(const testing::Matcher<uint32_t> stream_id,
const testing::Matcher<size_t> length,
const testing::Matcher<int> flags,
const testing::Matcher<size_t> padding)
: stream_id_(stream_id),
length_(length),
flags_(flags),
padding_(padding) {}
bool MatchAndExplain(const nghttp2_frame* frame,
testing::MatchResultListener* listener) const override {
if (frame->hd.type != NGHTTP2_DATA) {
*listener << "; expected DATA frame, saw frame of type "
<< static_cast<int>(frame->hd.type);
return false;
}
bool matched = true;
if (!stream_id_.MatchAndExplain(frame->hd.stream_id, listener)) {
matched = false;
}
if (!length_.MatchAndExplain(frame->hd.length, listener)) {
matched = false;
}
if (!flags_.MatchAndExplain(frame->hd.flags, listener)) {
matched = false;
}
if (!padding_.MatchAndExplain(frame->data.padlen, listener)) {
matched = false;
}
return matched;
}
void DescribeTo(std::ostream* os) const override {
*os << "contains a DATA frame, ";
stream_id_.DescribeTo(os);
length_.DescribeTo(os);
flags_.DescribeTo(os);
}
void DescribeNegationTo(std::ostream* os) const override {
*os << "does not contain a DATA frame, ";
stream_id_.DescribeNegationTo(os);
length_.DescribeNegationTo(os);
flags_.DescribeNegationTo(os);
}
private:
const testing::Matcher<uint32_t> stream_id_;
const testing::Matcher<size_t> length_;
const testing::Matcher<int> flags_;
const testing::Matcher<size_t> padding_;
};
class HeadersMatcher : public testing::MatcherInterface<const nghttp2_frame*> {
public:
HeadersMatcher(const testing::Matcher<uint32_t> stream_id,
const testing::Matcher<int> flags,
const testing::Matcher<int> category)
: stream_id_(stream_id), flags_(flags), category_(category) {}
bool MatchAndExplain(const nghttp2_frame* frame,
testing::MatchResultListener* listener) const override {
if (frame->hd.type != NGHTTP2_HEADERS) {
*listener << "; expected HEADERS frame, saw frame of type "
<< static_cast<int>(frame->hd.type);
return false;
}
bool matched = true;
if (!stream_id_.MatchAndExplain(frame->hd.stream_id, listener)) {
matched = false;
}
if (!flags_.MatchAndExplain(frame->hd.flags, listener)) {
matched = false;
}
if (!category_.MatchAndExplain(frame->headers.cat, listener)) {
matched = false;
}
return matched;
}
void DescribeTo(std::ostream* os) const override {
*os << "contains a HEADERS frame, ";
stream_id_.DescribeTo(os);
flags_.DescribeTo(os);
category_.DescribeTo(os);
}
void DescribeNegationTo(std::ostream* os) const override {
*os << "does not contain a HEADERS frame, ";
stream_id_.DescribeNegationTo(os);
flags_.DescribeNegationTo(os);
category_.DescribeNegationTo(os);
}
private:
const testing::Matcher<uint32_t> stream_id_;
const testing::Matcher<int> flags_;
const testing::Matcher<int> category_;
};
class RstStreamMatcher
: public testing::MatcherInterface<const nghttp2_frame*> {
public:
RstStreamMatcher(const testing::Matcher<uint32_t> stream_id,
const testing::Matcher<uint32_t> error_code)
: stream_id_(stream_id), error_code_(error_code) {}
bool MatchAndExplain(const nghttp2_frame* frame,
testing::MatchResultListener* listener) const override {
if (frame->hd.type != NGHTTP2_RST_STREAM) {
*listener << "; expected RST_STREAM frame, saw frame of type "
<< static_cast<int>(frame->hd.type);
return false;
}
bool matched = true;
if (!stream_id_.MatchAndExplain(frame->hd.stream_id, listener)) {
matched = false;
}
if (!error_code_.MatchAndExplain(frame->rst_stream.error_code, listener)) {
matched = false;
}
return matched;
}
void DescribeTo(std::ostream* os) const override {
*os << "contains a RST_STREAM frame, ";
stream_id_.DescribeTo(os);
error_code_.DescribeTo(os);
}
void DescribeNegationTo(std::ostream* os) const override {
*os << "does not contain a RST_STREAM frame, ";
stream_id_.DescribeNegationTo(os);
error_code_.DescribeNegationTo(os);
}
private:
const testing::Matcher<uint32_t> stream_id_;
const testing::Matcher<uint32_t> error_code_;
};
class SettingsMatcher : public testing::MatcherInterface<const nghttp2_frame*> {
public:
SettingsMatcher(const testing::Matcher<std::vector<Http2Setting>> values)
: values_(values) {}
bool MatchAndExplain(const nghttp2_frame* frame,
testing::MatchResultListener* listener) const override {
if (frame->hd.type != NGHTTP2_SETTINGS) {
*listener << "; expected SETTINGS frame, saw frame of type "
<< static_cast<int>(frame->hd.type);
return false;
}
std::vector<Http2Setting> settings;
settings.reserve(frame->settings.niv);
for (size_t i = 0; i < frame->settings.niv; ++i) {
const auto& p = frame->settings.iv[i];
settings.push_back({static_cast<uint16_t>(p.settings_id), p.value});
}
return values_.MatchAndExplain(settings, listener);
}
void DescribeTo(std::ostream* os) const override {
*os << "contains a SETTINGS frame, ";
values_.DescribeTo(os);
}
void DescribeNegationTo(std::ostream* os) const override {
*os << "does not contain a SETTINGS frame, ";
values_.DescribeNegationTo(os);
}
private:
const testing::Matcher<std::vector<Http2Setting>> values_;
};
class PingMatcher : public testing::MatcherInterface<const nghttp2_frame*> {
public:
PingMatcher(const testing::Matcher<uint64_t> id, bool is_ack)
: id_(id), is_ack_(is_ack) {}
bool MatchAndExplain(const nghttp2_frame* frame,
testing::MatchResultListener* listener) const override {
if (frame->hd.type != NGHTTP2_PING) {
*listener << "; expected PING frame, saw frame of type "
<< static_cast<int>(frame->hd.type);
return false;
}
bool matched = true;
bool frame_ack = frame->hd.flags & NGHTTP2_FLAG_ACK;
if (is_ack_ != frame_ack) {
*listener << "; expected is_ack=" << is_ack_ << ", saw " << frame_ack;
matched = false;
}
uint64_t data;
std::memcpy(&data, frame->ping.opaque_data, sizeof(data));
data = quiche::QuicheEndian::HostToNet64(data);
if (!id_.MatchAndExplain(data, listener)) {
matched = false;
}
return matched;
}
void DescribeTo(std::ostream* os) const override {
*os << "contains a PING frame, ";
id_.DescribeTo(os);
}
void DescribeNegationTo(std::ostream* os) const override {
*os << "does not contain a PING frame, ";
id_.DescribeNegationTo(os);
}
private:
const testing::Matcher<uint64_t> id_;
const bool is_ack_;
};
class GoAwayMatcher : public testing::MatcherInterface<const nghttp2_frame*> {
public:
GoAwayMatcher(const testing::Matcher<uint32_t> last_stream_id,
const testing::Matcher<uint32_t> error_code,
const testing::Matcher<absl::string_view> opaque_data)
: last_stream_id_(last_stream_id),
error_code_(error_code),
opaque_data_(opaque_data) {}
bool MatchAndExplain(const nghttp2_frame* frame,
testing::MatchResultListener* listener) const override {
if (frame->hd.type != NGHTTP2_GOAWAY) {
*listener << "; expected GOAWAY frame, saw frame of type "
<< static_cast<int>(frame->hd.type);
return false;
}
bool matched = true;
if (!last_stream_id_.MatchAndExplain(frame->goaway.last_stream_id,
listener)) {
matched = false;
}
if (!error_code_.MatchAndExplain(frame->goaway.error_code, listener)) {
matched = false;
}
auto opaque_data =
ToStringView(frame->goaway.opaque_data, frame->goaway.opaque_data_len);
if (!opaque_data_.MatchAndExplain(opaque_data, listener)) {
matched = false;
}
return matched;
}
void DescribeTo(std::ostream* os) const override {
*os << "contains a GOAWAY frame, ";
last_stream_id_.DescribeTo(os);
error_code_.DescribeTo(os);
opaque_data_.DescribeTo(os);
}
void DescribeNegationTo(std::ostream* os) const override {
*os << "does not contain a GOAWAY frame, ";
last_stream_id_.DescribeNegationTo(os);
error_code_.DescribeNegationTo(os);
opaque_data_.DescribeNegationTo(os);
}
private:
const testing::Matcher<uint32_t> last_stream_id_;
const testing::Matcher<uint32_t> error_code_;
const testing::Matcher<absl::string_view> opaque_data_;
};
class WindowUpdateMatcher
: public testing::MatcherInterface<const nghttp2_frame*> {
public:
WindowUpdateMatcher(const testing::Matcher<uint32_t> delta) : delta_(delta) {}
bool MatchAndExplain(const nghttp2_frame* frame,
testing::MatchResultListener* listener) const override {
if (frame->hd.type != NGHTTP2_WINDOW_UPDATE) {
*listener << "; expected WINDOW_UPDATE frame, saw frame of type "
<< static_cast<int>(frame->hd.type);
return false;
}
return delta_.MatchAndExplain(frame->window_update.window_size_increment,
listener);
}
void DescribeTo(std::ostream* os) const override {
*os << "contains a WINDOW_UPDATE frame, ";
delta_.DescribeTo(os);
}
void DescribeNegationTo(std::ostream* os) const override {
*os << "does not contain a WINDOW_UPDATE frame, ";
delta_.DescribeNegationTo(os);
}
private:
const testing::Matcher<uint32_t> delta_;
};
} // namespace
testing::Matcher<const nghttp2_frame_hd*> HasFrameHeader(
uint32_t streamid, uint8_t type, const testing::Matcher<int> flags) {
return MakeMatcher(new PointerToFrameHeaderMatcher(streamid, type, flags));
}
testing::Matcher<const nghttp2_frame_hd&> HasFrameHeaderRef(
uint32_t streamid, uint8_t type, const testing::Matcher<int> flags) {
return MakeMatcher(new ReferenceToFrameHeaderMatcher(streamid, type, flags));
}
testing::Matcher<const nghttp2_frame*> IsData(
const testing::Matcher<uint32_t> stream_id,
const testing::Matcher<size_t> length, const testing::Matcher<int> flags,
const testing::Matcher<size_t> padding) {
return MakeMatcher(new DataMatcher(stream_id, length, flags, padding));
}
testing::Matcher<const nghttp2_frame*> IsHeaders(
const testing::Matcher<uint32_t> stream_id,
const testing::Matcher<int> flags, const testing::Matcher<int> category) {
return MakeMatcher(new HeadersMatcher(stream_id, flags, category));
}
testing::Matcher<const nghttp2_frame*> IsRstStream(
const testing::Matcher<uint32_t> stream_id,
const testing::Matcher<uint32_t> error_code) {
return MakeMatcher(new RstStreamMatcher(stream_id, error_code));
}
testing::Matcher<const nghttp2_frame*> IsSettings(
const testing::Matcher<std::vector<Http2Setting>> values) {
return MakeMatcher(new SettingsMatcher(values));
}
testing::Matcher<const nghttp2_frame*> IsPing(
const testing::Matcher<uint64_t> id) {
return MakeMatcher(new PingMatcher(id, false));
}
testing::Matcher<const nghttp2_frame*> IsPingAck(
const testing::Matcher<uint64_t> id) {
return MakeMatcher(new PingMatcher(id, true));
}
testing::Matcher<const nghttp2_frame*> IsGoAway(
const testing::Matcher<uint32_t> last_stream_id,
const testing::Matcher<uint32_t> error_code,
const testing::Matcher<absl::string_view> opaque_data) {
return MakeMatcher(
new GoAwayMatcher(last_stream_id, error_code, opaque_data));
}
testing::Matcher<const nghttp2_frame*> IsWindowUpdate(
const testing::Matcher<uint32_t> delta) {
return MakeMatcher(new WindowUpdateMatcher(delta));
}
} // namespace test
} // namespace adapter
} // namespace http2