gleam_stdlib

-module(gleam@uri_test).
-compile(no_auto_import).

-export([full_parse_test/0, parse_only_path_test/0, parse_only_host_test/0, error_parsing_uri_test/0, full_uri_to_string_test/0, path_only_uri_to_string_test/0, parse_query_string_test/0, parse_empty_query_string_test/0, parse_query_string_with_empty_test/0, error_parsing_query_test/0, query_to_string_test/0, empty_query_to_string_test/0, percent_encode_test/0, percent_encode_consistency_test/0, percent_decode_test/0, percent_decode_consistency_test/0, parse_segments_test/0, origin_test/0, merge_test/0]).

-spec full_parse_test() -> gleam@should:expectation().
full_parse_test() ->
    Parsed@1 = case gleam@uri:parse(
        <<"https://foo:bar@example.com:1234/path?query=true#fragment"/utf8>>
    ) of
        {ok, Parsed} -> Parsed;
        Gleam@Assert ->
            erlang:error(#{gleam_error => assert,
                           message => <<"Assertion pattern match failed"/utf8>>,
                           value => Gleam@Assert,
                           module => <<"gleam/uri_test"/utf8>>,
                           function => <<"full_parse_test"/utf8>>,
                           line => 8})
    end,
    gleam@should:equal(erlang:element(2, Parsed@1), {some, <<"https"/utf8>>}),
    gleam@should:equal(erlang:element(3, Parsed@1), {some, <<"foo:bar"/utf8>>}),
    gleam@should:equal(
        erlang:element(4, Parsed@1),
        {some, <<"example.com"/utf8>>}
    ),
    gleam@should:equal(erlang:element(5, Parsed@1), {some, 1234}),
    gleam@should:equal(erlang:element(6, Parsed@1), <<"/path"/utf8>>),
    gleam@should:equal(
        erlang:element(7, Parsed@1),
        {some, <<"query=true"/utf8>>}
    ),
    gleam@should:equal(erlang:element(8, Parsed@1), {some, <<"fragment"/utf8>>}).

-spec parse_only_path_test() -> gleam@should:expectation().
parse_only_path_test() ->
    Parsed@1 = case gleam@uri:parse(<<""/utf8>>) of
        {ok, Parsed} -> Parsed;
        Gleam@Assert ->
            erlang:error(#{gleam_error => assert,
                           message => <<"Assertion pattern match failed"/utf8>>,
                           value => Gleam@Assert,
                           module => <<"gleam/uri_test"/utf8>>,
                           function => <<"parse_only_path_test"/utf8>>,
                           line => 20})
    end,
    gleam@should:equal(erlang:element(2, Parsed@1), none),
    gleam@should:equal(erlang:element(3, Parsed@1), none),
    gleam@should:equal(erlang:element(4, Parsed@1), none),
    gleam@should:equal(erlang:element(5, Parsed@1), none),
    gleam@should:equal(erlang:element(6, Parsed@1), <<""/utf8>>),
    gleam@should:equal(erlang:element(7, Parsed@1), none),
    gleam@should:equal(erlang:element(8, Parsed@1), none).

-spec parse_only_host_test() -> gleam@should:expectation().
parse_only_host_test() ->
    Parsed@1 = case gleam@uri:parse(<<"//"/utf8>>) of
        {ok, Parsed} -> Parsed;
        Gleam@Assert ->
            erlang:error(#{gleam_error => assert,
                           message => <<"Assertion pattern match failed"/utf8>>,
                           value => Gleam@Assert,
                           module => <<"gleam/uri_test"/utf8>>,
                           function => <<"parse_only_host_test"/utf8>>,
                           line => 31})
    end,
    gleam@should:equal(erlang:element(2, Parsed@1), none),
    gleam@should:equal(erlang:element(3, Parsed@1), none),
    gleam@should:equal(erlang:element(4, Parsed@1), {some, <<""/utf8>>}),
    gleam@should:equal(erlang:element(5, Parsed@1), none),
    gleam@should:equal(erlang:element(6, Parsed@1), <<""/utf8>>),
    gleam@should:equal(erlang:element(7, Parsed@1), none),
    gleam@should:equal(erlang:element(8, Parsed@1), none).

-spec error_parsing_uri_test() -> gleam@should:expectation().
error_parsing_uri_test() ->
    gleam@should:equal(gleam@uri:parse(<<"::"/utf8>>), {error, nil}).

-spec full_uri_to_string_test() -> gleam@should:expectation().
full_uri_to_string_test() ->
    Test_uri = {uri,
                {some, <<"https"/utf8>>},
                {some, <<"foo:bar"/utf8>>},
                {some, <<"example.com"/utf8>>},
                {some, 1234},
                <<"/path"/utf8>>,
                {some, <<"query=true"/utf8>>},
                {some, <<"fragment"/utf8>>}},
    gleam@should:equal(
        gleam@uri:to_string(Test_uri),
        <<"https://foo:bar@example.com:1234/path?query=true#fragment"/utf8>>
    ).

-spec path_only_uri_to_string_test() -> gleam@should:expectation().
path_only_uri_to_string_test() ->
    Test_uri = {uri, none, none, none, none, <<"/"/utf8>>, none, none},
    gleam@should:equal(gleam@uri:to_string(Test_uri), <<"/"/utf8>>).

-spec parse_query_string_test() -> gleam@should:expectation().
parse_query_string_test() ->
    Parsed@1 = case gleam@uri:parse_query(<<"foo+bar=1&city=%C3%B6rebro"/utf8>>) of
        {ok, Parsed} -> Parsed;
        Gleam@Assert ->
            erlang:error(#{gleam_error => assert,
                           message => <<"Assertion pattern match failed"/utf8>>,
                           value => Gleam@Assert,
                           module => <<"gleam/uri_test"/utf8>>,
                           function => <<"parse_query_string_test"/utf8>>,
                           line => 68})
    end,
    gleam@should:equal(
        Parsed@1,
        [{<<"foo bar"/utf8>>, <<"1"/utf8>>},
         {<<"city"/utf8>>, <<"örebro"/utf8>>}]
    ).

-spec parse_empty_query_string_test() -> gleam@should:expectation().
parse_empty_query_string_test() ->
    Parsed@1 = case gleam@uri:parse_query(<<""/utf8>>) of
        {ok, Parsed} -> Parsed;
        Gleam@Assert ->
            erlang:error(#{gleam_error => assert,
                           message => <<"Assertion pattern match failed"/utf8>>,
                           value => Gleam@Assert,
                           module => <<"gleam/uri_test"/utf8>>,
                           function => <<"parse_empty_query_string_test"/utf8>>,
                           line => 73})
    end,
    gleam@should:equal(Parsed@1, []).

-spec parse_query_string_with_empty_test() -> gleam@should:expectation().
parse_query_string_with_empty_test() ->
    gleam@should:equal(
        gleam@uri:parse_query(<<"present"/utf8>>),
        {ok, [{<<"present"/utf8>>, <<""/utf8>>}]}
    ).

-spec error_parsing_query_test() -> gleam@should:expectation().
error_parsing_query_test() ->
    gleam@should:equal(gleam@uri:parse_query(<<"%C2"/utf8>>), {error, nil}).

-spec query_to_string_test() -> gleam@should:expectation().
query_to_string_test() ->
    Query_string = gleam@uri:query_to_string(
        [{<<"foo bar"/utf8>>, <<"1"/utf8>>},
         {<<"city"/utf8>>, <<"örebro"/utf8>>}]
    ),
    gleam@should:equal(Query_string, <<"foo+bar=1&city=%C3%B6rebro"/utf8>>).

-spec empty_query_to_string_test() -> gleam@should:expectation().
empty_query_to_string_test() ->
    Query_string = gleam@uri:query_to_string([]),
    gleam@should:equal(Query_string, <<""/utf8>>).

-spec percent_codec_fixtures() -> list({binary(), binary()}).
percent_codec_fixtures() ->
    [{<<" "/utf8>>, <<"+"/utf8>>},
     {<<","/utf8>>, <<"%2C"/utf8>>},
     {<<";"/utf8>>, <<"%3B"/utf8>>},
     {<<":"/utf8>>, <<"%3A"/utf8>>},
     {<<"!"/utf8>>, <<"%21"/utf8>>},
     {<<"?"/utf8>>, <<"%3F"/utf8>>},
     {<<"'"/utf8>>, <<"%27"/utf8>>},
     {<<"("/utf8>>, <<"%28"/utf8>>},
     {<<")"/utf8>>, <<"%29"/utf8>>},
     {<<"["/utf8>>, <<"%5B"/utf8>>},
     {<<"@"/utf8>>, <<"%40"/utf8>>},
     {<<"/"/utf8>>, <<"%2F"/utf8>>},
     {<<"\\"/utf8>>, <<"%5C"/utf8>>},
     {<<"&"/utf8>>, <<"%26"/utf8>>},
     {<<"#"/utf8>>, <<"%23"/utf8>>},
     {<<"="/utf8>>, <<"%3D"/utf8>>},
     {<<"~"/utf8>>, <<"%7E"/utf8>>},
     {<<"ñ"/utf8>>, <<"%C3%B1"/utf8>>},
     {<<"-"/utf8>>, <<"-"/utf8>>},
     {<<"_"/utf8>>, <<"_"/utf8>>},
     {<<"."/utf8>>, <<"."/utf8>>},
     {<<"*"/utf8>>, <<"*"/utf8>>},
     {<<"100% great"/utf8>>, <<"100%25+great"/utf8>>}].

-spec percent_encode_test() -> list(gleam@should:expectation()).
percent_encode_test() ->
    gleam@list:map(percent_codec_fixtures(), fun(T) -> {A, B} = T,
            gleam@should:equal(gleam@uri:percent_encode(A), B) end).

-spec percent_encode_consistency_test() -> gleam@should:expectation().
percent_encode_consistency_test() ->
    K = <<"foo bar[]"/utf8>>,
    V = <<"ñaña (,:*~)"/utf8>>,
    Query_string = gleam@uri:query_to_string([{K, V}]),
    Encoded_key = gleam@uri:percent_encode(K),
    Encoded_value = gleam@uri:percent_encode(V),
    Manual_query_string = gleam@string:concat(
        [Encoded_key, <<"="/utf8>>, Encoded_value]
    ),
    gleam@should:equal(Query_string, Manual_query_string).

-spec percent_decode_test() -> list(gleam@should:expectation()).
percent_decode_test() ->
    gleam@list:map(percent_codec_fixtures(), fun(T) -> {A, B} = T,
            gleam@should:equal(gleam@uri:percent_decode(B), {ok, A}) end).

-spec percent_decode_consistency_test() -> gleam@should:expectation().
percent_decode_consistency_test() ->
    K = <<"foo+bar[]"/utf8>>,
    V = <<"%C3%B6rebro"/utf8>>,
    Query = gleam@string:concat([K, <<"="/utf8>>, V]),
    Parsed@1 = case gleam@uri:parse_query(Query) of
        {ok, Parsed} -> Parsed;
        Gleam@Assert ->
            erlang:error(#{gleam_error => assert,
                           message => <<"Assertion pattern match failed"/utf8>>,
                           value => Gleam@Assert,
                           module => <<"gleam/uri_test"/utf8>>,
                           function => <<"percent_decode_consistency_test"/utf8>>,
                           line => 161})
    end,
    Decoded_key@1 = case gleam@uri:percent_decode(K) of
        {ok, Decoded_key} -> Decoded_key;
        Gleam@Assert@1 ->
            erlang:error(#{gleam_error => assert,
                           message => <<"Assertion pattern match failed"/utf8>>,
                           value => Gleam@Assert@1,
                           module => <<"gleam/uri_test"/utf8>>,
                           function => <<"percent_decode_consistency_test"/utf8>>,
                           line => 163})
    end,
    Decoded_value@1 = case gleam@uri:percent_decode(V) of
        {ok, Decoded_value} -> Decoded_value;
        Gleam@Assert@2 ->
            erlang:error(#{gleam_error => assert,
                           message => <<"Assertion pattern match failed"/utf8>>,
                           value => Gleam@Assert@2,
                           module => <<"gleam/uri_test"/utf8>>,
                           function => <<"percent_decode_consistency_test"/utf8>>,
                           line => 164})
    end,
    gleam@should:equal(Parsed@1, [{Decoded_key@1, Decoded_value@1}]).

-spec parse_segments_test() -> gleam@should:expectation().
parse_segments_test() ->
    gleam@should:equal(gleam@uri:path_segments(<<"/"/utf8>>), []),
    gleam@should:equal(
        gleam@uri:path_segments(<<"/foo/bar"/utf8>>),
        [<<"foo"/utf8>>, <<"bar"/utf8>>]
    ),
    gleam@should:equal(gleam@uri:path_segments(<<"////"/utf8>>), []),
    gleam@should:equal(
        gleam@uri:path_segments(<<"/foo//bar"/utf8>>),
        [<<"foo"/utf8>>, <<"bar"/utf8>>]
    ),
    gleam@should:equal(gleam@uri:path_segments(<<"/."/utf8>>), []),
    gleam@should:equal(
        gleam@uri:path_segments(<<"/.foo"/utf8>>),
        [<<".foo"/utf8>>]
    ),
    gleam@should:equal(
        gleam@uri:path_segments(<<"/../bar"/utf8>>),
        [<<"bar"/utf8>>]
    ),
    gleam@should:equal(
        gleam@uri:path_segments(<<"../bar"/utf8>>),
        [<<"bar"/utf8>>]
    ),
    gleam@should:equal(
        gleam@uri:path_segments(<<"/foo/../bar"/utf8>>),
        [<<"bar"/utf8>>]
    ).

-spec origin_test() -> gleam@should:expectation().
origin_test() ->
    Parsed@1 = case gleam@uri:parse(<<"http://example.test/path?foo#bar"/utf8>>) of
        {ok, Parsed} -> Parsed;
        Gleam@Assert ->
            erlang:error(#{gleam_error => assert,
                           message => <<"Assertion pattern match failed"/utf8>>,
                           value => Gleam@Assert,
                           module => <<"gleam/uri_test"/utf8>>,
                           function => <<"origin_test"/utf8>>,
                           line => 184})
    end,
    gleam@should:equal(
        gleam@uri:origin(Parsed@1),
        {ok, <<"http://example.test"/utf8>>}
    ),
    Parsed@3 = case gleam@uri:parse(<<"http://example.test:8080"/utf8>>) of
        {ok, Parsed@2} -> Parsed@2;
        Gleam@Assert@1 ->
            erlang:error(#{gleam_error => assert,
                           message => <<"Assertion pattern match failed"/utf8>>,
                           value => Gleam@Assert@1,
                           module => <<"gleam/uri_test"/utf8>>,
                           function => <<"origin_test"/utf8>>,
                           line => 188})
    end,
    gleam@should:equal(
        gleam@uri:origin(Parsed@3),
        {ok, <<"http://example.test:8080"/utf8>>}
    ),
    Parsed@5 = case gleam@uri:parse(<<"https://example.test"/utf8>>) of
        {ok, Parsed@4} -> Parsed@4;
        Gleam@Assert@2 ->
            erlang:error(#{gleam_error => assert,
                           message => <<"Assertion pattern match failed"/utf8>>,
                           value => Gleam@Assert@2,
                           module => <<"gleam/uri_test"/utf8>>,
                           function => <<"origin_test"/utf8>>,
                           line => 192})
    end,
    gleam@should:equal(
        gleam@uri:origin(Parsed@5),
        {ok, <<"https://example.test"/utf8>>}
    ),
    Parsed@7 = case gleam@uri:parse(<<"http:///path"/utf8>>) of
        {ok, Parsed@6} -> Parsed@6;
        Gleam@Assert@3 ->
            erlang:error(#{gleam_error => assert,
                           message => <<"Assertion pattern match failed"/utf8>>,
                           value => Gleam@Assert@3,
                           module => <<"gleam/uri_test"/utf8>>,
                           function => <<"origin_test"/utf8>>,
                           line => 196})
    end,
    gleam@should:equal(gleam@uri:origin(Parsed@7), {ok, <<"http://"/utf8>>}),
    Parsed@9 = case gleam@uri:parse(<<"http://"/utf8>>) of
        {ok, Parsed@8} -> Parsed@8;
        Gleam@Assert@4 ->
            erlang:error(#{gleam_error => assert,
                           message => <<"Assertion pattern match failed"/utf8>>,
                           value => Gleam@Assert@4,
                           module => <<"gleam/uri_test"/utf8>>,
                           function => <<"origin_test"/utf8>>,
                           line => 200})
    end,
    gleam@should:equal(gleam@uri:origin(Parsed@9), {ok, <<"http://"/utf8>>}),
    Parsed@11 = case gleam@uri:parse(<<"/path"/utf8>>) of
        {ok, Parsed@10} -> Parsed@10;
        Gleam@Assert@5 ->
            erlang:error(#{gleam_error => assert,
                           message => <<"Assertion pattern match failed"/utf8>>,
                           value => Gleam@Assert@5,
                           module => <<"gleam/uri_test"/utf8>>,
                           function => <<"origin_test"/utf8>>,
                           line => 204})
    end,
    gleam@should:equal(gleam@uri:origin(Parsed@11), {error, nil}),
    Parsed@13 = case gleam@uri:parse(<<"file:///dev/null"/utf8>>) of
        {ok, Parsed@12} -> Parsed@12;
        Gleam@Assert@6 ->
            erlang:error(#{gleam_error => assert,
                           message => <<"Assertion pattern match failed"/utf8>>,
                           value => Gleam@Assert@6,
                           module => <<"gleam/uri_test"/utf8>>,
                           function => <<"origin_test"/utf8>>,
                           line => 208})
    end,
    gleam@should:equal(gleam@uri:origin(Parsed@13), {error, nil}).

-spec merge_test() -> gleam@should:expectation().
merge_test() ->
    A@1 = case gleam@uri:parse(<<"/relative"/utf8>>) of
        {ok, A} -> A;
        Gleam@Assert ->
            erlang:error(#{gleam_error => assert,
                           message => <<"Assertion pattern match failed"/utf8>>,
                           value => Gleam@Assert,
                           module => <<"gleam/uri_test"/utf8>>,
                           function => <<"merge_test"/utf8>>,
                           line => 214})
    end,
    B@1 = case gleam@uri:parse(<<""/utf8>>) of
        {ok, B} -> B;
        Gleam@Assert@1 ->
            erlang:error(#{gleam_error => assert,
                           message => <<"Assertion pattern match failed"/utf8>>,
                           value => Gleam@Assert@1,
                           module => <<"gleam/uri_test"/utf8>>,
                           function => <<"merge_test"/utf8>>,
                           line => 215})
    end,
    gleam@should:equal(gleam@uri:merge(A@1, B@1), {error, nil}),
    A@3 = case gleam@uri:parse(<<"http://google.com/foo"/utf8>>) of
        {ok, A@2} -> A@2;
        Gleam@Assert@2 ->
            erlang:error(#{gleam_error => assert,
                           message => <<"Assertion pattern match failed"/utf8>>,
                           value => Gleam@Assert@2,
                           module => <<"gleam/uri_test"/utf8>>,
                           function => <<"merge_test"/utf8>>,
                           line => 219})
    end,
    B@3 = case gleam@uri:parse(<<"http://example.com/baz"/utf8>>) of
        {ok, B@2} -> B@2;
        Gleam@Assert@3 ->
            erlang:error(#{gleam_error => assert,
                           message => <<"Assertion pattern match failed"/utf8>>,
                           value => Gleam@Assert@3,
                           module => <<"gleam/uri_test"/utf8>>,
                           function => <<"merge_test"/utf8>>,
                           line => 220})
    end,
    gleam@should:equal(
        gleam@uri:merge(A@3, B@3),
        gleam@uri:parse(<<"http://example.com/baz"/utf8>>)
    ),
    A@5 = case gleam@uri:parse(<<"http://google.com/foo"/utf8>>) of
        {ok, A@4} -> A@4;
        Gleam@Assert@4 ->
            erlang:error(#{gleam_error => assert,
                           message => <<"Assertion pattern match failed"/utf8>>,
                           value => Gleam@Assert@4,
                           module => <<"gleam/uri_test"/utf8>>,
                           function => <<"merge_test"/utf8>>,
                           line => 224})
    end,
    B@5 = case gleam@uri:parse(<<"http://example.com/.././bar/../../baz"/utf8>>) of
        {ok, B@4} -> B@4;
        Gleam@Assert@5 ->
            erlang:error(#{gleam_error => assert,
                           message => <<"Assertion pattern match failed"/utf8>>,
                           value => Gleam@Assert@5,
                           module => <<"gleam/uri_test"/utf8>>,
                           function => <<"merge_test"/utf8>>,
                           line => 225})
    end,
    gleam@should:equal(
        gleam@uri:merge(A@5, B@5),
        gleam@uri:parse(<<"http://example.com/baz"/utf8>>)
    ),
    A@7 = case gleam@uri:parse(<<"http://google.com/foo"/utf8>>) of
        {ok, A@6} -> A@6;
        Gleam@Assert@6 ->
            erlang:error(#{gleam_error => assert,
                           message => <<"Assertion pattern match failed"/utf8>>,
                           value => Gleam@Assert@6,
                           module => <<"gleam/uri_test"/utf8>>,
                           function => <<"merge_test"/utf8>>,
                           line => 229})
    end,
    B@7 = case gleam@uri:parse(<<"//example.com/baz"/utf8>>) of
        {ok, B@6} -> B@6;
        Gleam@Assert@7 ->
            erlang:error(#{gleam_error => assert,
                           message => <<"Assertion pattern match failed"/utf8>>,
                           value => Gleam@Assert@7,
                           module => <<"gleam/uri_test"/utf8>>,
                           function => <<"merge_test"/utf8>>,
                           line => 230})
    end,
    gleam@should:equal(
        gleam@uri:merge(A@7, B@7),
        gleam@uri:parse(<<"http://example.com/baz"/utf8>>)
    ),
    A@9 = case gleam@uri:parse(<<"http://google.com/foo"/utf8>>) of
        {ok, A@8} -> A@8;
        Gleam@Assert@8 ->
            erlang:error(#{gleam_error => assert,
                           message => <<"Assertion pattern match failed"/utf8>>,
                           value => Gleam@Assert@8,
                           module => <<"gleam/uri_test"/utf8>>,
                           function => <<"merge_test"/utf8>>,
                           line => 234})
    end,
    B@9 = case gleam@uri:parse(<<"//example.com/.././bar/../../../baz"/utf8>>) of
        {ok, B@8} -> B@8;
        Gleam@Assert@9 ->
            erlang:error(#{gleam_error => assert,
                           message => <<"Assertion pattern match failed"/utf8>>,
                           value => Gleam@Assert@9,
                           module => <<"gleam/uri_test"/utf8>>,
                           function => <<"merge_test"/utf8>>,
                           line => 235})
    end,
    gleam@should:equal(
        gleam@uri:merge(A@9, B@9),
        gleam@uri:parse(<<"http://example.com/baz"/utf8>>)
    ),
    A@11 = case gleam@uri:parse(<<"http://example.com/foo/bar"/utf8>>) of
        {ok, A@10} -> A@10;
        Gleam@Assert@10 ->
            erlang:error(#{gleam_error => assert,
                           message => <<"Assertion pattern match failed"/utf8>>,
                           value => Gleam@Assert@10,
                           module => <<"gleam/uri_test"/utf8>>,
                           function => <<"merge_test"/utf8>>,
                           line => 239})
    end,
    B@11 = case gleam@uri:parse(<<"/baz"/utf8>>) of
        {ok, B@10} -> B@10;
        Gleam@Assert@11 ->
            erlang:error(#{gleam_error => assert,
                           message => <<"Assertion pattern match failed"/utf8>>,
                           value => Gleam@Assert@11,
                           module => <<"gleam/uri_test"/utf8>>,
                           function => <<"merge_test"/utf8>>,
                           line => 240})
    end,
    gleam@should:equal(
        gleam@uri:merge(A@11, B@11),
        gleam@uri:parse(<<"http://example.com/baz"/utf8>>)
    ),
    A@13 = case gleam@uri:parse(<<"http://example.com/foo/bar"/utf8>>) of
        {ok, A@12} -> A@12;
        Gleam@Assert@12 ->
            erlang:error(#{gleam_error => assert,
                           message => <<"Assertion pattern match failed"/utf8>>,
                           value => Gleam@Assert@12,
                           module => <<"gleam/uri_test"/utf8>>,
                           function => <<"merge_test"/utf8>>,
                           line => 244})
    end,
    B@13 = case gleam@uri:parse(<<"baz"/utf8>>) of
        {ok, B@12} -> B@12;
        Gleam@Assert@13 ->
            erlang:error(#{gleam_error => assert,
                           message => <<"Assertion pattern match failed"/utf8>>,
                           value => Gleam@Assert@13,
                           module => <<"gleam/uri_test"/utf8>>,
                           function => <<"merge_test"/utf8>>,
                           line => 245})
    end,
    gleam@should:equal(
        gleam@uri:merge(A@13, B@13),
        gleam@uri:parse(<<"http://example.com/foo/baz"/utf8>>)
    ),
    A@15 = case gleam@uri:parse(<<"http://example.com/foo/"/utf8>>) of
        {ok, A@14} -> A@14;
        Gleam@Assert@14 ->
            erlang:error(#{gleam_error => assert,
                           message => <<"Assertion pattern match failed"/utf8>>,
                           value => Gleam@Assert@14,
                           module => <<"gleam/uri_test"/utf8>>,
                           function => <<"merge_test"/utf8>>,
                           line => 249})
    end,
    B@15 = case gleam@uri:parse(<<"baz"/utf8>>) of
        {ok, B@14} -> B@14;
        Gleam@Assert@15 ->
            erlang:error(#{gleam_error => assert,
                           message => <<"Assertion pattern match failed"/utf8>>,
                           value => Gleam@Assert@15,
                           module => <<"gleam/uri_test"/utf8>>,
                           function => <<"merge_test"/utf8>>,
                           line => 250})
    end,
    gleam@should:equal(
        gleam@uri:merge(A@15, B@15),
        gleam@uri:parse(<<"http://example.com/foo/baz"/utf8>>)
    ),
    A@17 = case gleam@uri:parse(<<"http://example.com"/utf8>>) of
        {ok, A@16} -> A@16;
        Gleam@Assert@16 ->
            erlang:error(#{gleam_error => assert,
                           message => <<"Assertion pattern match failed"/utf8>>,
                           value => Gleam@Assert@16,
                           module => <<"gleam/uri_test"/utf8>>,
                           function => <<"merge_test"/utf8>>,
                           line => 254})
    end,
    B@17 = case gleam@uri:parse(<<"baz"/utf8>>) of
        {ok, B@16} -> B@16;
        Gleam@Assert@17 ->
            erlang:error(#{gleam_error => assert,
                           message => <<"Assertion pattern match failed"/utf8>>,
                           value => Gleam@Assert@17,
                           module => <<"gleam/uri_test"/utf8>>,
                           function => <<"merge_test"/utf8>>,
                           line => 255})
    end,
    gleam@should:equal(
        gleam@uri:merge(A@17, B@17),
        gleam@uri:parse(<<"http://example.com/baz"/utf8>>)
    ),
    A@19 = case gleam@uri:parse(<<"http://example.com"/utf8>>) of
        {ok, A@18} -> A@18;
        Gleam@Assert@18 ->
            erlang:error(#{gleam_error => assert,
                           message => <<"Assertion pattern match failed"/utf8>>,
                           value => Gleam@Assert@18,
                           module => <<"gleam/uri_test"/utf8>>,
                           function => <<"merge_test"/utf8>>,
                           line => 259})
    end,
    B@19 = case gleam@uri:parse(<<"/.././bar/../../../baz"/utf8>>) of
        {ok, B@18} -> B@18;
        Gleam@Assert@19 ->
            erlang:error(#{gleam_error => assert,
                           message => <<"Assertion pattern match failed"/utf8>>,
                           value => Gleam@Assert@19,
                           module => <<"gleam/uri_test"/utf8>>,
                           function => <<"merge_test"/utf8>>,
                           line => 260})
    end,
    gleam@should:equal(
        gleam@uri:merge(A@19, B@19),
        gleam@uri:parse(<<"http://example.com/baz"/utf8>>)
    ),
    A@21 = case gleam@uri:parse(<<"http://example.com/foo/bar"/utf8>>) of
        {ok, A@20} -> A@20;
        Gleam@Assert@20 ->
            erlang:error(#{gleam_error => assert,
                           message => <<"Assertion pattern match failed"/utf8>>,
                           value => Gleam@Assert@20,
                           module => <<"gleam/uri_test"/utf8>>,
                           function => <<"merge_test"/utf8>>,
                           line => 264})
    end,
    B@21 = case gleam@uri:parse(<<""/utf8>>) of
        {ok, B@20} -> B@20;
        Gleam@Assert@21 ->
            erlang:error(#{gleam_error => assert,
                           message => <<"Assertion pattern match failed"/utf8>>,
                           value => Gleam@Assert@21,
                           module => <<"gleam/uri_test"/utf8>>,
                           function => <<"merge_test"/utf8>>,
                           line => 265})
    end,
    gleam@should:equal(
        gleam@uri:merge(A@21, B@21),
        gleam@uri:parse(<<"http://example.com/foo/bar"/utf8>>)
    ),
    A@23 = case gleam@uri:parse(<<"http://example.com/foo/bar"/utf8>>) of
        {ok, A@22} -> A@22;
        Gleam@Assert@22 ->
            erlang:error(#{gleam_error => assert,
                           message => <<"Assertion pattern match failed"/utf8>>,
                           value => Gleam@Assert@22,
                           module => <<"gleam/uri_test"/utf8>>,
                           function => <<"merge_test"/utf8>>,
                           line => 269})
    end,
    B@23 = case gleam@uri:parse(<<"#fragment"/utf8>>) of
        {ok, B@22} -> B@22;
        Gleam@Assert@23 ->
            erlang:error(#{gleam_error => assert,
                           message => <<"Assertion pattern match failed"/utf8>>,
                           value => Gleam@Assert@23,
                           module => <<"gleam/uri_test"/utf8>>,
                           function => <<"merge_test"/utf8>>,
                           line => 270})
    end,
    gleam@should:equal(
        gleam@uri:merge(A@23, B@23),
        gleam@uri:parse(<<"http://example.com/foo/bar#fragment"/utf8>>)
    ),
    A@25 = case gleam@uri:parse(<<"http://example.com/foo/bar"/utf8>>) of
        {ok, A@24} -> A@24;
        Gleam@Assert@24 ->
            erlang:error(#{gleam_error => assert,
                           message => <<"Assertion pattern match failed"/utf8>>,
                           value => Gleam@Assert@24,
                           module => <<"gleam/uri_test"/utf8>>,
                           function => <<"merge_test"/utf8>>,
                           line => 274})
    end,
    B@25 = case gleam@uri:parse(<<"?query"/utf8>>) of
        {ok, B@24} -> B@24;
        Gleam@Assert@25 ->
            erlang:error(#{gleam_error => assert,
                           message => <<"Assertion pattern match failed"/utf8>>,
                           value => Gleam@Assert@25,
                           module => <<"gleam/uri_test"/utf8>>,
                           function => <<"merge_test"/utf8>>,
                           line => 275})
    end,
    gleam@should:equal(
        gleam@uri:merge(A@25, B@25),
        gleam@uri:parse(<<"http://example.com/foo/bar?query"/utf8>>)
    ),
    A@27 = case gleam@uri:parse(<<"http://example.com/foo/bar?query1"/utf8>>) of
        {ok, A@26} -> A@26;
        Gleam@Assert@26 ->
            erlang:error(#{gleam_error => assert,
                           message => <<"Assertion pattern match failed"/utf8>>,
                           value => Gleam@Assert@26,
                           module => <<"gleam/uri_test"/utf8>>,
                           function => <<"merge_test"/utf8>>,
                           line => 279})
    end,
    B@27 = case gleam@uri:parse(<<"?query2"/utf8>>) of
        {ok, B@26} -> B@26;
        Gleam@Assert@27 ->
            erlang:error(#{gleam_error => assert,
                           message => <<"Assertion pattern match failed"/utf8>>,
                           value => Gleam@Assert@27,
                           module => <<"gleam/uri_test"/utf8>>,
                           function => <<"merge_test"/utf8>>,
                           line => 280})
    end,
    gleam@should:equal(
        gleam@uri:merge(A@27, B@27),
        gleam@uri:parse(<<"http://example.com/foo/bar?query2"/utf8>>)
    ),
    A@29 = case gleam@uri:parse(<<"http://example.com/foo/bar?query"/utf8>>) of
        {ok, A@28} -> A@28;
        Gleam@Assert@28 ->
            erlang:error(#{gleam_error => assert,
                           message => <<"Assertion pattern match failed"/utf8>>,
                           value => Gleam@Assert@28,
                           module => <<"gleam/uri_test"/utf8>>,
                           function => <<"merge_test"/utf8>>,
                           line => 284})
    end,
    B@29 = case gleam@uri:parse(<<""/utf8>>) of
        {ok, B@28} -> B@28;
        Gleam@Assert@29 ->
            erlang:error(#{gleam_error => assert,
                           message => <<"Assertion pattern match failed"/utf8>>,
                           value => Gleam@Assert@29,
                           module => <<"gleam/uri_test"/utf8>>,
                           function => <<"merge_test"/utf8>>,
                           line => 285})
    end,
    gleam@should:equal(
        gleam@uri:merge(A@29, B@29),
        gleam@uri:parse(<<"http://example.com/foo/bar?query"/utf8>>)
    ).