%% Copyright (c) Loïc Hoguin <essen@ninenines.eu>
%%
%% Permission to use, copy, modify, and/or distribute this software for any
%% purpose with or without fee is hereby granted, provided that the above
%% copyright notice and this permission notice appear in all copies.
%%
%% THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
%% WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
%% MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
%% ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
%% WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
%% ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
%% OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

-module(http2_SUITE).
-compile(export_all).
-compile(nowarn_export_all).

-import(ct_helper, [config/2]).
-import(ct_helper, [doc/1]).
-import(ct_helper, [get_remote_pid_tcp/1]).
-import(cowboy_test, [gun_open/1]).

all() -> [{group, clear}].

groups() -> [{clear, [parallel], ct_helper:all(?MODULE)}].

init_dispatch(_) ->
	cowboy_router:compile([{"localhost", [
		{"/", hello_h, []},
		{"/echo/:key", echo_h, []},
		{"/resp_iolist_body", resp_iolist_body_h, []},
		{"/streamed_result/:n/:interval", streamed_result_h, []},
		{"/inform", resp_invalid_headers_h, []},
		{"/reply", resp_invalid_headers_h, []},
		{"/stream_reply", resp_invalid_headers_h, []},
		{"/stream_trailers", resp_invalid_headers_h, []},
		{"/switch_protocol", resp_invalid_headers_h, []},
		{"/push", resp_invalid_headers_h, []}
	]}]).

%% Do a prior knowledge handshake (function originally copied from rfc7540_SUITE).
do_handshake(Config) ->
	do_handshake(#{}, Config).

do_handshake(Settings, Config) ->
	{ok, Socket} = gen_tcp:connect("localhost", config(port, Config),
		[binary, {active, false}|proplists:get_value(tcp_opts, Config, [])]),
	%% Send a valid preface.
	ok = gen_tcp:send(Socket, ["PRI * HTTP/2.0\r\n\r\nSM\r\n\r\n", cow_http2:settings(Settings)]),
	%% Receive the server preface.
	{ok, << Len:24 >>} = gen_tcp:recv(Socket, 3, 1000),
	{ok, << 4:8, 0:40, _:Len/binary >>} = gen_tcp:recv(Socket, 6 + Len, 1000),
	%% Send the SETTINGS ack.
	ok = gen_tcp:send(Socket, cow_http2:settings_ack()),
	%% Receive the SETTINGS ack.
	{ok, << 0:24, 4:8, 1:8, 0:32 >>} = gen_tcp:recv(Socket, 9, 1000),
	{ok, Socket}.

hibernate(Config) ->
	doc("Ensure that we can enable hibernation for HTTP/1.1 connections."),
	{ok, _} = cowboy:start_clear(?FUNCTION_NAME, [{port, 0}], #{
		env => #{dispatch => init_dispatch(Config)},
		hibernate => true
	}),
	Port = ranch:get_port(?FUNCTION_NAME),
	try
		ConnPid = gun_open([{type, tcp}, {protocol, http2}, {port, Port}|Config]),
		{ok, http2} = gun:await_up(ConnPid),
		StreamRef1 = gun:get(ConnPid, "/"),
		StreamRef2 = gun:get(ConnPid, "/"),
		StreamRef3 = gun:get(ConnPid, "/"),
		{response, nofin, 200, _} = gun:await(ConnPid, StreamRef1),
		{response, nofin, 200, _} = gun:await(ConnPid, StreamRef2),
		{response, nofin, 200, _} = gun:await(ConnPid, StreamRef3),
		gun:close(ConnPid)
	after
		cowboy:stop_listener(?FUNCTION_NAME)
	end.

idle_timeout(Config) ->
	doc("Terminate when the idle timeout is reached."),
	ProtoOpts = #{
		env => #{dispatch => init_dispatch(Config)},
		idle_timeout => 1000
	},
	{ok, _} = cowboy:start_clear(?FUNCTION_NAME, [{port, 0}], ProtoOpts),
	Port = ranch:get_port(?FUNCTION_NAME),
	try
		{ok, Socket} = do_handshake([{port, Port}|Config]),
		timer:sleep(1000),
		%% Receive a GOAWAY frame back with NO_ERROR.
		{ok, << _:24, 7:8, _:72, 0:32 >>} = gen_tcp:recv(Socket, 17, 1000),
		gen_tcp:close(Socket)
	after
		cowboy:stop_listener(?FUNCTION_NAME)
	end.

idle_timeout_infinity(Config) ->
	doc("Ensure the idle_timeout option accepts the infinity value."),
	ProtoOpts = #{
		env => #{dispatch => init_dispatch(Config)},
		idle_timeout => infinity
	},
	{ok, _} = cowboy:start_clear(?FUNCTION_NAME, [{port, 0}], ProtoOpts),
	Port = ranch:get_port(?FUNCTION_NAME),
	try
		{ok, Socket} = do_handshake([{port, Port}|Config]),
		timer:sleep(1000),
		%% Don't receive a GOAWAY frame.
		{error, timeout} = gen_tcp:recv(Socket, 17, 1000),
		gen_tcp:close(Socket)
	after
		cowboy:stop_listener(?FUNCTION_NAME)
	end.

idle_timeout_reset_on_data(Config) ->
	doc("Terminate when the idle timeout is reached."),
	ProtoOpts = #{
		env => #{dispatch => init_dispatch(Config)},
		idle_timeout => 1000
	},
	{ok, _} = cowboy:start_clear(?FUNCTION_NAME, [{port, 0}], ProtoOpts),
	Port = ranch:get_port(?FUNCTION_NAME),
	try
		{ok, Socket} = do_handshake([{port, Port}|Config]),
		%% We wait a little, send a PING, receive a PING ack.
		{error, timeout} = gen_tcp:recv(Socket, 17, 500),
		ok = gen_tcp:send(Socket, cow_http2:ping(0)),
		{ok, <<8:24, 6:8, 0:7, 1:1, 0:96>>} = gen_tcp:recv(Socket, 17, 1000),
		%% Again.
		{error, timeout} = gen_tcp:recv(Socket, 17, 500),
		ok = gen_tcp:send(Socket, cow_http2:ping(0)),
		{ok, <<8:24, 6:8, 0:7, 1:1, 0:96>>} = gen_tcp:recv(Socket, 17, 1000),
		%% And one more time.
		{error, timeout} = gen_tcp:recv(Socket, 17, 500),
		ok = gen_tcp:send(Socket, cow_http2:ping(0)),
		{ok, <<8:24, 6:8, 0:7, 1:1, 0:96>>} = gen_tcp:recv(Socket, 17, 1000),
		%% The connection goes away soon after we stop sending data.
		timer:sleep(1000),
		{ok, << _:24, 7:8, _:72, 0:32 >>} = gen_tcp:recv(Socket, 17, 1000),
		gen_tcp:close(Socket)
	after
		cowboy:stop_listener(?FUNCTION_NAME)
	end.

idle_timeout_on_send(Config) ->
	doc("Ensure the idle timeout is not reset when sending (by default)."),
	http_SUITE:do_idle_timeout_on_send(Config, http2).

idle_timeout_reset_on_send(Config) ->
	doc("Ensure the reset_idle_timeout_on_send results in the "
		"idle timeout resetting when sending ."),
	http_SUITE:do_idle_timeout_reset_on_send(Config, http2).

inactivity_timeout(Config) ->
	doc("Terminate when the inactivity timeout is reached."),
	ProtoOpts = #{
		env => #{dispatch => init_dispatch(Config)},
		inactivity_timeout => 1000
	},
	{ok, _} = cowboy:start_clear(?FUNCTION_NAME, [{port, 0}], ProtoOpts),
	Port = ranch:get_port(?FUNCTION_NAME),
	try
		{ok, Socket} = do_handshake([{port, Port}|Config]),
		receive after 1000 -> ok end,
		%% Receive a GOAWAY frame back with an INTERNAL_ERROR.
		{ok, << _:24, 7:8, _:72, 2:32 >>} = gen_tcp:recv(Socket, 17, 1000),
		gen_tcp:close(Socket)
	after
		cowboy:stop_listener(?FUNCTION_NAME)
	end.

initial_connection_window_size(Config) ->
	doc("Confirm a WINDOW_UPDATE frame is sent when the configured "
		"connection window is larger than the default."),
	ConfiguredSize = 100000,
	ProtoOpts = #{
		env => #{dispatch => init_dispatch(Config)},
		initial_connection_window_size => ConfiguredSize
	},
	{ok, _} = cowboy:start_clear(?FUNCTION_NAME, [{port, 0}], ProtoOpts),
	Port = ranch:get_port(?FUNCTION_NAME),
	try
		{ok, Socket} = gen_tcp:connect("localhost", Port, [binary, {active, false}]),
		%% Send a valid preface.
		ok = gen_tcp:send(Socket, ["PRI * HTTP/2.0\r\n\r\nSM\r\n\r\n", cow_http2:settings(#{})]),
		%% Receive the server preface.
		{ok, << Len:24 >>} = gen_tcp:recv(Socket, 3, 1000),
		{ok, << 4:8, 0:40, _:Len/binary >>} = gen_tcp:recv(Socket, 6 + Len, 1000),
		%% Receive a WINDOW_UPDATE frame incrementing the connection window to 100000.
		{ok, <<4:24, 8:8, 0:41, Size:31>>} = gen_tcp:recv(Socket, 13, 1000),
		ConfiguredSize = Size + 65535,
		gen_tcp:close(Socket)
	after
		cowboy:stop_listener(?FUNCTION_NAME)
	end.

invalid_response_headers_inform(Config) ->
	doc("Ensure invalid response headers are rejected by default."),
	{ok, _} = cowboy:start_clear(?FUNCTION_NAME, [{port, 0}], #{
		env => #{dispatch => init_dispatch(Config)}
	}),
	Port = ranch:get_port(?FUNCTION_NAME),
	try
		ConnPid = gun_open([{type, tcp}, {protocol, http2}, {port, Port}|Config]),
		{ok, http2} = gun:await_up(ConnPid),
		StreamRef = gun:get(ConnPid, "/inform"),
		{error,{stream_error,{stream_error,internal_error,_}}}
			= gun:await(ConnPid, StreamRef),
		gun:close(ConnPid)
	after
		cowboy:stop_listener(?FUNCTION_NAME)
	end.

invalid_response_headers_inform_ignore(Config) ->
	doc("Ensure invalid response headers are sent "
		"when allowed by configuration."),
	{ok, _} = cowboy:start_clear(?FUNCTION_NAME, [{port, 0}], #{
		env => #{dispatch => init_dispatch(Config)},
		invalid_response_headers => ignore
	}),
	Port = ranch:get_port(?FUNCTION_NAME),
	try
		ConnPid = gun_open([{type, tcp}, {protocol, http2}, {port, Port}|Config]),
		{ok, http2} = gun:await_up(ConnPid),
		StreamRef = gun:get(ConnPid, "/inform"),
		%% Gun rejects invalid response headers with a protocol_error stream error.
		{error,{stream_error,{stream_error,protocol_error,_}}}
			= gun:await(ConnPid, StreamRef),
		gun:close(ConnPid)
	after
		cowboy:stop_listener(?FUNCTION_NAME)
	end.

invalid_response_headers_reply(Config) ->
	doc("Ensure invalid response headers are rejected by default."),
	{ok, _} = cowboy:start_clear(?FUNCTION_NAME, [{port, 0}], #{
		env => #{dispatch => init_dispatch(Config)}
	}),
	Port = ranch:get_port(?FUNCTION_NAME),
	try
		ConnPid = gun_open([{type, tcp}, {protocol, http2}, {port, Port}|Config]),
		{ok, http2} = gun:await_up(ConnPid),
		StreamRef = gun:get(ConnPid, "/reply"),
		{error,{stream_error,{stream_error,internal_error,_}}}
			= gun:await(ConnPid, StreamRef),
		gun:close(ConnPid)
	after
		cowboy:stop_listener(?FUNCTION_NAME)
	end.

invalid_response_headers_reply_ignore(Config) ->
	doc("Ensure invalid response headers are sent "
		"when allowed by configuration."),
	{ok, _} = cowboy:start_clear(?FUNCTION_NAME, [{port, 0}], #{
		env => #{dispatch => init_dispatch(Config)},
		invalid_response_headers => ignore
	}),
	Port = ranch:get_port(?FUNCTION_NAME),
	try
		ConnPid = gun_open([{type, tcp}, {protocol, http2}, {port, Port}|Config]),
		{ok, http2} = gun:await_up(ConnPid),
		StreamRef = gun:get(ConnPid, "/reply"),
		%% Gun rejects invalid response headers with a protocol_error stream error.
		{error,{stream_error,{stream_error,protocol_error,_}}}
			= gun:await(ConnPid, StreamRef),
		gun:close(ConnPid)
	after
		cowboy:stop_listener(?FUNCTION_NAME)
	end.

invalid_response_headers_stream_reply(Config) ->
	doc("Ensure invalid response headers are rejected by default."),
	{ok, _} = cowboy:start_clear(?FUNCTION_NAME, [{port, 0}], #{
		env => #{dispatch => init_dispatch(Config)},
		invalid_response_headers => error_terminate
	}),
	Port = ranch:get_port(?FUNCTION_NAME),
	try
		ConnPid = gun_open([{type, tcp}, {protocol, http2}, {port, Port}|Config]),
		{ok, http2} = gun:await_up(ConnPid),
		StreamRef = gun:get(ConnPid, "/stream_reply"),
		{error,{stream_error,{stream_error,internal_error,_}}}
			= gun:await(ConnPid, StreamRef),
		gun:close(ConnPid)
	after
		cowboy:stop_listener(?FUNCTION_NAME)
	end.

invalid_response_headers_stream_reply_ignore(Config) ->
	doc("Ensure invalid response headers are sent "
		"when allowed by configuration."),
	{ok, _} = cowboy:start_clear(?FUNCTION_NAME, [{port, 0}], #{
		env => #{dispatch => init_dispatch(Config)},
		invalid_response_headers => ignore
	}),
	Port = ranch:get_port(?FUNCTION_NAME),
	try
		ConnPid = gun_open([{type, tcp}, {protocol, http2}, {port, Port}|Config]),
		{ok, http2} = gun:await_up(ConnPid),
		StreamRef = gun:get(ConnPid, "/stream_reply"),
		%% Gun rejects invalid response headers with a protocol_error stream error.
		{error,{stream_error,{stream_error,protocol_error,_}}}
			= gun:await(ConnPid, StreamRef),
		gun:close(ConnPid)
	after
		cowboy:stop_listener(?FUNCTION_NAME)
	end.

invalid_response_headers_stream_trailers(Config) ->
	doc("Ensure invalid response headers are rejected by default."),
	{ok, _} = cowboy:start_clear(?FUNCTION_NAME, [{port, 0}], #{
		env => #{dispatch => init_dispatch(Config)},
		invalid_response_headers => error_terminate
	}),
	Port = ranch:get_port(?FUNCTION_NAME),
	try
		ConnPid = gun_open([{type, tcp}, {protocol, http2}, {port, Port}|Config]),
		{ok, http2} = gun:await_up(ConnPid),
		StreamRef = gun:get(ConnPid, "/stream_trailers", #{
			<<"te">> => <<"trailers">>
		}),
		{response, nofin, 200, _} = gun:await(ConnPid, StreamRef),
		{error,{stream_error,{stream_error,internal_error,_}}}
			= gun:await_body(ConnPid, StreamRef),
		gun:close(ConnPid)
	after
		cowboy:stop_listener(?FUNCTION_NAME)
	end.

invalid_response_headers_stream_trailers_ignore(Config) ->
	doc("Ensure invalid response headers are sent "
		"when allowed by configuration."),
	{ok, _} = cowboy:start_clear(?FUNCTION_NAME, [{port, 0}], #{
		env => #{dispatch => init_dispatch(Config)},
		invalid_response_headers => ignore
	}),
	Port = ranch:get_port(?FUNCTION_NAME),
	try
		ConnPid = gun_open([{type, tcp}, {protocol, http2}, {port, Port}|Config]),
		{ok, http2} = gun:await_up(ConnPid),
		StreamRef = gun:get(ConnPid, "/stream_trailers", #{
			<<"te">> => <<"trailers">>
		}),
		{response, nofin, 200, _} = gun:await(ConnPid, StreamRef),
		%% Gun rejects invalid response headers with a protocol_error stream error.
		{error,{stream_error,{stream_error,protocol_error,_}}}
			= gun:await_body(ConnPid, StreamRef),
		gun:close(ConnPid)
	after
		cowboy:stop_listener(?FUNCTION_NAME)
	end.

invalid_response_headers_switch_protocol(Config) ->
	doc("Ensure invalid response headers are rejected by default."),
	{ok, _} = cowboy:start_clear(?FUNCTION_NAME, [{port, 0}], #{
		env => #{dispatch => init_dispatch(Config)}
	}),
	Port = ranch:get_port(?FUNCTION_NAME),
	try
		ConnPid = gun_open([{type, tcp}, {protocol, http2}, {port, Port}|Config]),
		{ok, http2} = gun:await_up(ConnPid),
		StreamRef = gun:get(ConnPid, "/switch_protocol"),
		{error,{stream_error,{stream_error,internal_error,_}}}
			= gun:await(ConnPid, StreamRef),
		gun:close(ConnPid)
	after
		cowboy:stop_listener(?FUNCTION_NAME)
	end.

invalid_response_headers_switch_protocol_ignore(Config) ->
	doc("Ensure invalid response headers are sent "
		"when allowed by configuration."),
	{ok, _} = cowboy:start_clear(?FUNCTION_NAME, [{port, 0}], #{
		env => #{dispatch => init_dispatch(Config)},
		invalid_response_headers => ignore
	}),
	Port = ranch:get_port(?FUNCTION_NAME),
	try
		ConnPid = gun_open([{type, tcp}, {protocol, http2}, {port, Port}|Config]),
		{ok, http2} = gun:await_up(ConnPid),
		StreamRef = gun:get(ConnPid, "/switch_protocol"),
		%% Gun rejects invalid response headers with a protocol_error stream error.
		{error,{stream_error,{stream_error,protocol_error,_}}}
			= gun:await(ConnPid, StreamRef),
		gun:close(ConnPid)
	after
		cowboy:stop_listener(?FUNCTION_NAME)
	end.

invalid_response_headers_push(Config) ->
	doc("Ensure invalid response headers in push are rejected by default."),
	{ok, _} = cowboy:start_clear(?FUNCTION_NAME, [{port, 0}], #{
		env => #{dispatch => init_dispatch(Config)}
	}),
	Port = ranch:get_port(?FUNCTION_NAME),
	try
		ConnPid = gun_open([{type, tcp}, {protocol, http2}, {port, Port}|Config]),
		{ok, http2} = gun:await_up(ConnPid),
		StreamRef = gun:get(ConnPid, "/push"),
		{error,{stream_error,{stream_error,internal_error,_}}}
			= gun:await(ConnPid, StreamRef),
		gun:close(ConnPid)
	after
		cowboy:stop_listener(?FUNCTION_NAME)
	end.

invalid_response_headers_push_ignore(Config) ->
	doc("Ensure invalid response headers in push are sent "
		"when allowed by configuration."),
	{ok, _} = cowboy:start_clear(?FUNCTION_NAME, [{port, 0}], #{
		env => #{dispatch => init_dispatch(Config)},
		invalid_response_headers => ignore
	}),
	Port = ranch:get_port(?FUNCTION_NAME),
	try
		ConnPid = gun_open([{type, tcp}, {protocol, http2}, {port, Port}|Config]),
		{ok, http2} = gun:await_up(ConnPid),
		StreamRef = gun:get(ConnPid, "/push"),
		%% The pushed response doesn't go through because
		%% Gun rejects it as a protocol error.
		{response, _, 200, _} = gun:await(ConnPid, StreamRef),
		gun:close(ConnPid)
	after
		cowboy:stop_listener(?FUNCTION_NAME)
	end.

invalid_response_headers_early_error(Config) ->
	doc("Ensure invalid response headers are rejected by default."),
	{ok, _} = cowboy:start_clear(?FUNCTION_NAME, [{port, 0}], #{
		env => #{dispatch => init_dispatch(Config)},
		stream_handlers => [stream_handler_invalid_headers_h]
	}),
	Port = ranch:get_port(?FUNCTION_NAME),
	try
		ConnPid = gun_open([{type, tcp}, {protocol, http2}, {port, Port}|Config]),
		{ok, http2} = gun:await_up(ConnPid),
		StreamRef = gun:headers(ConnPid, "TRACE", "/", []),
		{error,{stream_error,{stream_error,internal_error,_}}}
			= gun:await(ConnPid, StreamRef),
		gun:close(ConnPid)
	after
		cowboy:stop_listener(?FUNCTION_NAME)
	end.

invalid_response_headers_early_error_ignore(Config) ->
	doc("Ensure invalid response headers are sent "
		"when allowed by configuration."),
	{ok, _} = cowboy:start_clear(?FUNCTION_NAME, [{port, 0}], #{
		env => #{dispatch => init_dispatch(Config)},
		invalid_response_headers => ignore,
		stream_handlers => [stream_handler_invalid_headers_h]
	}),
	Port = ranch:get_port(?FUNCTION_NAME),
	try
		ConnPid = gun_open([{type, tcp}, {protocol, http2}, {port, Port}|Config]),
		{ok, http2} = gun:await_up(ConnPid),
		StreamRef = gun:headers(ConnPid, "TRACE", "/", []),
		%% Gun rejects invalid response headers with a protocol_error stream error.
		{error,{stream_error,{stream_error,protocol_error,_}}}
			= gun:await(ConnPid, StreamRef),
		gun:close(ConnPid)
	after
		cowboy:stop_listener(?FUNCTION_NAME)
	end.

max_authority_length_authority_pseudo_header(Config0) ->
	doc("Confirm the max_authority_length option correctly limits "
		"the length of the authority component in the :authority pseudo-header."),
	ProtoOpts = #{
		env => #{dispatch => init_dispatch(Config0)},
		max_authority_length => 10
	},
	{ok, _} = cowboy:start_clear(?FUNCTION_NAME, [{port, 0}], ProtoOpts),
	Port = ranch:get_port(?FUNCTION_NAME),
	Config = [{port, Port}|Config0],
	try
		%% At limit.
		{ok, Socket1} = do_handshake(Config),
		Headers1 = [
			{<<":method">>, <<"GET">>},
			{<<":scheme">>, <<"http">>},
			{<<":authority">>, <<"example.co">>},
			{<<":path">>, <<"/">>}
		],
		{HeadersBlock1, _} = cow_hpack:encode(Headers1),
		ok = gen_tcp:send(Socket1, cow_http2:headers(1, fin, HeadersBlock1)),
		{ok, <<_:24, 1:8, _:40>>} = gen_tcp:recv(Socket1, 9, 6000),
		gen_tcp:close(Socket1),
		%% Over limit.
		{ok, Socket2} = do_handshake(Config),
		Headers2 = [
			{<<":method">>, <<"GET">>},
			{<<":scheme">>, <<"http">>},
			{<<":authority">>, <<"example.com">>},
			{<<":path">>, <<"/">>}
		],
		{HeadersBlock2, _} = cow_hpack:encode(Headers2),
		ok = gen_tcp:send(Socket2, cow_http2:headers(1, fin, HeadersBlock2)),
		{ok, <<_:24, 3:8, _:8, 1:32, 1:32>>} = gen_tcp:recv(Socket2, 13, 6000),
		gen_tcp:close(Socket2)
	after
		cowboy:stop_listener(?FUNCTION_NAME)
	end.

max_authority_length_host_header(Config0) ->
	doc("Confirm the max_authority_length option correctly limits "
		"the length of the authority component in the host header."),
	ProtoOpts = #{
		env => #{dispatch => init_dispatch(Config0)},
		max_authority_length => 10
	},
	{ok, _} = cowboy:start_clear(?FUNCTION_NAME, [{port, 0}], ProtoOpts),
	Port = ranch:get_port(?FUNCTION_NAME),
	Config = [{port, Port}|Config0],
	try
		%% At limit.
		{ok, Socket1} = do_handshake(Config),
		Headers1 = [
			{<<":method">>, <<"GET">>},
			{<<":scheme">>, <<"http">>},
			{<<":path">>, <<"/">>},
			{<<"host">>, <<"example.co">>}
		],
		{HeadersBlock1, _} = cow_hpack:encode(Headers1),
		ok = gen_tcp:send(Socket1, cow_http2:headers(1, fin, HeadersBlock1)),
		{ok, <<_:24, 1:8, _:40>>} = gen_tcp:recv(Socket1, 9, 6000),
		gen_tcp:close(Socket1),
		%% Over limit.
		{ok, Socket2} = do_handshake(Config),
		Headers2 = [
			{<<":method">>, <<"GET">>},
			{<<":scheme">>, <<"http">>},
			{<<":path">>, <<"/">>},
			{<<"host">>, <<"example.com">>}
		],
		{HeadersBlock2, _} = cow_hpack:encode(Headers2),
		ok = gen_tcp:send(Socket2, cow_http2:headers(1, fin, HeadersBlock2)),
		{ok, <<_:24, 3:8, _:8, 1:32, 1:32>>} = gen_tcp:recv(Socket2, 13, 6000),
		gen_tcp:close(Socket2)
	after
		cowboy:stop_listener(?FUNCTION_NAME)
	end.

max_frame_size_sent(Config) ->
	doc("Confirm that frames sent by Cowboy are limited in size "
		"by the max_frame_size_sent configuration value."),
	MaxFrameSize = 20000,
	ProtoOpts = #{
		env => #{dispatch => init_dispatch(Config)},
		max_frame_size_sent => MaxFrameSize
	},
	{ok, _} = cowboy:start_clear(?FUNCTION_NAME, [{port, 0}], ProtoOpts),
	Port = ranch:get_port(?FUNCTION_NAME),
	try
		{ok, Socket} = do_handshake(#{max_frame_size => MaxFrameSize + 10000},
			[{port, Port}|Config]),
		%% Send a request with a 30000 bytes body.
		{HeadersBlock, _} = cow_hpack:encode([
			{<<":method">>, <<"POST">>},
			{<<":scheme">>, <<"http">>},
			{<<":authority">>, <<"localhost">>}, %% @todo Correct port number.
			{<<":path">>, <<"/echo/read_body">>}
		]),
		ok = gen_tcp:send(Socket, [
			cow_http2:headers(1, nofin, HeadersBlock),
			cow_http2:data(1, nofin, <<0:16384/unit:8>>),
			cow_http2:data(1, fin, <<0:13616/unit:8>>)
		]),
		%% Receive a HEADERS frame as a response.
		{ok, << SkipLen:24, 1:8, _:8, 1:32 >>} = case gen_tcp:recv(Socket, 9, 1000) of
			%% We received a WINDOW_UPDATE first. Skip it and the next.
			{ok, <<4:24, 8:8, 0:40>>} ->
				{ok, _} = gen_tcp:recv(Socket, 4 + 13, 1000),
				gen_tcp:recv(Socket, 9, 1000);
			Res ->
				Res
		end,
		{ok, _} = gen_tcp:recv(Socket, SkipLen, 6000),
		%% The DATA frames following must have lengths of 20000
		%% and then 10000 due to the limit.
		{ok, <<20000:24, 0:8, _:40, _:20000/unit:8>>} = gen_tcp:recv(Socket, 20009, 6000),
		{ok, <<10000:24, 0:8, _:40, _:10000/unit:8>>} = gen_tcp:recv(Socket, 10009, 6000),
		gen_tcp:close(Socket)
	after
		cowboy:stop_listener(?FUNCTION_NAME)
	end.

max_headers(Config0) ->
	doc("Confirm that headers received by Cowboy are limited in number "
		"by the max_headers configuration value."),
	ProtoOpts = #{
		env => #{dispatch => init_dispatch(Config0)},
		max_headers => 10000
	},
	{ok, _} = cowboy:start_clear(?FUNCTION_NAME, [{port, 0}], ProtoOpts),
	Port = ranch:get_port(?FUNCTION_NAME),
	Config = [{port, Port}|Config0],
	try
		%% Sending exactly 10000 headers.
		{ok, Socket1} = do_handshake(Config),
		Headers1 = [
			{<<":method">>, <<"GET">>},
			{<<":scheme">>, <<"http">>},
			{<<":authority">>, <<"localhost">>},
			{<<":path">>, <<"/">>}
			|lists:duplicate(9996, {<<"x-custom">>, <<"value">>})
		],
		{HeadersBlock1, _} = cow_hpack:encode(Headers1),
		ok = gen_tcp:send(Socket1, cow_http2:headers(1, fin, HeadersBlock1)),
		%% Success: we get a response back.
		{ok, <<_:24, 1:8, _:40>>} = gen_tcp:recv(Socket1, 9, 6000),
		gen_tcp:close(Socket1),
		%% Sending 10001 headers, above the limit.
		{ok, Socket2} = do_handshake(Config),
		Headers2 = [
			{<<":method">>, <<"GET">>},
			{<<":scheme">>, <<"http">>},
			{<<":authority">>, <<"localhost">>},
			{<<":path">>, <<"/">>}
			|lists:duplicate(9997, {<<"x-custom">>, <<"value">>})
		],
		{HeadersBlock2, _} = cow_hpack:encode(Headers2),
		ok = gen_tcp:send(Socket2, cow_http2:headers(1, fin, HeadersBlock2)),
		%% Receive an ENHANCE_YOUR_CALM connection error.
		{ok, <<_:24, 7:8, _:72, 11:32>>} = gen_tcp:recv(Socket2, 17, 6000),
		ok
	after
		cowboy:stop_listener(?FUNCTION_NAME)
	end.

persistent_term_router(Config) ->
	doc("The router can retrieve the routes from persistent_term storage."),
	case erlang:function_exported(persistent_term, get, 1) of
		true -> do_persistent_term_router(Config);
		false -> {skip, "This test uses the persistent_term functionality added in Erlang/OTP 21.2."}
	end.

do_persistent_term_router(Config) ->
	persistent_term:put(?FUNCTION_NAME, init_dispatch(Config)),
	{ok, _} = cowboy:start_clear(?FUNCTION_NAME, [{port, 0}], #{
		env => #{dispatch => {persistent_term, ?FUNCTION_NAME}}
	}),
	Port = ranch:get_port(?FUNCTION_NAME),
	try
		ConnPid = gun_open([{type, tcp}, {protocol, http2}, {port, Port}|Config]),
		{ok, http2} = gun:await_up(ConnPid),
		StreamRef = gun:get(ConnPid, "/"),
		{response, nofin, 200, _} = gun:await(ConnPid, StreamRef),
		gun:close(ConnPid)
	after
		cowboy:stop_listener(?FUNCTION_NAME)
	end.

preface_timeout_infinity(Config) ->
	doc("Ensure infinity for preface_timeout is accepted."),
	ProtoOpts = #{
		env => #{dispatch => init_dispatch(Config)},
		preface_timeout => infinity
	},
	{ok, _} = cowboy:start_clear(?FUNCTION_NAME, [{port, 0}], ProtoOpts),
	Port = ranch:get_port(?FUNCTION_NAME),
	try
		{ok, Socket} = do_handshake([{port, Port}|Config]),
		Pid = get_remote_pid_tcp(Socket),
		Ref = erlang:monitor(process, Pid),
		receive
			{'DOWN', Ref, process, Pid, Reason} ->
				error(Reason)
		after 1000 ->
			gen_tcp:close(Socket)
		end
	after
		cowboy:stop_listener(?FUNCTION_NAME)
	end.

resp_iolist_body(Config) ->
	doc("Regression test when response bodies are iolists that "
		"include improper lists, empty lists and empty binaries. "
		"The original issue failed to split the body into frames properly."),
	ProtoOpts = #{
		env => #{dispatch => init_dispatch(Config)}
	},
	{ok, _} = cowboy:start_clear(?FUNCTION_NAME, [{port, 0}], ProtoOpts),
	Port = ranch:get_port(?FUNCTION_NAME),
	try
		ConnPid = gun_open([{type, tcp}, {protocol, http2}, {port, Port}|Config]),
		Ref = gun:get(ConnPid, "/resp_iolist_body"),
		{response, nofin, 200, RespHeaders} = gun:await(ConnPid, Ref),
		{_, BinLen} = lists:keyfind(<<"content-length">>, 1, RespHeaders),
		Len = binary_to_integer(BinLen),
		{ok, RespBody} = gun:await_body(ConnPid, Ref),
		Len = iolist_size(RespBody),
		gun:close(ConnPid)
	after
		cowboy:stop_listener(?FUNCTION_NAME)
	end.

settings_timeout_infinity(Config) ->
	doc("Ensure infinity for settings_timeout is accepted."),
	ProtoOpts = #{
		env => #{dispatch => init_dispatch(Config)},
		settings_timeout => infinity
	},
	{ok, _} = cowboy:start_clear(?FUNCTION_NAME, [{port, 0}], ProtoOpts),
	Port = ranch:get_port(?FUNCTION_NAME),
	try
		{ok, Socket} = do_handshake([{port, Port}|Config]),
		Pid = get_remote_pid_tcp(Socket),
		Ref = erlang:monitor(process, Pid),
		receive
			{'DOWN', Ref, process, Pid, Reason} ->
				error(Reason)
		after 1000 ->
			gen_tcp:close(Socket)
		end
	after
		cowboy:stop_listener(?FUNCTION_NAME)
	end.

graceful_shutdown_connection(Config) ->
	doc("Check that ongoing requests are handled before gracefully shutting down a connection."),
	Dispatch = cowboy_router:compile([{"localhost", [
		{"/delay_hello", delay_hello_h,
			#{delay => 500, notify_received => self()}}
	]}]),
	ProtoOpts = #{
		env => #{dispatch => Dispatch}
	},
	{ok, _} = cowboy:start_clear(?FUNCTION_NAME, [{port, 0}], ProtoOpts),
	Port = ranch:get_port(?FUNCTION_NAME),
	try
		ConnPid = gun_open([{type, tcp}, {protocol, http2}, {port, Port}|Config]),
		Ref = gun:get(ConnPid, "/delay_hello"),
		%% Make sure the request is received.
		receive {request_received, <<"/delay_hello">>} -> ok end,
		%% Tell the connection to shutdown while the handler is working.
		[CowboyConnPid] = ranch:procs(?FUNCTION_NAME, connections),
		monitor(process, CowboyConnPid),
		ok = sys:terminate(CowboyConnPid, goaway),
		%% Check that the response is sent to the client before the
		%% connection goes down.
		{response, nofin, 200, _RespHeaders} = gun:await(ConnPid, Ref),
		{ok, RespBody} = gun:await_body(ConnPid, Ref),
		<<"Hello world!">> = iolist_to_binary(RespBody),
		%% Check that the connection is gone soon afterwards. (The exit
		%% reason is supposed to be 'goaway' as passed to
		%% sys:terminate/2, but it is {shutdown, closed}.)
		receive
			{'DOWN', _, process, CowboyConnPid, _Reason} ->
				ok
		end,
		[] = ranch:procs(?FUNCTION_NAME, connections),
		gun:close(ConnPid)
	after
		cowboy:stop_listener(?FUNCTION_NAME)
	end.

graceful_shutdown_timeout(Config) ->
	doc("Check that a connection is closed when gracefully shutting down times out."),
	Dispatch = cowboy_router:compile([{"localhost", [
		{"/long_delay_hello", delay_hello_h,
			#{delay => 10000, notify_received => self()}}
	]}]),
	ProtoOpts = #{
		env => #{dispatch => Dispatch},
		goaway_initial_timeout => 200,
		goaway_complete_timeout => 500
	},
	{ok, _} = cowboy:start_clear(?FUNCTION_NAME, [{port, 0}], ProtoOpts),
	Port = ranch:get_port(?FUNCTION_NAME),
	try
		ConnPid = gun_open([{type, tcp}, {protocol, http2}, {port, Port}|Config]),
		Ref = gun:get(ConnPid, "/long_delay_hello"),
		%% Make sure the request is received.
		receive {request_received, <<"/long_delay_hello">>} -> ok end,
		%% Tell the connection to shutdown while the handler is working.
		[CowboyConnPid] = ranch:procs(?FUNCTION_NAME, connections),
		monitor(process, CowboyConnPid),
		ok = sys:terminate(CowboyConnPid, goaway),
		%% Check that connection didn't wait for the slow handler.
		{error, {stream_error, closed}} = gun:await(ConnPid, Ref),
		%% Check that the connection is gone. (The exit reason is
		%% supposed to be 'goaway' as passed to sys:terminate/2, but it
		%% is {shutdown, {stop, {exit, goaway}, 'Graceful shutdown timed
		%% out.'}}.)
		receive
			{'DOWN', _, process, CowboyConnPid, _Reason} ->
				ok
		after 100 ->
		       error(still_alive)
		end,
		[] = ranch:procs(?FUNCTION_NAME, connections),
		gun:close(ConnPid)
	after
		cowboy:stop_listener(?FUNCTION_NAME)
	end.

graceful_shutdown_listener(Config) ->
	doc("Check that connections are shut down gracefully when stopping a listener."),
	TransOpts = #{
		socket_opts => [{port, 0}],
		shutdown => 1000 %% Shorter timeout to make the test case faster.
	},
	Dispatch = cowboy_router:compile([{"localhost", [
		{"/delay_hello", delay_hello_h,
			#{delay => 500, notify_received => self()}}
	]}]),
	ProtoOpts = #{
		env => #{dispatch => Dispatch}
	},
	{ok, Listener} = cowboy:start_clear(?FUNCTION_NAME, TransOpts, ProtoOpts),
	Port = ranch:get_port(?FUNCTION_NAME),
	ConnPid = gun_open([{type, tcp}, {protocol, http2}, {port, Port}|Config]),
	Ref = gun:get(ConnPid, "/delay_hello"),
	%% Shutdown listener while the handlers are working.
	receive {request_received, <<"/delay_hello">>} -> ok end,
	ListenerMonitorRef = monitor(process, Listener),
	%% Note: This call does not complete quickly and will
	%% prevent other cowboy:stop_listener/1 calls to complete.
	ok = cowboy:stop_listener(?FUNCTION_NAME),
	receive
		{'DOWN', ListenerMonitorRef, process, Listener, _Reason} ->
			ok
	end,
	%% Check that the request is handled before shutting down.
	{response, nofin, 200, _RespHeaders} = gun:await(ConnPid, Ref),
	{ok, RespBody} = gun:await_body(ConnPid, Ref),
	<<"Hello world!">> = iolist_to_binary(RespBody),
	gun:close(ConnPid).

graceful_shutdown_listener_timeout(Config) ->
	doc("Check that connections are shut down when gracefully stopping a listener times out."),
	TransOpts = #{
		socket_opts => [{port, 0}],
		shutdown => 1000 %% Shorter timeout to make the test case faster.
	},
	Dispatch = cowboy_router:compile([{"localhost", [
		{"/long_delay_hello", delay_hello_h,
			#{delay => 10000, notify_received => self()}}
	]}]),
	ProtoOpts = #{
		env => #{dispatch => Dispatch},
		goaway_initial_timeout => 200,
		goaway_complete_timeout => 500
	},
	{ok, Listener} = cowboy:start_clear(?FUNCTION_NAME, TransOpts, ProtoOpts),
	Port = ranch:get_port(?FUNCTION_NAME),
	ConnPid = gun_open([{type, tcp}, {protocol, http2}, {port, Port}|Config]),
	Ref = gun:get(ConnPid, "/long_delay_hello"),
	%% Shutdown listener while the handlers are working.
	receive {request_received, <<"/long_delay_hello">>} -> ok end,
	ListenerMonitorRef = monitor(process, Listener),
	%% Note: This call does not complete quickly and will
	%% prevent other cowboy:stop_listener/1 calls to complete.
	ok = cowboy:stop_listener(?FUNCTION_NAME),
	receive
		{'DOWN', ListenerMonitorRef, process, Listener, _Reason} ->
			ok
	end,
	%% Check that the slow request is aborted.
	{error, {stream_error, closed}} = gun:await(ConnPid, Ref),
	gun:close(ConnPid).

send_timeout_close(Config) ->
	doc("Check that connections are closed on send timeout."),
	TransOpts = #{
		socket_opts => [
			{port, 0},
			{send_timeout, 100},
			{send_timeout_close, true},
			{sndbuf, 10}
		]
	},
	Dispatch = cowboy_router:compile([{"localhost", [
		{"/endless", loop_handler_endless_h, #{delay => 100}}
	]}]),
	ProtoOpts = #{
		env => #{dispatch => Dispatch},
		idle_timeout => infinity
	},
	{ok, _} = cowboy:start_clear(?FUNCTION_NAME, TransOpts, ProtoOpts),
	Port = ranch:get_port(?FUNCTION_NAME),
	try
		%% Connect a client that sends a request and waits indefinitely.
		{ok, ClientSocket} = do_handshake([{port, Port},
			{tcp_opts, [{recbuf, 10}, {buffer, 10}, {active, false}]}|Config]),
		{HeadersBlock, _} = cow_hpack:encode([
			{<<":method">>, <<"GET">>},
			{<<":scheme">>, <<"http">>},
			{<<":authority">>, <<"localhost">>}, %% @todo Correct port number.
			{<<":path">>, <<"/endless">>},
			{<<"x-test-pid">>, pid_to_list(self())}
		]),
		ok = gen_tcp:send(ClientSocket, [
			cow_http2:headers(1, fin, HeadersBlock),
			%% Greatly increase the window to make sure we don't run
			%% out of space before we get send timeouts.
			cow_http2:window_update(10000000),
			cow_http2:window_update(1, 10000000)
		]),
		%% Wait for the handler to start then get its pid,
		%% the remote connection's pid and socket.
		StreamPid = receive
			{Self, StreamPid0, init} when Self =:= self() ->
				StreamPid0
		after 1000 ->
			error(timeout)
		end,
		ServerPid = ct_helper:get_remote_pid_tcp(ClientSocket),
		{links, ServerLinks} = process_info(ServerPid, links),
		[ServerSocket] = [PidOrPort || PidOrPort <- ServerLinks, is_port(PidOrPort)],
		%% Poll the socket repeatedly until it is closed by the server.
		WaitClosedFun =
			fun F(T) when T =< 0 ->
					error({status, prim_inet:getstatus(ServerSocket)});
				F(T) ->
					Snooze = 100,
					case inet:sockname(ServerSocket) of
						{error, _} ->
							timer:sleep(Snooze);
						{ok, _} ->
							timer:sleep(Snooze),
							F(T - Snooze)
					end
			end,
		ok = WaitClosedFun(2000),
		false = erlang:is_process_alive(StreamPid),
		false = erlang:is_process_alive(ServerPid),
		gen_tcp:close(ClientSocket)
	after
		cowboy:stop_listener(?FUNCTION_NAME)
	end.
