-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() -> {ok, gleam@regex:regex()} |
    {error, gleam@regex:compile_error()}.
from_string_test() ->
    {ok, Re@1} = case gleam@regex:from_string(<<"[0-9]"/utf8>>) of
        {ok, Re} -> {ok, Re};
        _try ->
            erlang:error(#{gleam_error => assert,
                           message => <<"Assertion pattern match failed"/utf8>>,
                           value => _try,
                           module => <<"gleam/regex_test"/utf8>>,
                           function => <<"from_string_test"/utf8>>,
                           line => 7})
    end,
    _pipe = gleam@regex:check(Re@1, <<"abc123"/utf8>>),
    gleam@should:equal(_pipe, true),
    _pipe@1 = gleam@regex:check(Re@1, <<"abcxyz"/utf8>>),
    gleam@should:equal(_pipe@1, false),
    {error, _@2} = case gleam@regex:from_string(<<"[0-9"/utf8>>) of
        {error, _@1} -> {error, _@1};
        _try@1 ->
            erlang:error(#{gleam_error => assert,
                           message => <<"Assertion pattern match failed"/utf8>>,
                           value => _try@1,
                           module => <<"gleam/regex_test"/utf8>>,
                           function => <<"from_string_test"/utf8>>,
                           line => 15})
    end.

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

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

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

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