-module(dialyzer_test).
-export([dialyzer_test/6]).
-include("test_server.hrl").
-define(test_case_dir, "src").
-define(results_dir,"results").
-define(plt_filename,".dialyzer_plt").
-define(required_modules, "kernel stdlib compiler erts").
dialyzer_test(Options, TestCase, Kind, Dir, OutDir, Dog) ->
PltFilename = filename:join(OutDir, ?plt_filename),
case file:read_file_info(PltFilename) of
{ok, _} -> ok;
{error, _ } -> create_plt(OutDir, Dog)
end,
SrcDir = filename:join(Dir, ?test_case_dir),
ResDir = filename:join(Dir, ?results_dir),
TestCaseString = atom_to_list(TestCase),
Filename = filename:join(SrcDir, TestCaseString),
CorrectOptions = convert_relative_paths(Options, Dir),
FilesOption =
case Kind of
file -> {files, [Filename ++ ".erl"]};
dir -> {files_rec, [Filename]}
end,
ResFile = TestCaseString,
NewResFile = filename:join(OutDir, ResFile),
OldResFile = filename:join(ResDir, ResFile),
RawWarns = dialyzer:run([FilesOption,
{init_plt, PltFilename},
{from, src_code},
{check_plt, false} | CorrectOptions]),
Warns = lists:sort([dialyzer:format_warning(W) || W <- RawWarns]),
case Warns of
[] -> ok;
_ ->
case file:open(NewResFile,['write']) of
{ok, OutFile} ->
io:format(OutFile,"\n~s",[Warns]),
file:close(OutFile);
Other -> erlang:error(Other)
end
end,
case diff(NewResFile, OldResFile) of
'same' -> file:delete(NewResFile),
'same';
Any -> Any
end.
create_plt(OutDir, Dog) ->
PltFilename = filename:join(OutDir, ?plt_filename),
?t:timetrap_cancel(Dog),
?t:format("Generating plt..."),
HomeDir = os:getenv("HOME"),
HomePlt = filename:join(HomeDir, ?plt_filename),
file:copy(HomePlt, PltFilename),
try
AddCommand = "dialyzer --add_to_plt --output_plt " ++
PltFilename ++ " --apps " ++ ?required_modules,
?t:format(AddCommand ++ "\n"),
?t:format(os:cmd(AddCommand)),
dialyzer:run([{analysis_type, plt_check},
{init_plt, PltFilename}]) of
[] -> ok
catch
_:_ ->
BuildCommand = "dialyzer --build_plt --output_plt " ++
PltFilename ++ " --apps " ++ ?required_modules,
?t:format(BuildCommand ++ "\n"),
?t:format(os:cmd(BuildCommand))
end.
convert_relative_paths(Options, Dir) ->
convert_relative_paths(Options, Dir, []).
convert_relative_paths([], _Dir, Acc) ->
Acc;
convert_relative_paths([{include_dirs, Paths}|Rest], Dir, Acc) ->
AbsolutePaths = convert_relative_paths_1(Paths, Dir, []),
convert_relative_paths(Rest, Dir, [{include_dirs, AbsolutePaths}|Acc]);
convert_relative_paths([Option|Rest], Dir, Acc) ->
convert_relative_paths(Rest, Dir, [Option|Acc]).
convert_relative_paths_1([], _Dir, Acc) ->
Acc;
convert_relative_paths_1([Path|Rest], Dir, Acc) ->
convert_relative_paths_1(Rest, Dir, [filename:join(Dir, Path)|Acc]).
diff(Filename1, Filename2) ->
File1 =
case file:open(Filename1, [read]) of
{ok, F1} -> {file, F1};
_ -> empty
end,
File2 =
case file:open(Filename2, [read]) of
{ok, F2} -> {file, F2};
_ -> empty
end,
case diff1(File1, File2) of
{error, {N, Error}} ->
case N of
1 -> {error, {Filename1, Error}};
2 -> {error, {Filename2, Error}}
end;
[] -> 'same';
DiffList -> {'differ', DiffList}
end.
diff1(File1, File2) ->
case file_to_lines(File1) of
{error, Error} -> {error, {1, Error}};
Lines1 ->
case file_to_lines(File2) of
{error, Error} -> {error, {2, Error}};
Lines2 ->
Common = lcs_fast(Lines1, Lines2),
diff2(Lines1, 1, Lines2, 1, Common, [])
end
end.
diff2([], _, [], _, [], Acc) -> lists:keysort(2,Acc);
diff2([H1|T1], N1, [], N2, [], Acc) ->
diff2(T1, N1+1, [], N2, [], [{new, N1, H1}|Acc]);
diff2([], N1, [H2|T2], N2, [], Acc) ->
diff2([], N1, T2, N2+1, [], [{old, N2, H2}|Acc]);
diff2([H1|T1], N1, [H2|T2], N2, [], Acc) ->
diff2(T1, N1+1, T2, N2+1, [], [{new, N1, H1}, {old, N2, H2}|Acc]);
diff2([H1|T1]=L1, N1, [H2|T2]=L2, N2, [HC|TC]=LC, Acc) ->
case H1 =:= H2 of
true -> diff2(T1, N1+1, T2, N2+1, TC, Acc);
false ->
case H1 =:= HC of
true -> diff2(L1, N1, T2, N2+1, LC, [{old, N2, H2}|Acc]);
false -> diff2(T1, N1+1, L2, N2, LC, [{new, N1, H1}|Acc])
end
end.
-spec lcs_fast([string()], [string()]) -> [string()].
lcs_fast(S1, S2) ->
M = length(S1),
N = length(S2),
Acc = array:new(M*N, {default, 0}),
{L, _} = lcs_fast(S1, S2, 1, 1, N, Acc),
L.
-spec lcs_fast([string()], [string()],
pos_integer(), pos_integer(),
non_neg_integer(), array()) -> {[string()], array()}.
lcs_fast([], _, _, _, _, Acc) ->
{[], Acc};
lcs_fast(_, [], _, _, _, Acc) ->
{[], Acc};
lcs_fast([H1|T1] = S1, [H2|T2] = S2, N1, N2, N, Acc) ->
I = (N1-1) * N + N2 - 1,
case array:get(I, Acc) of
0 ->
case string:equal(H1, H2) of
true ->
{T, NAcc} = lcs_fast(T1, T2, N1+1, N2+1, N, Acc),
L = [H1|T],
{L, array:set(I, L, NAcc)};
false ->
{L1, NAcc1} = lcs_fast(S1, T2, N1, N2+1, N, Acc),
{L2, NAcc2} = lcs_fast(T1, S2, N1+1, N2, N, NAcc1),
L = longest(L1, L2),
{L, array:set(I, L, NAcc2)}
end;
L ->
{L, Acc}
end.
-spec longest([string()], [string()]) -> [string()].
longest(S1, S2) ->
case length(S1) > length(S2) of
true -> S1;
false -> S2
end.
file_to_lines(empty) ->
[];
file_to_lines({file, File}) ->
case file_to_lines(File, []) of
{error, _} = Error -> Error;
Lines -> lists:reverse(Lines)
end.
file_to_lines(File, Acc) ->
case io:get_line(File, "") of
{error, _}=Error -> Error;
eof -> Acc;
A -> file_to_lines(File, [A|Acc])
end.
