%% %% %CopyrightBegin% %% %% Copyright Ericsson AB 1997-2011. 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(exception_SUITE). -export([all/0, suite/0,groups/0,init_per_suite/1, end_per_suite/1, init_per_group/2,end_per_group/2, badmatch/1, pending_errors/1, nil_arith/1, stacktrace/1, nested_stacktrace/1, raise/1, gunilla/1, per/1, exception_with_heap_frag/1]). -export([bad_guy/2]). -include_lib("test_server/include/test_server.hrl"). -import(lists, [foreach/2]). suite() -> [{ct_hooks,[ts_install_cth]}]. all() -> [badmatch, pending_errors, nil_arith, stacktrace, nested_stacktrace, raise, gunilla, per, exception_with_heap_frag]. groups() -> []. init_per_suite(Config) -> Config. end_per_suite(_Config) -> ok. init_per_group(_GroupName, Config) -> Config. end_per_group(_GroupName, Config) -> Config. -define(try_match(E), catch ?MODULE:bar(), {'EXIT', {{badmatch, nomatch}, _}} = (catch E = id(nomatch))). %% Test that deliberately bad matches are reported correctly. badmatch(Config) when is_list(Config) -> ?line ?try_match(a), ?line ?try_match(42), ?line ?try_match({a, b, c}), ?line ?try_match([]), ?line ?try_match(1.0), ok. %% Test various exceptions, in the presence of a previous error suppressed %% in a guard. pending_errors(Config) when is_list(Config) -> ?line pending(e_badmatch, {badmatch, b}), ?line pending(x, function_clause), ?line pending(e_case, {case_clause, xxx}), ?line pending(e_if, if_clause), ?line pending(e_badarith, badarith), ?line pending(e_undef, undef), ?line pending(e_timeoutval, timeout_value), ?line pending(e_badarg, badarg), ?line pending(e_badarg_spawn, badarg), ok. bad_guy(pe_badarith, Other) when Other+1 == 0 -> % badarith (suppressed) ok; bad_guy(pe_badarg, Other) when length(Other) > 0 -> % badarg (suppressed) ok; bad_guy(_, e_case) -> case id(xxx) of ok -> ok end; % case_clause bad_guy(_, e_if) -> if a == b -> ok end; % if_clause bad_guy(_, e_badarith) -> 1+b; % badarith bad_guy(_, e_undef) -> non_existing_module:foo(); % undef bad_guy(_, e_timeoutval) -> receive after arne -> % timeout_value ok end; bad_guy(_, e_badarg) -> node(xxx); % badarg bad_guy(_, e_badarg_spawn) -> spawn({}, {}, {}); % badarg bad_guy(_, e_badmatch) -> a = id(b). % badmatch pending(Arg, Expected) -> pending(pe_badarith, Arg, Expected), pending(pe_badarg, Arg, Expected). pending(First, Second, Expected) -> pending_catched(First, Second, Expected), pending_exit_message([First, Second], Expected). pending_catched(First, Second, Expected) -> ok = io:format("Catching bad_guy(~p, ~p)", [First, Second]), case catch bad_guy(First, Second) of {'EXIT', Reason} -> pending(Reason, bad_guy, [First, Second], Expected); Other -> test_server:fail({not_exit, Other}) end. pending_exit_message(Args, Expected) -> ok = io:format("Trapping EXITs from spawn_link(~p, ~p, ~p)", [?MODULE, bad_guy, Args]), process_flag(trap_exit, true), Pid = spawn_link(?MODULE, bad_guy, Args), receive {'EXIT', Pid, Reason} -> pending(Reason, bad_guy, Args, Expected); Other -> test_server:fail({unexpected_message, Other}) after 10000 -> test_server:fail(timeout) end, process_flag(trap_exit, false). pending({badarg, [{erlang,Bif,BifArgs},{?MODULE,Func,Arity}|_]}, Func, Args, _Code) when is_atom(Bif), is_list(BifArgs), length(Args) == Arity -> ok; pending({undef,[{non_existing_module,foo,[]}|_]}, _, _, _) -> ok; pending({function_clause,[{?MODULE,Func,Args}|_]}, Func, Args, _Code) -> ok; pending({Code,[{?MODULE,Func,Arity}|_]}, Func, Args, Code) when length(Args) == Arity -> ok; pending(Reason, _Function, _Args, _Code) -> test_server:fail({bad_exit_reason,Reason}). %% Test that doing arithmetics on [] gives a badarith EXIT and not a crash. nil_arith(Config) when is_list(Config) -> ?line ba_plus_minus_times([], []), ?line ba_plus_minus_times([], 0), ?line ba_plus_minus_times([], 42), ?line ba_plus_minus_times([], 38724978123478923784), ?line ba_plus_minus_times([], 38.72), ?line ba_plus_minus_times(0, []), ?line ba_plus_minus_times(334, []), ?line ba_plus_minus_times(387249797813478923784, []), ?line ba_plus_minus_times(344.22, []), ?line ba_div_rem([], []), ?line ba_div_rem([], 0), ?line ba_div_rem([], 1), ?line ba_div_rem([], 42), ?line ba_div_rem([], 38724978123478923784), ?line ba_div_rem(344.22, []), ?line ba_div_rem(0, []), ?line ba_div_rem(1, []), ?line ba_div_rem(334, []), ?line ba_div_rem(387249797813478923784, []), ?line ba_div_rem(344.22, []), ?line ba_div_rem(344.22, 0.0), ?line ba_div_rem(1, 0.0), ?line ba_div_rem(392873498733971, 0.0), ?line ba_bop([], []), ?line ba_bop(0, []), ?line ba_bop(42, []), ?line ba_bop(-42342742987343, []), ?line ba_bop(238.342, []), ?line ba_bop([], 0), ?line ba_bop([], -243), ?line ba_bop([], 243), ?line ba_bop([], 2438724982478933), ?line ba_bop([], 3987.37), ?line ba_bnot([]), ?line ba_bnot(23.33), ?line ba_shift([], []), ?line ba_shift([], 0), ?line ba_shift([], 4), ?line ba_shift([], -4), ?line ba_shift([], 2343333333333), ?line ba_shift([], -333333333), ?line ba_shift([], 234.00), ?line ba_shift(23, []), ?line ba_shift(0, []), ?line ba_shift(-3433443433433323, []), ?line ba_shift(433443433433323, []), ?line ba_shift(343.93, []), ok. ba_plus_minus_times(A, B) -> io:format("~p + ~p", [A, B]), {'EXIT', {badarith, _}} = (catch A + B), io:format("~p - ~p", [A, B]), {'EXIT', {badarith, _}} = (catch A - B), io:format("~p * ~p", [A, B]), {'EXIT', {badarith, _}} = (catch A * B). ba_div_rem(A, B) -> io:format("~p / ~p", [A, B]), {'EXIT', {badarith, _}} = (catch A / B), io:format("~p div ~p", [A, B]), {'EXIT', {badarith, _}} = (catch A div B), io:format("~p rem ~p", [A, B]), {'EXIT', {badarith, _}} = (catch A rem B). ba_bop(A, B) -> io:format("~p band ~p", [A, B]), {'EXIT', {badarith, _}} = (catch A band B), io:format("~p bor ~p", [A, B]), {'EXIT', {badarith, _}} = (catch A bor B), io:format("~p bxor ~p", [A, B]), {'EXIT', {badarith, _}} = (catch A bxor B). ba_shift(A, B) -> io:format("~p bsl ~p", [A, B]), {'EXIT', {badarith, _}} = (catch A bsl B), io:format("~p bsr ~p", [A, B]), {'EXIT', {badarith, _}} = (catch A bsr B). ba_bnot(A) -> io:format("bnot ~p", [A]), {'EXIT', {badarith, _}} = (catch bnot A). stacktrace(Conf) when is_list(Conf) -> Tag = make_ref(), ?line {_,Mref} = spawn_monitor(fun() -> exit({Tag,erlang:get_stacktrace()}) end), ?line {Tag,[]} = receive {'DOWN',Mref,_,_,Info} -> Info end, V = [make_ref()|self()], ?line {value2,{caught1,badarg,[{erlang,abs,[V]}|_]=St1}} = stacktrace_1({'abs',V}, error, {value,V}), ?line St1 = erase(stacktrace1), ?line St1 = erase(stacktrace2), ?line St1 = erlang:get_stacktrace(), ?line {caught2,{error,badarith},[{?MODULE,my_add,2}|_]=St2} = stacktrace_1({'div',{1,0}}, error, {'add',{0,a}}), ?line [{?MODULE,my_div,2}|_] = erase(stacktrace1), ?line St2 = erase(stacktrace2), ?line St2 = erlang:get_stacktrace(), ?line {caught2,{error,{try_clause,V}},[{?MODULE,stacktrace_1,3}|_]=St3} = stacktrace_1({value,V}, error, {value,V}), ?line St3 = erase(stacktrace1), ?line St3 = erase(stacktrace2), ?line St3 = erlang:get_stacktrace(), ?line {caught2,{throw,V},[{?MODULE,foo,1}|_]=St4} = stacktrace_1({value,V}, error, {throw,V}), ?line [{?MODULE,stacktrace_1,3}|_] = erase(stacktrace1), ?line St4 = erase(stacktrace2), ?line St4 = erlang:get_stacktrace(), try ?line stacktrace_2() catch error:{badmatch,_} -> [{?MODULE,stacktrace_2,0}, {?MODULE,stacktrace,1}|_] = erlang:get_stacktrace(), ok end. stacktrace_1(X, C1, Y) -> erase(stacktrace1), erase(stacktrace2), try try foo(X) of C1 -> value1 catch C1:D1 -> {caught1,D1,erlang:get_stacktrace()} after put(stacktrace1, erlang:get_stacktrace()), foo(Y) end of V2 -> {value2,V2} catch C2:D2 -> {caught2,{C2,D2},erlang:get_stacktrace()} after put(stacktrace2, erlang:get_stacktrace()) end. stacktrace_2() -> ok = erlang:process_info(self(), current_function), ok. nested_stacktrace(Conf) when is_list(Conf) -> V = [{make_ref()}|[self()]], ?line value1 = nested_stacktrace_1({{value,{V,x1}},void,{V,x1}}, {void,void,void}), ?line {caught1, [{?MODULE,my_add,2}|_], value2, [{?MODULE,my_add,2}|_]} = nested_stacktrace_1({{'add',{V,x1}},error,badarith}, {{value,{V,x2}},void,{V,x2}}), ?line {caught1, [{?MODULE,my_add,2}|_], {caught2,[{erlang,abs,[V]}|_]}, [{erlang,abs,[V]}|_]} = nested_stacktrace_1({{'add',{V,x1}},error,badarith}, {{'abs',V},error,badarg}), ok. nested_stacktrace_1({X1,C1,V1}, {X2,C2,V2}) -> try foo(X1) of V1 -> value1 catch C1:V1 -> S1 = erlang:get_stacktrace(), T2 = try foo(X2) of V2 -> value2 catch C2:V2 -> {caught2,erlang:get_stacktrace()} end, {caught1,S1,T2,erlang:get_stacktrace()} end. raise(Conf) when is_list(Conf) -> ?line erase(raise), ?line A = try ?line try foo({'div',{1,0}}) catch error:badarith -> put(raise, A0 = erlang:get_stacktrace()), ?line erlang:raise(error, badarith, A0) end catch error:badarith -> ?line A1 = erlang:get_stacktrace(), ?line A1 = get(raise) end, ?line A = erlang:get_stacktrace(), ?line A = get(raise), ?line [{?MODULE,my_div,2}|_] = A, %% N = 8, % Must be even ?line N = erlang:system_flag(backtrace_depth, N), ?line try even(N) catch error:function_clause -> ok end, ?line B = odd_even(N, []), ?line B = erlang:get_stacktrace(), %% ?line C0 = odd_even(N+1, []), ?line C = lists:sublist(C0, N), ?line try odd(N+1) catch error:function_clause -> ok end, ?line C = erlang:get_stacktrace(), ?line try erlang:raise(error, function_clause, C0) catch error:function_clause -> ok end, ?line C = erlang:get_stacktrace(), ok. odd_even(N, R) when is_integer(N), N > 1 -> odd_even(N-1, [if (N rem 2) == 0 -> {?MODULE,even,1}; true -> {?MODULE,odd,1} end|R]); odd_even(1, R) -> [{?MODULE,odd,[1]}|R]. even(N) when is_integer(N), N > 1, (N rem 2) == 0 -> odd(N-1)++[N]. odd(N) when is_integer(N), N > 1, (N rem 2) == 1 -> even(N-1)++[N]. foo({value,Value}) -> Value; foo({'div',{A,B}}) -> my_div(A, B); foo({'add',{A,B}}) -> my_add(A, B); foo({'abs',X}) -> my_abs(X); foo({error,Error}) -> erlang:error(Error); foo({throw,Throw}) -> erlang:throw(Throw); foo({exit,Exit}) -> erlang:exit(Exit); foo({raise,{Class,Reason,Stacktrace}}) -> erlang:raise(Class, Reason, Stacktrace). %%foo(function_clause) -> % must not be defined! my_div(A, B) -> A div B. my_add(A, B) -> A + B. my_abs(X) -> abs(X). gunilla(Config) when is_list(Config) -> ?line {throw,kalle} = gunilla_1(), ?line [] = erlang:get_stacktrace(), ok. gunilla_1() -> try try arne() after pelle end catch C:R -> {C,R} end. arne() -> %% Empty stack trace used to cause change the error class to 'error'. erlang:raise(throw, kalle, []). per(Config) when is_list(Config) -> try t1(0,pad,0), t2(0,pad,0) catch error:badarith -> ok end. t1(_,X,_) -> (1 bsl X) + 1. t2(_,X,_) -> (X bsl 1) + 1. %% %% Make sure that even if a BIF builds an heap fragment, then causes an exception, %% the stacktrace term will still be OK (specifically, that it does not contain %% stale pointers to the arguments). %% exception_with_heap_frag(Config) when is_list(Config) -> Sizes = lists:seq(0, 512), %% Floats are only validated when the heap fragment has been allocated. BadFloat = <<131,99,53,46,48,$X,48,48,48,48,48,48,48,48,48,48,48,48,48,48,48,48,48,48,101,45,48,49,0,0,0,0,0>>, ?line do_exception_with_heap_frag(BadFloat, Sizes), %% {Binary,BadFloat}: When the error in float is discovered, a refc-binary %% has been allocated and the list of refc-binaries goes through the %% heap fragment. BinAndFloat = <<131,104,2,109,0,0,1,0,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,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45, 46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70, 71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95, 96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115, 116,117,118,119,120,121,122,123,124,125,126,127,128,129,130,131,132,133,134, 135,136,137,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,153, 154,155,156,157,158,159,160,161,162,163,164,165,166,167,168,169,170,171,172, 173,174,175,176,177,178,179,180,181,182,183,184,185,186,187,188,189,190,191, 192,193,194,195,196,197,198,199,200,201,202,203,204,205,206,207,208,209,210, 211,212,213,214,215,216,217,218,219,220,221,222,223,224,225,226,227,228,229, 230,231,232,233,234,235,236,237,238,239,240,241,242,243,244,245,246,247,248, 249,250,251,252,253,254,255,99,51,46,49,52,$B,$l,$u,$r,$f,48,48,48,48,48,48, 48,48,49,50,52,51,52,101,43,48,48,0,0,0,0,0>>, ?line do_exception_with_heap_frag(BinAndFloat, Sizes), %% {Fun,BadFloat} FunAndFloat = <<131,104,2,112,0,0,0,66,0,238,239,135,138,137,216,89,57,22,111,52,126,16,84, 71,8,0,0,0,0,0,0,0,0,100,0,1,116,97,0,98,5,175,169,123,103,100,0,13,110,111, 110,111,100,101,64,110,111,104,111,115,116,0,0,0,41,0,0,0,0,0,99,50,46,55,48, $Y,57,57,57,57,57,57,57,57,57,57,57,57,57,54,52,52,55,101,43,48,48,0,0,0,0,0>>, ?line do_exception_with_heap_frag(FunAndFloat, Sizes), %% [ExternalPid|BadFloat] ExtPidAndFloat = <<131,108,0,0,0,1,103,100,0,13,107,97,108,108,101,64,115,116,114,105,100,101, 114,0,0,0,36,0,0,0,0,2,99,48,46,$@,48,48,48,48,48,48,48,48,48,48,48,48,48,48, 48,48,48,48,48,101,43,48,48,0,0,0,0,0>>, ?line do_exception_with_heap_frag(ExtPidAndFloat, Sizes), ok. do_exception_with_heap_frag(Bin, [Sz|Sizes]) -> Filler = erlang:make_tuple(Sz, a), spawn(fun() -> try binary_to_term(Bin) catch _:_ -> %% term_to_binary/1 is an easy way to traverse the %% entire stacktrace term to make sure that every part %% of it is OK. term_to_binary(erlang:get_stacktrace()) end, id(Filler) end), do_exception_with_heap_frag(Bin, Sizes); do_exception_with_heap_frag(_, []) -> ok. id(I) -> I.