diff options
Diffstat (limited to 'lib/stdlib/test/re_SUITE.erl')
| -rw-r--r-- | lib/stdlib/test/re_SUITE.erl | 526 |
1 files changed, 526 insertions, 0 deletions
diff --git a/lib/stdlib/test/re_SUITE.erl b/lib/stdlib/test/re_SUITE.erl new file mode 100644 index 0000000000..98eb66d1fb --- /dev/null +++ b/lib/stdlib/test/re_SUITE.erl @@ -0,0 +1,526 @@ +%% +%% %CopyrightBegin% +%% +%% Copyright Ericsson AB 2008-2009. All Rights Reserved. +%% +%% The contents of this file are subject to the Erlang Public License, +%% Version 1.1, (the "License"); you may not use this file except in +%% compliance with the License. You should have received a copy of the +%% Erlang Public License along with this software. If not, it can be +%% retrieved online at http://www.erlang.org/. +%% +%% Software distributed under the License is distributed on an "AS IS" +%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See +%% the License for the specific language governing rights and limitations +%% under the License. +%% +%% %CopyrightEnd% +%% +-module(re_SUITE). + +-export([all/1, pcre/1,compile_options/1,run_options/1,combined_options/1,replace_autogen/1,global_capture/1,replace_return/1,split_autogen/1,split_options/1,split_specials/1,error_handling/1]). + +-include("test_server.hrl"). +-include_lib("kernel/include/file.hrl"). + +all(suite) -> [pcre,compile_options,run_options,combined_options,replace_autogen,global_capture,replace_return,split_autogen,split_options,split_specials,error_handling]. + +pcre(doc) -> + ["Run all applicable tests from the PCRE testsuites."]; +pcre(Config) when is_list(Config) -> + Dog = ?t:timetrap(?t:minutes(3)), + RootDir = ?config(data_dir, Config), + Res = run_pcre_tests:test(RootDir), + 0 = lists:sum([ X || {X,_,_} <- Res ]), + ?t:timetrap_cancel(Dog), + {comment,Res}. + +compile_options(doc) -> + ["Test all documented compile options"]; +compile_options(Config) when is_list(Config) -> + ?line ok = ctest("ABDabcdABCD","abcd",[],true,{match,[{3,4}]}), + ?line ok = ctest("ABDabcdABCD","abcd",[anchored],true,nomatch), + ?line ok = ctest("ABDabcdABCD",".*abcd",[anchored],true,{match,[{0,7}]}), + ?line ok = ctest("ABCabcdABC","ABCD",[],true,nomatch), + ?line ok = ctest("ABCabcdABC","ABCD",[caseless],true,{match,[{3,4}]}), + ?line ok = ctest("abcdABC\n","ABC$",[],true,{match,[{4,3}]}), + ?line ok = ctest("abcdABC\n","ABC$",[dollar_endonly],true,nomatch), + ?line ok = ctest("abcdABC\n","ABC.",[],true,nomatch), + ?line ok = ctest("abcdABC\n","ABC.",[dotall],true,{match,[{4,4}]}), + ?line ok = ctest("abcdABCD","ABC .",[],true,nomatch), + ?line ok = ctest("abcdABCD","ABC .",[extended],true,{match,[{4,4}]}), + ?line ok = ctest("abcd\nABCD","ABC",[],true,{match,[{5,3}]}), + ?line ok = ctest("abcd\nABCD","ABC",[firstline],true,nomatch), + ?line ok = ctest("abcd\nABCD","^ABC",[],true,nomatch), + ?line ok = ctest("abcd\nABCD","^ABC",[multiline],true,{match,[{5,3}]}), + ?line ok = ctest("abcdABCD","(ABC)",[],true,{match,[{4,3},{4,3}]}), + ?line ok = ctest("abcdABCD","(ABC)",[no_auto_capture],true,{match,[{4,3}]}), + ?line ok = ctest(notused,"(?<FOO>ABC)|(?<FOO>DEF)",[],false,notused), + ?line ok = ctest("abcdABCD","(?<FOO>ABC)|(?<FOO>DEF)",[dupnames],true,{match,[{4,3},{4,3}]}), + ?line ok = ctest("abcdABCDabcABCD","abcd.*D",[],true,{match,[{0,15}]}), + ?line ok = ctest("abcdABCDabcABCD","abcd.*D",[ungreedy],true,{match,[{0,8}]}), + ?line ok = ctest("abcdABCabcABC\nD","abcd.*D",[],true,nomatch), + ?line ok = ctest("abcdABCabcABC\nD","abcd.*D",[{newline,cr}],true,{match,[{0,15}]}), + ?line ok = ctest("abcdABCabcABC\rD","abcd.*D",[],true,{match,[{0,15}]}), + ?line ok = ctest("abcdABCabcABC\rD","abcd.*D",[{newline,lf}],true,{match,[{0,15}]}), + ?line ok = ctest("abcdABCabcd\r\n","abcd$",[{newline,lf}],true,nomatch), + ?line ok = ctest("abcdABCabcd\r\n","abcd$",[{newline,cr}],true,nomatch), + ?line ok = ctest("abcdABCabcd\r\n","abcd$",[{newline,crlf}],true,{match,[{7,4}]}), + + ?line ok = ctest("abcdABCabcd\r","abcd$",[{newline,crlf}],true,nomatch), + ?line ok = ctest("abcdABCabcd\n","abcd$",[{newline,crlf}],true,nomatch), + ?line ok = ctest("abcdABCabcd\r\n","abcd$",[{newline,anycrlf}],true,{match,[{7,4}]}), + + ?line ok = ctest("abcdABCabcd\r","abcd$",[{newline,anycrlf}],true,{match,[{7,4}]}), + ?line ok = ctest("abcdABCabcd\n","abcd$",[{newline,anycrlf}],true,{match,[{7,4}]}), + ok. + +run_options(doc) -> + ["Test all documented run specific options"]; +run_options(Config) when is_list(Config) -> + ?line rtest("ABCabcdABC","abc",[],[],true), + ?line rtest("ABCabcdABC","abc",[anchored],[],false), + % Anchored in run overrides unanchored in compilation + ?line rtest("ABCabcdABC","abc",[],[anchored],false), + + ?line rtest("","a?b?",[],[],true), + ?line rtest("","a?b?",[],[notempty],false), + + ?line rtest("abc","^a",[],[],true), + ?line rtest("abc","^a",[],[notbol],false), + ?line rtest("ab\nc","^a",[multiline],[],true), + ?line rtest("ab\nc","^a",[multiline],[notbol],false), + ?line rtest("ab\nc","^c",[multiline],[notbol],true), + + ?line rtest("abc","c$",[],[],true), + ?line rtest("abc","c$",[],[noteol],false), + + ?line rtest("ab\nc","b$",[multiline],[],true), + ?line rtest("ab\nc","c$",[multiline],[],true), + ?line rtest("ab\nc","b$",[multiline],[noteol],true), + ?line rtest("ab\nc","c$",[multiline],[noteol],false), + + ?line rtest("abc","ab",[],[{offset,0}],true), + ?line rtest("abc","ab",[],[{offset,1}],false), + + ?line rtest("abcdABCabcABC\nD","abcd.*D",[],[],false), + ?line rtest("abcdABCabcABC\nD","abcd.*D",[],[{newline,cr}],true), + ?line rtest("abcdABCabcABC\rD","abcd.*D",[],[],true), + ?line rtest("abcdABCabcABC\rD","abcd.*D",[{newline,cr}],[{newline,lf}],true), + ?line rtest("abcdABCabcd\r\n","abcd$",[],[{newline,lf}],false), + ?line rtest("abcdABCabcd\r\n","abcd$",[],[{newline,cr}],false), + ?line rtest("abcdABCabcd\r\n","abcd$",[],[{newline,crlf}],true), + + ?line rtest("abcdABCabcd\r","abcd$",[],[{newline,crlf}],false), + ?line rtest("abcdABCabcd\n","abcd$",[],[{newline,crlf}],false), + ?line rtest("abcdABCabcd\r\n","abcd$",[],[{newline,anycrlf}],true), + + ?line rtest("abcdABCabcd\r","abcd$",[],[{newline,anycrlf}],true), + ?line rtest("abcdABCabcd\n","abcd$",[],[{newline,anycrlf}],true), + + ?line {ok,MP} = re:compile(".*(abcd).*"), + ?line {match,[{0,10},{3,4}]} = re:run("ABCabcdABC",MP,[]), + ?line {match,[{0,10},{3,4}]} = re:run("ABCabcdABC",MP,[{capture,all}]), + ?line {match,[{0,10},{3,4}]} = re:run("ABCabcdABC",MP,[{capture,all,index}]), + ?line {match,["ABCabcdABC","abcd"]} = re:run("ABCabcdABC",MP,[{capture,all,list}]), + ?line {match,[<<"ABCabcdABC">>,<<"abcd">>]} = re:run("ABCabcdABC",MP,[{capture,all,binary}]), + ?line {match,[{0,10}]} = re:run("ABCabcdABC",MP,[{capture,first}]), + ?line {match,[{0,10}]} = re:run("ABCabcdABC",MP,[{capture,first,index}]), ?line {match,["ABCabcdABC"]} = re:run("ABCabcdABC",MP,[{capture,first,list}]), + ?line {match,[<<"ABCabcdABC">>]} = re:run("ABCabcdABC",MP,[{capture,first,binary}]), + + ?line {match,[{3,4}]} = re:run("ABCabcdABC",MP,[{capture,all_but_first}]), + ?line {match,[{3,4}]} = re:run("ABCabcdABC",MP,[{capture,all_but_first,index}]), + ?line {match,["abcd"]} = re:run("ABCabcdABC",MP,[{capture,all_but_first,list}]), + ?line {match,[<<"abcd">>]} = re:run("ABCabcdABC",MP,[{capture,all_but_first,binary}]), + + ?line match = re:run("ABCabcdABC",MP,[{capture,none}]), + ?line match = re:run("ABCabcdABC",MP,[{capture,none,index}]), + ?line match = re:run("ABCabcdABC",MP,[{capture,none,list}]), + ?line match = re:run("ABCabcdABC",MP,[{capture,none,binary}]), + + ?line {ok,MP2} = re:compile(".*(?<FOO>abcd).*"), + ?line {match,[{3,4}]} = re:run("ABCabcdABC",MP2,[{capture,[1]}]), + ?line {match,[{3,4}]} = re:run("ABCabcdABC",MP2,[{capture,['FOO']}]), + ?line {match,[{3,4}]} = re:run("ABCabcdABC",MP2,[{capture,["FOO"]}]), + ?line {match,["abcd"]} = re:run("ABCabcdABC",MP2,[{capture,["FOO"],list}]), + ?line {match,[<<"abcd">>]} = re:run("ABCabcdABC",MP2,[{capture,["FOO"],binary}]), + + ?line {match,[{-1,0}]} = re:run("ABCabcdABC",MP2,[{capture,[200]}]), + ?line {match,[{-1,0}]} = re:run("ABCabcdABC",MP2,[{capture,['BAR']}]), + ?line {match,[""]} = re:run("ABCabcdABC",MP2,[{capture,[200],list}]), + ?line {match,[""]} = re:run("ABCabcdABC",MP2,[{capture,['BAR'],list}]), + ?line {match,[<<>>]} = re:run("ABCabcdABC",MP2,[{capture,[200],binary}]), + ?line {match,[<<>>]} = re:run("ABCabcdABC",MP2,[{capture,['BAR'],binary}]), + + ?line {ok, MP3} = re:compile(".*((?<FOO>abdd)|a(..d)).*"), + ?line {match,[{0,10},{3,4},{-1,0},{4,3}]} = re:run("ABCabcdABC",MP3,[]), + ?line {match,[{0,10},{3,4},{-1,0},{4,3}]} = re:run("ABCabcdABC",MP3,[{capture,all,index}]), + ?line {match,[<<"ABCabcdABC">>,<<"abcd">>,<<>>,<<"bcd">>]} = re:run("ABCabcdABC",MP3,[{capture,all,binary}]), + ?line {match,["ABCabcdABC","abcd",[],"bcd"]} = re:run("ABCabcdABC",MP3,[{capture,all,list}]), + ok. + + + +combined_options(doc) -> + ["Test compile options given directly to run"]; +combined_options(Config) when is_list(Config) -> + ?line ok = crtest("ABDabcdABCD","abcd",[],true,{match,[{3,4}]}), + ?line ok = crtest("ABDabcdABCD","abcd",[anchored],true,nomatch), + ?line ok = crtest("ABDabcdABCD",".*abcd",[anchored],true,{match,[{0,7}]}), + ?line ok = crtest("ABCabcdABC","ABCD",[],true,nomatch), + ?line ok = crtest("ABCabcdABC","ABCD",[caseless],true,{match,[{3,4}]}), + ?line ok = crtest("abcdABC\n","ABC$",[],true,{match,[{4,3}]}), + ?line ok = crtest("abcdABC\n","ABC$",[dollar_endonly],true,nomatch), + ?line ok = crtest("abcdABC\n","ABC.",[],true,nomatch), + ?line ok = crtest("abcdABC\n","ABC.",[dotall],true,{match,[{4,4}]}), + ?line ok = crtest("abcdABCD","ABC .",[],true,nomatch), + ?line ok = crtest("abcdABCD","ABC .",[extended],true,{match,[{4,4}]}), + ?line ok = crtest("abcd\nABCD","ABC",[],true,{match,[{5,3}]}), + ?line ok = crtest("abcd\nABCD","ABC",[firstline],true,nomatch), + ?line ok = crtest("abcd\nABCD","^ABC",[],true,nomatch), + ?line ok = crtest("abcd\nABCD","^ABC",[multiline],true,{match,[{5,3}]}), + ?line ok = crtest("abcdABCD","(ABC)",[],true,{match,[{4,3},{4,3}]}), + ?line ok = crtest("abcdABCD","(ABC)",[no_auto_capture],true,{match,[{4,3}]}), + ?line ok = crtest(notused,"(?<FOO>ABC)|(?<FOO>DEF)",[],false,notused), + ?line ok = crtest("abcdABCD","(?<FOO>ABC)|(?<FOO>DEF)",[dupnames],true,{match,[{4,3},{4,3}]}), + ?line ok = crtest("abcdABCDabcABCD","abcd.*D",[],true,{match,[{0,15}]}), + ?line ok = crtest("abcdABCDabcABCD","abcd.*D",[ungreedy],true,{match,[{0,8}]}), + ?line ok = ctest("abcdABCabcABC\nD","abcd.*D",[],true,nomatch), + ?line ok = crtest("abcdABCabcABC\nD","abcd.*D",[{newline,cr}],true,{match,[{0,15}]}), + ?line ok = crtest("abcdABCabcABC\rD","abcd.*D",[],true,{match,[{0,15}]}), + ?line ok = crtest("abcdABCabcABC\rD","abcd.*D",[{newline,lf}],true,{match,[{0,15}]}), + ?line ok = crtest("abcdABCabcd\r\n","abcd$",[{newline,lf}],true,nomatch), + ?line ok = crtest("abcdABCabcd\r\n","abcd$",[{newline,cr}],true,nomatch), + ?line ok = crtest("abcdABCabcd\r\n","abcd$",[{newline,crlf}],true,{match,[{7,4}]}), + + ?line ok = crtest("abcdABCabcd\r","abcd$",[{newline,crlf}],true,nomatch), + ?line ok = crtest("abcdABCabcd\n","abcd$",[{newline,crlf}],true,nomatch), + ?line ok = crtest("abcdABCabcd\r\n","abcd$",[{newline,anycrlf}],true,{match,[{7,4}]}), + + ?line ok = crtest("abcdABCabcd\r","abcd$",[{newline,anycrlf}],true,{match,[{7,4}]}), + ?line ok = crtest("abcdABCabcd\n","abcd$",[{newline,anycrlf}],true,{match,[{7,4}]}), + + ?line ok = crtest("abcdABCabcd\r\n","abcd$",[{newline,anycrlf},{capture,all,list}],true,{match,["abcd"]}), + + ?line ok = crtest("abcdABCabcd\r","abcd$",[{newline,anycrlf},{capture,all,list}],true,{match,["abcd"]}), + + ?line ok = crtest("abcdABCabcd\n","abcd$",[{newline,anycrlf},{capture,all,list}],true,{match,["abcd"]}), + + ?line ok = crtest("abcdABCabcd\r\n","abcd$",[{newline,anycrlf},{capture,all,binary}],true,{match,[<<"abcd">>]}), + + ?line ok = crtest("abcdABCabcd\r","abcd$",[{newline,anycrlf},{capture,all,binary}],true,{match,[<<"abcd">>]}), + ?line ok = crtest("abcdABCabcd\n","abcd$",[{newline,anycrlf},{capture,all,binary}],true,{match,[<<"abcd">>]}), + + % Check that unique run-options fail in compile only case: + ?line {'EXIT',{badarg,_}} = (catch re:compile("abcd$",[{newline,anycrlf},{capture,all,binary}])), + ?line {'EXIT',{badarg,_}} = (catch re:compile("abcd$",[{newline,anycrlf},{offset,3}])), + ?line {'EXIT',{badarg,_}} = (catch re:compile("abcd$",[{newline,anycrlf},notempty])), + ?line {'EXIT',{badarg,_}} = (catch re:compile("abcd$",[{newline,anycrlf},notbol])), + ?line {'EXIT',{badarg,_}} = (catch re:compile("abcd$",[{newline,anycrlf},noteol])), + + + ?line {match,_} = re:run("abcdABCabcd\r\n","abcd$",[{newline,crlf}]), + ?line nomatch = re:run("abcdABCabcd\r\nefgh","abcd$",[{newline,crlf}]), + ?line {match,_} = re:run("abcdABCabcd\r\nefgh","abcd$",[{newline,crlf},multiline]), + ?line nomatch = re:run("abcdABCabcd\r\nefgh","efgh$",[{newline,crlf},multiline,noteol]), + ?line {match,_} = re:run("abcdABCabcd\r\nefgh","abcd$",[{newline,crlf},multiline,noteol]), + ?line {match,_} = re:run("abcdABCabcd\r\nefgh","^abcd",[{newline,crlf},multiline,noteol]), + ?line nomatch = re:run("abcdABCabcd\r\nefgh","^abcd",[{newline,crlf},multiline,notbol]), + ?line {match,_} = re:run("abcdABCabcd\r\nefgh","^efgh",[{newline,crlf},multiline,notbol]), + ?line {match,_} = re:run("ABC\nD","[a-z]*",[{newline,crlf}]), + ?line nomatch = re:run("ABC\nD","[a-z]*",[{newline,crlf},notempty]), + ok. + +replace_autogen(doc) -> + ["Test replace with autogenerated erlang module"]; +replace_autogen(Config) when is_list(Config) -> + Dog = ?t:timetrap(?t:minutes(3)), + re_testoutput1_replacement_test:run(), + ?t:timetrap_cancel(Dog), + ok. + +global_capture(doc) -> + ["Tests capture options together with global searching"]; +global_capture(Config) when is_list(Config) -> + Dog = ?t:timetrap(?t:minutes(3)), + ?line {match,[{3,4}]} = re:run("ABCabcdABC",".*(?<FOO>abcd).*",[{capture,[1]}]), + ?line {match,[{10,4}]} = re:run("ABCabcdABCabcdA",".*(?<FOO>abcd).*",[{capture,[1]}]), + ?line {match,[[{10,4}]]} = re:run("ABCabcdABCabcdA",".*(?<FOO>abcd).*",[global,{capture,[1]}]), + ?line {match,[{3,4}]} = re:run("ABCabcdABC",".*(?<FOO>abcd).*",[{capture,['FOO']}]), + ?line {match,[{10,4}]} = re:run("ABCabcdABCabcdA",".*(?<FOO>abcd).*",[{capture,['FOO']}]), + ?line {match,[[{10,4}]]} = re:run("ABCabcdABCabcdA",".*(?<FOO>abcd).*",[global,{capture,['FOO']}]), + ?line {match,[[{3,4},{3,4}],[{10,4},{10,4}]]} = re:run("ABCabcdABCabcdA","(?<FOO>abcd)",[global]), + ?line {match,[[{3,4},{3,4}],[{10,4},{10,4}]]} = re:run("ABCabcdABCabcdA","(?<FOO>abcd)",[global,{capture,all}]), + ?line {match,[[{3,4},{3,4}],[{10,4},{10,4}]]} = re:run("ABCabcdABCabcdA","(?<FOO>abcd)",[global,{capture,all,index}]), + ?line {match,[[{3,4}],[{10,4}]]} = re:run("ABCabcdABCabcdA","(?<FOO>abcd)",[global,{capture,first}]), + ?line {match,[[{3,4}],[{10,4}]]} = re:run("ABCabcdABCabcdA","(?<FOO>abcd)",[global,{capture,all_but_first}]), + ?line {match,[[<<"bcd">>],[<<"bcd">>]]} = re:run("ABCabcdABCabcdA","a(?<FOO>bcd)",[global,{capture,all_but_first,binary}]), + ?line {match,[["bcd"],["bcd"]]} = re:run("ABCabcdABCabcdA","a(?<FOO>bcd)",[global,{capture,all_but_first,list}]), + ?line {match,[["abcd","bcd"],["abcd","bcd"]]} = re:run("ABCabcdABCabcdA","a(?<FOO>bcd)",[global,{capture,all,list}]), + ?line {match,[[<<"abcd">>,<<"bcd">>],[<<"abcd">>,<<"bcd">>]]} = re:run("ABCabcdABCabcdA","a(?<FOO>bcd)",[global,{capture,all,binary}]), + ?line {match,[[{3,4},{4,3}],[{10,4},{11,3}]]} = re:run("ABCabcdABCabcdA","a(?<FOO>bcd)",[global,{capture,all,index}]), + ?line match = re:run("ABCabcdABCabcdA","a(?<FOO>bcd)",[global,{capture,none,index}]), + ?line match = re:run("ABCabcdABCabcdA","a(?<FOO>bcd)",[global,{capture,none,binary}]), + ?line match = re:run("ABCabcdABCabcdA","a(?<FOO>bcd)",[global,{capture,none,list}]), + ?line {match,[[<<195,133,98,99,100>>,<<"bcd">>],[<<"abcd">>,<<"bcd">>]]} = re:run("ABC�bcdABCabcdA",".(?<FOO>bcd)",[global,{capture,all,binary},unicode]), + ?line {match,[["�bcd","bcd"],["abcd","bcd"]]} = re:run(<<"ABC",8#303,8#205,"bcdABCabcdA">>,".(?<FOO>bcd)",[global,{capture,all,list},unicode]), + ?line {match,[["�bcd","bcd"],["abcd","bcd"]]} = re:run("ABC�bcdABCabcdA",".(?<FOO>bcd)",[global,{capture,all,list},unicode]), + ?line {match,[[{3,5},{5,3}],[{11,4},{12,3}]]} = re:run("ABC�bcdABCabcdA",".(?<FOO>bcd)",[global,{capture,all,index},unicode]), + ?t:timetrap_cancel(Dog), + ok. + +replace_return(doc) -> + ["Tests return options of replace together with global searching"]; +replace_return(Config) when is_list(Config) -> + Dog = ?t:timetrap(?t:minutes(3)), + ?line {'EXIT',{badarg,_}} = (catch re:replace("na","(a","")), + ?line <<"nasse">> = re:replace(<<"nisse">>,"i","a",[{return,binary}]), + ?line <<"ABC�XABCXA">> = re:replace("ABC\305abcdABCabcdA","a(?<FOO>bcd)","X",[global,{return,binary}]), + + ?line [<<"ABC�">>, + <<"X">>, + <<"ABC">>, + <<"X">> | + <<"A">> ] = + re:replace("ABC�abcdABCabcdA","a(?<FOO>bcd)","X",[global,{return,iodata}]), + ?line "ABC�XABCXA" = re:replace("ABC�abcdABCabcdA","a(?<FOO>bcd)","X",[global,{return,list},unicode]), + ?line <<65,66,67,195,133,88,65,66,67,88,65>> = re:replace("ABC�abcdABCabcdA","a(?<FOO>bcd)","X",[global,{return,binary},unicode]), + ?line <<65,66,67,195,133,88,65,66,67,97,98,99,100,65>> = re:replace("ABC�abcdABCabcdA","a(?<FOO>bcd)","X",[{return,binary},unicode]), + ?line <<"iXk">> = re:replace("abcdefghijk","(.)(.)(.)(.)(.)(.)(.)(.)(.)(.)","\\9X",[{return,binary}]), + ?line <<"jXk">> = re:replace("abcdefghijk","(.)(.)(.)(.)(.)(.)(.)(.)(.)(.)","\\10X",[{return,binary}]), + ?line <<"Xk">> = re:replace("abcdefghijk","(.)(.)(.)(.)(.)(.)(.)(.)(.)(.)","\\11X",[{return,binary}]), + ?t:timetrap_cancel(Dog), + ok. + +rtest(Subj, RE, Copt, Ropt, true) -> + {ok,MP} = re:compile(RE,Copt), + {match,_} = re:run(Subj,MP,Ropt), + ok; +rtest(Subj, RE, Copt, Ropt, false) -> + {ok,MP} = re:compile(RE,Copt), + nomatch = re:run(Subj,MP,Ropt), + ok. + +ctest(_,RE,Options,false,_) -> + case re:compile(RE,Options) of + {ok,_} -> + error; + {error,_} -> + ok + end; +ctest(Subject,RE,Options,true,Result) -> + try + {ok, Prog} = re:compile(RE,Options), + Result = re:run(Subject,Prog,[]), + ok + catch + _:_ -> + error + end. +crtest(_,RE,Options,false,_) -> + case (catch re:run("",RE,Options)) of + {'EXIT',{badarg,_}} -> + ok; + _ -> + error + end; +crtest(Subject,RE,Options,true,Result) -> + try + Result = re:run(Subject,RE,Options), + ok + catch + _:_ -> + error + end. + +split_autogen(doc) -> + ["Test split with autogenerated erlang module"]; +split_autogen(Config) when is_list(Config) -> + Dog = ?t:timetrap(?t:minutes(3)), + re_testoutput1_split_test:run(), + ?t:timetrap_cancel(Dog), + ok. + +split_options(doc) -> + ["Test special options to split."]; +split_options(Config) when is_list(Config) -> + Dog = ?t:timetrap(?t:minutes(1)), + ?line [[<<"a">>,<<" ">>],[<<"b">>,<<" ">>],[<<"c">>,<<" ">>]] = re:split("a b c ","( )",[group,trim]), + ?line [[<<"a">>,<<" ">>],[<<"b">>,<<" ">>],[<<"c">>,<<" ">>]] = re:split("a b c ","( )",[group,{parts,0}]), + ?line [[<<"a">>,<<" ">>],[<<"b">>,<<" ">>],[<<"c">>,<<" ">>],[<<>>]] = + re:split("a b c ","( )",[{parts,infinity},group]), + ?line [[<<"a">>,<<" ">>],[<<"b">>,<<" ">>],[<<"c">>,<<" ">>],[<<>>]] = + re:split("a b c ","( )",[group]), + ?line [[<<>>,<<" ">>],[<<"a">>,<<" ">>],[<<"b">>,<<" ">>], + [<<"c">>,<<" ">>],[<<"d">>,<<" ">>]] = + re:split(" a b c d ","( +)",[group,trim]), + ?line [[<<>>,<<" ">>],[<<"a">>,<<" ">>],[<<"b">>,<<" ">>], + [<<"c">>,<<" ">>],[<<"d">>,<<" ">>]] = + re:split(" a b c d ","( +)",[{parts,0},group]), + ?line [[<<>>,<<" ">>],[<<"a">>,<<" ">>],[<<"b">>,<<" ">>], + [<<"c">>,<<" ">>],[<<"d">>,<<" ">>],[<<>>]] = + re:split(" a b c d ","( +)",[{parts,infinity},group]), + ?line [[<<"a">>,<<" ">>],[<<"b c d">>]] = + re:split("a b c d","( +)",[{parts,2},group]), + ?line [[[967]," "],["b c d"]] = + re:split([967]++" b c d","( +)", + [{parts,2},group,{return,list},unicode]), + ?line [[<<207,135>>,<<" ">>],[<<"b c d">>]] = + re:split([967]++" b c d","( +)", + [{parts,2},group,{return,binary},unicode]), + ?line {'EXIT',{badarg,_}} = + (catch re:split([967]++" b c d","( +)", + [{parts,2},group,{return,binary}])), + ?line {'EXIT',{badarg,_}} = + (catch re:split("a b c d","( +)",[{parts,-2}])), + ?line {'EXIT',{badarg,_}} = + (catch re:split("a b c d","( +)",[{parts,banan}])), + ?line {'EXIT',{badarg,_}} = + (catch re:split("a b c d","( +)",[{capture,all}])), + ?line {'EXIT',{badarg,_}} = + (catch re:split("a b c d","( +)",[{capture,[],binary}])), + % Parts 0 is equal to no parts specification (implicit strip) + ?line ["a"," ","b"," ","c"," ","d"] = + re:split("a b c d","( *)",[{parts,0},{return,list}]), + ?t:timetrap_cancel(Dog), + ok. + +join([]) -> []; +join([A]) -> [A]; +join([H|T]) -> [H,<<":">>|join(T)]. + +split_specials(doc) -> + ["Some special cases of split that are easy to get wrong."]; +split_specials(Config) when is_list(Config) -> + %% More or less just to remember these icky cases + Dog = ?t:timetrap(?t:minutes(1)), + ?line <<"::abd:f">> = + iolist_to_binary(join(re:split("abdf","^(?!(ab)de|x)(abd)(f)",[trim]))), + ?line <<":abc2xyzabc3">> = + iolist_to_binary(join(re:split("abc1abc2xyzabc3","\\Aabc.",[trim]))), + ?t:timetrap_cancel(Dog), + ok. + + +error_handling(doc) -> + ["Test that errors are handled correctly by the erlang code."]; +error_handling(Config) when is_list(Config) -> + % This test checks the exception tuples manufactured in the erlang + % code to hide the trapping from the user at least when it comes to errors + Dog = ?t:timetrap(?t:minutes(1)), + % The malformed precomiled RE is detected after + % the trap to re:grun from grun, in the grun function clause + % that handles precompiled expressions + ?line {'EXIT',{badarg,[{re,run,["apa",{1,2,3,4},[global]]}, + {?MODULE, error_handling,1} | _]}} = + (catch re:run("apa",{1,2,3,4},[global])), + % An invalid capture list will also cause a badarg late, + % but with a non pre compiled RE, the exception should be thrown by the + % grun function clause that handles RE's compiled implicitly by + % the run/3 BIF before trapping. + ?line {'EXIT',{badarg,[{re,run,["apa","p",[{capture,[1,{a}]},global]]}, + {?MODULE, error_handling,1} | _]}} = + (catch re:run("apa","p",[{capture,[1,{a}]},global])), + % And so the case of a precompiled expression together with + % a compile-option (binary and list subject): + ?line {ok,RE} = re:compile("(p)"), + ?line {match,[[{1,1},{1,1}]]} = re:run(<<"apa">>,RE,[global]), + ?line {match,[[{1,1},{1,1}]]} = re:run("apa",RE,[global]), + {'EXIT',{badarg,[{re,run, + [<<"apa">>, + {re_pattern,1,0,_}, + [global,unicode]]}, + {?MODULE, error_handling,1} | _]}} = + (catch re:run(<<"apa">>,RE,[global,unicode])), + {'EXIT',{badarg,[{re,run, + ["apa", + {re_pattern,1,0,_}, + [global,unicode]]}, + {?MODULE, error_handling,1} | _]}} = + (catch re:run("apa",RE,[global,unicode])), + ?line {'EXIT',{badarg,_}} = (catch re:run("apa","(p",[])), + ?line {'EXIT',{badarg,_}} = (catch re:run("apa","(p",[global])), + % The replace errors: + ?line {'EXIT',{badarg,[{re,replace,["apa",{1,2,3,4},"X",[]]}, + {?MODULE, error_handling,1} | _]}} = + (catch re:replace("apa",{1,2,3,4},"X",[])), + ?line {'EXIT',{badarg,[{re,replace,["apa",{1,2,3,4},"X",[global]]}, + {?MODULE, error_handling,1} | _]}} = + (catch re:replace("apa",{1,2,3,4},"X",[global])), + ?line {'EXIT',{badarg,[{re,replace, + ["apa", + {re_pattern,1,0,_}, + "X", + [unicode]]}, + {?MODULE, error_handling,1} | _]}} = + (catch re:replace("apa",RE,"X",[unicode])), + ?line <<"aXa">> = iolist_to_binary(re:replace("apa","p","X",[])), + ?line {'EXIT',{badarg,[{re,replace, + ["apa","p","X",[{capture,all,binary}]]}, + {?MODULE, error_handling,1} | _]}} = + (catch iolist_to_binary(re:replace("apa","p","X", + [{capture,all,binary}]))), + ?line {'EXIT',{badarg,[{re,replace, + ["apa","p","X",[{capture,all}]]}, + {?MODULE, error_handling,1} | _]}} = + (catch iolist_to_binary(re:replace("apa","p","X", + [{capture,all}]))), + ?line {'EXIT',{badarg,[{re,replace, + ["apa","p","X",[{return,banana}]]}, + {?MODULE, error_handling,1} | _]}} = + (catch iolist_to_binary(re:replace("apa","p","X", + [{return,banana}]))), + ?line {'EXIT',{badarg,_}} = (catch re:replace("apa","(p","X",[])), + % Badarg, not compile error. + ?line {'EXIT',{badarg,[{re,replace, + ["apa","(p","X",[{return,banana}]]}, + {?MODULE, error_handling,1} | _]}} = + (catch iolist_to_binary(re:replace("apa","(p","X", + [{return,banana}]))), + % And the split errors: + ?line [<<"a">>,<<"a">>] = (catch re:split("apa","p",[])), + ?line [<<"a">>,<<"p">>,<<"a">>] = (catch re:split("apa",RE,[])), + ?line {'EXIT',{badarg,[{re,split,["apa","p",[global]]}, + {?MODULE, error_handling,1} | _]}} = + (catch re:split("apa","p",[global])), + ?line {'EXIT',{badarg,[{re,split,["apa","p",[{capture,all}]]}, + {?MODULE, error_handling,1} | _]}} = + (catch re:split("apa","p",[{capture,all}])), + ?line {'EXIT',{badarg,[{re,split,["apa","p",[{capture,all,binary}]]}, + {?MODULE, error_handling,1} | _]}} = + (catch re:split("apa","p",[{capture,all,binary}])), + ?line {'EXIT',{badarg,[{re,split,["apa",{1,2,3,4},[]]}, + {?MODULE, error_handling,1} | _]}} = + (catch re:split("apa",{1,2,3,4})), + ?line {'EXIT',{badarg,[{re,split,["apa",{1,2,3,4},[]]}, + {?MODULE, error_handling,1} | _]}} = + (catch re:split("apa",{1,2,3,4},[])), + ?line {'EXIT',{badarg,[{re,split, + ["apa", + RE, + [unicode]]}, + {?MODULE, error_handling,1} | _]}} = + (catch re:split("apa",RE,[unicode])), + ?line {'EXIT',{badarg,[{re,split, + ["apa", + RE, + [{return,banana}]]}, + {?MODULE, error_handling,1} | _]}} = + (catch re:split("apa",RE,[{return,banana}])), + ?line {'EXIT',{badarg,[{re,split, + ["apa", + RE, + [banana]]}, + {?MODULE, error_handling,1} | _]}} = + (catch re:split("apa",RE,[banana])), + ?line {'EXIT',{badarg,_}} = (catch re:split("apa","(p")), + %Exception on bad argument, not compilation error + ?line {'EXIT',{badarg,[{re,split, + ["apa", + "(p", + [banana]]}, + {?MODULE, error_handling,1} | _]}} = + (catch re:split("apa","(p",[banana])), + ?t:timetrap_cancel(Dog), + ok. + |