You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
244 lines
8.6 KiB
244 lines
8.6 KiB
%% -------------------------------------------------------------------
|
|
%%
|
|
%% trunc_io_eqc: QuickCheck test for trunc_io:format with maxlen
|
|
%%
|
|
%% Copyright (c) 2011-2012 Basho Technologies, Inc. All Rights Reserved.
|
|
%%
|
|
%% This file is provided to you under the Apache License,
|
|
%% Version 2.0 (the "License"); you may not use this file
|
|
%% except in compliance with the License. You may obtain
|
|
%% a copy of the License at
|
|
%%
|
|
%% http://www.apache.org/licenses/LICENSE-2.0
|
|
%%
|
|
%% Unless required by applicable law or agreed to in writing,
|
|
%% software distributed under the License is distributed on an
|
|
%% "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
|
|
%% KIND, either express or implied. See the License for the
|
|
%% specific language governing permissions and limitations
|
|
%% under the License.
|
|
%%
|
|
%% -------------------------------------------------------------------
|
|
-module(trunc_io_eqc).
|
|
|
|
-ifdef(TEST).
|
|
-ifdef(EQC).
|
|
-export([test/0, test/1, check/0, prop_format/0, prop_equivalence/0]).
|
|
|
|
-include_lib("eqc/include/eqc.hrl").
|
|
-include_lib("eunit/include/eunit.hrl").
|
|
|
|
-define(QC_OUT(P),
|
|
eqc:on_output(fun(Str, Args) -> io:format(user, Str, Args) end, P)).
|
|
|
|
%%====================================================================
|
|
%% eunit test
|
|
%%====================================================================
|
|
|
|
eqc_test_() ->
|
|
{timeout, 60,
|
|
{spawn,
|
|
[
|
|
{timeout, 30, ?_assertEqual(true, eqc:quickcheck(eqc:testing_time(14, ?QC_OUT(prop_format()))))},
|
|
{timeout, 30, ?_assertEqual(true, eqc:quickcheck(eqc:testing_time(14, ?QC_OUT(prop_equivalence()))))}
|
|
]
|
|
}}.
|
|
|
|
%%====================================================================
|
|
%% Shell helpers
|
|
%%====================================================================
|
|
|
|
test() ->
|
|
test(100).
|
|
|
|
test(N) ->
|
|
quickcheck(numtests(N, prop_format())).
|
|
|
|
check() ->
|
|
check(prop_format(), current_counterexample()).
|
|
|
|
%%====================================================================
|
|
%% Generators
|
|
%%====================================================================
|
|
|
|
gen_fmt_args() ->
|
|
list(oneof([gen_print_str(),
|
|
"~~",
|
|
{"~10000000.p", gen_any(5)},
|
|
{"~w", gen_any(5)},
|
|
{"~s", oneof([gen_print_str(), gen_atom(), gen_quoted_atom(), gen_print_bin(), gen_iolist(5)])},
|
|
{"~1000000.P", gen_any(5), 4},
|
|
{"~W", gen_any(5), 4},
|
|
{"~i", gen_any(5)},
|
|
{"~B", nat()},
|
|
{"~b", nat()},
|
|
{"~X", nat(), "0x"},
|
|
{"~x", nat(), "0x"},
|
|
{"~.10#", nat()},
|
|
{"~.10+", nat()},
|
|
{"~.36B", nat()},
|
|
{"~1000000.62P", gen_any(5), 4},
|
|
{"~c", gen_char()},
|
|
{"~tc", gen_char()},
|
|
{"~f", real()},
|
|
{"~10.f", real()},
|
|
{"~g", real()},
|
|
{"~10.g", real()},
|
|
{"~e", real()},
|
|
{"~10.e", real()}
|
|
])).
|
|
|
|
|
|
%% Generates a printable string
|
|
gen_print_str() ->
|
|
?LET(Xs, list(char()), [X || X <- Xs, io_lib:printable_list([X]), X /= $~, X < 255]).
|
|
|
|
gen_print_bin() ->
|
|
?LET(Xs, gen_print_str(), list_to_binary(Xs)).
|
|
|
|
gen_any(MaxDepth) ->
|
|
oneof([largeint(),
|
|
gen_atom(),
|
|
gen_quoted_atom(),
|
|
nat(),
|
|
%real(),
|
|
binary(),
|
|
gen_bitstring(),
|
|
gen_pid(),
|
|
gen_port(),
|
|
gen_ref(),
|
|
gen_fun()] ++
|
|
[?LAZY(list(gen_any(MaxDepth - 1))) || MaxDepth /= 0] ++
|
|
[?LAZY(gen_tuple(gen_any(MaxDepth - 1))) || MaxDepth /= 0]).
|
|
|
|
gen_iolist(0) ->
|
|
[];
|
|
gen_iolist(Depth) ->
|
|
list(oneof([gen_char(), gen_print_str(), gen_print_bin(), gen_iolist(Depth-1)])).
|
|
|
|
gen_atom() ->
|
|
elements([abc, def, ghi]).
|
|
|
|
gen_quoted_atom() ->
|
|
elements(['abc@bar', '@bar', '10gen']).
|
|
|
|
gen_bitstring() ->
|
|
?LET(XS, binary(), <<XS/binary, 1:7>>).
|
|
|
|
gen_tuple(Gen) ->
|
|
?LET(Xs, list(Gen), list_to_tuple(Xs)).
|
|
|
|
gen_max_len() -> %% Generate length from 3 to whatever. Needs space for ... in output
|
|
?LET(Xs, int(), 3 + abs(Xs)).
|
|
|
|
gen_pid() ->
|
|
?LAZY(spawn(fun() -> ok end)).
|
|
|
|
gen_port() ->
|
|
?LAZY(begin
|
|
Port = erlang:open_port({spawn, "true"}, []),
|
|
catch(erlang:port_close(Port)),
|
|
Port
|
|
end).
|
|
|
|
gen_ref() ->
|
|
?LAZY(make_ref()).
|
|
|
|
gen_fun() ->
|
|
?LAZY(fun() -> ok end).
|
|
|
|
gen_char() ->
|
|
oneof(lists:seq($A, $z)).
|
|
|
|
%%====================================================================
|
|
%% Property
|
|
%%====================================================================
|
|
|
|
%% Checks that trunc_io:format produces output less than or equal to MaxLen
|
|
prop_format() ->
|
|
?FORALL({FmtArgs, MaxLen}, {gen_fmt_args(), gen_max_len()},
|
|
begin
|
|
%% Because trunc_io will print '...' when its running out of
|
|
%% space, even if the remaining space is less than 3, it
|
|
%% doesn't *exactly* stick to the specified limit.
|
|
|
|
%% Also, since we don't truncate terms not printed with
|
|
%% ~p/~P/~w/~W/~s, we also need to calculate the wiggle room
|
|
%% for those. Hence the fudge factor calculated below.
|
|
FudgeLen = calculate_fudge(FmtArgs, 50),
|
|
{FmtStr, Args} = build_fmt_args(FmtArgs),
|
|
try
|
|
Str = lists:flatten(lager_trunc_io:format(FmtStr, Args, MaxLen)),
|
|
?WHENFAIL(begin
|
|
io:format(user, "FmtStr: ~p\n", [FmtStr]),
|
|
io:format(user, "Args: ~p\n", [Args]),
|
|
io:format(user, "FudgeLen: ~p\n", [FudgeLen]),
|
|
io:format(user, "MaxLen: ~p\n", [MaxLen]),
|
|
io:format(user, "ActLen: ~p\n", [length(Str)]),
|
|
io:format(user, "Str: ~p\n", [Str])
|
|
end,
|
|
%% Make sure the result is a printable list
|
|
%% and if the format string is less than the length,
|
|
%% the result string is less than the length.
|
|
conjunction([{printable, Str == "" orelse
|
|
io_lib:printable_list(Str)},
|
|
{length, length(FmtStr) > MaxLen orelse
|
|
length(Str) =< MaxLen + FudgeLen}]))
|
|
catch
|
|
_:Err ->
|
|
io:format(user, "\nException: ~p\n", [Err]),
|
|
io:format(user, "FmtStr: ~p\n", [FmtStr]),
|
|
io:format(user, "Args: ~p\n", [Args]),
|
|
false
|
|
end
|
|
end).
|
|
|
|
%% Checks for equivalent formatting to io_lib
|
|
prop_equivalence() ->
|
|
?FORALL(FmtArgs, gen_fmt_args(),
|
|
begin
|
|
{FmtStr, Args} = build_fmt_args(FmtArgs),
|
|
Expected = lists:flatten(io_lib:format(FmtStr, Args)),
|
|
Actual = lists:flatten(lager_trunc_io:format(FmtStr, Args, 10485760)),
|
|
?WHENFAIL(begin
|
|
io:format(user, "FmtStr: ~p\n", [FmtStr]),
|
|
io:format(user, "Args: ~p\n", [Args]),
|
|
io:format(user, "Expected: ~p\n", [Expected]),
|
|
io:format(user, "Actual: ~p\n", [Actual])
|
|
end,
|
|
Expected == Actual)
|
|
end).
|
|
|
|
|
|
%%====================================================================
|
|
%% Internal helpers
|
|
%%====================================================================
|
|
|
|
%% Build a tuple of {Fmt, Args} from a gen_fmt_args() return
|
|
build_fmt_args(FmtArgs) ->
|
|
F = fun({Fmt, Arg}, {FmtStr0, Args0}) ->
|
|
{FmtStr0 ++ Fmt, Args0 ++ [Arg]};
|
|
({Fmt, Arg1, Arg2}, {FmtStr0, Args0}) ->
|
|
{FmtStr0 ++ Fmt, Args0 ++ [Arg1, Arg2]};
|
|
(Str, {FmtStr0, Args0}) ->
|
|
{FmtStr0 ++ Str, Args0}
|
|
end,
|
|
lists:foldl(F, {"", []}, FmtArgs).
|
|
|
|
calculate_fudge([], Acc) ->
|
|
Acc;
|
|
calculate_fudge([{"~62P", _Arg, _Depth}|T], Acc) ->
|
|
calculate_fudge(T, Acc+62);
|
|
calculate_fudge([{Fmt, Arg}|T], Acc) when
|
|
Fmt == "~f"; Fmt == "~10.f";
|
|
Fmt == "~g"; Fmt == "~10.g";
|
|
Fmt == "~e"; Fmt == "~10.e";
|
|
Fmt == "~x"; Fmt == "~X";
|
|
Fmt == "~B"; Fmt == "~b"; Fmt == "~36B";
|
|
Fmt == "~.10#"; Fmt == "~10+" ->
|
|
calculate_fudge(T, Acc + length(lists:flatten(io_lib:format(Fmt, [Arg]))));
|
|
calculate_fudge([_|T], Acc) ->
|
|
calculate_fudge(T, Acc).
|
|
|
|
-endif. % (EQC).
|
|
-endif. % (TEST).
|