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

-export([from_string_test/0, compile_test/0, check_test/0, split_test/0, scan_test/0]).

-spec from_string_test() -> gleam@should:expectation().
from_string_test() ->
    Re@1 = case gleam@regex:from_string(<<"[0-9]"/utf8>>) of
        {ok, Re} -> Re;
        Gleam@Assert ->
            erlang:error(#{gleam_error => assert,
                           message => <<"Assertion pattern match failed"/utf8>>,
                           value => Gleam@Assert,
                           module => <<"gleam/regex_test"/utf8>>,
                           function => <<"from_string_test"/utf8>>,
                           line => 7})
    end,
    gleam@should:equal(gleam@regex:check(Re@1, <<"abc123"/utf8>>), true),
    gleam@should:equal(gleam@regex:check(Re@1, <<"abcxyz"/utf8>>), false),
    From_string_err@1 = case gleam@regex:from_string(<<"[0-9"/utf8>>) of
        {error, From_string_err} -> From_string_err;
        Gleam@Assert@1 ->
            erlang:error(#{gleam_error => assert,
                           message => <<"Assertion pattern match failed"/utf8>>,
                           value => Gleam@Assert@1,
                           module => <<"gleam/regex_test"/utf8>>,
                           function => <<"from_string_test"/utf8>>,
                           line => 15})
    end,
    gleam@should:equal(
        From_string_err@1,
        {compile_error, <<"missing terminating ] for character class"/utf8>>, 4}
    ).

-spec compile_test() -> gleam@should:expectation().
compile_test() ->
    Options = {options, true, false},
    Re@1 = case gleam@regex:compile(<<"[A-B]"/utf8>>, Options) of
        {ok, Re} -> Re;
        Gleam@Assert ->
            erlang:error(#{gleam_error => assert,
                           message => <<"Assertion pattern match failed"/utf8>>,
                           value => Gleam@Assert,
                           module => <<"gleam/regex_test"/utf8>>,
                           function => <<"compile_test"/utf8>>,
                           line => 26})
    end,
    gleam@should:equal(gleam@regex:check(Re@1, <<"abc123"/utf8>>), true),
    Options@1 = {options, false, true},
    Re@3 = case gleam@regex:compile(<<"^[0-9]"/utf8>>, Options@1) of
        {ok, Re@2} -> Re@2;
        Gleam@Assert@1 ->
            erlang:error(#{gleam_error => assert,
                           message => <<"Assertion pattern match failed"/utf8>>,
                           value => Gleam@Assert@1,
                           module => <<"gleam/regex_test"/utf8>>,
                           function => <<"compile_test"/utf8>>,
                           line => 32})
    end,
    gleam@should:equal(gleam@regex:check(Re@3, <<"abc\n123"/utf8>>), true).

-spec check_test() -> gleam@should:expectation().
check_test() ->
    Re@1 = case gleam@regex:from_string(<<"^f.o.?"/utf8>>) of
        {ok, Re} -> Re;
        Gleam@Assert ->
            erlang:error(#{gleam_error => assert,
                           message => <<"Assertion pattern match failed"/utf8>>,
                           value => Gleam@Assert,
                           module => <<"gleam/regex_test"/utf8>>,
                           function => <<"check_test"/utf8>>,
                           line => 39})
    end,
    gleam@should:equal(gleam@regex:check(Re@1, <<"foo"/utf8>>), true),
    gleam@should:equal(gleam@regex:check(Re@1, <<"boo"/utf8>>), false).

-spec split_test() -> gleam@should:expectation().
split_test() ->
    Re@1 = case gleam@regex:from_string(<<" *, *"/utf8>>) of
        {ok, Re} -> Re;
        Gleam@Assert ->
            erlang:error(#{gleam_error => assert,
                           message => <<"Assertion pattern match failed"/utf8>>,
                           value => Gleam@Assert,
                           module => <<"gleam/regex_test"/utf8>>,
                           function => <<"split_test"/utf8>>,
                           line => 49})
    end,
    gleam@should:equal(
        gleam@regex:split(Re@1, <<"foo,32, 4, 9  ,0"/utf8>>),
        [<<"foo"/utf8>>,
         <<"32"/utf8>>,
         <<"4"/utf8>>,
         <<"9"/utf8>>,
         <<"0"/utf8>>]
    ).

-spec scan_test() -> gleam@should:expectation().
scan_test() ->
    Re@1 = case gleam@regex:from_string(<<"Gl\\w+"/utf8>>) of
        {ok, Re} -> Re;
        Gleam@Assert ->
            erlang:error(#{gleam_error => assert,
                           message => <<"Assertion pattern match failed"/utf8>>,
                           value => Gleam@Assert,
                           module => <<"gleam/regex_test"/utf8>>,
                           function => <<"scan_test"/utf8>>,
                           line => 56})
    end,
    gleam@should:equal(
        gleam@regex:scan(Re@1, <<"!Gleam"/utf8>>),
        [{match, <<"Gleam"/utf8>>, 1, []}]
    ),
    gleam@should:equal(
        gleam@regex:scan(Re@1, <<"हGleam"/utf8>>),
        [{match, <<"Gleam"/utf8>>, 3, []}]
    ),
    gleam@should:equal(
        gleam@regex:scan(Re@1, <<"𐍈Gleam"/utf8>>),
        [{match, <<"Gleam"/utf8>>, 4, []}]
    ),
    Re@3 = case gleam@regex:from_string(<<"[oi]n a(.?) (\\w+)"/utf8>>) of
        {ok, Re@2} -> Re@2;
        Gleam@Assert@1 ->
            erlang:error(#{gleam_error => assert,
                           message => <<"Assertion pattern match failed"/utf8>>,
                           value => Gleam@Assert@1,
                           module => <<"gleam/regex_test"/utf8>>,
                           function => <<"scan_test"/utf8>>,
                           line => 67})
    end,
    gleam@should:equal(
        gleam@regex:scan(Re@3, <<"I am on a boat in a lake."/utf8>>),
        [{match, <<"on a boat"/utf8>>, 5, [none, {some, <<"boat"/utf8>>}]},
         {match, <<"in a lake"/utf8>>, 15, [none, {some, <<"lake"/utf8>>}]}]
    ).