Switch testsuite to common_test, part #1

The migrated tests are the external ones executed from
`rabbit_tests.erl`:
    o  credit_flow_test
    o  gm_tests
    o  mirrored_supervisor_tests
    o  on_disk_store_tunable_parameter_validation_test
    o  password_hashing_tests
    o  rabbit_ctl_timeout_tests
    o  rabbit_resource_monitor_misc_test
    o  supervisor2_tests
    o  truncate
    o  vm_memory_monitor_tests

References #725.
[#116526487]

1 files changed, 4 insertions, 71 deletions

diff --git a/src/truncate.erl b/src/truncate.erl
index 1c9b08ed27..a1586b0cb0 100644
--- a/src/truncate.erl
+++ b/src/truncate.erl
@@ -21,8 +21,10 @@
 -record(params, {content, struct, content_dec, struct_dec}).
 
 -export([log_event/2, term/2]).
-%% exported for testing
--export([test/0]).
+
+-ifdef(TEST).
+-export([term_size/3]).
+-endif.
 
 log_event({Type, GL, {Pid, Format, Args}}, Params)
   when Type =:= error orelse
@@ -123,72 +125,3 @@ tuple_term_size(_T, M, I, S, _W) when I > S ->
     M;
 tuple_term_size(T, M, I, S, W) ->
     tuple_term_size(T, lim(term_size(element(I, T), M, W), 2 * W), I + 1, S, W).
-
-%%----------------------------------------------------------------------------
-
-test() ->
-    test_short_examples_exactly(),
-    test_term_limit(),
-    test_large_examples_for_size(),
-    ok.
-
-test_short_examples_exactly() ->
-    F = fun (Term, Exp) ->
-                Exp = term(Term, {1, {10, 10, 5, 5}}),
-                Term = term(Term, {100000, {10, 10, 5, 5}})
-        end,
-    FSmall = fun (Term, Exp) ->
-                     Exp = term(Term, {1, {2, 2, 2, 2}}),
-                     Term = term(Term, {100000, {2, 2, 2, 2}})
-             end,
-    F([], []),
-    F("h", "h"),
-    F("hello world", "hello w..."),
-    F([[h,e,l,l,o,' ',w,o,r,l,d]], [[h,e,l,l,o,'...']]),
-    F([a|b], [a|b]),
-    F(<<"hello">>, <<"hello">>),
-    F([<<"hello world">>], [<<"he...">>]),
-    F(<<1:1>>, <<1:1>>),
-    F(<<1:81>>, <<0:56, "...">>),
-    F({{{{a}}},{b},c,d,e,f,g,h,i,j,k}, {{{'...'}},{b},c,d,e,f,g,h,i,j,'...'}),
-    FSmall({a,30,40,40,40,40}, {a,30,'...'}),
-    FSmall([a,30,40,40,40,40], [a,30,'...']),
-    P = spawn(fun() -> receive die -> ok end end),
-    F([0, 0.0, <<1:1>>, F, P], [0, 0.0, <<1:1>>, F, P]),
-    P ! die,
-    R = make_ref(),
-    F([R], [R]),
-    ok.
-
-test_term_limit() ->
-    W = erlang:system_info(wordsize),
-    S = <<"abc">>,
-    1 = term_size(S, 4, W),
-    limit_exceeded = term_size(S, 3, W),
-    case 100 - term_size([S, S], 100, W) of
-        22 -> ok; %% 32 bit
-        38 -> ok  %% 64 bit
-    end,
-    case 100 - term_size([S, [S]], 100, W) of
-        30 -> ok; %% ditto
-        54 -> ok
-    end,
-    limit_exceeded = term_size([S, S], 6, W),
-    ok.
-
-test_large_examples_for_size() ->
-    %% Real world values
-    Shrink = fun(Term) -> term(Term, {1, {1000, 100, 50, 5}}) end,
-    TestSize = fun(Term) ->
-                       true = 5000000 < size(term_to_binary(Term)),
-                       true = 500000 > size(term_to_binary(Shrink(Term)))
-               end,
-    TestSize(lists:seq(1, 5000000)),
-    TestSize(recursive_list(1000, 10)),
-    TestSize(recursive_list(5000, 20)),
-    TestSize(gb_sets:from_list([I || I <- lists:seq(1, 1000000)])),
-    TestSize(gb_trees:from_orddict([{I, I} || I <- lists:seq(1, 1000000)])),
-    ok.
-
-recursive_list(S, 0) -> lists:seq(1, S);
-recursive_list(S, N) -> [recursive_list(S div N, N-1) || _ <- lists:seq(1, S)].