aboutsummaryrefslogtreecommitdiffstats
path: root/lib/stdlib/test/io_proto_SUITE.erl
diff options
context:
space:
mode:
Diffstat (limited to 'lib/stdlib/test/io_proto_SUITE.erl')
-rw-r--r--lib/stdlib/test/io_proto_SUITE.erl1824
1 files changed, 1824 insertions, 0 deletions
diff --git a/lib/stdlib/test/io_proto_SUITE.erl b/lib/stdlib/test/io_proto_SUITE.erl
new file mode 100644
index 0000000000..46407193d7
--- /dev/null
+++ b/lib/stdlib/test/io_proto_SUITE.erl
@@ -0,0 +1,1824 @@
+%%
+%% %CopyrightBegin%
+%%
+%% Copyright Ericsson AB 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_proto_SUITE).
+
+-export([all/1]).
+
+-export([init_per_testcase/2, fin_per_testcase/2]).
+
+-export([setopts_getopts/1,unicode_options/1,unicode_options_gen/1, binary_options/1, bc_with_r12/1,
+ bc_with_r12_gl/1, read_modes_gl/1,bc_with_r12_ogl/1, read_modes_ogl/1, broken_unicode/1,eof_on_pipe/1]).
+
+
+-export([io_server_proxy/1,start_io_server_proxy/0, proxy_getall/1, proxy_setnext/2, proxy_quit/1]).
+%% For spawn
+-export([toerl_server/3,hold_the_line/3,answering_machine1/3,
+ answering_machine2/3]).
+
+%-define(without_test_server, true).
+
+-ifdef(without_test_server).
+-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(privdir(Conf), ?config(priv_dir, Conf)).
+-endif.
+
+%-define(debug, true).
+
+-ifdef(debug).
+-define(format(S, A), io:format(S, A)).
+-define(dbg(Data),io:format(standard_error, "DBG: ~p\r\n",[Data])).
+-else.
+-define(format(S, A), ok).
+-define(dbg(Data),noop).
+-endif.
+
+
+% Default timetrap timeout (set in init_per_testcase).
+-define(default_timeout, ?t:minutes(20)).
+
+init_per_testcase(_Case, Config) ->
+ ?line Dog = ?t:timetrap(?default_timeout),
+ Term = case os:getenv("TERM") of
+ List when is_list(List) ->
+ List;
+ _ ->
+ "dumb"
+ end,
+ os:putenv("TERM","vt100"),
+ [{watchdog, Dog}, {term, Term} | Config].
+fin_per_testcase(_Case, Config) ->
+ Dog = ?config(watchdog, Config),
+ Term = ?config(term,Config),
+ os:putenv("TERM",Term),
+ test_server:timetrap_cancel(Dog),
+ ok.
+
+all(doc) ->
+ ["Test cases for the io_protocol."];
+all(suite) ->
+ [setopts_getopts, unicode_options, unicode_options_gen, binary_options, bc_with_r12,
+ bc_with_r12_gl,bc_with_r12_ogl, read_modes_gl, read_modes_ogl,
+ broken_unicode,eof_on_pipe].
+
+
+-record(state, {
+ q = [],
+ nxt = eof,
+ mode = list
+ }).
+
+setopts_getopts(suite) ->
+ [];
+setopts_getopts(doc) ->
+ ["Check io:setopts and io:getopts functions"];
+setopts_getopts(Config) when is_list(Config) ->
+ ?line FileName = filename:join([?config(priv_dir,Config),
+ "io_proto_SUITE_setopts_getopts.dat"]),
+ ?line {ok,WFile} = file:open(FileName,[write]),
+ ?line Server = start_io_server_proxy(),
+ ?line [{binary, false}] = io:getopts(Server),
+ ?line [getopts] = proxy_getall(Server),
+ ?line [{binary,false},{encoding,latin1}] = lists:sort(io:getopts(WFile)),
+ ?line proxy_setnext(Server,"Hej"),
+ ?line "Hej" = io:get_line(Server,''),
+ ?line proxy_setnext(Server,"Hej"++[532]),
+ ?line [$H,$e,$j,532] = io:get_line(Server,''),
+ ?line ok = io:setopts(Server,[{binary,true}]),
+ ?line proxy_setnext(Server,"Hej"),
+ ?line <<"Hej">> = io:get_line(Server,''),
+ ?line proxy_setnext(Server,"Hej"++[532]),
+ ?line <<72,101,106,200,148>> = io:get_line(Server,''),
+ ?line [$H,$e,$j,532] = lists:flatten(io_lib:format("~ts",[<<72,101,106,200,148>>])),
+ ?line file:write(WFile,<<"HejA">>),
+ ?line file:write(WFile,unicode:characters_to_binary("Hej"++[532],unicode,unicode)),
+ ?line file:write(WFile,unicode:characters_to_binary("Hej"++[532],unicode,{utf16,big})),
+ ?line file:write(WFile,unicode:characters_to_binary("Hej"++[532],unicode,{utf16,little})),
+ ?line file:write(WFile,unicode:characters_to_binary("Hej"++[532],unicode,{utf32,big})),
+ ?line file:write(WFile,unicode:characters_to_binary("Hej"++[532],unicode,{utf32,little})),
+ ?line file:close(WFile),
+ ?line {ok,RFile} = file:open(FileName,[read]),
+ ?line [{binary,false},{encoding,latin1}] = lists:sort(io:getopts(RFile)),
+ ?line [$H,$e,$j,$A] = io:get_chars(RFile,'',4),
+ ?line io:setopts(RFile,[{encoding,unicode}]),
+ ?line [$H,$e,$j,532] = io:get_chars(RFile,'',4),
+ ?line [{binary,false},{encoding,unicode}] = lists:sort(io:getopts(RFile)),
+ ?line io:setopts(RFile,[{encoding,{utf16,big}}]),
+ ?line [$H,$e,$j,532] = io:get_chars(RFile,'',4),
+ ?line [{binary,false},{encoding,{utf16,big}}] =
+ lists:sort(io:getopts(RFile)),
+ ?line io:setopts(RFile,[{encoding,{utf16,little}}]),
+ ?line [$H,$e,$j,532] = io:get_chars(RFile,'',4),
+ ?line [{binary,false},{encoding,{utf16,little}}] =
+ lists:sort(io:getopts(RFile)),
+ ?line io:setopts(RFile,[{encoding,{utf32,big}}]),
+ ?line [$H,$e,$j,532] = io:get_chars(RFile,'',4),
+ ?line [{binary,false},{encoding,{utf32,big}}] =
+ lists:sort(io:getopts(RFile)),
+ ?line io:setopts(RFile,[{encoding,{utf32,little}}]),
+ ?line [$H,$e,$j,532] = io:get_chars(RFile,'',4),
+ ?line [{binary,false},{encoding,{utf32,little}}] =
+ lists:sort(io:getopts(RFile)),
+ ?line eof = io:get_line(RFile,''),
+ ?line file:position(RFile,0),
+ ?line io:setopts(RFile,[{binary,true},{encoding,latin1}]),
+ ?line <<$H,$e,$j,$A>> = io:get_chars(RFile,'',4),
+ ?line [{binary,true},{encoding,latin1}] = lists:sort(io:getopts(RFile)),
+ ?line io:setopts(RFile,[{encoding,unicode}]),
+ ?line <<$H,$e,$j,532/utf8>> = io:get_chars(RFile,'',4),
+ ?line [{binary,true},{encoding,unicode}] = lists:sort(io:getopts(RFile)),
+ ?line io:setopts(RFile,[{encoding,{utf16,big}}]),
+ ?line <<$H,$e,$j,532/utf8>> = io:get_chars(RFile,'',4),
+ ?line [{binary,true},{encoding,{utf16,big}}] =
+ lists:sort(io:getopts(RFile)),
+ ?line io:setopts(RFile,[{encoding,{utf16,little}}]),
+ ?line <<$H,$e,$j,532/utf8>> = io:get_chars(RFile,'',4),
+ ?line [{binary,true},{encoding,{utf16,little}}] =
+ lists:sort(io:getopts(RFile)),
+ ?line io:setopts(RFile,[{encoding,{utf32,big}}]),
+ ?line <<$H,$e,$j,532/utf8>> = io:get_chars(RFile,'',4),
+ ?line [{binary,true},{encoding,{utf32,big}}] =
+ lists:sort(io:getopts(RFile)),
+ ?line io:setopts(RFile,[{encoding,{utf32,little}}]),
+ ?line <<$H,$e,$j,532/utf8>> = io:get_chars(RFile,'',4),
+ ?line [{binary,true},{encoding,{utf32,little}}] =
+ lists:sort(io:getopts(RFile)),
+ ?line eof = io:get_line(RFile,''),
+ ?line file:close(RFile),
+ %% So, lets test another node with new interactive shell
+ ?line rtnode([{putline,""},
+ {putline, "2."},
+ {getline, "2"},
+ {putline, "lists:keyfind(binary,1,io:getopts())."},
+ {getline, "{binary,false}"},
+ {putline, "io:get_line('')."},
+ {putline, "hej"},
+ {getline, "\"hej\\n\""},
+ {putline, "io:setopts([{binary,true}])."},
+ {getline, "ok"},
+ {putline, "io:get_line('')."},
+ {putline, "hej"},
+ {getline, "<<\"hej\\n\">>"}
+ ],[]),
+ %% And one with oldshell
+ ?line rtnode([{putline,""},
+ {putline, "2."},
+ {getline_re, ".*2."},
+ {getline, "2"},
+ {putline, "lists:keyfind(binary,1,io:getopts())."},
+ {getline_re, ".*{binary,false}"},
+ {putline, "io:get_line('')."},
+ {putline, "hej"},
+ {getline_re, ".*\"hej\\\\n\""},
+ {putline, "io:setopts([{binary,true}])."},
+ {getline_re, ".*ok"},
+ {putline, "io:get_line('')."},
+ {putline, "hej"},
+ {getline_re, ".*<<\"hej\\\\n\">>"}
+ ],[],[],"-oldshell"),
+ ok.
+
+unicode_options(suite) ->
+ [];
+unicode_options(doc) ->
+ ["Tests various unicode options"];
+unicode_options(Config) when is_list(Config) ->
+ DataDir = ?config(data_dir,Config),
+ PrivDir = ?config(priv_dir,Config),
+ %% A string in both russian and greek characters, which is present
+ %% in all the internal test files (but in different formats of course)...
+ TestData = [1090,1093,1077,32,1073,1080,1075,32,
+ 1088,1077,1076,32,1092,1086,1100,32,1093,
+ 1072,1089,32,1089,1086,1100,32,932,951,949,
+ 32,946,953,947,32,961,949,948,32,
+ 963,959,967,32,945,961,949,32,966,959,967,949,963],
+ %% Testdata from Chinese open source customer, that triggered OTP-7974
+ TestData2 = [46,46,46,12411,12370,12411,12370,44,12411,12370,12411,12370,44,
+ 12411,12370,12411,12370,44,12411,12370,12411,12370,44,12411,12370,
+ 12411,12370,44,44,44,12411,12370,12411,12370,44,44,12411,12370,12411,
+ 12370,44,12411,12370,12411,12370,44,12411,12370,12411,12370,44,12411,
+ 12370,12411,12370,44,12411,12370,12411,12370,44,44,44,10],
+
+ %% The external test files are generated with a BOM writing
+ %% text editor. A shorter line is written (with two characters
+ %% larger than 127).
+ ExternalTestData = [197,116,101,114,101,114,246,118,114,97],
+ InternalBomFiles = ["testdata_utf8_bom.dat",
+ "testdata_utf16_big_bom.dat",
+ "testdata_utf16_little_bom.dat",
+ "testdata_utf32_big_bom.dat",
+ "testdata_utf32_little_bom.dat"],
+ AllNoBom = [{utf8,"testdata_utf8.dat"},
+ {utf16,"testdata_utf16_big.dat"},
+ {{utf16,big},"testdata_utf16_big.dat"},
+ {{utf16,little},"testdata_utf16_little.dat"},
+ {utf32,"testdata_utf32_big.dat"},
+ {{utf32,big},"testdata_utf32_big.dat"},
+ {{utf32,little},"testdata_utf32_little.dat"}],
+ ExternalBomFiles = ["external_utf8_bom.dat",
+ "external_utf16_little_bom.dat",
+ "external_utf16_big_bom.dat"],
+ ReadBomFile = fun(File,Dir) ->
+ %io:format(standard_error,"~s\r\n",[filename:join([Dir,File])]),
+ {ok,F} = file:open(filename:join([Dir,File]),
+ [read,binary]),
+ {ok,Bin} = file:read(F,4),
+ {Type,Bytes} = unicode:bom_to_encoding(Bin),
+ %io:format(standard_error,"~p\r\n",[{Type,Bytes}]),
+
+ file:position(F,Bytes),
+ io:setopts(F,[{encoding,Type}]),
+ R = unicode:characters_to_list(
+ io:get_chars(F,'',length(TestData)),unicode),
+ file:close(F),
+ R
+ end,
+ ReadBomlessFile = fun({Type,File},DataLen,Dir) ->
+ {ok,F} = file:open(filename:join([Dir,File]),
+ [read,binary,
+ {encoding,Type}]),
+ R = unicode:characters_to_list(
+ io:get_chars(F,'',DataLen),unicode),
+ file:close(F),
+ R
+ end,
+ ReadBomlessFileList = fun({Type,File},DataLen,Dir) ->
+ {ok,F} = file:open(filename:join([Dir,File]),
+ [read,
+ {encoding,Type}]),
+ R = io:get_chars(F,'',DataLen),
+ file:close(F),
+ R
+ end,
+ ReadBomlessFileListLine = fun({Type,File},Dir) ->
+ {ok,F} = file:open(filename:join([Dir,File]),
+ [read,
+ {encoding,Type}]),
+ R = io:get_line(F,''),
+ file:close(F),
+ R
+ end,
+ ?line [TestData = ReadBomFile(F,DataDir) || F <- InternalBomFiles ],
+ ?line [ExternalTestData = ReadBomFile(F,DataDir) || F <- ExternalBomFiles ],
+ ?line [TestData = ReadBomlessFile(F,length(TestData),DataDir) || F <- AllNoBom ],
+ ?line [TestData = ReadBomlessFileList(F,length(TestData),DataDir) || F <- AllNoBom ],
+ ?line [TestData = ReadBomlessFileListLine(F,DataDir) || F <- AllNoBom ],
+
+ BomDir = filename:join([PrivDir,"BOMDATA"]),
+ BomlessDir = filename:join([PrivDir,"BOMLESSDATA"]),
+ file:make_dir(BomDir),
+ file:make_dir(BomlessDir),
+
+ WriteBomFile = fun({Enc,File},Dir) ->
+ {ok,F} = file:open(filename:join([Dir,File]),
+ [write,binary]),
+ file:write(F,unicode:encoding_to_bom(Enc)),
+ io:setopts(F,[{encoding,Enc}]),
+ io:put_chars(F,TestData),
+ file:close(F),
+ ok
+ end,
+ ?line [ ok = WriteBomFile(F,BomDir) || F <- AllNoBom ],
+ ?line [TestData = ReadBomFile(F,BomDir) || {_,F} <- AllNoBom ],
+ WriteBomlessFile = fun({Enc,File},TData,Dir) ->
+ {ok,F} = file:open(
+ filename:join([Dir,File]),
+ [write,binary,{encoding,Enc}]),
+ io:put_chars(F,TData),
+ file:close(F),
+ ok
+ end,
+ ?line [ ok = WriteBomlessFile(F,TestData,BomlessDir) || F <- AllNoBom ],
+ ?line [TestData = ReadBomlessFile(F,length(TestData),BomlessDir) || F <- AllNoBom ],
+ ?line [TestData = ReadBomlessFileList(F,length(TestData),BomlessDir) || F <- AllNoBom ],
+ ?line [TestData = ReadBomlessFileListLine(F,BomlessDir) || F <- AllNoBom ],
+
+ CannotReadFile = fun({Enc,File},Dir) ->
+ %io:format(standard_error,"~s\r\n",[filename:join([Dir,File])]),
+ {ok,F} = file:open(
+ filename:join([Dir,File]),
+ [read,binary,{encoding,Enc}]),
+ Enc2 = case Enc of
+ utf8 ->
+ unicode;
+ Tpl when is_tuple(Tpl) ->
+ Tpl;
+ Atom when is_atom(Atom) ->
+ {Atom, big}
+ end,
+ {error, {no_translation,Enc2,latin1}} =
+ file:read(F,10),
+ {error,terminated} = io:get_chars(F,'',10),
+ ok
+ end,
+ ?line [ ok = CannotReadFile(F,DataDir) || F <- AllNoBom ],
+ ?line [ ok = CannotReadFile(F,BomlessDir) || F <- AllNoBom ],
+ ?line [ ok = CannotReadFile(F,BomDir) || F <- AllNoBom ],
+
+ ?line [ ok = WriteBomlessFile(F,TestData2,BomlessDir) || F <- AllNoBom ],
+ ?line [TestData2 = ReadBomlessFile(F,length(TestData2),BomlessDir) || F <- AllNoBom ],
+ ?line [TestData2 = ReadBomlessFileList(F,length(TestData2),BomlessDir) || F <- AllNoBom ],
+ ?line [TestData2 = ReadBomlessFileListLine(F,BomlessDir) || F <- AllNoBom ],
+
+
+ FailDir = filename:join([PrivDir,"FAIL"]),
+ file:make_dir(FailDir),
+
+ CannotWriteFile = fun({_Enc,File},Dir) ->
+ {ok,F} = file:open(
+ filename:join([Dir,File]),
+ [write,binary]),
+ ?line {'EXIT', {no_translation,_}} =
+ (catch io:put_chars(F,TestData)),
+ ?line {'EXIT', {terminated,_}} = (catch io:put_chars(F,TestData)),
+ ok
+ end,
+ ?line [ ok = CannotWriteFile(F,FailDir) || F <- AllNoBom ],
+
+ %% OK, time for the group_leaders...
+ ?line rtnode([{putline,""},
+ {putline, "2."},
+ {getline, "2"},
+ {putline, "lists:keyfind(encoding,1,io:getopts())."},
+ {getline, "{encoding,latin1}"},
+ {putline, "io:format(\"~ts~n\",[[1024]])."},
+ {getline, "\\x{400}"},
+ {putline, "io:setopts([unicode])."},
+ {getline, "ok"},
+ {putline, "io:format(\"~ts~n\",[[1024]])."},
+ {getline,
+ binary_to_list(unicode:characters_to_binary(
+ [1024],unicode,utf8))}
+ ],[],"LC_CTYPE=\"ISO-8859-1\"; export LC_CTYPE; "),
+ ?line rtnode([{putline,""},
+ {putline, "2."},
+ {getline_re, ".*2."},
+ {getline, "2"},
+ {putline, "lists:keyfind(encoding,1,io:getopts())."},
+ {getline_re, ".*{encoding,latin1}"},
+ {putline, "io:format(\"~ts~n\",[[1024]])."},
+ {getline_re, ".*\\\\x{400\\}"},
+ {putline, "io:setopts([{encoding,unicode}])."},
+ {getline_re, ".*ok"},
+ {putline, "io:format(\"~ts~n\",[[1024]])."},
+ {getline_re,
+ ".*"++binary_to_list(unicode:characters_to_binary(
+ [1024],unicode,utf8))}
+ ],[],"LC_CTYPE=\"ISO-8859-1\"; export LC_CTYPE; ",
+ " -oldshell "),
+
+ ok.
+
+unicode_options_gen(suite) ->
+ [];
+unicode_options_gen(doc) ->
+ ["Tests various unicode options on random generated files"];
+unicode_options_gen(Config) when is_list(Config) ->
+ ?line random:seed(1240,900586,553728),
+ ?line PrivDir = ?config(priv_dir,Config),
+ ?line AllModes = [utf8,utf16,{utf16,big},{utf16,little},utf32,{utf32,big},{utf32,little}],
+ ?line FSize = 17*1024,
+ ?line NumItersRead = 2,
+ ?line NumItersWrite = 2,
+ ?line Dir = filename:join([PrivDir,"GENDATA1"]),
+ ?line file:make_dir(Dir),
+
+ %dbg:tracer(process,{fun(A,_) -> erlang:display(A) end,true}),
+ %dbg:tpl(file_io_server,x),
+ %dbg:ctpl(file_io_server,cafu),
+ %dbg:tp(unicode,x),
+
+ DoOneFile1 = fun(Encoding,N,M) ->
+ ?dbg({Encoding,M,N}),
+ io:format("Read test: Encoding ~p, Chunk size ~p, Iteration ~p~n",[Encoding,M,N]),
+ io:format(standard_error,"Read test: Encoding ~p, Chunk size ~p, Iteration ~p\r\n",[Encoding,M,N]),
+ ?line Fname = filename:join([Dir,"genfile_"++enc2str(Encoding)++"_"++integer_to_list(N)]),
+ ?dbg(?LINE),
+ ?line Ulist = random_unicode(FSize),
+ ?dbg(?LINE),
+ ?line my_write_file(Fname,Ulist,Encoding),
+ ?dbg(?LINE),
+ ?line {ok,F1} = file:open(Fname,[read,{encoding,Encoding}]),
+
+ ?dbg(?LINE),
+ ?line Res1 = read_whole_file(fun(FD) -> io:get_line(FD,'') end,F1),
+ ?dbg(?LINE),
+ ?line Ulist = unicode:characters_to_list(Res1,unicode),
+ ?dbg(?LINE),
+ ?line file:close(F1),
+ ?line {ok,F2} = file:open(Fname, [read,binary,{encoding,Encoding}]),
+ ?line Res2 = read_whole_file(fun(FD) -> io:get_chars(FD,'',M) end,F2),
+ ?line Ulist = unicode:characters_to_list(Res2,unicode),
+ ?dbg(?LINE),
+ ?line file:close(F2),
+ ?line {ok,F3} = file:open(Fname, [read,binary,{encoding,Encoding}]),
+ ?dbg(?LINE),
+%% case {Encoding,M,N} of
+%% {{utf16,little},10,2} ->
+%% dbg:p(F3,call);
+%% _ ->
+%% ok
+%% end,
+
+ ?line Res3 = read_whole_file(fun(FD) -> case io:fread(FD,'',"~ts") of {ok,D} -> D; O -> O end end, F3),
+ ?dbg(?LINE),
+ ?line Ulist2 = [ X || X <- Ulist,
+ X =/= $\n, X =/= $ ],
+ ?dbg(?LINE),
+ ?line Ulist2 = unicode:characters_to_list(Res3,unicode),
+ ?dbg(?LINE),
+ ?line file:close(F3),
+ ?line {ok,F4} = file:open(Fname, [read,{encoding,Encoding}]),
+ ?line Res4 = read_whole_file(fun(FD) -> case io:fread(FD,'',"~tc") of {ok,D} -> D; O -> O end end,F4),
+ ?line Ulist3 = [ X || X <- Ulist,
+ X =/= $\n ],
+ ?line Ulist3 = unicode:characters_to_list(Res4,unicode),
+ ?dbg(?LINE),
+ ?line file:close(F4),
+ ?line file:delete(Fname)
+ end,
+
+ [ [ [ DoOneFile1(E,N,M) || E <- AllModes ] || M <- [10,1000,128,1024,8192,8193] ] || N <- lists:seq(1,NumItersRead)],
+ DoOneFile2 = fun(Encoding,N,M) ->
+ ?dbg({Encoding,M,N}),
+ io:format("Write test: Encoding ~p, Chunk size ~p, Iteration ~p~n",[Encoding,M,N]),
+ io:format(standard_error,"Write test: Encoding ~p, Chunk size ~p, Iteration ~p\r\n",[Encoding,M,N]),
+ ?line Fname = filename:join([Dir,"genfile_"++enc2str(Encoding)++"_"++integer_to_list(N)]),
+ ?dbg(?LINE),
+ ?line Ulist = random_unicode(FSize),
+ ?dbg(?LINE),
+ ?line {ok,F1} = file:open(Fname,[write,{encoding,Encoding}]),
+ ?line io:put_chars(F1,Ulist),
+ ?line file:close(F1),
+ ?line Ulist = my_read_file(Fname,Encoding),
+ ?line file:delete(Fname),
+ ?line {ok,F2} = file:open(Fname,[write,binary,{encoding,Encoding}]),
+ ?line io:put_chars(F2,Ulist),
+ ?line file:close(F2),
+ ?line Ulist = my_read_file(Fname,Encoding),
+ ?line file:delete(Fname),
+ ?line {ok,F3} = file:open(Fname,[write,{encoding,Encoding}]),
+ ?line LL = string:tokens(Ulist,"\n"),
+ ?line Ulist2 = lists:flatten(LL),
+ ?line [ io:format(F3,"~ts",[L]) || L <- LL ],
+ ?line file:close(F3),
+ ?line Ulist2 = my_read_file(Fname,Encoding),
+ ?line file:delete(Fname),
+ ?line {ok,F4} = file:open(Fname,[write,{encoding,Encoding}]),
+ ?line [ io:format(F4,"~tc",[C]) || C <- Ulist ],
+ ?line file:close(F4),
+ ?line Ulist = my_read_file(Fname,Encoding),
+ ?line file:delete(Fname),
+ ?line {ok,F5} = file:open(Fname,[write,{encoding,Encoding}]),
+ ?line io:put_chars(F5,unicode:characters_to_binary(Ulist)),
+ ?line file:close(F5),
+ ?line Ulist = my_read_file(Fname,Encoding),
+ ?line file:delete(Fname),
+ ok
+ end,
+ [ [ [ DoOneFile2(E,N,M) || E <- AllModes ] || M <- [10,1000,128,1024,8192,8193] ] || N <- lists:seq(1,NumItersWrite)],
+ ok.
+
+
+
+
+read_whole_file(Fun,F) ->
+ case Fun(F) of
+ eof ->
+ [];
+ {error,Error} ->
+ ?dbg(Error),
+ receive after 10000 -> ok end,
+ exit(Error);
+ Other ->
+ %?dbg(Other),
+ [Other | read_whole_file(Fun,F)]
+ end.
+
+
+enc2str(Atom) when is_atom(Atom) ->
+ atom_to_list(Atom);
+enc2str({A1,A2}) when is_atom(A1), is_atom(A2) ->
+ atom_to_list(A1)++"_"++atom_to_list(A2).
+
+
+
+
+my_write_file(Filename,UniList,Encoding) ->
+ Bin = unicode:characters_to_binary(UniList,utf8,Encoding),
+ file:write_file(Filename,Bin).
+
+my_read_file(Filename,Encoding) ->
+ {ok,Bin} = file:read_file(Filename),
+ unicode:characters_to_list(Bin,Encoding).
+
+random_unicode(0) ->
+ [];
+random_unicode(N) ->
+ % Favour large unicode and make linebreaks
+ X = case random:uniform(20) of
+ A when A =< 1 -> $\n;
+ A0 when A0 =< 3 -> random:uniform(16#10FFFF);
+ A1 when A1 =< 6 -> random:uniform(16#10FFFF - 16#7F) + 16#7F;
+ A2 when A2 =< 12 -> random:uniform(16#10FFFF - 16#7FF) + 16#7FF;
+ _ -> random:uniform(16#10FFFF - 16#FFFF) + 16#FFFF
+ end,
+ case X of
+ Inv1 when Inv1 >= 16#D800, Inv1 =< 16#DFFF;
+ Inv1 =:= 16#FFFE;
+ Inv1 =:= 16#FFFF ->
+ random_unicode(N);
+ _ ->
+ [X | random_unicode(N-1)]
+ end.
+
+
+binary_options(suite) ->
+ [];
+binary_options(doc) ->
+ ["Tests variants with binary option"];
+binary_options(Config) when is_list(Config) ->
+ DataDir = ?config(data_dir,Config),
+ PrivDir = ?config(priv_dir,Config),
+ TestData = unicode:characters_to_binary(
+ [1090,1093,1077,32,1073,1080,1075,32,
+ 1088,1077,1076,32,1092,1086,1100,32,1093,
+ 1072,1089,32,1089,1086,1100,32,932,951,949,
+ 32,946,953,947,32,961,949,948,32,
+ 963,959,967,32,945,961,949,32,966,959,967,949,963]),
+ <<First10:10/binary,Second10:10/binary,_/binary>> = TestData,
+ First10List = binary_to_list(First10),
+ Second10List = binary_to_list(Second10),
+ TestFile = filename:join([DataDir, "testdata_utf8.dat"]),
+ ?line {ok, F} = file:open(TestFile,[read]),
+ ?line {ok, First10List} = file:read(F,10),
+ ?line io:setopts(F,[binary]),
+ ?line {ok, Second10} = file:read(F,10),
+ ?line file:close(F),
+ ?line {ok, F2} = file:open(TestFile,[read,binary]),
+ ?line {ok, First10} = file:read(F2,10),
+ ?line io:setopts(F2,[list]),
+ ?line {ok, Second10List} = file:read(F2,10),
+ ?line file:position(F2,0),
+ %dbg:tracer(),dbg:p(F2,call),dbg:tpl(file_io_server,x),
+ ?line First10List = io:get_chars(F2,'',10),
+ ?line io:setopts(F2,[binary]),
+ ?line Second10 = unicode:characters_to_binary(io:get_chars(F2,'',10),unicode,latin1),
+ ?line file:close(F2),
+ ?line LineBreakFileName = filename:join([PrivDir, "testdata.dat"]),
+ ?line LineBreakTestData = <<TestData/binary,$\n>>,
+ ?line LineBreakTestDataList = binary_to_list(LineBreakTestData),
+ ?line file:write_file(LineBreakFileName,[LineBreakTestData,LineBreakTestData,LineBreakTestData,TestData]),
+ ?line {ok, F3} = file:open(LineBreakFileName,[read]),
+ ?line LineBreakTestDataList = io:get_line(F3,''),
+ ?line io:setopts(F3,[binary]),
+ ?line LineBreakTestData = unicode:characters_to_binary(io:get_line(F3,''),unicode,latin1),
+ ?line io:setopts(F3,[list]),
+ ?line LineBreakTestDataList = io:get_line(F3,''),
+ ?line io:setopts(F3,[binary]),
+ %ok = io:format(standard_error,"TestData = ~w~n",[TestData]),
+ ?line TestData = unicode:characters_to_binary(io:get_line(F3,''),unicode,latin1),
+ ?line eof = io:get_line(F3,''),
+ ?line file:close(F3),
+ %% OK, time for the group_leaders...
+ %% io:format(standard_error,"Hmmm:~w~n",["<<\""++binary_to_list(<<"\345\344\366"/utf8>>)++"\\n\">>"]),
+ ?line rtnode([{putline,""},
+ {putline, "2."},
+ {getline, "2"},
+ {putline, "lists:keyfind(binary,1,io:getopts())."},
+ {getline, "{binary,false}"},
+ {putline, "io:get_line('')."},
+ {putline, "hej"},
+ {getline, "\"hej\\n\""},
+ {putline, "io:setopts([{binary,true},unicode])."},
+ {getline, "ok"},
+ {putline, "io:get_line('')."},
+ {putline, "hej"},
+ {getline, "<<\"hej\\n\">>"},
+ {putline, "io:get_line('')."},
+ {putline, binary_to_list(<<"\345\344\366"/utf8>>)},
+ {getline, "<<\""++binary_to_list(unicode:characters_to_binary(<<"\345\344\366"/utf8>>,latin1,utf8))++"\\n\">>"}
+ ],[]),
+ %% And one with oldshell
+ ?line rtnode([{putline,""},
+ {putline, "2."},
+ {getline_re, ".*2."},
+ {getline, "2"},
+ {putline, "lists:keyfind(binary,1,io:getopts())."},
+ {getline_re, ".*{binary,false}"},
+ {putline, "io:get_line('')."},
+ {putline, "hej"},
+ {getline_re, ".*\"hej\\\\n\""},
+ {putline, "io:setopts([{binary,true},unicode])."},
+ {getline_re, ".*ok"},
+ {putline, "io:get_line('')."},
+ {putline, "hej"},
+ {getline_re, ".*<<\"hej\\\\n\">>"},
+ {putline, "io:get_line('')."},
+ {putline, binary_to_list(<<"\345\344\366"/utf8>>)},
+ {getline_re, ".*<<\""++binary_to_list(unicode:characters_to_binary(<<"\345\344\366"/utf8>>,latin1,utf8))++"\\\\n\">>"}
+ ],[],[],"-oldshell"),
+ ok.
+
+bc_with_r12(suite) ->
+ [];
+bc_with_r12(doc) ->
+ ["Test io protocol compatibility with R12 nodes"];
+bc_with_r12(Config) when is_list(Config) ->
+ case ?t:is_release_available("r12b") of
+ true -> bc_with_r12_1(Config);
+ false -> {skip,"No R12B found"}
+ end.
+
+bc_with_r12_1(Config) ->
+ PA = filename:dirname(code:which(?MODULE)),
+ Name1 = io_proto_r12_1,
+ ?line N1 = list_to_atom(atom_to_list(Name1) ++ "@" ++ hostname()),
+ ?line ?t:start_node(Name1, peer, [{args, "-pz "++PA},{erl,[{release,"r12b"}]}]),
+ DataDir = ?config(data_dir,Config),
+ %PrivDir = ?config(priv_dir,Config),
+ FileName1 = filename:join([DataDir,"testdata_latin1.dat"]),
+ TestDataLine1 = [229,228,246],
+ TestDataLine2 = [197,196,214],
+ ?line SPid1 = rpc:call(N1,erlang,spawn,[?MODULE,hold_the_line,[self(),FileName1,[read]]]),
+ ?line {ok,F1} = receive
+ {SPid1,Res1} ->
+ Res1
+ after 5000 ->
+ exit(timeout)
+ end,
+ ?line TestDataLine1 = chomp(io:get_line(F1,'')),
+ ?line SPid1 ! die,
+ receive after 1000 -> ok end,
+ ?line SPid2 = rpc:call(N1,erlang,spawn,[?MODULE,hold_the_line,[self(),FileName1,[read,binary]]]),
+ ?line {ok,F2} = receive
+ {SPid2,Res2} ->
+ Res2
+ after 5000 ->
+ exit(timeout)
+ end,
+ TestDataLine1BinUtf = unicode:characters_to_binary(TestDataLine1),
+ TestDataLine1BinLatin = list_to_binary(TestDataLine1),
+ TestDataLine2BinUtf = unicode:characters_to_binary(TestDataLine2),
+ TestDataLine2BinLatin = list_to_binary(TestDataLine2),
+ ?line TestDataLine1BinUtf = chomp(io:get_line(F2,'')),
+ ?line TestDataLine2BinUtf = chomp(io:get_line(F2,'')),
+ %io:format(standard_error,"Exec:~s\r\n",[rpc:call(N1,os,find_executable,["erl"])]),
+ %io:format(standard_error,"Io:~s\r\n",[rpc:call(N1,code,which,[io])]),
+ %io:format(standard_error,"File_io_server:~s\r\n",[rpc:call(N1,code,which,[file_io_server])]),
+ ?line file:position(F2,0),
+ ?line TestDataLine1BinLatin = chomp(rpc:call(N1,io,get_line,[F2,''])),
+ ?line TestDataLine2BinUtf = chomp(io:get_line(F2,'')),
+ ?line file:position(F2,0),
+ ?line TestDataLine1BinUtf = chomp(io:get_line(F2,'')),
+ ?line TestDataLine2BinLatin = chomp(rpc:call(N1,io,get_line,[F2,''])),
+ ?line eof = chomp(rpc:call(N1,io,get_line,[F2,''])),
+ ?line file:position(F2,0),
+ ?line TestDataLine1BinLatin = rpc:call(N1,io,get_chars,[F2,'',3]),
+ io:get_chars(F2,'',1),
+ ?line TestDataLine2BinLatin = chomp(rpc:call(N1,io,get_line,[F2,''])),
+ ?line file:position(F2,0),
+ ?line {ok,[TestDataLine1]} = io:fread(F2,'',"~s"),
+ ?line {ok,[TestDataLine2]} = rpc:call(N1,io,fread,[F2,'',"~s"]),
+
+ ?line DataLen1 = length(TestDataLine1),
+ ?line DataLen2 = length(TestDataLine2),
+
+ ?line file:position(F2,0),
+ ?line {ok,TestDataLine1BinLatin} = file:read(F2,DataLen1),
+ ?line {ok,_} = file:read(F2,1),
+ ?line {ok,TestDataLine2BinLatin} = rpc:call(N1,file,read,[F2,DataLen2]),
+ ?line {ok,_} = file:read(F2,1),
+ ?line eof = rpc:call(N1,file,read,[F2,1]),
+ %% As r12 has a bug when setting options with setopts, we need
+ %% to reopen the file...
+ ?line SPid2 ! die,
+ receive after 1000 -> ok end,
+ ?line SPid3 = rpc:call(N1,erlang,spawn,[?MODULE,hold_the_line,[self(),FileName1,[read]]]),
+ ?line {ok,F3} = receive
+ {SPid3,Res3} ->
+ Res3
+ after 5000 ->
+ exit(timeout)
+ end,
+
+ ?line file:position(F3,0),
+ ?line {ok,[TestDataLine1]} = io:fread(F3,'',"~s"),
+ ?line {ok,[TestDataLine2]} = rpc:call(N1,io,fread,[F3,'',"~s"]),
+
+
+ ?line file:position(F3,0),
+ ?line {ok,TestDataLine1} = file:read(F3,DataLen1),
+ ?line {ok,_} = file:read(F3,1),
+ ?line {ok,TestDataLine2} = rpc:call(N1,file,read,[F3,DataLen2]),
+ ?line {ok,_} = file:read(F3,1),
+ ?line eof = rpc:call(N1,file,read,[F3,1]),
+
+
+ %% So, lets do it all again, but the other way around
+ {ok,F4} = file:open(FileName1,[read]),
+ ?line TestDataLine1 = chomp(io:get_line(F4,'')),
+ ?line file:position(F4,0),
+ ?line io:setopts(F4,[binary]),
+ ?line TestDataLine1BinUtf = chomp(io:get_line(F4,'')),
+ ?line TestDataLine2BinUtf = chomp(io:get_line(F4,'')),
+ ?line file:position(F4,0),
+ ?line TestDataLine1BinUtf = chomp(io:get_line(F4,'')),
+ ?line TestDataLine2BinUtf = chomp(io:get_line(F4,'')),
+ ?line file:position(F4,0),
+ %dbg:tracer(),dbg:p(F4,[call,m]),dbg:tpl(file_io_server,x),dbg:tpl(io_lib,x),
+ ?line TestDataLine1BinUtf = chomp(io:get_line(F4,'')),
+ ?line TestDataLine2BinLatin = chomp(rpc:call(N1,io,get_line,[F4,''])),
+ ?line file:position(F4,0),
+ ?line TestDataLine1BinLatin = chomp(rpc:call(N1,io,get_line,[F4,''])),
+ ?line TestDataLine2BinUtf = chomp(io:get_line(F4,'')),
+ ?line eof = chomp(rpc:call(N1,io,get_line,[F4,''])),
+ ?line file:position(F4,0),
+ ?line TestDataLine1BinLatin = rpc:call(N1,io,get_chars,[F4,'',3]),
+ io:get_chars(F4,'',1),
+ ?line TestDataLine2BinLatin = chomp(rpc:call(N1,io,get_line,[F4,''])),
+ ?line file:position(F4,0),
+ ?line {ok,[TestDataLine1]} = io:fread(F4,'',"~s"),
+ ?line {ok,[TestDataLine2]} = rpc:call(N1,io,fread,[F4,'',"~s"]),
+ ?line file:position(F4,0),
+ ?line {ok,TestDataLine1BinLatin} = file:read(F4,DataLen1),
+ ?line {ok,_} = file:read(F4,1),
+ ?line {ok,TestDataLine2BinLatin} = rpc:call(N1,file,read,[F4,DataLen2]),
+ ?line {ok,_} = file:read(F4,1),
+ ?line eof = rpc:call(N1,file,read,[F4,1]),
+ ?line io:setopts(F4,[list]),
+
+ ?line file:position(F4,0),
+ ?line {ok,[TestDataLine1]} = io:fread(F4,'',"~s"),
+ ?line {ok,[TestDataLine2]} = rpc:call(N1,io,fread,[F4,'',"~s"]),
+
+
+ ?line file:position(F4,0),
+ ?line {ok,TestDataLine1} = file:read(F4,DataLen1),
+ ?line {ok,_} = file:read(F4,1),
+ ?line {ok,TestDataLine2} = rpc:call(N1,file,read,[F4,DataLen2]),
+ ?line {ok,_} = file:read(F4,1),
+ ?line eof = rpc:call(N1,file,read,[F4,1]),
+
+ file:close(F4),
+ ?t:stop_node(N1),
+ ok.
+
+hold_the_line(Parent,Filename,Options) ->
+ Parent ! {self(), file:open(Filename,Options)},
+ receive
+ die ->
+ ok
+ end.
+
+
+bc_with_r12_gl(suite) ->
+ [];
+bc_with_r12_gl(doc) ->
+ ["Test io protocol compatibility with R12 nodes (terminals)"];
+bc_with_r12_gl(Config) when is_list(Config) ->
+ case ?t:is_release_available("r12b") of
+ true ->
+ case get_progs() of
+ {error,Reason} ->
+ {skip, Reason};
+ _ ->
+ bc_with_r12_gl_1(Config,answering_machine1)
+ end;
+ false ->
+ {skip,"No R12B found"}
+ end.
+
+bc_with_r12_ogl(suite) ->
+ [];
+bc_with_r12_ogl(doc) ->
+ ["Test io protocol compatibility with R12 nodes (oldshell)"];
+bc_with_r12_ogl(Config) when is_list(Config) ->
+ case ?t:is_release_available("r12b") of
+ true ->
+ case get_progs() of
+ {error,Reason} ->
+ {skip, Reason};
+ _ ->
+ bc_with_r12_gl_1(Config,answering_machine2)
+ end;
+ false ->
+ {skip,"No R12B found"}
+ end.
+
+bc_with_r12_gl_1(_Config,Machine) ->
+ PA = filename:dirname(code:which(?MODULE)),
+ Name1 = io_proto_r12_gl_1,
+ ?line N1 = list_to_atom(atom_to_list(Name1) ++ "@" ++ hostname()),
+ ?line ?t:start_node(Name1, peer, [{args, "-pz "++PA},{erl,[{release,"r12b"}]}]),
+ TestDataLine1 = [229,228,246],
+ TestDataLine1BinUtf = unicode:characters_to_binary(TestDataLine1),
+ TestDataLine1BinLatin = list_to_binary(TestDataLine1),
+
+ N2List = create_nodename(),
+ MyNodeList = atom_to_list(node()),
+ register(io_proto_suite,self()),
+ AM1 = spawn(?MODULE,Machine,
+ [MyNodeList, "io_proto_suite", N2List]),
+
+ ?line GL = receive X when is_pid(X) -> X end,
+ %% get_line
+ ?line "Hej\n" = rpc:call(N1,io,get_line,[GL,"Prompt\n"]),
+ ?line io:setopts(GL,[binary]),
+ ?line io:format(GL,"Okej~n",[]),
+ ?line <<"Hej\n">> = rpc:call(N1,io,get_line,[GL,"Prompt\n"]),
+ ?line io:setopts(GL,[{encoding,latin1}]),
+ ?line io:format(GL,"Okej~n",[]),
+ ?line TestDataLine1BinLatin = chomp(rpc:call(N1,io,get_line,[GL,"Prompt\n"])),
+ ?line io:format(GL,"Okej~n",[]),
+ ?line TestDataLine1BinUtf = chomp(io:get_line(GL,"Prompt\n")),
+ ?line io:setopts(GL,[{encoding,unicode}]),
+
+ ?line io:format(GL,"Okej~n",[]),
+ ?line TestDataLine1BinLatin = chomp(rpc:call(N1,io,get_line,[GL,"Prompt\n"])),
+ ?line io:format(GL,"Okej~n",[]),
+ ?line TestDataLine1BinUtf = chomp(io:get_line(GL,"Prompt\n")),
+ ?line io:setopts(GL,[list]),
+ ?line io:format(GL,"Okej~n",[]),
+
+ %%get_chars
+ ?line "Hej" = rpc:call(N1,io,get_chars,[GL,"Prompt\n",3]),
+ ?line io:setopts(GL,[binary]),
+ ?line io:format(GL,"Okej~n",[]),
+ ?line <<"Hej">> = rpc:call(N1,io,get_chars,[GL,"Prompt\n",3]),
+ ?line io:setopts(GL,[{encoding,latin1}]),
+ ?line io:format(GL,"Okej~n",[]),
+ ?line TestDataLine1BinLatin = rpc:call(N1,io,get_chars,[GL,"Prompt\n",3]),
+ ?line io:format(GL,"Okej~n",[]),
+ ?line TestDataLine1BinUtf = io:get_chars(GL,"Prompt\n",3),
+ ?line io:setopts(GL,[{encoding,unicode}]),
+
+ ?line io:format(GL,"Okej~n",[]),
+ ?line TestDataLine1BinLatin = rpc:call(N1,io,get_chars,[GL,"Prompt\n",3]),
+ ?line io:format(GL,"Okej~n",[]),
+ ?line TestDataLine1BinUtf = io:get_chars(GL,"Prompt\n",3),
+ ?line io:setopts(GL,[list]),
+ ?line io:format(GL,"Okej~n",[]),
+ %%fread
+ ?line {ok,["Hej"]} = rpc:call(N1,io,fread,[GL,"Prompt\n","~s"]),
+ ?line io:setopts(GL,[binary]),
+ ?line io:format(GL,"Okej~n",[]),
+ ?line {ok,["Hej"]} = rpc:call(N1,io,fread,[GL,"Prompt\n","~s"]),
+ ?line io:setopts(GL,[{encoding,latin1}]),
+ ?line io:format(GL,"Okej~n",[]),
+ ?line {ok,[TestDataLine1]} = rpc:call(N1,io,fread,[GL,"Prompt\n","~s"]),
+ ?line io:format(GL,"Okej~n",[]),
+ ?line {ok,[TestDataLine1]} = io:fread(GL,"Prompt\n","~s"),
+ ?line io:setopts(GL,[{encoding,unicode}]),
+ ?line io:format(GL,"Okej~n",[]),
+ ?line {ok,[TestDataLine1]} = rpc:call(N1,io,fread,[GL,"Prompt\n","~s"]),
+ ?line io:format(GL,"Okej~n",[]),
+ ?line {ok,[TestDataLine1]} = io:fread(GL,"Prompt\n","~s"),
+ ?line io:setopts(GL,[list]),
+ ?line io:format(GL,"Okej~n",[]),
+
+
+ ?line receive
+ {AM1,done} ->
+ ok
+ after 5000 ->
+ exit(timeout)
+ end,
+ ?t:stop_node(N1),
+ ok.
+
+
+answering_machine1(OthNode,OthReg,Me) ->
+ TestDataLine1 = [229,228,246],
+ TestDataUtf = binary_to_list(unicode:characters_to_binary(TestDataLine1)),
+ ?line rtnode([{putline,""},
+ {putline, "2."},
+ {getline, "2"},
+ {putline, "{"++OthReg++","++OthNode++"} ! group_leader()."},
+ {getline, "<"},
+ % get_line
+ {getline_re, ".*Prompt"},
+ {putline, "Hej"},
+ {getline_re, ".*Okej"},
+ {getline_re, ".*Prompt"},
+ {putline, "Hej"},
+ {getline_re, ".*Okej"},
+ {getline_re, ".*Prompt"},
+ {putline, TestDataLine1},
+ {getline_re, ".*Okej"},
+ {getline_re, ".*Prompt"},
+ {putline, TestDataLine1},
+ {getline_re, ".*Okej"},
+ {getline_re, ".*Prompt"},
+ {putline, TestDataUtf},
+ {getline_re, ".*Okej"},
+ {getline_re, ".*Prompt"},
+ {putline, TestDataUtf},
+ {getline_re, ".*Okej"},
+ % get_chars
+ {getline_re, ".*Prompt"},
+ {putline, "Hej"},
+ {getline_re, ".*Okej"},
+ {getline_re, ".*Prompt"},
+ {putline, "Hej"},
+ {getline_re, ".*Okej"},
+ {getline_re, ".*Prompt"},
+ {putline, TestDataLine1},
+ {getline_re, ".*Okej"},
+ {getline_re, ".*Prompt"},
+ {putline, TestDataLine1},
+ {getline_re, ".*Okej"},
+ {getline_re, ".*Prompt"},
+ {putline, TestDataUtf},
+ {getline_re, ".*Okej"},
+ {getline_re, ".*Prompt"},
+ {putline, TestDataUtf},
+ {getline_re, ".*Okej"},
+ % fread
+ {getline_re, ".*Prompt"},
+ {putline, "Hej"},
+ {getline_re, ".*Okej"},
+ {getline_re, ".*Prompt"},
+ {putline, "Hej"},
+ {getline_re, ".*Okej"},
+ {getline_re, ".*Prompt"},
+ {putline, TestDataLine1},
+ {getline_re, ".*Okej"},
+ {getline_re, ".*Prompt"},
+ {putline, TestDataLine1},
+ {getline_re, ".*Okej"},
+ {getline_re, ".*Prompt"},
+ {putline, TestDataUtf},
+ {getline_re, ".*Okej"},
+ {getline_re, ".*Prompt"},
+ {putline, TestDataUtf},
+ {getline_re, ".*Okej"}
+
+ ],Me,"LC_CTYPE=\"ISO-8859-1\"; export LC_CTYPE; "),
+ O = list_to_atom(OthReg),
+ O ! {self(),done},
+ ok.
+
+answering_machine2(OthNode,OthReg,Me) ->
+ TestDataLine1 = [229,228,246],
+ TestDataUtf = binary_to_list(unicode:characters_to_binary(TestDataLine1)),
+ ?line rtnode([{putline,""},
+ {putline, "2."},
+ {getline, "2"},
+ {putline, "{"++OthReg++","++OthNode++"} ! group_leader()."},
+ {getline_re, ".*<[0-9].*"},
+ % get_line
+ {getline_re, ".*Prompt"},
+ {putline, "Hej"},
+ {getline_re, ".*Okej"},
+ {getline_re, ".*Prompt"},
+ {putline, "Hej"},
+ {getline_re, ".*Okej"},
+ {getline_re, ".*Prompt"},
+ {putline, TestDataLine1},
+ {getline_re, ".*Okej"},
+ {getline_re, ".*Prompt"},
+ {putline, TestDataLine1},
+ {getline_re, ".*Okej"},
+ {getline_re, ".*Prompt"},
+ {putline, TestDataUtf},
+ {getline_re, ".*Okej"},
+ {getline_re, ".*Prompt"},
+ {putline, TestDataUtf},
+ {getline_re, ".*Okej"},
+ % get_chars
+ {getline_re, ".*Prompt"},
+ {putline, "Hej"},
+ {getline_re, ".*Okej"},
+ {getline_re, ".*Prompt"},
+ {putline, "Hej"},
+ {getline_re, ".*Okej"},
+ {getline_re, ".*Prompt"},
+ {putline, TestDataLine1},
+ {getline_re, ".*Okej"},
+ {getline_re, ".*Prompt"},
+ {putline, TestDataLine1},
+ {getline_re, ".*Okej"},
+ {getline_re, ".*Prompt"},
+ {putline, TestDataUtf},
+ {getline_re, ".*Okej"},
+ {getline_re, ".*Prompt"},
+ {putline, TestDataUtf},
+ {getline_re, ".*Okej"},
+ % fread
+ {getline_re, ".*Prompt"},
+ {putline, "Hej"},
+ {getline_re, ".*Okej"},
+ {getline_re, ".*Prompt"},
+ {putline, "Hej"},
+ {getline_re, ".*Okej"},
+ {getline_re, ".*Prompt"},
+ {putline, TestDataLine1},
+ {getline_re, ".*Okej"},
+ {getline_re, ".*Prompt"},
+ {putline, TestDataLine1},
+ {getline_re, ".*Okej"},
+ {getline_re, ".*Prompt"},
+ {putline, TestDataUtf},
+ {getline_re, ".*Okej"},
+ {getline_re, ".*Prompt"},
+ {putline, TestDataUtf},
+ {getline_re, ".*Okej"}
+
+ ],Me,"LC_CTYPE=\"ISO-8859-1\"; export LC_CTYPE; "," -oldshell "),
+ O = list_to_atom(OthReg),
+ O ! {self(),done},
+ ok.
+
+
+read_modes_ogl(suite) ->
+ [];
+read_modes_ogl(doc) ->
+ ["Test various modes when reading from the group leade from another machine"];
+read_modes_ogl(Config) when is_list(Config) ->
+ case get_progs() of
+ {error,Reason} ->
+ {skipped,Reason};
+ _ ->
+ read_modes_gl_1(Config,answering_machine2)
+ end.
+
+read_modes_gl(suite) ->
+ [];
+read_modes_gl(doc) ->
+ ["Test various modes when reading from the group leade from another machine"];
+read_modes_gl(Config) when is_list(Config) ->
+ case get_progs() of
+ {error,Reason} ->
+ {skipped,Reason};
+ _ ->
+ read_modes_gl_1(Config,answering_machine1)
+ end.
+
+read_modes_gl_1(_Config,Machine) ->
+ TestDataLine1 = [229,228,246],
+ TestDataLine1BinUtf = unicode:characters_to_binary(TestDataLine1),
+ TestDataLine1BinLatin = list_to_binary(TestDataLine1),
+
+ N2List = create_nodename(),
+ MyNodeList = atom_to_list(node()),
+ register(io_proto_suite,self()),
+ AM1 = spawn(?MODULE,Machine,
+ [MyNodeList, "io_proto_suite", N2List]),
+
+ ?line GL = receive X when is_pid(X) -> X end,
+ %% get_line
+ ?line "Hej\n" = io:get_line(GL,"Prompt\n"),
+ ?line io:setopts(GL,[binary]),
+ ?line io:format(GL,"Okej~n",[]),
+ ?line <<"Hej\n">> = io:get_line(GL,"Prompt\n"),
+ ?line io:setopts(GL,[{encoding,latin1}]),
+ ?line io:format(GL,"Okej~n",[]),
+ ?line TestDataLine1BinLatin = chomp(io:request(GL,{get_line,latin1,"Prompt\n"})),
+ ?line io:format(GL,"Okej~n",[]),
+ ?line TestDataLine1BinUtf = chomp(io:get_line(GL,"Prompt\n")),
+ ?line io:setopts(GL,[{encoding,unicode}]),
+
+ ?line io:format(GL,"Okej~n",[]),
+ ?line TestDataLine1BinLatin = chomp(io:request(GL,{get_line,latin1,"Prompt\n"})),
+ ?line io:format(GL,"Okej~n",[]),
+ ?line TestDataLine1BinUtf = chomp(io:get_line(GL,"Prompt\n")),
+ ?line io:setopts(GL,[list]),
+ ?line io:format(GL,"Okej~n",[]),
+
+ %%get_chars
+ ?line "Hej" = io:get_chars(GL,"Prompt\n",3),
+ ?line io:setopts(GL,[binary]),
+ ?line io:format(GL,"Okej~n",[]),
+ ?line <<"Hej">> = io:get_chars(GL,"Prompt\n",3),
+ ?line io:setopts(GL,[{encoding,latin1}]),
+ ?line io:format(GL,"Okej~n",[]),
+ ?line TestDataLine1BinLatin = io:request(GL,{get_chars,latin1,"Prompt\n",3}),
+ ?line io:format(GL,"Okej~n",[]),
+ ?line TestDataLine1BinUtf = io:get_chars(GL,"Prompt\n",3),
+ ?line io:setopts(GL,[{encoding,unicode}]),
+
+ ?line io:format(GL,"Okej~n",[]),
+ ?line TestDataLine1BinLatin = io:request(GL,{get_chars,latin1,"Prompt\n",3}),
+ ?line io:format(GL,"Okej~n",[]),
+ ?line TestDataLine1BinUtf = io:get_chars(GL,"Prompt\n",3),
+ ?line io:setopts(GL,[list]),
+ ?line io:format(GL,"Okej~n",[]),
+ %%fread
+ ?line {ok,["Hej"]} = io:fread(GL,"Prompt\n","~s"),
+ ?line io:setopts(GL,[binary]),
+ ?line io:format(GL,"Okej~n",[]),
+ ?line {ok,["Hej"]} = io:fread(GL,"Prompt\n","~s"),
+ ?line io:setopts(GL,[{encoding,latin1}]),
+ ?line io:format(GL,"Okej~n",[]),
+ ?line {ok,[TestDataLine1]} = io:fread(GL,"Prompt\n","~s"),
+ ?line io:format(GL,"Okej~n",[]),
+ ?line {ok,[TestDataLine1]} = io:fread(GL,"Prompt\n","~s"),
+ ?line io:setopts(GL,[{encoding,unicode}]),
+ ?line io:format(GL,"Okej~n",[]),
+ ?line {ok,[TestDataLine1]} = io:fread(GL,"Prompt\n","~s"),
+ ?line io:format(GL,"Okej~n",[]),
+ ?line {ok,[TestDataLine1]} = io:fread(GL,"Prompt\n","~s"),
+ ?line io:setopts(GL,[list]),
+ ?line io:format(GL,"Okej~n",[]),
+
+
+ ?line receive
+ {AM1,done} ->
+ ok
+ after 5000 ->
+ exit(timeout)
+ end,
+ ok.
+
+
+broken_unicode(suite) ->
+ [];
+broken_unicode(doc) ->
+ ["Test behaviour when reading broken Unicode files"];
+broken_unicode(Config) when is_list(Config) ->
+ Dir = ?config(priv_dir,Config),
+ Latin1Name = filename:join([Dir,"latin1_data_file.dat"]),
+ Utf8Name = filename:join([Dir,"utf8_data_file.dat"]),
+ Latin1Data = iolist_to_binary(lists:duplicate(10,lists:seq(0,255)++[255,255,255])),
+ Utf8Data = unicode:characters_to_binary(
+ lists:duplicate(10,lists:seq(0,255))),
+ file:write_file(Latin1Name,Latin1Data),
+ file:write_file(Utf8Name,Utf8Data),
+ ?line [ latin1 = heuristic_encoding_file2(Latin1Name,N,utf8) || N <- lists:seq(1,100)++[1024,2048,10000]],
+ ?line [ utf8 = heuristic_encoding_file2(Utf8Name,N,utf8) || N <- lists:seq(1,100)++[1024,2048,10000]],
+ ?line [ latin1 = heuristic_encoding_file2(Latin1Name,N,utf16) || N <- lists:seq(1,100)++[1024,2048,10000]],
+ ?line [ latin1 = heuristic_encoding_file2(Latin1Name,N,utf32) || N <- lists:seq(1,100)++[1024,2048,10000]],
+ ok.
+
+
+%%
+%% From the cookbook, more or less
+heuristic_encoding_file2(FileName,Chunk,Enc) ->
+ {ok,F} = file:open(FileName,[read,binary,{encoding,Enc}]),
+ loop_through_file2(F,io:get_chars(F,'',Chunk),Chunk,Enc).
+
+loop_through_file2(_,eof,_,Enc) ->
+ Enc;
+loop_through_file2(_,{error,_Err},_,_) ->
+ latin1;
+loop_through_file2(F,Bin,Chunk,Enc) when is_binary(Bin) ->
+ loop_through_file2(F,io:get_chars(F,'',Chunk),Chunk,Enc).
+
+
+
+eof_on_pipe(suite) ->
+ [];
+eof_on_pipe(doc) ->
+ ["tests eof before newline on stdin when erlang is in pipe"];
+eof_on_pipe(Config) when is_list(Config) ->
+ case {get_progs(),os:type()} of
+ {{error,Reason},_} ->
+ {skipped,Reason};
+ {{_,_,Erl},{unix,linux}} ->
+ %% Not even Linux is reliable - echo can be both styles
+ try
+ EchoLine = case os:cmd("echo -ne \"test\\ntest\"") of
+ "test\ntest" ->
+ "echo -ne \"a\\nbu\" | ";
+ _ ->
+ case os:cmd("echo \"test\\ntest\\c\"") of
+ "test\ntest" ->
+ "echo \"a\\nbu\\c\" | ";
+ _ ->
+ throw(skip)
+ end
+ end,
+ CommandLine1 = EchoLine ++
+ Erl++" -noshell -eval "
+ "'io:format(\"~p\",[io:get_line(\"\")]),"
+ "io:format(\"~p\",[io:get_line(\"\")]),"
+ "io:format(\"~p\",[io:get_line(\"\")]).' -run init stop",
+ case os:cmd(CommandLine1) of
+ "\"a\\n\"\"bu\"eof" ->
+ ok;
+ Other1 ->
+ exit({unexpected1,Other1})
+ end,
+ CommandLine2 = EchoLine ++
+ Erl++" -noshell -eval "
+ "'io:setopts([binary]),io:format(\"~p\",[io:get_line(\"\")]),"
+ "io:format(\"~p\",[io:get_line(\"\")]),"
+ "io:format(\"~p\",[io:get_line(\"\")]).' -run init stop",
+ case os:cmd(CommandLine2) of
+ "<<\"a\\n\">><<\"bu\">>eof" ->
+ ok;
+ Other2 ->
+ exit({unexpected2,Other2})
+ end
+ catch
+ throw:skip ->
+ {skipped,"unsupported echo program"}
+ end;
+ {_,_} ->
+ {skipped,"Only on linux"}
+ end.
+
+
+%%
+%% Tool for running interactive shell (stolen from the kernel
+%% test suite interactive_shell_SUITE)
+%%
+-undef(line).
+-define(line,).
+rtnode(C,N) ->
+ rtnode(C,N,[]).
+rtnode(Commands,Nodename,ErlPrefix) ->
+ rtnode(Commands,Nodename,ErlPrefix,[]).
+rtnode(Commands,Nodename,ErlPrefix,Extra) ->
+ ?line case get_progs() of
+ {error,_Reason} ->
+ ?line {skip,"No runerl present"};
+ {RunErl,ToErl,Erl} ->
+ ?line case create_tempdir() of
+ {error, Reason2} ->
+ ?line {skip, Reason2};
+ Tempdir ->
+ ?line SPid =
+ start_runerl_node(RunErl,ErlPrefix++Erl,
+ Tempdir,Nodename, Extra),
+ ?line CPid = start_toerl_server(ToErl,Tempdir),
+ ?line erase(getline_skipped),
+ ?line Res =
+ (catch get_and_put(CPid, Commands,1)),
+ ?line case stop_runerl_node(CPid) of
+ {error,_} ->
+ ?line CPid2 =
+ start_toerl_server
+ (ToErl,Tempdir),
+ ?line erase(getline_skipped),
+ ?line ok = get_and_put
+ (CPid2,
+ [{putline,[7]},
+ {sleep,
+ timeout(short)},
+ {putline,""},
+ {getline," -->"},
+ {putline,"s"},
+ {putline,"c"},
+ {putline,""}],1),
+ ?line stop_runerl_node(CPid2);
+ _ ->
+ ?line ok
+ end,
+ ?line wait_for_runerl_server(SPid),
+ ?line ok = rm_rf(Tempdir),
+ ?line ok = Res
+ end
+ end.
+
+timeout(long) ->
+ 2 * timeout(normal);
+timeout(short) ->
+ timeout(normal) div 10;
+timeout(normal) ->
+ 10000 * test_server:timetrap_scale_factor().
+
+
+%% start_noshell_node(Name) ->
+%% PADir = filename:dirname(code:which(?MODULE)),
+%% {ok, Node} = test_server:start_node(Name,slave,[{args," -noshell -pa "++
+%% PADir++" "}]),
+%% Node.
+%% stop_noshell_node(Node) ->
+%% test_server:stop_node(Node).
+
+
+rm_rf(Dir) ->
+ try
+ {ok,List} = file:list_dir(Dir),
+ Files = [filename:join([Dir,X]) || X <- List],
+ [case file:list_dir(Y) of
+ {error, enotdir} ->
+ ok = file:delete(Y);
+ _ ->
+ ok = rm_rf(Y)
+ end || Y <- Files],
+ ok = file:del_dir(Dir),
+ ok
+ catch
+ _:Exception -> {error, {Exception,Dir}}
+ end.
+
+
+get_and_put(_CPid,[],_) ->
+ ok;
+get_and_put(CPid, [{sleep, X}|T],N) ->
+ ?dbg({sleep, X}),
+ receive
+ after X ->
+ get_and_put(CPid,T,N+1)
+ end;
+get_and_put(CPid, [{getline, Match}|T],N) ->
+ ?dbg({getline, Match}),
+ CPid ! {self(), {get_line, timeout(normal)}},
+ receive
+ {get_line, timeout} ->
+ error_logger:error_msg("~p: getline timeout waiting for \"~s\" "
+ "(command number ~p, skipped: ~p)~n",
+ [?MODULE, Match,N,get(getline_skipped)]),
+ {error, timeout};
+ {get_line, Data} ->
+ ?dbg({data,Data}),
+ case lists:prefix(Match, Data) of
+ true ->
+ erase(getline_skipped),
+ get_and_put(CPid, T,N+1);
+ false ->
+ case get(getline_skipped) of
+ undefined ->
+ put(getline_skipped,[Data]);
+ List ->
+ put(getline_skipped,List ++ [Data])
+ end,
+ get_and_put(CPid, [{getline, Match}|T],N)
+ end
+ end;
+get_and_put(CPid, [{getline_re, Match}|T],N) ->
+ ?dbg({getline_re, Match}),
+ CPid ! {self(), {get_line, timeout(normal)}},
+ receive
+ {get_line, timeout} ->
+ error_logger:error_msg("~p: getline_re timeout waiting for \"~s\" "
+ "(command number ~p, skipped: ~p)~n",
+ [?MODULE, Match,N,get(getline_skipped)]),
+ {error, timeout};
+ {get_line, Data} ->
+ ?dbg({data,Data}),
+ case re:run(Data, Match,[{capture,none}]) of
+ match ->
+ erase(getline_skipped),
+ get_and_put(CPid, T,N+1);
+ _ ->
+ case get(getline_skipped) of
+ undefined ->
+ put(getline_skipped,[Data]);
+ List ->
+ put(getline_skipped,List ++ [Data])
+ end,
+ get_and_put(CPid, [{getline_re, Match}|T],N)
+ end
+ end;
+
+get_and_put(CPid, [{putline_raw, Line}|T],N) ->
+ ?dbg({putline_raw, Line}),
+ CPid ! {self(), {send_line, Line}},
+ Timeout = timeout(normal),
+ receive
+ {send_line, ok} ->
+ get_and_put(CPid, T,N+1)
+ after Timeout ->
+ error_logger:error_msg("~p: putline_raw timeout (~p) sending "
+ "\"~s\" (command number ~p)~n",
+ [?MODULE, Timeout, Line, N]),
+ {error, timeout}
+ end;
+
+get_and_put(CPid, [{putline, Line}|T],N) ->
+ ?dbg({putline, Line}),
+ CPid ! {self(), {send_line, Line}},
+ Timeout = timeout(normal),
+ receive
+ {send_line, ok} ->
+ get_and_put(CPid, [{getline, []}|T],N)
+ after Timeout ->
+ error_logger:error_msg("~p: putline timeout (~p) sending "
+ "\"~s\" (command number ~p)~n[~p]~n",
+ [?MODULE, Timeout, Line, N,get()]),
+ {error, timeout}
+ end.
+
+wait_for_runerl_server(SPid) ->
+ Ref = erlang:monitor(process, SPid),
+ Timeout = timeout(long),
+ receive
+ {'DOWN', Ref, process, SPid, _} ->
+ ok
+ after Timeout ->
+ {error, timeout}
+ end.
+
+
+
+stop_runerl_node(CPid) ->
+ Ref = erlang:monitor(process, CPid),
+ CPid ! {self(), kill_emulator},
+ Timeout = timeout(long),
+ receive
+ {'DOWN', Ref, process, CPid, noproc} ->
+ ok;
+ {'DOWN', Ref, process, CPid, normal} ->
+ ok;
+ {'DOWN', Ref, process, CPid, {error, Reason}} ->
+ {error, Reason}
+ after Timeout ->
+ {error, timeout}
+ end.
+
+get_progs() ->
+ case os:type() of
+ {unix,freebsd} ->
+ {error,"cant use run_erl on freebsd"};
+ {unix,openbsd} ->
+ {error,"cant use run_erl on openbsd"};
+ {unix,_} ->
+ case os:find_executable("run_erl") of
+ RE when is_list(RE) ->
+ case os:find_executable("to_erl") of
+ TE when is_list(TE) ->
+ case os:find_executable("erl") of
+ E when is_list(E) ->
+ {RE,TE,E};
+ _ ->
+ {error, "Could not find erl command"}
+ end;
+ _ ->
+ {error, "Could not find to_erl command"}
+ end;
+ _ ->
+ {error, "Could not find run_erl command"}
+ end;
+ _ ->
+ {error, "Not a unix OS"}
+ end.
+
+create_tempdir() ->
+ create_tempdir(filename:join(["/tmp","rtnode"++os:getpid()]),$A).
+
+create_tempdir(Dir,X) when X > $Z, X < $a ->
+ create_tempdir(Dir,$a);
+create_tempdir(Dir,X) when X > $z ->
+ Estr = lists:flatten(
+ io_lib:format("Unable to create ~s, reason eexist",
+ [Dir++[$z]])),
+ {error, Estr};
+create_tempdir(Dir0, Ch) ->
+ % Expect fairly standard unix.
+ Dir = Dir0++[Ch],
+ case file:make_dir(Dir) of
+ {error, eexist} ->
+ create_tempdir(Dir0, Ch+1);
+ {error, Reason} ->
+ Estr = lists:flatten(
+ io_lib:format("Unable to create ~s, reason ~p",
+ [Dir,Reason])),
+ {error,Estr};
+ ok ->
+ Dir
+ end.
+
+create_nodename() ->
+ create_nodename($A).
+
+create_nodename(X) when X > $Z, X < $a ->
+ create_nodename($a);
+create_nodename(X) when X > $z ->
+ {error,out_of_nodenames};
+create_nodename(X) ->
+ NN = "rtnode"++os:getpid()++[X],
+ case file:read_file_info(filename:join(["/tmp",NN])) of
+ {error,enoent} ->
+ Host = lists:nth(2,string:tokens(atom_to_list(node()),"@")),
+ NN++"@"++Host;
+ _ ->
+ create_nodename(X+1)
+ end.
+
+
+start_runerl_node(RunErl,Erl,Tempdir,Nodename,Extra) ->
+ XArg = case Nodename of
+ [] ->
+ [];
+ _ ->
+ " -sname "++(if is_atom(Nodename) -> atom_to_list(Nodename);
+ true -> Nodename
+ end)++
+ " -setcookie "++atom_to_list(erlang:get_cookie())
+ end,
+ XXArg = case Extra of
+ [] ->
+ [];
+ _ ->
+ " "++Extra
+ end,
+ spawn(fun() ->
+ os:cmd(RunErl++" "++Tempdir++"/ "++Tempdir++" \""++
+ Erl++XArg++XXArg++"\"")
+ end).
+
+start_toerl_server(ToErl,Tempdir) ->
+ Pid = spawn(?MODULE,toerl_server,[self(),ToErl,Tempdir]),
+ receive
+ {Pid,started} ->
+ Pid;
+ {Pid,error,Reason} ->
+ {error,Reason}
+ end.
+
+try_to_erl(_Command, 0) ->
+ {error, cannot_to_erl};
+try_to_erl(Command, N) ->
+ ?dbg({?LINE,N}),
+ Port = open_port({spawn, Command},[eof,{line,1000}]),
+ Timeout = timeout(normal) div 2,
+ receive
+ {Port, eof} ->
+ receive after Timeout ->
+ ok
+ end,
+ try_to_erl(Command, N-1)
+ after Timeout ->
+ ?dbg(Port),
+ Port
+ end.
+
+toerl_server(Parent,ToErl,Tempdir) ->
+ Port = try_to_erl(ToErl++" "++Tempdir++"/ 2>/dev/null",8),
+ case Port of
+ P when is_port(P) ->
+ Parent ! {self(),started};
+ {error,Other} ->
+ Parent ! {self(),error,Other},
+ exit(Other)
+ end,
+ case toerl_loop(Port,[]) of
+ normal ->
+ ok;
+ {error, Reason} ->
+ error_logger:error_msg("toerl_server exit with reason ~p~n",
+ [Reason]),
+ exit(Reason)
+ end.
+
+toerl_loop(Port,Acc) ->
+ ?dbg({toerl_loop, Port, Acc}),
+ receive
+ {Port,{data,{Tag0,Data}}} when is_port(Port) ->
+ ?dbg({?LINE,Port,{data,{Tag0,Data}}}),
+ case Acc of
+ [{noeol,Data0}|T0] ->
+ toerl_loop(Port,[{Tag0, Data0++Data}|T0]);
+ _ ->
+ toerl_loop(Port,[{Tag0,Data}|Acc])
+ end;
+ {Pid,{get_line,Timeout}} ->
+ case Acc of
+ [] ->
+ case get_data_within(Port,Timeout,[]) of
+ timeout ->
+ Pid ! {get_line, timeout},
+ toerl_loop(Port,[]);
+ {noeol,Data1} ->
+ Pid ! {get_line, timeout},
+ toerl_loop(Port,[{noeol,Data1}]);
+ {eol,Data2} ->
+ Pid ! {get_line, Data2},
+ toerl_loop(Port,[])
+ end;
+ [{noeol,Data3}] ->
+ case get_data_within(Port,Timeout,Data3) of
+ timeout ->
+ Pid ! {get_line, timeout},
+ toerl_loop(Port,Acc);
+ {noeol,Data4} ->
+ Pid ! {get_line, timeout},
+ toerl_loop(Port,[{noeol,Data4}]);
+ {eol,Data5} ->
+ Pid ! {get_line, Data5},
+ toerl_loop(Port,[])
+ end;
+ List ->
+ {NewAcc,[{eol,Data6}]} = lists:split(length(List)-1,List),
+ Pid ! {get_line,Data6},
+ toerl_loop(Port,NewAcc)
+ end;
+ {Pid, {send_line, Data7}} ->
+ Port ! {self(),{command, Data7++"\n"}},
+ Pid ! {send_line, ok},
+ toerl_loop(Port,Acc);
+ {_Pid, kill_emulator} ->
+ Port ! {self(),{command, "init:stop().\n"}},
+ Timeout1 = timeout(long),
+ receive
+ {Port,eof} ->
+ normal
+ after Timeout1 ->
+ {error, kill_timeout}
+ end;
+ {Port, eof} ->
+ {error, unexpected_eof};
+ Other ->
+ {error, {unexpected, Other}}
+ end.
+
+millistamp() ->
+ {Mega, Secs, Micros} = erlang:now(),
+ (Micros div 1000) + Secs * 1000 + Mega * 1000000000.
+
+get_data_within(Port, X, Acc) when X =< 0 ->
+ ?dbg({get_data_within, X, Acc, ?LINE}),
+ receive
+ {Port,{data,{Tag0,Data}}} ->
+ ?dbg({?LINE,Port,{data,{Tag0,Data}}}),
+ {Tag0, Acc++Data}
+ after 0 ->
+ case Acc of
+ [] ->
+ timeout;
+ Noeol ->
+ {noeol,Noeol}
+ end
+ end;
+
+
+get_data_within(Port, Timeout, Acc) ->
+ ?dbg({get_data_within, Timeout, Acc, ?LINE}),
+ T1 = millistamp(),
+ receive
+ {Port,{data,{noeol,Data}}} ->
+ ?dbg({?LINE,Port,{data,{noeol,Data}}}),
+ Elapsed = millistamp() - T1 + 1,
+ get_data_within(Port, Timeout - Elapsed, Acc ++ Data);
+ {Port,{data,{eol,Data1}}} ->
+ ?dbg({?LINE,Port,{data,{eol,Data1}}}),
+ {eol, Acc ++ Data1}
+ after Timeout ->
+ timeout
+ end.
+
+%%
+%% Test I/O-server
+%%
+
+start_io_server_proxy() ->
+ spawn_link(?MODULE,io_server_proxy,[#state{}]).
+
+proxy_getall(Pid) ->
+ req(Pid,{self(),getall}).
+proxy_setnext(Pid,Data) when is_list(Data) ->
+ req(Pid,{self(),next,Data}).
+proxy_quit(Pid) ->
+ req(Pid,{self(),quit}).
+
+req(Pid,Mess) ->
+ Pid ! Mess,
+ receive
+ {Pid, Answer} ->
+ Answer
+ after 5000 ->
+ exit(timeout)
+ end.
+
+io_server_proxy(State) ->
+ receive
+ {io_request, From, ReplyAs, Request} ->
+ case request(Request,State) of
+ {Tag, Reply, NewState} when Tag =:= ok; Tag =:= error ->
+ reply(From, ReplyAs, Reply),
+ io_server_proxy(NewState);
+ {stop, Reply, _NewState} ->
+ reply(From, ReplyAs, Reply),
+ exit(Reply)
+ end;
+ %% Private message
+ {From, next, Data} ->
+ From ! {self(), ok},
+ io_server_proxy(State#state{nxt = Data});
+ {From, getall} ->
+ From ! {self(), lists:reverse(State#state.q)},
+ io_server_proxy(State#state{q=[]});
+ {From, quit} ->
+ From ! {self(), lists:reverse(State#state.q)},
+ ok;
+ _Unknown ->
+ io_server_proxy(State)
+ end.
+
+reply(From, ReplyAs, Reply) ->
+ From ! {io_reply, ReplyAs, Reply}.
+
+request({put_chars, Encoding, Chars}, State) ->
+ {ok, ok, State#state{q=[{put_chars, Encoding, Chars} | State#state.q ]}};
+request({put_chars, Encoding, Module, Function, Args}, State) ->
+ {ok, ok, State#state{q=[{put_chars, Encoding, Module, Function, Args} |
+ State#state.q ]}};
+request({put_chars,Chars}, State) ->
+ {ok, ok, State#state{q=[{put_chars, Chars} | State#state.q ]}};
+request({put_chars,M,F,As}, State) ->
+ {ok, ok, State#state{q=[{put_chars, M,F,As} | State#state.q ]}};
+request({get_until, Encoding, Prompt, M, F, As}, State) ->
+ {ok, convert(State#state.nxt, Encoding, State#state.mode), State#state{nxt = eof, q = [{get_until, Encoding, Prompt, M, F, As} | State#state.q]}};
+request({get_chars, Encoding, Prompt, N}, State) ->
+ {ok, convert(State#state.nxt, Encoding, State#state.mode), State#state{nxt = eof,
+ q = [{get_chars, Encoding, Prompt, N} |
+ State#state.q]}};
+request({get_line, Encoding, Prompt}, State) ->
+ {ok, convert(State#state.nxt, Encoding, State#state.mode),
+ State#state{nxt = eof,
+ q = [{get_line, Encoding, Prompt} |
+ State#state.q]}};
+request({get_until, Prompt, M, F, As}, State) ->
+ {ok, convert(State#state.nxt, latin1, State#state.mode),
+ State#state{nxt = eof,
+ q = [{get_until, Prompt, M, F, As} | State#state.q]}};
+request({get_chars, Prompt, N}, State) ->
+ {ok, convert(State#state.nxt, latin1, State#state.mode),
+ State#state{nxt = eof,
+ q = [{get_chars, Prompt, N} |
+ State#state.q]}};
+request({get_line, Prompt}, State) ->
+ {ok, convert(State#state.nxt, latin1, State#state.mode),
+ State#state{nxt = eof,
+ q = [{get_line, Prompt} |
+ State#state.q]}};
+request({get_geomentry,_}, State) ->
+ {error, {error,enotsup}, State};
+request({setopts, Opts}, State) when Opts =:= [{binary, false}]; Opts =:= [list] ->
+ {ok, ok, State#state{q=[{setopts, Opts} | State#state.q ], mode = list}};
+request({setopts, Opts}, State) when Opts =:= [{binary, true}]; Opts =:= [binary] ->
+ {ok, ok, State#state{q=[{setopts, Opts} | State#state.q ], mode = binary}};
+request(getopts, State) ->
+ {ok, case State#state.mode of
+ list -> [{binary,false}];
+ binary -> [{binary, true}]
+ end, State#state{q=[getopts | State#state.q ]}};
+request({requests, Reqs}, State) ->
+ multi_request(Reqs, {ok, ok, State}).
+
+multi_request([R|Rs], {ok, _Res, State}) ->
+ multi_request(Rs, request(R, State));
+multi_request([_|_], Error) ->
+ Error;
+multi_request([], State) ->
+ State.
+
+convert(Atom,_,_) when is_atom(Atom) ->
+ Atom;
+convert(Data, unicode, list) ->
+ unicode:characters_to_list(Data,unicode);
+convert(Data, latin1, list) ->
+ try
+ L = unicode:characters_to_list(Data, unicode),
+ [ true = Ch =< 255 || Ch <- L ],
+ L
+ catch
+ _:_ ->
+ {error, {cannot_convert, unicode, latin1}}
+ end;
+convert(Data, unicode, binary) ->
+ unicode:characters_to_binary(Data,unicode,unicode);
+convert(Data, latin1, binary) ->
+ case unicode:characters_to_binary(Data, unicode, latin1) of
+ Bin when is_binary(Bin) ->
+ Bin;
+ _ ->
+ {error, {cannot_convert, unicode, latin1}}
+ end.
+
+hostname() ->
+ from($@, atom_to_list(node())).
+
+from(H, [H | T]) -> T;
+from(H, [_ | T]) -> from(H, T);
+from(_, []) -> [].
+
+chomp([]) ->
+ [];
+chomp([$\n]) ->
+ [];
+chomp([H|T]) ->
+ [H|chomp(T)];
+chomp(<<>>) ->
+ <<>>;
+chomp(<<$\n>>) ->
+ <<>>;
+chomp(<<Ch,Rest/binary>>) ->
+ X = chomp(Rest),
+ <<Ch,X/binary>>;
+chomp(Atom) ->
+ Atom.