Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(370)

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: net/http2/http2_constants_test.cc

Issue 2293613002: Add new HTTP/2 and HPACK decoder in net/http2/. (Closed)
Patch Set: Replace LOG(INFO) by VLOG(2) in DecodeBufferTest.SlowDecodeTestStruct so that trybots do not fail. Created 4 years ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« no previous file with comments | « net/http2/http2_constants.cc ('k') | net/http2/http2_constants_test_util.h » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: net/http2/http2_constants_test.cc
diff --git a/net/http2/http2_constants_test.cc b/net/http2/http2_constants_test.cc
new file mode 100644
index 0000000000000000000000000000000000000000..f7f24f79a8dd1d0c6686b71bf2df4fa196b065f0
--- /dev/null
+++ b/net/http2/http2_constants_test.cc
@@ -0,0 +1,272 @@
+// 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.
+
+#include "net/http2/http2_constants.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace net {
+namespace test {
+namespace {
+
+class Http2ConstantsTest : public testing::Test {};
+
+TEST(Http2ConstantsTest, Http2FrameType) {
+ EXPECT_EQ(Http2FrameType::DATA, static_cast<Http2FrameType>(0));
+ EXPECT_EQ(Http2FrameType::HEADERS, static_cast<Http2FrameType>(1));
+ EXPECT_EQ(Http2FrameType::PRIORITY, static_cast<Http2FrameType>(2));
+ EXPECT_EQ(Http2FrameType::RST_STREAM, static_cast<Http2FrameType>(3));
+ EXPECT_EQ(Http2FrameType::SETTINGS, static_cast<Http2FrameType>(4));
+ EXPECT_EQ(Http2FrameType::PUSH_PROMISE, static_cast<Http2FrameType>(5));
+ EXPECT_EQ(Http2FrameType::PING, static_cast<Http2FrameType>(6));
+ EXPECT_EQ(Http2FrameType::GOAWAY, static_cast<Http2FrameType>(7));
+ EXPECT_EQ(Http2FrameType::WINDOW_UPDATE, static_cast<Http2FrameType>(8));
+ EXPECT_EQ(Http2FrameType::CONTINUATION, static_cast<Http2FrameType>(9));
+ EXPECT_EQ(Http2FrameType::ALTSVC, static_cast<Http2FrameType>(10));
+}
+
+TEST(Http2ConstantsTest, Http2FrameTypeToString) {
+ EXPECT_EQ("DATA", Http2FrameTypeToString(Http2FrameType::DATA));
+ EXPECT_EQ("HEADERS", Http2FrameTypeToString(Http2FrameType::HEADERS));
+ EXPECT_EQ("PRIORITY", Http2FrameTypeToString(Http2FrameType::PRIORITY));
+ EXPECT_EQ("RST_STREAM", Http2FrameTypeToString(Http2FrameType::RST_STREAM));
+ EXPECT_EQ("SETTINGS", Http2FrameTypeToString(Http2FrameType::SETTINGS));
+ EXPECT_EQ("PUSH_PROMISE",
+ Http2FrameTypeToString(Http2FrameType::PUSH_PROMISE));
+ EXPECT_EQ("PING", Http2FrameTypeToString(Http2FrameType::PING));
+ EXPECT_EQ("GOAWAY", Http2FrameTypeToString(Http2FrameType::GOAWAY));
+ EXPECT_EQ("WINDOW_UPDATE",
+ Http2FrameTypeToString(Http2FrameType::WINDOW_UPDATE));
+ EXPECT_EQ("CONTINUATION",
+ Http2FrameTypeToString(Http2FrameType::CONTINUATION));
+ EXPECT_EQ("ALTSVC", Http2FrameTypeToString(Http2FrameType::ALTSVC));
+
+ EXPECT_EQ("DATA", Http2FrameTypeToString(0));
+ EXPECT_EQ("HEADERS", Http2FrameTypeToString(1));
+ EXPECT_EQ("PRIORITY", Http2FrameTypeToString(2));
+ EXPECT_EQ("RST_STREAM", Http2FrameTypeToString(3));
+ EXPECT_EQ("SETTINGS", Http2FrameTypeToString(4));
+ EXPECT_EQ("PUSH_PROMISE", Http2FrameTypeToString(5));
+ EXPECT_EQ("PING", Http2FrameTypeToString(6));
+ EXPECT_EQ("GOAWAY", Http2FrameTypeToString(7));
+ EXPECT_EQ("WINDOW_UPDATE", Http2FrameTypeToString(8));
+ EXPECT_EQ("CONTINUATION", Http2FrameTypeToString(9));
+ EXPECT_EQ("ALTSVC", Http2FrameTypeToString(10));
+
+ EXPECT_EQ("UnknownFrameType(99)", Http2FrameTypeToString(99));
+}
+
+TEST(Http2ConstantsTest, Http2FrameFlag) {
+ EXPECT_EQ(Http2FrameFlag::FLAG_END_STREAM, static_cast<Http2FrameFlag>(0x01));
+ EXPECT_EQ(Http2FrameFlag::FLAG_ACK, static_cast<Http2FrameFlag>(0x01));
+ EXPECT_EQ(Http2FrameFlag::FLAG_END_HEADERS,
+ static_cast<Http2FrameFlag>(0x04));
+ EXPECT_EQ(Http2FrameFlag::FLAG_PADDED, static_cast<Http2FrameFlag>(0x08));
+ EXPECT_EQ(Http2FrameFlag::FLAG_PRIORITY, static_cast<Http2FrameFlag>(0x20));
+
+ EXPECT_EQ(Http2FrameFlag::FLAG_END_STREAM, 0x01);
+ EXPECT_EQ(Http2FrameFlag::FLAG_ACK, 0x01);
+ EXPECT_EQ(Http2FrameFlag::FLAG_END_HEADERS, 0x04);
+ EXPECT_EQ(Http2FrameFlag::FLAG_PADDED, 0x08);
+ EXPECT_EQ(Http2FrameFlag::FLAG_PRIORITY, 0x20);
+}
+
+TEST(Http2ConstantsTest, Http2FrameFlagsToString) {
+ // Single flags...
+
+ // 0b00000001
+ EXPECT_EQ("END_STREAM",
+ Http2FrameFlagsToString(Http2FrameType::DATA,
+ Http2FrameFlag::FLAG_END_STREAM));
+ EXPECT_EQ("END_STREAM",
+ Http2FrameFlagsToString(Http2FrameType::HEADERS, 0x01));
+ EXPECT_EQ("ACK", Http2FrameFlagsToString(Http2FrameType::SETTINGS,
+ Http2FrameFlag::FLAG_ACK));
+ EXPECT_EQ("ACK", Http2FrameFlagsToString(Http2FrameType::PING, 0x01));
+
+ // 0b00000010
+ EXPECT_EQ("0x02", Http2FrameFlagsToString(0xff, 0x02));
+
+ // 0b00000100
+ EXPECT_EQ("END_HEADERS",
+ Http2FrameFlagsToString(Http2FrameType::HEADERS,
+ Http2FrameFlag::FLAG_END_HEADERS));
+ EXPECT_EQ("END_HEADERS",
+ Http2FrameFlagsToString(Http2FrameType::PUSH_PROMISE, 0x04));
+ EXPECT_EQ("END_HEADERS", Http2FrameFlagsToString(0x09, 0x04));
+ EXPECT_EQ("0x04", Http2FrameFlagsToString(0xff, 0x04));
+
+ // 0b00001000
+ EXPECT_EQ("PADDED", Http2FrameFlagsToString(Http2FrameType::DATA,
+ Http2FrameFlag::FLAG_PADDED));
+ EXPECT_EQ("PADDED", Http2FrameFlagsToString(Http2FrameType::HEADERS, 0x08));
+ EXPECT_EQ("PADDED", Http2FrameFlagsToString(0x05, 0x08));
+ EXPECT_EQ("0x08", Http2FrameFlagsToString(0xff, Http2FrameFlag::FLAG_PADDED));
+
+ // 0b00010000
+ EXPECT_EQ("0x10", Http2FrameFlagsToString(Http2FrameType::SETTINGS, 0x10));
+
+ // 0b00100000
+ EXPECT_EQ("PRIORITY", Http2FrameFlagsToString(Http2FrameType::HEADERS, 0x20));
+ EXPECT_EQ("0x20",
+ Http2FrameFlagsToString(Http2FrameType::PUSH_PROMISE, 0x20));
+
+ // 0b01000000
+ EXPECT_EQ("0x40", Http2FrameFlagsToString(0xff, 0x40));
+
+ // 0b10000000
+ EXPECT_EQ("0x80", Http2FrameFlagsToString(0xff, 0x80));
+
+ // Combined flags...
+
+ EXPECT_EQ("END_STREAM|PADDED|0xf6",
+ Http2FrameFlagsToString(Http2FrameType::DATA, 0xff));
+ EXPECT_EQ("END_STREAM|END_HEADERS|PADDED|PRIORITY|0xd2",
+ Http2FrameFlagsToString(Http2FrameType::HEADERS, 0xff));
+ EXPECT_EQ("0xff", Http2FrameFlagsToString(Http2FrameType::PRIORITY, 0xff));
+ EXPECT_EQ("0xff", Http2FrameFlagsToString(Http2FrameType::RST_STREAM, 0xff));
+ EXPECT_EQ("ACK|0xfe",
+ Http2FrameFlagsToString(Http2FrameType::SETTINGS, 0xff));
+ EXPECT_EQ("END_HEADERS|PADDED|0xf3",
+ Http2FrameFlagsToString(Http2FrameType::PUSH_PROMISE, 0xff));
+ EXPECT_EQ("ACK|0xfe", Http2FrameFlagsToString(Http2FrameType::PING, 0xff));
+ EXPECT_EQ("0xff", Http2FrameFlagsToString(Http2FrameType::GOAWAY, 0xff));
+ EXPECT_EQ("0xff",
+ Http2FrameFlagsToString(Http2FrameType::WINDOW_UPDATE, 0xff));
+ EXPECT_EQ("END_HEADERS|0xfb",
+ Http2FrameFlagsToString(Http2FrameType::CONTINUATION, 0xff));
+ EXPECT_EQ("0xff", Http2FrameFlagsToString(Http2FrameType::ALTSVC, 0xff));
+ EXPECT_EQ("0xff", Http2FrameFlagsToString(0xff, 0xff));
+}
+
+TEST(Http2ConstantsTest, Http2ErrorCode) {
+ EXPECT_EQ(Http2ErrorCode::HTTP2_NO_ERROR, static_cast<Http2ErrorCode>(0x0));
+ EXPECT_EQ(Http2ErrorCode::PROTOCOL_ERROR, static_cast<Http2ErrorCode>(0x1));
+ EXPECT_EQ(Http2ErrorCode::INTERNAL_ERROR, static_cast<Http2ErrorCode>(0x2));
+ EXPECT_EQ(Http2ErrorCode::FLOW_CONTROL_ERROR,
+ static_cast<Http2ErrorCode>(0x3));
+ EXPECT_EQ(Http2ErrorCode::SETTINGS_TIMEOUT, static_cast<Http2ErrorCode>(0x4));
+ EXPECT_EQ(Http2ErrorCode::STREAM_CLOSED, static_cast<Http2ErrorCode>(0x5));
+ EXPECT_EQ(Http2ErrorCode::FRAME_SIZE_ERROR, static_cast<Http2ErrorCode>(0x6));
+ EXPECT_EQ(Http2ErrorCode::REFUSED_STREAM, static_cast<Http2ErrorCode>(0x7));
+ EXPECT_EQ(Http2ErrorCode::CANCEL, static_cast<Http2ErrorCode>(0x8));
+ EXPECT_EQ(Http2ErrorCode::COMPRESSION_ERROR,
+ static_cast<Http2ErrorCode>(0x9));
+ EXPECT_EQ(Http2ErrorCode::CONNECT_ERROR, static_cast<Http2ErrorCode>(0xa));
+ EXPECT_EQ(Http2ErrorCode::ENHANCE_YOUR_CALM,
+ static_cast<Http2ErrorCode>(0xb));
+ EXPECT_EQ(Http2ErrorCode::INADEQUATE_SECURITY,
+ static_cast<Http2ErrorCode>(0xc));
+ EXPECT_EQ(Http2ErrorCode::HTTP_1_1_REQUIRED,
+ static_cast<Http2ErrorCode>(0xd));
+}
+
+TEST(Http2ConstantsTest, Http2ErrorCodeToString) {
+ EXPECT_EQ("NO_ERROR", Http2ErrorCodeToString(Http2ErrorCode::HTTP2_NO_ERROR));
+ EXPECT_EQ("NO_ERROR", Http2ErrorCodeToString(0x0));
+ EXPECT_EQ("PROTOCOL_ERROR",
+ Http2ErrorCodeToString(Http2ErrorCode::PROTOCOL_ERROR));
+ EXPECT_EQ("PROTOCOL_ERROR", Http2ErrorCodeToString(0x1));
+ EXPECT_EQ("INTERNAL_ERROR",
+ Http2ErrorCodeToString(Http2ErrorCode::INTERNAL_ERROR));
+ EXPECT_EQ("INTERNAL_ERROR", Http2ErrorCodeToString(0x2));
+ EXPECT_EQ("FLOW_CONTROL_ERROR",
+ Http2ErrorCodeToString(Http2ErrorCode::FLOW_CONTROL_ERROR));
+ EXPECT_EQ("FLOW_CONTROL_ERROR", Http2ErrorCodeToString(0x3));
+ EXPECT_EQ("SETTINGS_TIMEOUT",
+ Http2ErrorCodeToString(Http2ErrorCode::SETTINGS_TIMEOUT));
+ EXPECT_EQ("SETTINGS_TIMEOUT", Http2ErrorCodeToString(0x4));
+ EXPECT_EQ("STREAM_CLOSED",
+ Http2ErrorCodeToString(Http2ErrorCode::STREAM_CLOSED));
+ EXPECT_EQ("STREAM_CLOSED", Http2ErrorCodeToString(0x5));
+ EXPECT_EQ("FRAME_SIZE_ERROR",
+ Http2ErrorCodeToString(Http2ErrorCode::FRAME_SIZE_ERROR));
+ EXPECT_EQ("FRAME_SIZE_ERROR", Http2ErrorCodeToString(0x6));
+ EXPECT_EQ("REFUSED_STREAM",
+ Http2ErrorCodeToString(Http2ErrorCode::REFUSED_STREAM));
+ EXPECT_EQ("REFUSED_STREAM", Http2ErrorCodeToString(0x7));
+ EXPECT_EQ("CANCEL", Http2ErrorCodeToString(Http2ErrorCode::CANCEL));
+ EXPECT_EQ("CANCEL", Http2ErrorCodeToString(0x8));
+ EXPECT_EQ("COMPRESSION_ERROR",
+ Http2ErrorCodeToString(Http2ErrorCode::COMPRESSION_ERROR));
+ EXPECT_EQ("COMPRESSION_ERROR", Http2ErrorCodeToString(0x9));
+ EXPECT_EQ("CONNECT_ERROR",
+ Http2ErrorCodeToString(Http2ErrorCode::CONNECT_ERROR));
+ EXPECT_EQ("CONNECT_ERROR", Http2ErrorCodeToString(0xa));
+ EXPECT_EQ("ENHANCE_YOUR_CALM",
+ Http2ErrorCodeToString(Http2ErrorCode::ENHANCE_YOUR_CALM));
+ EXPECT_EQ("ENHANCE_YOUR_CALM", Http2ErrorCodeToString(0xb));
+ EXPECT_EQ("INADEQUATE_SECURITY",
+ Http2ErrorCodeToString(Http2ErrorCode::INADEQUATE_SECURITY));
+ EXPECT_EQ("INADEQUATE_SECURITY", Http2ErrorCodeToString(0xc));
+ EXPECT_EQ("HTTP_1_1_REQUIRED",
+ Http2ErrorCodeToString(Http2ErrorCode::HTTP_1_1_REQUIRED));
+ EXPECT_EQ("HTTP_1_1_REQUIRED", Http2ErrorCodeToString(0xd));
+
+ EXPECT_EQ("UnknownErrorCode(0x123)", Http2ErrorCodeToString(0x123));
+}
+
+TEST(Http2ConstantsTest, Http2SettingsParameter) {
+ EXPECT_EQ(Http2SettingsParameter::HEADER_TABLE_SIZE,
+ static_cast<Http2SettingsParameter>(0x1));
+ EXPECT_EQ(Http2SettingsParameter::ENABLE_PUSH,
+ static_cast<Http2SettingsParameter>(0x2));
+ EXPECT_EQ(Http2SettingsParameter::MAX_CONCURRENT_STREAMS,
+ static_cast<Http2SettingsParameter>(0x3));
+ EXPECT_EQ(Http2SettingsParameter::INITIAL_WINDOW_SIZE,
+ static_cast<Http2SettingsParameter>(0x4));
+ EXPECT_EQ(Http2SettingsParameter::MAX_FRAME_SIZE,
+ static_cast<Http2SettingsParameter>(0x5));
+ EXPECT_EQ(Http2SettingsParameter::MAX_HEADER_LIST_SIZE,
+ static_cast<Http2SettingsParameter>(0x6));
+
+ EXPECT_TRUE(IsSupportedHttp2SettingsParameter(
+ Http2SettingsParameter::HEADER_TABLE_SIZE));
+ EXPECT_TRUE(
+ IsSupportedHttp2SettingsParameter(Http2SettingsParameter::ENABLE_PUSH));
+ EXPECT_TRUE(IsSupportedHttp2SettingsParameter(
+ Http2SettingsParameter::MAX_CONCURRENT_STREAMS));
+ EXPECT_TRUE(IsSupportedHttp2SettingsParameter(
+ Http2SettingsParameter::INITIAL_WINDOW_SIZE));
+ EXPECT_TRUE(IsSupportedHttp2SettingsParameter(
+ Http2SettingsParameter::MAX_FRAME_SIZE));
+ EXPECT_TRUE(IsSupportedHttp2SettingsParameter(
+ Http2SettingsParameter::MAX_HEADER_LIST_SIZE));
+
+ EXPECT_FALSE(IsSupportedHttp2SettingsParameter(
+ static_cast<Http2SettingsParameter>(0)));
+ EXPECT_FALSE(IsSupportedHttp2SettingsParameter(
+ static_cast<Http2SettingsParameter>(7)));
+}
+
+TEST(Http2ConstantsTest, Http2SettingsParameterToString) {
+ EXPECT_EQ("HEADER_TABLE_SIZE",
+ Http2SettingsParameterToString(
+ Http2SettingsParameter::HEADER_TABLE_SIZE));
+ EXPECT_EQ("HEADER_TABLE_SIZE", Http2SettingsParameterToString(0x1));
+ EXPECT_EQ("ENABLE_PUSH", Http2SettingsParameterToString(
+ Http2SettingsParameter::ENABLE_PUSH));
+ EXPECT_EQ("ENABLE_PUSH", Http2SettingsParameterToString(0x2));
+ EXPECT_EQ("MAX_CONCURRENT_STREAMS",
+ Http2SettingsParameterToString(
+ Http2SettingsParameter::MAX_CONCURRENT_STREAMS));
+ EXPECT_EQ("MAX_CONCURRENT_STREAMS", Http2SettingsParameterToString(0x3));
+ EXPECT_EQ("INITIAL_WINDOW_SIZE",
+ Http2SettingsParameterToString(
+ Http2SettingsParameter::INITIAL_WINDOW_SIZE));
+ EXPECT_EQ("INITIAL_WINDOW_SIZE", Http2SettingsParameterToString(0x4));
+ EXPECT_EQ("MAX_FRAME_SIZE", Http2SettingsParameterToString(
+ Http2SettingsParameter::MAX_FRAME_SIZE));
+ EXPECT_EQ("MAX_FRAME_SIZE", Http2SettingsParameterToString(0x5));
+ EXPECT_EQ("MAX_HEADER_LIST_SIZE",
+ Http2SettingsParameterToString(
+ Http2SettingsParameter::MAX_HEADER_LIST_SIZE));
+ EXPECT_EQ("MAX_HEADER_LIST_SIZE", Http2SettingsParameterToString(0x6));
+
+ EXPECT_EQ("UnknownSettingsParameter(0x123)",
+ Http2SettingsParameterToString(0x123));
+}
+
+} // namespace
+} // namespace test
+} // namespace net
« no previous file with comments | « net/http2/http2_constants.cc ('k') | net/http2/http2_constants_test_util.h » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698