diff options
Diffstat (limited to 'lib/stdlib/test/io_SUITE.erl')
| -rw-r--r-- | lib/stdlib/test/io_SUITE.erl | 1900 |
1 files changed, 1900 insertions, 0 deletions
diff --git a/lib/stdlib/test/io_SUITE.erl b/lib/stdlib/test/io_SUITE.erl new file mode 100644 index 0000000000..73efeb004a --- /dev/null +++ b/lib/stdlib/test/io_SUITE.erl @@ -0,0 +1,1900 @@ +%% +%% %CopyrightBegin% +%% +%% Copyright Ericsson AB 1999-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(io_SUITE). + +-export([all/1]). + +-export([init_per_testcase/2, fin_per_testcase/2]). + +-export([error_1/1, float_g/1, otp_5403/1, otp_5813/1, otp_6230/1, + otp_6282/1, otp_6354/1, otp_6495/1, otp_6517/1, otp_6502/1, + manpage/1, otp_6708/1, otp_7084/1, otp_7421/1, + io_lib_collect_line_3_wb/1, cr_whitespace_in_string/1, + io_fread_newlines/1]). + +%-define(debug, true). + +-ifdef(debug). +-define(format(S, A), io:format(S, A)). +-define(line, put(line, ?LINE), ). +-define(config(X,Y), foo). +-define(t, test_server). +-define(privdir(_), "./io_SUITE_priv"). +-else. +-include("test_server.hrl"). +-define(format(S, A), ok). +-define(privdir(Conf), ?config(priv_dir, Conf)). +-endif. + + +% Default timetrap timeout (set in init_per_testcase). +-define(default_timeout, ?t:minutes(1)). + +init_per_testcase(_Case, Config) -> + ?line Dog = ?t:timetrap(?default_timeout), + [{watchdog, Dog} | Config]. +fin_per_testcase(_Case, _Config) -> + Dog = ?config(watchdog, _Config), + test_server:timetrap_cancel(Dog), + ok. + +all(doc) -> + ["Test cases for io."]; +all(suite) -> + [error_1,float_g,otp_5403,otp_5813,otp_6230,otp_6282,otp_6354,otp_6495, + otp_6517,otp_6502,manpage,otp_6708,otp_7084,otp_7421, + io_lib_collect_line_3_wb,cr_whitespace_in_string,io_fread_newlines]. + +error_1(doc) -> + ["Error cases for output"]; +error_1(suite) -> + []; +error_1(Config) when is_list(Config) -> + %% We don't do erroneous output on stdout - the test server + %% seems to catch that somehow. + ?line PrivDir = ?privdir(Config), + ?line File = filename:join(PrivDir, "slask"), + ?line {ok, F1} = file:open(File, [write]), + ?line {'EXIT', _} = (catch io:format(muttru, "hej", [])), + ?line {'EXIT', _} = (catch io:format(F1, pelle, "hej")), + ?line {'EXIT', _} = (catch io:format(F1, 1, "hej")), + ?line {'EXIT', _} = (catch io:format(F1, "~p~", [kaka])), + ?line {'EXIT', _} = (catch io:format(F1, "~m~n", [kaka])), + + %% This causes the file process to die, and it is linked to us, + %% so we can't catch the error this easily. +% ?line {'EXIT', _} = (catch io:put_chars(F1, 666)), + + ?line file:close(F1), + ?line {'EXIT', _} = (catch io:format(F1, "~p", ["hej"])), + ok. + +float_g(Config) when is_list(Config) -> + ?line ["5.00000e-2", + "0.500000", + "5.00000", + "50.0000", + "500.000", + "5000.00", + "5.00000e+4", + "5.00000e+5"] = float_g_1("~g", 5.0, -2, 5), + + ?line ["-5.0000e-2", + "-0.50000", + "-5.0000", + "-50.000", + "-500.00", + "-5000.0", + "-5.0000e+4", + "-5.0000e+5"] = float_g_1("~.5g", -5.0, -2, 5), + + ?line ["5.000e-2", + "0.5000", + "5.000", + "50.00", + "500.0", + "5.000e+3", + "5.000e+4", + "5.000e+5"] = float_g_1("~.4g", 5.0, -2, 5), + + ?line ["-5.00e-2", + "-0.500", + "-5.00", + "-50.0", + "-5.00e+2", + "-5.00e+3", + "-5.00e+4", + "-5.00e+5"] = float_g_1("~.3g", -5.0, -2, 5), + + ?line ["5.0e-2", + "0.50", + "5.0", + "5.0e+1", + "5.0e+2", + "5.0e+3", + "5.0e+4", + "5.0e+5"] = float_g_1("~.2g", 5.0, -2, 5), + + ?line + case catch fmt("~.1g", [0.5]) of + "0.5" -> + ?line + ["5.0e-2", + "0.5", + "5.0e+0", + "5.0e+1", + "5.0e+2", + "5.0e+3", + "5.0e+4", + "5.0e+5"] = float_g_1("~.1g", 5.0, -2, 5); + {'EXIT',_} -> ok + end, + + ?line ["4.99999e-2", + "0.499999", + "4.99999", + "49.9999", + "499.999", + "4999.99", + "4.99999e+4", + "4.99999e+5"] = float_g_1("~g", 4.9999949999, -2, 5), + + ?line ["-5.00000e-2", + "-0.500000", + "-5.00000", + "-50.0000", + "-500.000", + "-5000.00", + "-5.00000e+4", + "-5.00000e+5"] = float_g_1("~g", -4.9999950001, -2, 5), + ok. + +float_g_1(Fmt, V, Min, Max) -> + [fmt(Fmt, [V*math:pow(10, E)]) || E <- lists:seq(Min, Max)]. + +otp_5403(doc) -> + ["OTP-5403. ~s formats I/O lists and a single binary."]; +otp_5403(suite) -> + []; +otp_5403(Config) when is_list(Config) -> + ?line "atom" = fmt("~s", [atom]), + ?line "binary" = fmt("~s", [<<"binary">>]), + ?line "atail" = fmt("~s", [["a" | <<"tail">>]]), + ?line "deepcharlist" = fmt("~s", [["deep",["char",["list"]]]]), + ?line "somebinaries" = fmt("~s", [[<<"some">>,[<<"binaries">>]]]), + ok. + +otp_5813(doc) -> + ["OTP-5813. read/3 is new."]; +otp_5813(suite) -> + []; +otp_5813(Config) when is_list(Config) -> + ?line PrivDir = ?privdir(Config), + ?line File = filename:join(PrivDir, "test"), + + ?line ok = file:write_file(File, <<"a. ">>), + ?line {ok, Fd} = file:open(File, [read]), + ?line {ok, a, 1} = io:read(Fd, '', 1), + ?line {eof,1} = io:read(Fd, '', 1), + ok = file:close(Fd), + + ?line ok = file:write_file(File, <<"[}.">>), + ?line {ok, Fd2} = file:open(File, [read]), + ?line {error,{1,_,_},1} = io:read(Fd2, '', 1), + ?line ok = file:close(Fd), + + file:delete(File), + ok. + +otp_6230(doc) -> + ["OTP-6230. ~p and ~P with (huge) binaries."]; +otp_6230(suite) -> + []; +otp_6230(Config) when is_list(Config) -> + %% The problem is actually huge binaries, but the small tests here + %% just run through most of the modified code. + ?line "<<>>" = fmt("~P", [<<"">>,-1]), + ?line "<<\"hej\">>" = fmt("~P", [<<"hej">>,-1]), + ?line "{hej,...}" = fmt("~P", [{hej,<<"hej">>},2]), + ?line "{hej,<<...>>}" = fmt("~P", [{hej,<<"hej">>},3]), + ?line "{hej,<<\"hejs\"...>>}" = fmt("~P", [{hej,<<"hejsan">>},4]), + ?line "{hej,<<\"hej\">>}" = fmt("~P", [{hej,<<"hej">>},6]), + ?line "<<...>>" = fmt("~P", [<<"hej">>,1]), + ?line "<<\"hejs\"...>>" = fmt("~P", [<<"hejsan">>,2]), + ?line "<<\"hej\">>" = fmt("~P", [<<"hej">>,4]), + ?line "{hej,<<127,...>>}" = + fmt("~P", [{hej,<<127:8,<<"hej">>/binary>>},4]), + ?line "{hej,<<127,104,101,...>>}" = + fmt("~P", [{hej,<<127:8,<<"hej">>/binary>>},6]), + + B = list_to_binary(lists:duplicate(30000, $a)), + ?line "<<\"aaaa"++_ = fmt("~P", [B, 20000]), + ok. + +otp_6282(doc) -> + ["OTP-6282. ~p truncates strings (like binaries) depending on depth."]; +otp_6282(suite) -> + []; +otp_6282(Config) when is_list(Config) -> + ?line "[]" = p("", 1, 20, 1), + ?line "[]" = p("", 1, 20, -1), + ?line "[...]" = p("a", 1, 20, 1), + ?line "\"a\"" = p("a", 1, 20, 2), + ?line "\"aa\"" = p("aa", 1, 20, 2), + ?line "\"aaa\"" = p("aaa", 1, 20, 2), + ?line "\"aaaa\"" = p("aaaa", 1, 20, 2), + % ?line "\"aaaa\"..." = p("aaaaaa", 1, 20, 2), + ?line "\"a\"" = p("a", 1, 20, -1), + % ?line "\"aa\"..." = p([$a,$a,1000], 1, 20, 2), + % ?line "\"aa\"..." = p([$a,$a,1000], 1, 20, 3), + ?line "[97,97,1000]" = p([$a,$a,1000], 1, 20, 4), + S1 = lists:duplicate(200,$a), + ?line "[...]" = p(S1, 1, 20, 1), + % ?line "\"aaaaaaaaaaaaaaaa\"\n \"aaaaaaaaaaaaaaaa\"\n \"aaaa\"..." = + % ?line "\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"..." = + % p(S1, 1, 20, 10), + ?line true = "\"" ++ S1 ++ "\"" =:= p(S1, 1, 205, -1), + ?line "[97,97,1000|...]" = p([$a,$a,1000,1000], 1, 20, 4), + + ?line "[[]]" = p([""], 1, 20, 2), + ?line "[[]]" = p([""], 1, 20, -1), + ?line "[[...]]" = p(["a"], 1, 20, 2), + ?line "[\"a\"]" = p(["a"], 1, 20, 3), + ?line "[\"aa\"]" = p(["aa"], 1, 20, 3), + ?line "[\"aaa\"]" = p(["aaa"], 1, 20, 3), + ?line "[\"a\"]" = p(["a"], 1, 20, -1), + % ?line "[\"aa\"...]" = p([[$a,$a,1000]], 1, 20, 3), + % ?line "[\"aa\"...]" = p([[$a,$a,1000]], 1, 20, 4), + ?line "[[97,97,1000]]" = p([[$a,$a,1000]], 1, 20, 5), + ?line "[[...]]" = p([S1], 1, 20, 2), + % ?line "[\"aaaaaaaaaaaaaa\"\n \"aaaaaaaaaaaaaa\"\n \"aaaaaaaa\"...]" = + % ?line "[\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"...]" = + % p([S1], 1, 20, 11), + ?line true = "[\"" ++ S1 ++ "\"]" =:= p([S1], 1, 210, -1), + ?line "[[97,97,1000|...]]" = p([[$a,$a,1000,1000]], 1, 20, 5), + + % ?line "[\"aaaa\"...]" = p(["aaaaa"], 1, 10, 3), + ?line "[\"aaaaa\"]" = p(["aaaaa"], 1, 10, 6), + + ok. + +otp_6354(doc) -> + ["OTP-6354. io_lib_pretty rewritten."]; +otp_6354(suite) -> + []; +otp_6354(Config) when is_list(Config) -> + %% A few tuples: + ?line "{}" = p({}, 1, 20, -1), + ?line "..." = p({}, 1, 20, 0), + ?line "{}" = p({}, 1, 20, 1), + ?line "{}" = p({}, 1, 20, 2), + ?line "{a}" = p({a}, 1, 20, -1), + ?line "..." = p({a}, 1, 20, 0), + ?line "{...}" = p({a}, 1, 20, 1), + ?line "{a}" = p({a}, 1, 20, 2), + ?line "{a,b}" = p({a,b}, 1, 20, -1), + ?line "..." = p({a,b}, 1, 20, 0), + ?line "{...}" = p({a,b}, 1, 20, 1), + ?line "{a,...}" = p({a,b}, 1, 20, 2), + ?line "{a,b}" = p({a,b}, 1, 20, 3), + ?line "{}" = p({}, 1, 1, -1), + ?line "..." = p({}, 1, 1, 0), + ?line "{}" = p({}, 1, 1, 1), + ?line "{}" = p({}, 1, 1, 2), + ?line "{a}" = p({a}, 1, 1, -1), + ?line "..." = p({a}, 1, 1, 0), + ?line "{...}" = p({a}, 1, 1, 1), + ?line "{a}" = p({a}, 1, 1, 2), + ?line "{a,\n b}" = p({a,b}, 1, 1, -1), + ?line "{1,\n b}" = p({1,b}, 1, 1, -1), + ?line "..." = p({a,b}, 1, 1, 0), + ?line "{...}" = p({a,b}, 1, 1, 1), + ?line "{a,...}" = p({a,b}, 1, 1, 2), + ?line "{a,\n b}" = p({a,b}, 1, 1, 3), + ?line "{{}}" = p({{}}, 1, 1, 2), + ?line "{[]}" = p({[]}, 1, 1, 2), + ?line bt(<<"{1,2,a,b,{sfdsf,sdfdsfs},[sfsdf,sdfsdf]}">>, + p({1,2,a,b,{sfdsf,sdfdsfs},[sfsdf,sdfsdf]}, -1)), + ?line bt(<<"{abcd,ddddd,\n ddddd}">>, + p({abcd,ddddd,ddddd}, 1,16, -1)), + ?line bt(<<"{1,2,a,b,\n {sfdsf,sdfdsfs},\n [sfsdf,sdfsdf]}">>, + p({1,2,a,b,{sfdsf,sdfdsfs},[sfsdf,sdfsdf]}, 1, 35, 100)), + % With other terms than atomic ones on the same line: +% ?line bt(<<"{1,2,a,b,{sfdsf,sdfdsfs},\n [sfsdf,sdfsdf]}">>, +% p({1,2,a,b,{sfdsf,sdfdsfs},[sfsdf,sdfsdf]}, 1, 35, 100)), + % With line breaks: +% ?line bt(<<"{1,\n" +% " 2,\n" +% " a,\n" +% " b,\n" +% " {sfdsf,sdfdsfs},\n" +% " [sfsdf,sdfsdf]}">>, +% p({1,2,a,b,{sfdsf,sdfdsfs},[sfsdf,sdfsdf]}, 1, 35, 100)), + ?line "{1,{1,{2,3}}}" = p({1,{1,{2,3}}}, 1, 80, 100), + + ?line bt(<<"{wwwww,{wwwww,{wwwww,{wwwww,{wwwww,lkjsldfj,klsdjfjklds,\n" + " sdkfjdsl,sdakfjdsklj,sdkljfsdj}}}}}">>, + p({wwwww,{wwwww,{wwwww,{wwwww,{wwwww,lkjsldfj,klsdjfjklds, + sdkfjdsl,sdakfjdsklj,sdkljfsdj}}}}}, -1)), + + % With no restriction on number of characters per line: +% ?line bt(<<"{wwwww,{wwwww,{wwwww,{wwwww,{wwwww,lkjsldfj,klsdjfjklds," +% "sdkfjdsl,sdakfjdsklj,\n" +% " sdkljfsdj}}}}}">>, +% p({wwwww,{wwwww,{wwwww,{wwwww,{wwwww,lkjsldfj,klsdjfjklds, +% sdkfjdsl,sdakfjdsklj,sdkljfsdj}}}}}, -1)), + + % With line breaks: +% ?line bt(<<"{wwwww,{wwwww,{wwwww,{wwwww,{wwwww,lkjsldfj,\n" +% " klsdjfjklds,\n" +% " sdkfjdsl,\n" +% " sdakfjdsklj,\n" +% " sdkljfsdj}}}}}">>, +% p({wwwww,{wwwww,{wwwww,{wwwww,{wwwww,lkjsldfj,klsdjfjklds, +% sdkfjdsl,sdakfjdsklj,sdkljfsdj}}}}}, -1)), + ?line bt(<<"{wwwww,\n" + " {wwwww,\n" + " {wwwww,\n" + " {wwwww,\n" + " {wwwww,\n" + " {lkjsldfj,\n" + " {klsdjfjklds,\n" + " {klajsljls,\n" + " #aaaaaaaaaaaaaaaaaaaaa" + "aaaaaaaaaaaaaaaaaaaaaaaaaaaaa{}}}}}}}}}">>, + p({wwwww,{wwwww,{wwwww,{wwwww,{wwwww,{lkjsldfj, + {klsdjfjklds,{klajsljls, + {aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa}}}}}}}}}, + -1)), + ?line "{{...},...}" = p({{a,b},{a,b,c},{d,e,f}},1,8,2), + %% Closing brackets and parentheses count: + ?line "{{a,b,c},\n {{1,2,\n 3}}}" = p({{a,b,c},{{1,2,3}}},1,11,-1), + % With line breaks: +% ?line "{{a,b,c},\n {{1,\n 2,\n 3}}}" = p({{a,b,c},{{1,2,3}}},1,11,-1), + ?line "{{a,b,c},\n [1,2,\n 3]}" = p({{a,b,c},[1,2,3]},1,10,-1), + % With line breaks: +% ?line "{{a,b,c},\n [1,\n 2,\n 3]}" = p({{a,b,c},[1,2,3]},1,10,-1), + ?line "[{{a,b,c},\n {1,2,\n 3}}]" = p([{{a,b,c},{1,2,3}}],1,12,-1), + % With line breaks: +% ?line "[{{a,b,c},\n {1,\n 2,\n 3}}]" = p([{{a,b,c},{1,2,3}}],1,12,-1), + + %% A few lists: + ?line "[]" = p([], 1, 20, -1), + ?line "..." = p([], 1, 20, 0), + ?line "[]" = p([], 1, 20, 1), + ?line "[]" = p([], 1, 20, 2), + ?line "[a]" = p([a], 1, 20, -1), + ?line "..." = p([a], 1, 20, 0), + ?line "[...]" = p([a], 1, 20, 1), + ?line "[a]" = p([a], 1, 20, 2), + ?line "[a,b]" = p([a,b], 1, 20, -1), + ?line "..." = p([a,b], 1, 20, 0), + ?line "[...]" = p([a,b], 1, 20, 1), + ?line "[a|...]" = p([a,b], 1, 20, 2), + ?line "[a,b]" = p([a,b], 1, 20, 3), + ?line "[a|b]" = p([a|b], 1, 20, -1), + ?line "..." = p([a|b], 1, 20, 0), + ?line "[...]" = p([a|b], 1, 20, 1), + ?line "[a|...]" = p([a|b], 1, 20, 2), + ?line "[a|b]" = p([a|b], 1, 20, 3), + ?line "[]" = p([], 1, 1, -1), + ?line "..." = p([], 1, 1, 0), + ?line "[]" = p([], 1, 1, 1), + ?line "[]" = p([], 1, 1, 2), + ?line "[a]" = p([a], 1, 1, -1), + ?line "..." = p([a], 1, 1, 0), + ?line "[...]" = p([a], 1, 1, 1), + ?line "[a]" = p([a], 1, 1, 2), + ?line "[a,\n b]" = p([a,b], 1, 1, -1), + ?line "..." = p([a,b], 1, 1, 0), + ?line "[...]" = p([a,b], 1, 1, 1), + ?line "[a|...]" = p([a,b], 1, 1, 2), + ?line "[a,\n b]" = p([a,b], 1, 1, 3), + ?line "[a|\n b]" = p([a|b], 1, 1, -1), + ?line "..." = p([a|b], 1, 1, 0), + ?line "[...]" = p([a|b], 1, 1, 1), + ?line "[a|...]" = p([a|b], 1, 1, 2), + ?line "[a|\n b]" = p([a|b], 1, 1, 3), + ?line "[{}]" = p([{}], 1, 1, 2), + ?line "[[]]" = p([[]], 1, 1, 2), + ?line bt(<<"[1,2,a,b,{sfdsf,sdfdsfs},[sfsdf,sdfsdf]]">>, + p([1,2,a,b,{sfdsf,sdfdsfs},[sfsdf,sdfsdf]], -1)), + ?line bt(<<"[1,2,a,b,\n {sfdsf,sdfdsfs},\n [sfsdf,sdfsdf]]">>, + p([1,2,a,b,{sfdsf,sdfdsfs},[sfsdf,sdfsdf]], 1, 35, 100)), + % With other terms than atomic ones on the same line: +% ?line bt(<<"[1,2,a,b,{sfdsf,sdfdsfs},\n [sfsdf,sdfsdf]]">>, +% p([1,2,a,b,{sfdsf,sdfdsfs},[sfsdf,sdfsdf]], 1, 35, 100)), + % With line breaks: +% ?line bt(<<"[1,\n" +% " 2,\n" +% " a,\n" +% " b,\n" +% " {sfdsf,sdfdsfs},\n" +% " [sfsdf,sdfsdf]]">>, +% p([1,2,a,b,{sfdsf,sdfdsfs},[sfsdf,sdfsdf]], 1, 35, 100)), + %% Element #8 is not printable: + ?line "[49," ++ _ = p("1234567"++[3,4,5,6,7], 1, 100, 9), + % ?line "\"1234567\"..." = p("1234567"++[3,4,5,6,7], 1, 100, 8), + + %% A few records: + %% -record(a, {}). + %% -record(a, {}). + ?line "..." = p({a}, 0), + ?line "{...}" = p({a}, 1), + ?line "#a{}" = p({a}, 2), + ?line "#a{}" = p({a}, -1), + %% -record(b, {f}). + ?line "{...}" = p({b}, 1), + ?line "..." = p({b,c}, 0), + ?line "{...}" = p({b,c}, 1), + ?line "#b{...}" = p({b,c}, 2), + ?line "#b{f = c}" = p({b,c}, 3), + ?line "#b{f = c}" = p({b,c}, -1), + ?line "..." = p({b,{c,d}}, 0), + ?line "{...}" = p({b,{c,d}}, 1), + ?line "#b{...}" = p({b,{c,d}}, 2), + ?line "#b{f = {...}}" = p({b,{c,d}}, 3), + ?line "#b{f = {c,...}}" = p({b,{c,d}}, 4), + ?line "#b{f = {c,d}}" = p({b,{c,d}}, 5), + ?line "#b{f = {...}}" = p({b,{b,c}}, 3), + ?line "#b{f = #b{...}}" = p({b,{b,c}}, 4), + ?line "#b{f = #b{f = c}}" = p({b,{b,c}}, 5), + %% -record(c, {f1, f2}). + ?line "#c{f1 = d,f2 = e}" = p({c,d,e}, -1), + ?line "..." = p({c,d,e}, 0), + ?line "{...}" = p({c,d,e}, 1), + ?line "#c{...}" = p({c,d,e}, 2), + ?line "#c{f1 = d,...}" = p({c,d,e}, 3), + ?line "#c{f1 = d,f2 = e}" = p({c,d,e}, 4), + %% -record(d, {a..., b..., c.., d...}). + ?line bt(<<"#d{aaaaaaaaaaaaaaaaaaaa = 1,bbbbbbbbbbbbbbbbbbbb = 2,\n" + " cccccccccccccccccccc = 3,dddddddddddddddddddd = 4,\n" + " eeeeeeeeeeeeeeeeeeee = 5}">>, + p({d,1,2,3,4,5}, -1)), + % With no restriction on number of characters per line: +% ?line bt(<<"#d{aaaaaaaaaaaaaaaaaaaa = 1,bbbbbbbbbbbbbbbbbbbb = 2," +% "cccccccccccccccccccc = 3,\n dddddddddddddddddddd = 4," +% "eeeeeeeeeeeeeeeeeeee = 5}">>, +% p({d,1,2,3,4,5}, -1)), + % With line breaks: +% ?line bt(<<"#d{aaaaaaaaaaaaaaaaaaaa = 1,\n" +% " bbbbbbbbbbbbbbbbbbbb = 2,\n" +% " cccccccccccccccccccc = 3,\n" +% " dddddddddddddddddddd = 4,\n" +% " eeeeeeeeeeeeeeeeeeee = 5}">>, +% p({d,1,2,3,4,5}, -1)), + ?line "..." = p({d,1,2,3,4,5}, 0), + ?line "{...}" = p({d,1,2,3,4,5}, 1), + ?line "#d{...}" = p({d,1,2,3,4,5}, 2), + ?line "#d{aaaaaaaaaaaaaaaaaaaa = 1,...}" = p({d,1,2,3,4,5}, 3), + ?line bt(<<"#d{aaaaaaaaaaaaaaaaaaaa = 1,bbbbbbbbbbbbbbbbbbbb = 2,...}">>, + p({d,1,2,3,4,5}, 4)), + ?line bt(<<"#d{aaaaaaaaaaaaaaaaaaaa = 1,bbbbbbbbbbbbbbbbbbbb = 2,\n" + " cccccccccccccccccccc = 3,...}">>, + p({d,1,2,3,4,5}, 5)), % longer than 80 characters... + % With no restriction on number of characters per line: +% ?line bt(<<"#d{aaaaaaaaaaaaaaaaaaaa = 1,bbbbbbbbbbbbbbbbbbbb = 2," +% "cccccccccccccccccccc = 3,...}">>, +% p({d,1,2,3,4,5}, 5)), % longer than 80 characters... + % With line breaks: +% ?line bt(<<"#d{aaaaaaaaaaaaaaaaaaaa = 1,\n" +% " bbbbbbbbbbbbbbbbbbbb = 2,\n" +% " cccccccccccccccccccc = 3,...}">>, +% p({d,1,2,3,4,5}, 5)), + ?line bt(<<"#d{aaaaaaaaaaaaaaaaaaaa = 1,bbbbbbbbbbbbbbbbbbbb = 2,\n" + " cccccccccccccccccccc = 3,dddddddddddddddddddd = 4,...}">>, + p({d,1,2,3,4,5}, 6)), + % With no restriction on number of characters per line: +% ?line bt(<<"#d{aaaaaaaaaaaaaaaaaaaa = 1,bbbbbbbbbbbbbbbbbbbb = 2," +% "cccccccccccccccccccc = 3,\n dddddddddddddddddddd = 4,...}">>, +% p({d,1,2,3,4,5}, 6)), + % With line breaks: +% ?line bt(<<"#d{aaaaaaaaaaaaaaaaaaaa = 1,\n" +% " bbbbbbbbbbbbbbbbbbbb = 2,\n" +% " cccccccccccccccccccc = 3,\n" +% " dddddddddddddddddddd = 4,...}">>, +% p({d,1,2,3,4,5}, 6)), + ?line bt(<<"#d{aaaaaaaaaaaaaaaaaaaa = 1,bbbbbbbbbbbbbbbbbbbb = 2,\n" + " cccccccccccccccccccc = 3,dddddddddddddddddddd = 4,\n" + " eeeeeeeeeeeeeeeeeeee = 5}">>, + p({d,1,2,3,4,5}, 7)), + % With no restriction on number of characters per line: +% ?line bt(<<"#d{aaaaaaaaaaaaaaaaaaaa = 1,bbbbbbbbbbbbbbbbbbbb = 2," +% "cccccccccccccccccccc = 3,\n dddddddddddddddddddd = 4," +% "eeeeeeeeeeeeeeeeeeee = 5}">>, +% p({d,1,2,3,4,5}, 7)), + % With line breaks: +% ?line bt(<<"#d{aaaaaaaaaaaaaaaaaaaa = 1,\n" +% " bbbbbbbbbbbbbbbbbbbb = 2,\n" +% " cccccccccccccccccccc = 3,\n" +% " dddddddddddddddddddd = 4,\n" +% " eeeeeeeeeeeeeeeeeeee = 5}">>, +% p({d,1,2,3,4,5}, 7)), + ?line bt(<<"#rrrrr{\n" + " f1 = 1,\n" + " f2 = #rrrrr{f1 = a,f2 = b,f3 = c},\n" + " f3 = \n" + " #rrrrr{\n" + " f1 = h,f2 = i,\n" + " f3 = \n" + " #rrrrr{\n" + " f1 = aa,\n" + " f2 = \n" + " #rrrrr{\n" + " f1 = #rrrrr{f1 = a,f2 = b,f3 = c},\n" + " f2 = 2,f3 = 3},\n" + " f3 = bb}}}">>, + p({rrrrr,1,{rrrrr,a,b,c},{rrrrr,h,i, + {rrrrr,aa,{rrrrr,{rrrrr,a,b,c}, + 2,3},bb}}}, + -1)), + % With other terms than atomic ones on the same line: +% ?line bt(<<"#rrrrr{\n" +% " f1 = 1,f2 = #rrrrr{f1 = a,f2 = b,f3 = c},\n" +% " f3 = \n" +% " #rrrrr{\n" +% " f1 = h,f2 = i,\n" +% " f3 = \n" +% " #rrrrr{\n" +% " f1 = aa,\n" +% " f2 = \n" +% " #rrrrr{\n" +% " f1 = #rrrrr{f1 = a,f2 = b," +% "f3 = c},f2 = 2,f3 = 3},\n" +% " f3 = bb}}}">>, +% p({rrrrr,1,{rrrrr,a,b,c},{rrrrr,h,i, +% {rrrrr,aa,{rrrrr,{rrrrr,a,b,c}, +% 2,3},bb}}}, +% -1)), + % With line breaks: +% ?line bt(<<"#rrrrr{\n" +% " f1 = 1,\n" +% " f2 = #rrrrr{f1 = a,f2 = b,f3 = c},\n" +% " f3 = \n" +% " #rrrrr{\n" +% " f1 = h,\n" +% " f2 = i,\n" +% " f3 = \n" +% " #rrrrr{\n" +% " f1 = aa,\n" +% " f2 = \n" +% " #rrrrr{\n" +% " f1 = #rrrrr{f1 = a,f2 = b," +% "f3 = c},\n" +% " f2 = 2,\n" +% " f3 = 3},\n" +% " f3 = bb}}}">>, +% p({rrrrr,1,{rrrrr,a,b,c},{rrrrr,h,i, +% {rrrrr,aa,{rrrrr,{rrrrr,a,b,c}, +% 2,3},bb}}}, +% -1)), + ?line bt(<<"#d{aaaaaaaaaaaaaaaaaaaa = 1,\n" + " bbbbbbbbbbbbbbbbbbbb = \n" + " #d{aaaaaaaaaaaaaaaaaaaa = a,bbbbbbbbbbbbbbbbbbbb = b,\n" + " cccccccccccccccccccc = c,dddddddddddddddddddd = d,\n" + " eeeeeeeeeeeeeeeeeeee = e},\n" + " cccccccccccccccccccc = 3,\n" + " dddddddddddddddddddd = \n" + " #d{aaaaaaaaaaaaaaaaaaaa = h,bbbbbbbbbbbbbbbbbbbb = i,\n" + " cccccccccccccccccccc = \n" + " #d{aaaaaaaaaaaaaaaaaaaa = aa," + "bbbbbbbbbbbbbbbbbbbb = bb,\n" + " cccccccccccccccccccc = \n" + " #d{aaaaaaaaaaaaaaaaaaaa = 1," + "bbbbbbbbbbbbbbbbbbbb = 2,\n" + " cccccccccccccccccccc = 3," + "dddddddddddddddddddd = 4,\n" + " eeeeeeeeeeeeeeeeeeee = 5},\n" + " dddddddddddddddddddd = dd," + "eeeeeeeeeeeeeeeeeeee = ee},\n" + " dddddddddddddddddddd = k," + "eeeeeeeeeeeeeeeeeeee = l},\n" + " eeeeeeeeeeeeeeeeeeee = 5}">>, + p({d,1,{d,a,b,c,d,e},3,{d,h,i,{d,aa,bb,{d,1,2,3,4,5},dd,ee}, + k,l},5}, -1)), + % With line breaks: +% ?line bt(<<"#d{aaaaaaaaaaaaaaaaaaaa = 1,\n" +% " bbbbbbbbbbbbbbbbbbbb = \n" +% " #d{aaaaaaaaaaaaaaaaaaaa = a,\n" +% " bbbbbbbbbbbbbbbbbbbb = b,\n" +% " cccccccccccccccccccc = c,\n" +% " dddddddddddddddddddd = d,\n" +% " eeeeeeeeeeeeeeeeeeee = e},\n" +% " cccccccccccccccccccc = 3,\n" +% " dddddddddddddddddddd = \n" +% " #d{aaaaaaaaaaaaaaaaaaaa = h,\n" +% " bbbbbbbbbbbbbbbbbbbb = i,\n" +% " cccccccccccccccccccc = \n" +% " #d{aaaaaaaaaaaaaaaaaaaa = aa,\n" +% " bbbbbbbbbbbbbbbbbbbb = bb,\n" +% " cccccccccccccccccccc = \n" +% " #d{aaaaaaaaaaaaaaaaaaaa = 1,\n" +% " bbbbbbbbbbbbbbbbbbbb = 2,\n" +% " cccccccccccccccccccc = 3,\n" +% " dddddddddddddddddddd = 4,\n" +% " eeeeeeeeeeeeeeeeeeee = 5},\n" +% " dddddddddddddddddddd = dd,\n" +% " eeeeeeeeeeeeeeeeeeee = ee},\n" +% " dddddddddddddddddddd = k,\n" +% " eeeeeeeeeeeeeeeeeeee = l},\n" +% " eeeeeeeeeeeeeeeeeeee = 5}">>, +% p({d,1,{d,a,b,c,d,e},3,{d,h,i,{d,aa,bb,{d,1,2,3,4,5},dd,ee}, +% k,l},5}, -1)), + + A = aaaaaaaaaaaaa, + %% Print the record with dots at the end of the line (Ll = 80). + ?line "{aaaaaaa" ++ _ = + p({A,{A,{A,{A,{A,{A,{A,{A,{A,{A,{A,{A,{A,{A,{A,{A,{A,{A,{A,{A,{A, + {A,{A,{A,{A,{A,{A,{A,{A,{A,{A,{A,{A,{A,{A,{A,{A,{A,{A,{A,{A, + {A,{A,{A,{A,{A,{A,{A,{A,{A,{A,{A,{A,{A,{A,{A,{A,{A,{A,{A,{A, + {A,{A,{ggg,{hhh,{ii,{jj,{kk,{ll,{mm,{nn,{oo,{d,1,2,3,4,5} + }}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}} + }}}}}}}}}}}}}}}}, 146), + ?line "{aaaaaaa" ++ _ = + p({A,{A,{A,{A,{A,{A,{A,{A,{A,{A,{A,{A,{A,{A,{A,{A,{A,{A,{A,{A,{A, + {A,{A,{A,{A,{A,{A,{A,{A,{A,{A,{A,{A,{A,{A,{A,{A,{A,{A,{A,{A, + {A,{A,{A,{A,{A,{A,{A,{A,{A,{A,{A,{A,{A,{A,{A,{A,{A,{A,{A,{A, + {A,{A,{A,{A,{A,{ggg,{hhh,{ii,{jj,{kk,{ll,{mm,{nn,{oo,{a} + }}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}} + }}}}}}}}}}}}}}}}}}}, 152), + + ?line bt(<<"{aaaaaaaaaaaaa,\n" + " {aaaaaaaaaaaaa,\n" + " {aaaaaaaaaaaaa,\n" + " {aaaaaaaaaaaaa,\n" + " {aaaaaaaaaaaaa,\n" + " {aaaaaaaaaaaaa,\n" + " {g,{h,{i,{j,{k,{l,{m,{n,{o,#" + "d{...}}}}}}}}}}}}}}}}">>, + p({A,{A,{A,{A,{A,{A, + {g,{h,{i,{j,{k,{l,{m,{n,{o,{d,1,2,3,4,5}}}}}}}}}}}}}}}}, 32)), + ?line bt(<<"{a,#b{f = {c,{d,{e,{f,...}}}}}}">>, + p({a,{b,{c,{d,{e,{f,g}}}}}}, 12)), + ?line bt(<<"{aaaaaaaaaaaaa,\n" + " {aaaaaaaaaaaaa,\n" + " {aaaaaaaaaaaaa,\n" + " {aaaaaaaaaaaaa,\n" + " {aaaaaaaaaaaaa,\n" + " {aaaaaaaaaaaaa,\n" + " {aaaaaaaaaaaaa,\n" + " {aaaaaaaaaaaaa,\n" + " {aaaaaaaaaaaaa,#c{f1 = ddd," + "f2 = eee}}}}}}}}}}">>, + p({A,{A,{A,{A,{A,{A,{A,{A,{A,{c,ddd,eee}}}}}}}}}}, 100)), + ?line bt(<<"{aaaaaaaaaaaaa,\n" + " {aaaaaaaaaaaaa,{aaaaaaaaaaaaa,{aaaaaaaaaaaaa,...}}}}">>, + p({A,{A,{A,{A,{b}}}}}, 8)), + % With no restriction on number of characters per line: +% ?line bt(<<"{aaaaaaaaaaaaa,{aaaaaaaaaaaaa,{aaaaaaaaaaaaa," +% "{aaaaaaaaaaaaa,...}}}}">>, +% p({A,{A,{A,{A,{b}}}}}, 8)), + ?line bt(<<"{aaaaaaaaaaaaa,\n" + " {aaaaaaaaaaaaa,\n" + " {aaaaaaaaaaaaa,{aaaaaaaaaaaaa,{aaaaaaaaaaaaa,...}}}}}">>, + p({A,{A,{A,{A,{A,{b}}}}}}, 10)), + % With no restriction on number of characters per line: +% ?line bt(<<"{aaaaaaaaaaaaa,\n" +% " {aaaaaaaaaaaaa,{aaaaaaaaaaaaa,{aaaaaaaaaaaaa," +% "{aaaaaaaaaaaaa,...}}}}}">>, +% p({A,{A,{A,{A,{A,{b}}}}}}, 10)), + ?line bt(<<"{aaaaaaaaaaaaa,\n" + " {aaaaaaaaaaaaa,\n" + " {aaaaaaaaaaaaa,\n" + " {aaaaaaaaaaaaa,\n" + " {aaaaaaaaaaaaa,\n" + " {aaaaaaaaaaaaa,\n" + " {aaaaaaaaaaaaa,\n" + " {aaaaaaaaaaaaa,\n" + " {aaaaaaaaaaaaa," + "{aaaaaaaaaaaaa,#a{}}}}}}}}}}}">>, + p({A,{A,{A,{A,{A,{A,{A,{A,{A,{A,{a}}}}}}}}}}}, 23)), + ?line bt(<<"{aaaaaaaaaaaaa,\n" + " {aaaaaaaaaaaaa,\n" + " {aaaaaaaaaaaaa,\n", + " #rrrrr{\n" + " f1 = kljlkjlksfdgkljlsdkjf," + "f2 = kljkljsdaflkjlkjsdf,...}}}}">>, + p({A,{A,{A,{rrrrr, kljlkjlksfdgkljlsdkjf, + kljkljsdaflkjlkjsdf, + asdfkldsjfklkljsdklfds}}}}, 10)), + % With no restriction on number of characters per line: +% ?line bt(<<"{aaaaaaaaaaaaa,\n" +% " {aaaaaaaaaaaaa,\n" +% " {aaaaaaaaaaaaa,\n", +% " #rrrrr{f1 = kljlkjlksfdgkljlsdkjf,f2 = " +% "kljkljsdaflkjlkjsdf,...}}}}">>, +% p({A,{A,{A,{rrrrr, kljlkjlksfdgkljlsdkjf, +% kljkljsdaflkjlkjsdf, +% asdfkldsjfklkljsdklfds}}}}, 10)), + ?line bt(<<"{aaaaaaaaaaaaa,\n" + " {aaaaaaaaaaaaa,\n" + " {aaaaaaaaaaaaa,\n" + " {aaaaaaaaaaaaa,\n" + " {aaaaaaaaaaaaa,\n" + " {aaaaaaaaaaaaa,\n" + " {aaaaaaaaaaaaa,\n" + " {g,{h,{i,{j,{k,{l,{m,{n," + "{o,#a{}}}}}}}}}}}}}}}}}">>, + p({A,{A,{A,{A,{A,{A,{A, + {g,{h,{i,{j,{k,{l,{m,{n,{o,{a}}}}}}}}}}}}}}}}}, 100)), + ?line bt(<<"#c{\n" + " f1 = \n" + " #c{\n" + " f1 = \n" + " #c{\n" + " f1 = \n" + " #c{\n" + " f1 = \n" + " #c{\n" + " f1 = \n" + " #c{\n" + " f1 = \n" + " #c{\n" + " f1 = \n" + " #c{\n" + " f1 = \n" + " #c{\n" + " f1 = #c{f1 = #c{f1 = #c{f1 = a," + "f2 = b},f2 = b},f2 = b},\n" + " f2 = b},\n" + " f2 = b},\n" + " f2 = b},\n" + " f2 = b},\n" + " f2 = b},\n" + " f2 = b},\n" + " f2 = b},\n" + " f2 = b},\n" + " f2 = b}">>, + p({c,{c,{c,{c,{c,{c,{c,{c,{c,{c,{c,{c,a,b},b},b},b},b},b}, + b},b},b},b},b},b}, -1)), + ?line bt(<<"#rrrrr{\n" + " f1 = \n" + " #rrrrr{\n" + " f1 = \n" + " #rrrrr{\n" + " f1 = \n" + " #rrrrr{\n" + " f1 = \n" + " {rrrrr,{rrrrr,a,#rrrrr{f1 = {rrrrr,1,2},f2 = a," + "f3 = b}},b},\n" + " f2 = {rrrrr,c,d},\n" + " f3 = {rrrrr,1,2}},\n" + " f2 = 1,f3 = 2},\n" + " f2 = 3,f3 = 4},\n" + " f2 = 5,f3 = 6}">>, + p({rrrrr,{rrrrr,{rrrrr,{rrrrr,{rrrrr,{rrrrr,a,{rrrrr, + {rrrrr,1,2},a,b}},b},{rrrrr,c,d},{rrrrr,1,2}}, + 1,2},3,4},5,6}, -1)), + % With other terms than atomic ones on the same line: +% ?line bt(<<"#rrrrr{\n" +% " f1 = \n" +% " #rrrrr{\n" +% " f1 = \n" +% " #rrrrr{\n" +% " f1 = \n" +% " #rrrrr{\n" +% " f1 = \n" +% " {rrrrr,{rrrrr,a,#rrrrr{f1 = {rrrrr,1,2},f2 = a," +% "f3 = b}},b},\n" +% " f2 = {rrrrr,c,d},f3 = {rrrrr,1,2}},\n" +% " f2 = 1,f3 = 2},\n" +% " f2 = 3,f3 = 4},\n" +% " f2 = 5,f3 = 6}">>, +% p({rrrrr,{rrrrr,{rrrrr,{rrrrr,{rrrrr,{rrrrr,a,{rrrrr, +% {rrrrr,1,2},a,b}},b},{rrrrr,c,d},{rrrrr,1,2}}, +% 1,2},3,4},5,6}, -1)), + % With no restriction on number of characters per line: +% ?line bt(<<"#rrrrr{\n" +% " f1 = \n" +% " #rrrrr{\n" +% " f1 = \n" +% " #rrrrr{\n" +% " f1 = \n" +% " #rrrrr{\n" +% " f1 = {rrrrr,{rrrrr,a,#rrrrr{f1 = {rrrrr,1,2},f2 = a," +% "f3 = b}},b},\n" +% " f2 = {rrrrr,c,d},f3 = {rrrrr,1,2}},\n" +% " f2 = 1,f3 = 2},\n" +% " f2 = 3,f3 = 4},\n" +% " f2 = 5,f3 = 6}">>, +% p({rrrrr,{rrrrr,{rrrrr,{rrrrr,{rrrrr,{rrrrr,a,{rrrrr, +% {rrrrr,1,2},a,b}},b},{rrrrr,c,d},{rrrrr,1,2}}, +% 1,2},3,4},5,6}, -1)), + % With line breaks: +% ?line bt(<<"#rrrrr{\n" +% " f1 = \n" +% " #rrrrr{\n" +% " f1 = \n" +% " #rrrrr{\n" +% " f1 = \n" +% " #rrrrr{\n" +% " f1 = {rrrrr,{rrrrr,a,#rrrrr{f1 = {rrrrr,1,2},f2 = a," +% "f3 = b}},b},\n" +% " f2 = {rrrrr,c,d},\n" +% " f3 = {rrrrr,1,2}},\n" +% " f2 = 1,\n" +% " f3 = 2},\n" +% " f2 = 3,\n" +% " f3 = 4},\n" +% " f2 = 5,\n" +% " f3 = 6}">>, +% p({rrrrr,{rrrrr,{rrrrr,{rrrrr,{rrrrr,{rrrrr,a,{rrrrr, +% {rrrrr,1,2},a,b}},b},{rrrrr,c,d},{rrrrr,1,2}}, +% 1,2},3,4},5,6}, -1)), + ?line "{aaa,\n {aaa," ++ _ = + p({aaa,{aaa,{aaa,{aaa,{aaa,{aaa,{aaa,{aaa,{aaa,{aaa,{aaa,{aaa,{aaa, + {aaa,{aaa,{aaa,{aaa,{aaa,{aaa,{aaa,{aaa,{aaa,{aaa,{aaa,{aaa, + {aaa,{aaa,{aaa,{aaa,{aaa,{aaa,{aaa,{aaa,{aaa,{aaa,{aaa, + {aaa,{aaa,{aaa,{aaa,{aaa,{aaa,{aaa,{aaa,{aaa,{aaa, + {aaa,a}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}, + 1, 80, -1), + + %% A few other cases... + ?line "{a,#Fun<" ++ _ = lists:flatten(io_lib_pretty:print({a,fun fmt/2})), + ?line "#Fun<" ++ _ = io_lib_pretty:print(fun() -> foo end), + % ?line "[<<\"foobar\">>|<<\"barf\"...>>]" = + % p([<<"foobar">>|<<"barfoo">>], 1, 30, 4), + %% No support for negative columns any more: + ?line "[a,\n [b,\n c,\n d,\n [e,\n f]],\n c]" = + p([a,[b,c,d,[e,f]],c], -1, 2, 10), + ?line "[a,\n [b,\n c,\n d,\n [e,\n f]],\n c]" = + p([a,[b,c,d,[e,f]],c], 0, 2, 10), + %% 20 bytes are tried first, then the rest. Try 21 bytes: + L = lists:duplicate(20, $a), + % ?line bt(<<"<<\"aaaaaa\"\n \"aaaaaa\"\n \"aaaaaa\"\n \"aaa\">>">>, + ?line bt(<<"<<\"aaaaaaaaaaaaaaaaaaaaa\">>">>, + p(list_to_binary([$a | L]), 1, 10, -1)), + ?line "<<97," ++ _ = p(list_to_binary(L ++ [3]), 1, 10, -1), + % ?line "<<\"aaaa\"...>>" = p(list_to_binary(L ++ [3]), 1, 10, 2), + % ?line "<<\"aaaaaa\"\n \"aa\"...>>" = + % ?line "<<\"aaaaaaaa\"...>>" = + % p(list_to_binary(L ++ [3]), 1, 10, 3), + % ?line "<<\"aaaaaa\"\n \"aaaaaa\"\n \"aaaaaa\"\n \"aa\"...>>" = + % ?line "<<\"aaaaaaaaaaaaaaaaaaaa\"...>>" = + % p(list_to_binary(L ++ [3]), 1, 10, 21), + ?line "<<97," ++ _ = p(list_to_binary(L ++ [3]), 1, 10, 22), + + ?line "\"\\b\\t\\n\\v\\f\\r\\e\250\"" = + p([8,9,10,11,12,13,27,168], 1, 40, -1), + % ?line "\"\\b\\t\\n\"\n \"\\v\\f\\r\"\n \"\\e\250\"" = + ?line "\"\\b\\t\\n\\v\\f\\r\\e�\"" = + p([8,9,10,11,12,13,27,168], 1, 10, -1), + ?line "\"\\b\\t\\n\\v\\f\\r\\e\250\"" = + p([8,9,10,11,12,13,27,168], 1, 40, 100), + % ?line "\"\\e\\t\\nab\"\n \"cd\"" = + ?line "\"\\e\\t\\nabcd\"" = + p("\e\t\nabcd", 1, 12, -1), + + %% DEL (127) is special... + ?line "[127]" = p("\d", 1, 10, -1), + ?line "[127]" = p([127], 1, 10, 100), + + ?line "<<\"\\b\\t\\n\\v\\f\\r\\e\250\">>" = + p(<<8,9,10,11,12,13,27,168>>, 1, 40, -1), + ?line "<<\"\\b\\t\\n\\v\\f\\r\\e\250\">>" = + p(<<8,9,10,11,12,13,27,168>>, 1, 10, -1), + ?line "<<127>>" = p(<<127>>, 1, 10, 100), + + %% "Partial" string binaries: + ?line "<<\"he\"...>>" = p(list_to_binary("he"++[3]), 1, 80, 2), + ?line "<<\"he\"...>>" = p(list_to_binary("he"++[3]), 1, 80, 3), + ?line "<<104,101,3>>" = p(list_to_binary("he"++[3]), 1, 80, 4), + ?line "<<...>>" = p(list_to_binary([3] ++ "he"), 1, 80, 1), + ?line "<<3,...>>" = p(list_to_binary([3] ++ "he"), 1, 80, 2), + ?line "<<3,104,...>>" = p(list_to_binary([3] ++ "he"), 1, 80, 3), + + ?line "<<\"12345678901234567890\"...>>" = + p(list_to_binary("12345678901234567890"++[3]), 1, 80, 8), + ?line "<<\"12345678901234567890\"...>>" = + p(list_to_binary("12345678901234567890"++[3]), 1, 80, 21), + ?line "<<49," ++ _ = + p(list_to_binary("12345678901234567890"++[3]), 1, 80, 22), + + ?line "{sdfsdfj,\n 23" ++ _ = + p({sdfsdfj,23423423342.23432423}, 1, 17, -1), + + ?line bt(<<"kljkljlksdjjlf kljalkjlsdajafasjdfj [kjljklasdf,kjlljsfd,sdfsdkjfsd,kjjsdf,jl, + lkjjlajsfd|jsdf]">>, + fmt("~w ~w ~p", + [kljkljlksdjjlf, + kljalkjlsdajafasjdfj, + [kjljklasdf,kjlljsfd,sdfsdkjfsd,kjjsdf,jl,lkjjlajsfd | + jsdf]])), + + %% Binaries are split as well: + ?line bt(<<"<<80,100,0,55,55,55,55,55,55,55,55,55,\n " + "55,55,55,55,55,55,55,...>>">>, + p(<<80,100,0,55,55,55,55,55,55,55,55,55,55,55,55,55,55,55, + 55,55,55,55,55,55,55,55,55,55,55,55>>,1,40,20)), + ?line bt(<<"<<80,100,0,55,55,55,55,55,55,55,55,55,\n " + "55,55,55,55,55,55,55,55,55,55,55,55,\n 55,55,55,55,55,55>>">>, + p(<<80,100,0,55,55,55,55,55,55,55,55,55,55,55,55,55,55,55, + 55,55,55,55,55,55,55,55,55,55,55,55>>,1,40,-1)), + ?line "<<0,0,0,\n ...>>" = p(<<0,0,0,0,0>>, 1, 10, 4), + + %% ~W now uses ",..." when printing tuples + ?line "[a,b|...]" = fmt("~W", [[a,b,c,d,e], 3]), + ?line "{a,b,...}" = fmt("~W", [{a,b,c,d,e}, 3]), + ok. + +otp_6495(doc) -> + ["OTP-6495. io_lib_pretty bugfix."]; +otp_6495(suite) -> + []; +otp_6495(Config) when is_list(Config) -> + ?line bt(<<"[120,120,120,120,120,120,120,120,120,120,120,120,120,120," + "120,120,120,120,120]<<1>>">>, + fmt("~w~p", ["xxxxxxxxxxxxxxxxxxx", <<1>>])), + ok. + +otp_6517(doc) -> + ["OTP-6517. The Format argument of fwrite can be a binary."]; +otp_6517(suite) -> + []; +otp_6517(Config) when is_list(Config) -> + ?line "string" = fmt(<<"~s">>, [<<"string">>]), + ok. + +otp_6502(doc) -> + ["OTP-6502. Bits."]; +otp_6502(suite) -> + []; +otp_6502(Config) when is_list(Config) -> + ?line bt(<< + "[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25]" + "<<0,0,8,\n" + " " + " 1:1>>">>, + fmt("~w~p", [lists:seq(0, 25), <<17:25>>])), + ok. + +otp_7421(doc) -> + ["OTP-7421. Soft limit of 60 chars removed when pretty printing."]; +otp_7421(suite) -> + []; +otp_7421(Config) when is_list(Config) -> + bt(<<"{aa,bb,\n" + " c,dd,\n" + " eee,\n" + " fff}">>, + rp({aa,bb,c,dd,eee,fff}, 1, 80, -1, 5, none)), + bt(<<"{aa,bb,\n" + " c,\n" + " dd,\n" + " eee,\n" + " fff}">>, + rp({aa,bb,c,dd,eee,fff}, 1, 80, -1, 4, none)), + ok. + +bt(Bin, R) -> + R = binary_to_list(Bin). + +p(Term, D) -> + rp(Term, 1, 80, D). + +p(Term, Col, Ll, D) -> + rp(Term, Col, Ll, D, no_fun). + +rp(Term, Col, Ll, D) -> + rp(Term, Col, Ll, D, fun rfd/2). + +-define(MAXCS, 60). + +rp(Term, Col, Ll, D, RF) -> + rp(Term, Col, Ll, D, ?MAXCS, RF). + +rp(Term, Col, Ll, D, M, RF) -> + %% io:format("~n~n*** Col = ~p Ll = ~p D = ~p~n~p~n-->~n", + %% [Col, Ll, D, Term]), + R = io_lib_pretty:print(Term, Col, Ll, D, M, RF), + %% io:format("~s~n<--~n", [R]), + lists:flatten(io_lib:format("~s", [R])). + +fmt(Fmt, Args) -> + lists:flatten(io_lib:format(Fmt, Args)). + +rfd(a, 0) -> + []; +rfd(b, 1) -> + [f]; +rfd(c, 2) -> + [f1, f2]; +rfd(e, 3) -> + [f, g, h]; +rfd(d, 5) -> + [aaaaaaaaaaaaaaaaaaaa, bbbbbbbbbbbbbbbbbbbb, + cccccccccccccccccccc, dddddddddddddddddddd, + eeeeeeeeeeeeeeeeeeee]; +rfd(rrrrr, 3) -> + [f1, f2, f3]; +rfd(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, 0) -> + []; +rfd(_, _) -> + no. + +manpage(doc) -> + ["The examples in io(3) and io_lib(3)."]; +manpage(suite) -> + []; +manpage(Config) when is_list(Config) -> + %% The examples that write or print only, not the ones that read... + + ?line bt(<<"Hello world!\n">>, + fmt("Hello world!~n", [])), + ?line bt(<<"| aaaaa|bbbbb |ccccc|\n">>, % bugfix + fmt("|~10.5c|~-10.5c|~5c|~n", [$a, $b, $c])), + ?line bt(<<"|**********|\n">>, + fmt("|~10w|~n", [{hey, hey, hey}])), + ?line bt(<<"|{hey,hey,h|\n">>, + fmt("|~10s|~n", [io_lib:write({hey, hey, hey})])), + + T = [{attributes,[[{id,age,1.50000},{mode,explicit}, + {typename,"INTEGER"}], [{id,cho},{mode,explicit},{typename,'Cho'}]]}, + {typename,'Person'},{tag,{'PRIVATE',3}},{mode,implicit}], + ?line bt(<<"[{attributes,[[{id,age,1.5},{mode,explicit},{typename," + "[73,78,84,69,71,69,82]}],[{id,cho},{mode,explicit}," + "{typename,'Cho'}]]},{typename,'Person'},{tag,{'PRIVATE',3}}," + "{mode,implicit}]\n">>, + fmt("~w~n", [T])), + ?line bt(<<"[{attributes,[[{id,age,1.5},\n" + " {mode,explicit},\n" + " {typename,\"INTEGER\"}],\n" + " [{id,cho},{mode,explicit},{typename,'Cho'}]]},\n" + " {typename,'Person'},\n" + " {tag,{'PRIVATE',3}},\n" + " {mode,implicit}]\n">>, + fmt("~62p~n", [T])), + ?line bt(<<"Here T = [{attributes,[[{id,age,1.5},\n" + " {mode,explicit},\n" + " {typename,\"INTEGER\"}],\n" + " [{id,cho},\n" + " {mode,explicit},\n" + " {typename,'Cho'}]]},\n" + " {typename,'Person'},\n" + " {tag,{'PRIVATE',3}},\n" + " {mode,implicit}]\n">>, + fmt("Here T = ~62p~n", [T])), + ?line bt(<<"[{attributes,[[{id,age,1.5},{mode,explicit}," + "{typename,...}],[{id,cho},{mode,...},{...}]]}," + "{typename,'Person'},{tag,{'PRIVATE',3}},{mode,implicit}]\n">>, + fmt("~W~n", [T,9])), + ?line bt(<<"[{attributes,[[{id,age,1.5},{mode,explicit},{typename,...}]," + "\n " + "[{id,cho},{mode,...},{...}]]},\n {typename,'Person'},\n " + "{tag,{'PRIVATE',3}},\n {mode,implicit}]\n">>, + fmt("~62P~n", [T,9])), + + ?line "1F\n" = fmt("~.16B~n", [31]), + ?line "-10011\n" = fmt("~.2B~n", [-19]), + ?line "5Z\n" = fmt("~.36B~n", [5*36+35]), + ?line "10#31\n" = fmt("~X~n", [31,"10#"]), + ?line "-0x1F\n" = fmt("~.16X~n", [-31,"0x"]), + ?line "10#31\n" = fmt("~.10#~n", [31]), + ?line "-16#1F\n" = fmt("~.16#~n", [-31]), + ?line "abc def 'abc def' {foo,1} A \n" = + fmt("~s ~w ~i ~w ~c ~n", + ['abc def', 'abc def', {foo, 1},{foo, 1}, 65]), + % fmt("~s", [65]), + + %% io_lib(3) + ?line bt(<<"{1,[2],[3],[...],...}">>, + lists:flatten(io_lib:write({1,[2],[3],[4,5],6,7,8,9}, 5))), + ok. + +otp_6708(doc) -> + ["OTP-6708. Fewer newlines when pretty-printing."]; +otp_6708(suite) -> + []; +otp_6708(Config) when is_list(Config) -> + ?line bt(<<"[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,\n" + " 23,24,25,26,27,28,29|...]">>, + p(lists:seq(1,1000), 30)), + ?line bt(<<"{lkjasklfjsdak,mlkasjdflksj,klasdjfklasd,jklasdfjkl,\n" + " jklsdjfklsd,masdfjkkl}">>, + p({lkjasklfjsdak,mlkasjdflksj,klasdjfklasd,jklasdfjkl, + jklsdjfklsd, masdfjkkl}, -1)), + ?line bt(<<"#b{f = {lkjljalksdf,jklaskfjd,kljasdlf,kljasdf,kljsdlkf,\n" + " kjdd}}">>, + p({b, {lkjljalksdf,jklaskfjd,kljasdlf,kljasdf,kljsdlkf,kjdd}}, + -1)), + ?line bt(<<"#b{f = {lkjljalksdf,jklaskfjd,kljasdlf,kljasdf,kljsdlkf,\n" + " kdd}}">>, + p({b, {lkjljalksdf,jklaskfjd,kljasdlf,kljasdf,kljsdlkf,kdd}}, + -1)), + ?line bt(<<"#e{f = undefined,g = undefined,\n" + " h = #e{f = 11,g = 22,h = 333}}">>, + p({e,undefined,undefined,{e,11,22,333}}, -1)), + ?line bt(<<"[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21|\n" + " apa11]">>, + p(lists:seq(1,21) ++ apa11, -1)), + ?line bt(<<"[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,\n" + " 23,\n" + " {{abadalkjlasdjflksdajfksdklfsdjlkfdlskjflsdj" + "flsdjfldsdsdddd}}]">>, + p(lists:seq(1,23) ++ + [{{abadalkjlasdjflksdajfksdklfsdjlkfdlskjflsdjflsdjfldsdsdddd}}], + -1)), + ?line bt(<<"{lkjasdf,\n" + " {kjkjsd,\n" + " {kjsd,\n" + " {kljsdf,\n" + " {kjlsd,{dkjsdf,{kjlds,{kljsd,{kljs," + "{kljlkjsd}}}}}}}}}}">>, + p({lkjasdf,{kjkjsd,{kjsd, + {kljsdf, + {kjlsd, + {dkjsdf,{kjlds, + {kljsd,{kljs,{kljlkjsd}}}}}}}}}}, + -1)), + ?line bt(<<"{lkjasdf,\n" + " {kjkjsd,\n" + " {kjsd,{kljsdf,{kjlsd,{dkjsdf,{kjlds," + "{kljsd,{kljs}}}}}}}}}">>, + p({lkjasdf,{kjkjsd,{kjsd, + {kljsdf,{kjlsd,{dkjsdf, + {kjlds,{kljsd,{kljs}}}}}}}}}, + -1)), + ?line bt(<<"<<1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,\n" + " 22,23>>">>, + p(list_to_binary(lists:seq(1,23)), -1)), + ?line bt(<<"<<100,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,\n" + " 27>>">>, + p(list_to_binary([100|lists:seq(10,27)]), -1)), + ?line bt(<<"<<100,101,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,\n" + " 26>>">>, + p(list_to_binary([100,101|lists:seq(10,26)]), -1)), + ?line bt(<<"{{<<100,101,102,10,11,12,13,14,15,16,17,18,19,20,21,22,\n" + " 23>>}}">>, + p({{list_to_binary([100,101,102|lists:seq(10,23)])}}, -1)), + ?line bt(<<"[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22|\n" + " ap]">>, + p(lists:seq(1,22) ++ ap, -1)), + ?line bt(<<"[1,2,3,4,5,6,7,8,9,10,{},[],\n <<>>,11,12,13,14,15]">>, + p(lists:seq(1,10) ++ [{},[],<<>>] ++ lists:seq(11,15),1,30,-1)), + ?line bt(<<"[ddd,ddd,\n" + " {1},\n" + " [1,2],\n" + " ddd,kdfd,\n" + " [[1,2],a,b,c],\n" + " <<\"foo\">>,<<\"bar\">>,1,\n" + " {2}]">>, + p([ddd,ddd,{1},[1,2],ddd,kdfd,[[1,2],a,b,c],<<"foo">>,<<"bar">>, + 1,{2}],1,50,-1)), + + ?line bt(<<"{dskljsadfkjsdlkjflksdjflksdjfklsdjklfjsdklfjlsdjfkl,jksd,\n" + " " + "lkjsdf,kljsdf,kljsf,kljsdf,kljsdf,jkldf,jklsdf,kljsdf,\n" + " " + "kljsdf,jklsdf,lkjfd,lkjsdf,kljsdf,kljsdf,lkjsdf,kljsdf,\n" + " " + "lkjsdfsd,kljsdf,kjsfj}">>, + p({dskljsadfkjsdlkjflksdjflksdjfklsdjklfjsdklfjlsdjfkl,jksd, + lkjsdf,kljsdf,kljsf,kljsdf,kljsdf,jkldf,jklsdf,kljsdf, + kljsdf,jklsdf,lkjfd,lkjsdf,kljsdf,kljsdf,lkjsdf,kljsdf, + lkjsdfsd,kljsdf,kjsfj}, 1, 110, -1)), + ?line bt(<<"{dskljsadfkjsdlkjflksdjflksdjfklsdjklfjsdklfjlsdjfkl," + "#d{aaaaaaaaaaaaaaaaaaaa = 1,\n" + " " + "bbbbbbbbbbbbbbbbbbbb = 2,cccccccccccccccccccc = 3,\n" + " " + "dddddddddddddddddddd = 4,eeeeeeeeeeeeeeeeeeee = 5}}">>, + rp({dskljsadfkjsdlkjflksdjflksdjfklsdjklfjsdklfjlsdjfkl, + {d,1,2,3,4,5}},1,200,-1)), + ok. + +-define(ONE(N), ((1 bsl N) - 1)). +-define(ALL_ONES, ((1 bsl 52) - 1)). + +otp_7084(doc) -> + ["OTP-7084. Printing floating point numbers nicely."]; +otp_7084(suite) -> + []; +otp_7084(Config) when is_list(Config) -> + OldDog=?config(watchdog, Config), + test_server:timetrap_cancel(OldDog), + Timeout = 180, + ?line Dog = test_server:timetrap({seconds,Timeout}), + L = [{g_warm_up, fun g_warm_up/0}, + {g_big_pos_float, fun g_big_pos_float/0}, + {g_small_neg_float, fun g_small_neg_float/0}, + {g_close_to_zero, fun g_close_to_zero/0}, + {g_denormalized, fun g_denormalized/0}, + {g_normalized, fun g_normalized/0}, + {g_choice, fun g_choice/0}, + {g_misc, fun g_misc/0}], + F = fun({M,T}) -> io:format("~p~n", [M]), T() end, + R = try + lists:foreach(fun(T) -> F(T) end, L), + ok + catch throw:Reason -> + Reason + end, + ?line test_server:timetrap_cancel(Dog), + R. + +g_warm_up() -> + g_t(0.5), + g_t(-0.5), + g_t((1 bsl 55) * 0.5), + g_t(-(1 bsl 55) * 0.5), + g_t(1.6799127650033296e+308), + g_t(pack(1, 0, 2#1010101010001100101000010111100101000000101100110001)), + g_t(pack(1, 0, 2#0001010000001001110100000101010101001110010001010110)), + g_t(234324324.23432432432432), + ok. + +g_big_pos_float() -> + %% The greatest positive float: + ft({{0,2046,?ONE(52)}, 100, 0}), + ok. + +g_small_neg_float() -> + %% The least negative float: + ft({{1,2046,?ONE(52)}, 0, 100}), + ok. + +g_close_to_zero() -> + %% A few denormalized floats close to zero: + ft({{0,0,0}, 100, 100}), + g_t(pack(1, 0, 0)), % -0.0 + ok. + +g_denormalized() -> + %% Denormalized floats (mantissa carry): +% D = 5, + %% Faster: + D = 1, + [ft({{S,0,?ONE(N)},D,D}) || S <- [0,1], N <- lists:seq(0, 52)], + ok. + +g_normalized() -> + %% Normalized floats (exponent carry): +% D = 5, + %% Faster: + D = 1, + [ft({{S,E,?ONE(52)},D,D}) || S <- [0,1], E <- lists:seq(0, 2045)], + ok. + +g_choice() -> + %% Exponent should be used when and only when the string is shorter. + %% (g_misc/0 checks this too, and probably more throughly). + L = [0.0003, 3.0e-5, 3.3e-5, 3.3e-4, + 314.0, 314.1, 310.0, 3.1e6, -100.0, + 3.34e4, 3.0e3, 3.34333e9, 3.3433323e10, 33433323700.0, + 0.00197963, 1.97963e-4], + lists:foreach(fun(V) -> g_t(V) end, L), + ok. + +g_misc() -> + L_0_308 = lists:seq(0, 308), + L_0_307 = lists:seq(0, 307), +% L_1_9 = lists:seq(1, 9), +% L_0_9 = lists:seq(0, 9), + %% Faster: + L_1_9 = [1,5,9], + L_0_9 = [0,1,5,9], + + %% 1.0,10.0, ... 2.0,20.0, ... 9.0,90.0, ... -1,-10, ... -2.0,-20.0... + [g_t(S*T*pow10(N)) || S <- [1.0, -1.0], T <- L_1_9, N <- L_0_307], + + %% 1.0,1.0/10,1.0/100,... 2.0,2.0/10,2.0/100, ... 9.0,9.0/10,9.0/100, + %% -1.0,-1.0/10,... -9.0,-9.0/10... + [g_t(S*T/pow10(N)) || S <- [1.0, -1.0], T <- L_1_9, N <- L_0_308], + + %% 0.0,1.0,2.0,...,9.0, 0.0,10.0,20.0,...,90.0,... + %% 0.0,-1.0,-2.0,...,-9.0, 0.0,-10.0,-20.0,...,-90.0,... + [g_t(S*list_to_float([D+$0]++lists:duplicate(N, $0)++".0")) || + S <- [1.0,-1.0], N <- lists:seq(0, 300), D <- L_0_9], + + %% 0.0,0.1,0.2,...0,9, 0.0,0.01,0.02,...,0.09, + %% 0.0,-0.1,-0.2,...-0,9, 0.0,-0.01,-0.02,...,-0.09, + [g_t(S*list_to_float("0."++lists:duplicate(N, $0)++[D+$0])) || + S <- [1.0,-1.0], N <- lists:seq(0, 300), D <- L_0_9], + ok. + +ft({{S,E,M}, L, G}) -> + ft({pack(S, E, M), L, G}); +ft({V, Less, Greater}) when is_float(V) -> + _ = g_t(V), + ft(V, fun inc/1, Greater), + ft(V, fun dec/1, Less). + +ft(V0, F, I) when I > 0, is_float(V0) -> + V = F(V0), + _ = g_t(V), + ft(V, F, I - 1); +ft(V, _F, 0) when is_float(V) -> + ok. + +g_t(V) when is_float(V) -> + %% io:format("Testing ~.17g~n", [V]), + Io = io_lib:format("~p", [V]), + Sv = binary_to_list(iolist_to_binary(Io)), + ok = g_t(V, Sv), + Sv. + +%% -> ok | THROW + +%% Checks that Sv is the shortest, correctly rounded string that +%% converts to V when read back with list_to_float/1. +%% Note: in a few cases the least significant digit has been +%% incremented by one, namely when the correctly rounded string +%% converts to another floating point number. +g_t(0.0, "0.0") -> + ok; +g_t(V, Sv) -> + try + g_t_1(V, Sv) + catch throw:Reason -> + throw({Reason, V, Sv}) + end. + +g_t_1(V, Sv) -> + %% Check that the least significant digit is correct. + %% If Sv is "3.14" then Sv- is "3.13" and Sv+ is "3.15". + %% Check that |V - Sv| =< (V - Sv-) and + %% that |V - Sv| =< (Sv+ - V) + Times = least_significant_digit(Sv), + case Times of + 0 -> throw(least_significant_digit_is_zero); + _ -> ok + end, + S = if V < 0 -> -1; true -> 1 end, + SvMinus = incr_lsd(Sv, -S), + SvPlus = incr_lsd(Sv, S), + Svr = s2r(Sv), + Svminusr = s2r(SvMinus), + Svplusr = s2r(SvPlus), + Vr = f2r(V), + + Abs_Sv_Vr = rat_abs(rat_minus(Svr, Vr)), + Svminus_Vr = rat_minus(Vr, Svminusr), + Svplus_Vr = rat_minus(Svplusr, Vr), + %% The are 45 (negative) floats where SvMinus (SvPlus) is closer + %% to V than Sv, but such that when reading SvMinus (SvPlus) wrong + %% float would be returned. + case rat_lte(Abs_Sv_Vr, Svminus_Vr) of + true -> + ok; + false -> + case list_to_float(SvMinus) of + V -> throw(vsminus_too_close_to_v); + _Vminus -> ok + end + end, + case rat_lte(Abs_Sv_Vr, Svplus_Vr) of + true -> + ok; + false -> + case list_to_float(SvPlus) of + V -> throw(vsplus_too_close_to_v); + _Vplus -> ok + end + end, + + %% Check that Sv is closer to V than to V- and V+. + %% Check that |V - Sv| =< (V - V-) and + %% that |V - Sv| =< (V+ - V) + %% (An alternative is V- + V =< 2*Sv =< V + V+.) + case inc(V) of + inf -> + ok; + Vplus -> + Vplusr = f2r(Vplus), + V_Vplusr = rat_minus(Vplusr, Vr), + case rat_lte(Abs_Sv_Vr, V_Vplusr) of + true -> ok; + false -> throw(vplus_too_close_to_sv) + end + end, + case dec(V) of + '-inf' -> + ok; + Vminus -> + Vminusr = f2r(Vminus), + V_Vminusr = rat_minus(Vr, Vminusr), + case rat_lte(Abs_Sv_Vr, V_Vminusr) of + true -> ok; + false -> throw(vminus_too_close_to_sv) + end + end, + + %% Check that no prefix of Sv yields V. + %% If Sv is "3.14" then Svlow is "3.1" and Svhigh is "3.2". + %% + %% This is just one way of getting Svlow and Svhigh: + if + V < 0 -> + SvHigh = step_lsd(Sv, -Times), + SvLow = step_lsd(Sv, 10 - Times); + true -> + SvHigh = step_lsd(Sv, 10 - Times), + SvLow = step_lsd(Sv, -Times) + end, + + case catch list_to_float(SvLow) of + V -> throw(low_is_v); + _ -> ok + end, + + case catch list_to_float(SvHigh) of + V -> throw(high_is_v); + _ -> ok + end, + + %% Check that Sv has enough digits. + case list_to_float(Sv) of + V -> ok; + _ -> throw(wrong_float) % cannot happen + end, + + g_choice(Sv), + + ok. + +%%% In "123450000.0", '5' is the lsd; +%%% in "1234.0000", (the last) '0' is the lsd; +%%% in "1234.0", '4' is the lsd (the Erlang syntax requires the final zero). + +%% Trailing zeroes are not significant ("3.0", "5.0e-324", "232000.0"). +least_significant_digit("-"++Ds) -> + least_significant_digit(Ds); +least_significant_digit("+"++Ds) -> + least_significant_digit(Ds); +least_significant_digit(Ds) -> + [MS|_E] = string:tokens(Ds, "eE"), + lsd0(lists:reverse(MS))-$0. + +lsd0("0."++Ds) -> + lsd1(Ds); +lsd0([D | _Ds]) -> + D. + +lsd1("0"++Ds) -> + lsd1(Ds); +lsd1([D | _Ds]) -> + D. + +step_lsd(Ds, 0) -> + Ds; +step_lsd(Ds, N) when N > 0 -> + NDs = incr_lsd(Ds, 1), + step_lsd(NDs, N - 1); +step_lsd(Ds, N) when N < 0 -> + NDs = incr_lsd(Ds, -1), + step_lsd(NDs, N + 1). + +%% Assumes Ds represents some other number than zero. +%% Increments or decrements the least significant digit. +incr_lsd("-"++Ds, I) -> + "-"++incr_lsd(Ds, I); +incr_lsd(Ds, I) when I =:= 1; I =:= -1 -> + [MS|E] = string:tokens(Ds, "eE"), + X = ["e" || true <- [E =/= []]], + lists:flatten([incr_lsd0(lists:reverse(MS), I, []), X, E]). + +incr_lsd0("0."++Ds, C, L) -> + incr_lsd1(Ds, C, [$., $0 | L]); +incr_lsd0(Ds, C, L) -> + incr_lsd2(Ds, C, L). + +incr_lsd1("0"++Ds, C, L) -> + incr_lsd1(Ds, C, [$0 | L]); +incr_lsd1(Ds, C, L) -> + incr_lsd2(Ds, C, L). + +incr_lsd2([], C, L) -> + [C + $0 | L]; +incr_lsd2("."++Ds, C, L) -> + incr_lsd2(Ds, C, [$. | L]); +incr_lsd2("9"++Ds, 1=C, L) -> + incr_lsd2(Ds, C, [$0 | L]); +incr_lsd2("0"++Ds, -1=C, L) -> + incr_lsd2(Ds, C, [$9 | L]); +incr_lsd2([D | Ds], C, L) -> + lists:reverse(Ds, [D + C | L]). + +s2r(S) when is_list(S) -> + case string:tokens(S, "eE") of + [MS] -> + s10(MS); + [MS, ES] -> + Mr = s10(MS), + E = list_to_integer(ES), + if + E < 0 -> + rat_multiply(Mr, {1,pow10(-E)}); + true -> + rat_multiply(Mr, {pow10(E), 1}) + end + end. + +s10("-"++S) -> + rat_multiply({-1,1},s10(S)); +s10(S) -> + [AS, BS] = string:tokens(S, "."), + Sc = length(BS), + A = list_to_integer(AS), + B = list_to_integer(BS), + F = pow10(Sc), + rat_multiply({1,1}, {A*F + B, F}). + +pow10(X) -> + int_pow(10, X). + +int_pow(X, 0) when is_integer(X) -> + 1; +int_pow(X, N) when is_integer(X), is_integer(N), N > 0 -> + int_pow(X, N, 1). + +int_pow(X, N, R) when N < 2 -> + R * X; +int_pow(X, N, R) -> + int_pow(X * X, N bsr 1, case N band 1 of 1 -> R * X; 0 -> R end). + +dec(F) when is_float(F) -> + <<S:1, BE:11, M:52>> = <<F:64/float>>, + dec({S,BE,M}); +dec({1,2046,?ALL_ONES}) -> + '-inf'; +dec({S,BE,M}) when 0 =< S, S =< 1, + 0 =< BE, BE =< 2046, + 0 =< M, M =< ?ALL_ONES -> + {S1,BE1,M1} = dec1(S, BE, M), + <<F:64/float>> = <<S:1, BE:11, M:52>>, + <<F1:64/float>> = <<S1:1, BE1:11, M1:52>>, + true = F1 < F, + F1. + + +dec1(0, 0, 0) -> + dec1(1, 0, 0); +dec1(0, BE, 0) -> + {0,BE-1,?ALL_ONES}; +dec1(0, BE, M) -> + {0,BE,M-1}; +dec1(1, BE, ?ALL_ONES) -> + {1,BE+1,0}; +dec1(1, BE, M) -> + {1,BE,M+1}. + +inc(F) when is_float(F) -> + <<S:1, BE:11, M:52>> = <<F:64/float>>, + inc({S,BE,M}); +inc({0,2046,?ALL_ONES}) -> + inf; +inc({S,BE,M}) when 0 =< S, S =< 1, + 0 =< BE, BE =< 2046, + 0 =< M, M =< ?ALL_ONES -> + {S1,BE1,M1} = inc1(S, BE, M), + <<F:64/float>> = <<S:1, BE:11, M:52>>, + <<F1:64/float>> = <<S1:1, BE1:11, M1:52>>, + true = F1 > F, + F1. + +inc1(0, BE, ?ALL_ONES) -> + {0,BE+1,0}; +inc1(0, BE, M) -> + {0,BE,M+1}; +inc1(1, 0, 0) -> + inc1(0, 0, 0); +inc1(1, BE, 0) -> + {1,BE-1,?ALL_ONES}; +inc1(1, BE, M) -> + {1,BE,M-1}. + +f2r(F) when is_float(F) -> + <<S:1, BE:11, M:52>> = <<F:64/float>>, + f2r({S,BE,M}); +f2r({S,BE,M}) when 0 =< S, S =< 1, + 0 =< BE, BE =< 2046, + 0 =< M, M =< ?ALL_ONES -> + Vr = {T,N} = f2r1(S, BE, M), + <<F:64/float>> = <<S:1, BE:11, M:52>>, + case catch T/N of + {'EXIT', _} -> ok; + TN -> true = F =:= TN + end, + Vr. + +f2r1(S, 0, M) -> + rat_multiply({sign(S),1}, {M, 1 bsl 1074}); +f2r1(S, BE, M) when BE - 1075 >= 0 -> + rat_multiply({sign(S),1}, {((1 bsl 52)+M) * (1 bsl (BE-1075)),1}); +f2r1(S, BE, M) -> + rat_multiply({sign(S),1}, {(1 bsl 52)+M, 1 bsl (1075-BE)}). + +sign(0) -> + 1; +sign(1) -> + -1. + +%%% Rational numbers (very scetchy). + +rat_abs({A,B}) when A < 0 -> + {-A,B}; +rat_abs({A,B}) -> + {A,B}. + +-ifdef(not_used). +rat_equal(R1, R2) -> + R1 =:= R2. + +rat_negate({A,B}) -> + {-A,B}. + +rat_divide({A,B},{C,D}) -> + rat_multiply({A,B},{D,C}). +-endif. + +rat_lte({A,B}, {C,D}) when B =/= 0, D =/= 0 -> + A*D =< C*B. + +rat_minus({A,B}, {C,D}) -> + rat_plus({A,B}, {-C,D}). + +rat_plus({A,B}, {C,D}) when B =/= 0, D =/= 0 -> + rat_normalize({A*D+B*C, B*D}). + +rat_multiply({A,B}, {C,D}) when B =/= 0, D =/= 0 -> + rat_normalize({A * C, B * D}). + +rat_normalize({T,N}) when N =/= 0 -> + G = gcd(T, N), + T2 = T div G, + N2 = N div G, + if + T2 < 0 -> + if + N2 < 0 -> {-T2,-N2}; + true -> {T2,N2} + end; + true -> + if + N2 < 0 -> {-T2,-N2}; + true -> {T2,N2} + end + end. + +gcd(A, 0) -> A; +gcd(A, B) -> gcd(B, A rem B). + +%%% End of rational numbers. + +%% Check that there is an exponent if and only if characters are +%% saved. Note: this assumes floating point numbers "Erlang style" +%% (with a single zero before and after the dot, and no extra leading +%% zero in the exponent). +g_choice(S) when is_list(S) -> + [MS | ES0] = string:tokens(S, "eE"), + [IS, FS] = string:tokens(MS, "."), + Il = length(IS), + Fl = length(FS), + Pre = z(MS), + Post = z(lists:reverse(MS)), + ES = lists:append(ES0), + El = length(ES), + I = list_to_integer(IS), + if + El =/= 0, ((I > 9) or (I < -9)) -> + throw(too_many_digits_before_the_dot); + El =/= 0, I =:= 0 -> + throw(zero_before_the_dot); + Pre =:= 0, Post > 0, El =:= 0 -> % DDDD0000.0 + Saving = if + I < 0, Il =:= Post + 2 -> + Post; + I > 0, Il =:= Post + 1 -> + Post; + I =/= 0, true -> + Post + 1 + end, + Cost = 1 + length(integer_to_list(Il - 1)), + if + Cost < Saving -> + throw(with_exponent_is_shorter); + true -> + ok + end; + Pre > 0, Post =:= 0, El =:= 0 -> % 0.000DDDD + Saving = if + Fl =:= Pre + 1 -> + Pre; + true -> + Pre + 1 + end, + Cost = 2 + length(integer_to_list(Pre + 1)), + if + Cost < Saving -> + throw(with_exponent_is_shorter); + true -> + ok + end; + Pre =:= 0, Post =:= 0, El > 0 -> % D.DDDeDD + E = list_to_integer(ES), + if + E >= 0 -> + Cost = E - (Fl - 1); + E < 0 -> + Cost = -E + end, + Saving = length(ES) + 1, + if + Cost =:= Saving -> + throw(draw_but_choose_form_without_exponent); + Cost < Saving -> + throw(without_exponent_is_shorter); + true -> + ok + end; + Pre =:= 0, Post =:= 0, El =:= 0 -> % DDD.DDD + ok; + true -> + throw(badly_formed_floating_point_string) + end. + +z("0."++Ds) -> + length(lists:takewhile(fun(D) -> D =:= $0 end, Ds)); +z(_Ds) -> + 0. + +pack(Sign, Exp, Frac) -> + <<Float:64/float>> = <<Sign:1, Exp:11, Frac:52>>, + Float. + +%% Whitebox test of io_lib:collect_line/3. +io_lib_collect_line_3_wb(Config) when is_list(Config) -> + ?line do_collect_line(binary, "\n"), + ?line do_collect_line(binary, "\r\n"), + ?line do_collect_line(list, "\n"), + ?line do_collect_line(list, "\r\n"), + ok. + +do_collect_line(Mode, Eol) -> + First = "abcde", + FirstNL = First++"\n", + Second = "unterminated line", + Data0 = First ++ Eol ++ Second, + {Data1,Result0} = do_collect_line_combine(Mode, Data0, FirstNL, Second), + do_collect_line_1(Mode, Data1, Result0, []), + + {Data,Result} = do_collect_line_combine(Mode, "unterm", "unterm", eof), + do_collect_line_1(Mode, Data, Result, []). + +do_collect_line_combine(binary, Data0, FirstNL, eof) -> + {list_to_binary(Data0), + {stop,list_to_binary(FirstNL),eof}}; +do_collect_line_combine(binary, Data0, FirstNL, Second) -> + {list_to_binary(Data0), + {stop,list_to_binary(FirstNL),list_to_binary(Second)}}; +do_collect_line_combine(list, Data0, FirstNL, Second) -> + {Data0,{stop,FirstNL,Second}}. + +do_collect_line_1(Mode, [H|T], Result, Acc0) -> + Acc = [H|Acc0], + Result = do_collect_line_2(lists:reverse(Acc), T), + do_collect_line_1(Mode, T, Result, Acc); +do_collect_line_1(Mode, <<H,T/binary>>, Result, Acc0) -> + Acc = [H|Acc0], + Result = do_collect_line_2(list_to_binary(lists:reverse(Acc)), T), + do_collect_line_1(Mode, T, Result, Acc); +do_collect_line_1(_Mode, [], _Result, _Acc) -> + ok; +do_collect_line_1(_Mode, <<>>, _Result, _Acc) -> + ok. + +do_collect_line_2(Part1, Part2) -> + Dummy = make_ref(), + do_collect_line_3(start, [Part1,Part2,eof], Dummy). + +do_collect_line_3(State0, [H|T], Dummy) -> + case io_lib:collect_line(State0, H, Dummy) of + {stop,Line,Rest} -> + {stop,Line,do_collect_line_adjust_rest(Rest, T)}; + State -> + do_collect_line_3(State, T, Dummy) + end. + +do_collect_line_adjust_rest(eof, []) -> eof; +do_collect_line_adjust_rest(eof, <<>>) -> eof; +do_collect_line_adjust_rest(Rest, [eof]) -> Rest; +do_collect_line_adjust_rest(Rest, [Bin|T]) when is_binary(Bin) -> + do_collect_line_adjust_rest(<<Rest/binary,Bin/binary>>, T); +do_collect_line_adjust_rest(Rest, [List|T]) when is_list(List) -> + do_collect_line_adjust_rest(Rest++List, T). + + + +cr_whitespace_in_string(Config) when is_list(Config) -> + ?line {ok,["abc"],[]} = io_lib:fread("~s", "\rabc"). + + + +io_fread_newlines(Config) when is_list(Config) -> + ?line PrivDir = ?privdir(Config), + ?line Fname = filename:join(PrivDir, "io_fread_newlines.txt"), + ?line F0 = [[0,1,2,3,4,5,6,7,8,9]], + ?line F1 = [[0,1,2,3,4,5,6,7,8],[9]], + ?line F2 = [[0,1,2,3,4,5,6,7],[8,9]], + ?line F3 = [[0,1,2,3,4,5,6],[7,8,9]], + ?line F4 = [[0,1,2,3,4,5],[6,7,8,9]], + ?line F5 = [[0,1,2,3,4],[5,6,7,8,9]], + ?line F6 = [[0,1,2,3],[4,5,6,7],[8,9]], + ?line F7 = [[0,1,2],[3,4,5],[6,7,8],[9]], + ?line F8 = [[0,1],[2,3],[4,5],[6,7],[8,9]], + ?line F9 = [[0],[1],[2],[3],[4],[5],[6],[7],[8],[9]], + ?line Newlines = ["\n", "\r\n", "\r"], + try + ?line io_fread_newlines_1([F0,F1,F2,F3,F4,F5,F6,F7,F8,F9], + Fname, Newlines) + after + file:delete(Fname) + end. + +io_fread_newlines_1(Fs, Fname, [Newline|Newlines]) -> + ?line ok = io_fread_newlines_2(Fs, Fname, Newline), + ?line io_fread_newlines_1(Fs, Fname, Newlines); +io_fread_newlines_1(_, _, []) -> ok. + +io_fread_newlines_2([F|Fs], Fname, Newline) -> + ?line N1 = write_newlines_file(Fname, F, Newline), + ?line {F2,N2} = read_newlines_file(Fname), + ?line io:format("~w ~p ~w~n~n", [N1,F,N2]), + ?line F2 = lists:flatten(F), + %% Intermediate newlines are not counted + ?line N2 = N1 - (length(F) - 1)*length(Newline), + ?line io_fread_newlines_2(Fs, Fname, Newline); +io_fread_newlines_2([], _, _) -> ok. + + +write_newlines_file(Fname, F, Newline) -> + Bytes = list_to_binary(digit_lines(F, Newline)), + io:format("Data: ~w~n~w~n", [Newline,Bytes]), + ok = file:write_file(Fname, Bytes), + size(Bytes). + +digit_lines([L], _) -> + digit_line(L); +digit_lines([L|Ls], Newline) -> + [digit_line(L),Newline|digit_lines(Ls, Newline)]. + +digit_line([D]) -> + integer_to_list(D); +digit_line([D|Ds]) -> + [integer_to_list(D), " ", digit_line(Ds)]. + +read_newlines_file(Fname) -> + {ok,Fd} = file:open(Fname, [read]), + try {L, N0} = R0 = read_newlines(Fd, [], 0), + case io:fread(Fd, "", "~*s~l") of + eof -> R0; + {ok,[N]} -> {L,N0+N} + end + after + file:close(Fd) + end. + + +read_newlines(Fd, Acc, N0) -> + case io:fread(Fd, "", "~d~l") of + {ok,[D,N]} -> + read_newlines(Fd, [D|Acc], N0+N); + eof -> + {lists:reverse(Acc),N0} + end. |