The R13B03 release.OTP_R13B03

1 files changed, 208 insertions, 0 deletions

diff --git a/erts/emulator/test/nofrag_SUITE.erl b/erts/emulator/test/nofrag_SUITE.erl
new file mode 100644
index 0000000000..ece55f433c
--- /dev/null
+++ b/erts/emulator/test/nofrag_SUITE.erl
@@ -0,0 +1,208 @@
+%%
+%% %CopyrightBegin%
+%% 
+%% Copyright Ericsson AB 2007-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(nofrag_SUITE).
+
+-include("test_server.hrl").
+
+-export([all/1,init_per_testcase/2,end_per_testcase/2,
+	 error_handler/1,error_handler_apply/1,
+	 error_handler_fixed_apply/1,error_handler_fun/1,
+	 error_handler_tuple_fun/1,
+	 debug_breakpoint/1]).
+
+%% Exported functions for an error_handler module.
+-export([undefined_function/3,undefined_lambda/3,breakpoint/3]).
+
+all(suite) ->
+    [error_handler,error_handler_apply,error_handler_fixed_apply,
+     error_handler_fun,error_handler_tuple_fun,debug_breakpoint].
+
+init_per_testcase(Func, Config) when is_atom(Func), is_list(Config) ->
+    Dog = ?t:timetrap(?t:minutes(3)),
+    [{watchdog,Dog}|Config].
+
+end_per_testcase(_Func, Config) ->
+    Dog = ?config(watchdog, Config),
+    ?t:timetrap_cancel(Dog).
+
+error_handler(Config) when is_list(Config) ->
+    ?line process_flag(error_handler, ?MODULE),
+    %% The term_to_binary/1 - binary_to_term/1 roundtrip is a good way
+    %% to traverse the entire term.
+    ?line Term = collect(1024),
+    ?line Term = binary_to_term(term_to_binary(Term)),
+    ?line 1024 = length(Term),
+    ?line [[a,b,c,d,[e,f,g]]] = lists:usort(Term),
+    ok.
+
+collect(0) ->
+    [];
+collect(N) ->
+    %% The next line calls the error handle function, which is
+    %% ?MODULE:undefined_function/3 (it simply returns the list
+    %% of args, i.e. [a,b,c,d,[e,f,g]]).
+    C = fooblurf:x(a, b, c, d, [e,f,id(g)]),
+
+    %% The variable C will be saved onto the stack frame; if C
+    %% points into a heap fragment the garbage collector will reach
+    %% it and the emulator will crash sooner or later (sooner if
+    %% the emulator is debug-compiled).
+    Res = collect(N-1),
+    [C|Res].
+
+collect_apply(0, _) ->
+    [];
+collect_apply(N, Mod) ->
+    %% The next line calls the error handle function, which is
+    %% ?MODULE:undefined_function/3 (it simply returns the list
+    %% of args).
+
+    C = apply(Mod, xyz, id([{a,id(42)},b,c,d,[e,f,id(g)]])),
+
+    %% The variable C will be saved onto the stack frame; if C
+    %% points into a heap fragment the garbage collector will reach
+    %% it and the emulator will crash sooner or later (sooner if
+    %% the emulator is debug-compiled).
+    Res = collect_apply(N-1, Mod),
+    [C|Res].
+
+error_handler_apply(Config) when is_list(Config) ->
+    ?line process_flag(error_handler, ?MODULE),
+
+    %% The term_to_binary/1 - binary_to_term/1 roundtrip is a good way
+    %% to traverse the entire term.
+    ?line Term = collect_apply(1024, fooblurfbar),
+    ?line Term = binary_to_term(term_to_binary(Term)),
+    ?line 1024 = length(Term),
+    ?line [[{a,42},b,c,d,[e,f,g]]] = lists:usort(Term),
+    ok.
+
+error_handler_fixed_apply(Config) when is_list(Config) ->
+    ?line process_flag(error_handler, ?MODULE),
+
+    %% The term_to_binary/1 - binary_to_term/1 roundtrip is a good way
+    %% to traverse the entire term.
+    ?line Term = collect_fixed_apply(1024, fooblurfbar),
+    ?line Term = binary_to_term(term_to_binary(Term)),
+    ?line 1024 = length(Term),
+    ?line [[{a,2},b,c,d,[e,f,g]]] = lists:usort(Term),
+    ok.
+
+collect_fixed_apply(0, _) ->
+    [];
+collect_fixed_apply(N, Mod) ->
+    %% The next line calls the error handle function, which is
+    %% ?MODULE:undefined_function/3 (it simply returns the list
+    %% of args).
+    C = Mod:x({a,id(2)}, b, c, d, [e,f,id(g)]),
+
+    %% The variable C will be saved onto the stack frame; if C
+    %% points into a heap fragment the garbage collector will reach
+    %% it and the emulator will crash sooner or later (sooner if
+    %% the emulator is debug-compiled).
+    Res = collect_fixed_apply(N-1, Mod),
+    [C|Res].
+
+undefined_function(_Mod, _Name, Args) ->
+    Args.
+
+error_handler_fun(Config) when is_list(Config) ->
+    ?line process_flag(error_handler, ?MODULE),
+
+    %% fun(A, B, C) -> {A,B,C,X} end in module foobarblurf.
+    B = <<131,112,0,0,0,84,3,109,96,69,208,5,175,207,75,36,93,112,218,232,222,22,251,0,
+	 0,0,0,0,0,0,1,100,0,11,102,111,111,98,97,114,98,108,117,114,102,97,0,98,5,
+	 244,197,144,103,100,0,13,110,111,110,111,100,101,64,110,111,104,111,115,116,
+	 0,0,0,46,0,0,0,0,0,104,3,97,1,97,2,97,3>>,
+    ?line Fun = binary_to_term(B),
+    ?line Term = collect_fun(1024, Fun),
+    ?line Term = binary_to_term(term_to_binary(Term)),
+    ?line 1024 = length(Term),
+    ?line [[{foo,bar},{99,1.0},[e,f,g]]] = lists:usort(Term),
+    ?line {env,[{1,2,3}]} = erlang:fun_info(Fun, env),
+    ok.
+
+collect_fun(0, _) ->
+    [];
+collect_fun(N, Fun) ->
+    %% The next line calls the error handle function, which is
+    %% ?MODULE:undefined_lambda/3 (it simply returns the list
+    %% of args).
+    C = Fun({foo,id(bar)}, {99,id(1.0)}, [e,f,id(g)]),
+
+    %% The variable C will be saved onto the stack frame; if C
+    %% points into a heap fragment the garbage collector will reach
+    %% it and the emulator will crash sooner or later (sooner if
+    %% the emulator is debug-compiled).
+    Res = collect_fun(N-1, Fun),
+    [C|Res].
+
+undefined_lambda(foobarblurf, Fun, Args) when is_function(Fun) ->
+    Args.
+
+error_handler_tuple_fun(Config) when is_list(Config) ->
+    ?line process_flag(error_handler, ?MODULE),
+    ?line Term = collect_tuple_fun(1024, {?MODULE,very_undefined_function}),
+    ?line Term = binary_to_term(term_to_binary(Term)),
+    ?line 1024 = length(Term),
+    ?line [[{foo,bar},42.0,[e,f,g]]] = lists:usort(Term),
+    ok.
+
+collect_tuple_fun(0, _) ->
+    [];
+collect_tuple_fun(N, Fun) ->
+    %% The next line calls the error handle function, which is
+    %% ?MODULE:undefined_function/3 (it simply returns the list
+    %% of args).
+    C = Fun({foo,id(bar)}, 42.0, [e,f,id(g)]),
+
+    %% The variable C will be saved onto the stack frame; if C
+    %% points into a heap fragment the garbage collector will reach
+    %% it and the emulator will crash sooner or later (sooner if
+    %% the emulator is debug-compiled).
+    Res = collect_tuple_fun(N-1, Fun),
+    [C|Res].
+
+debug_breakpoint(Config) when is_list(Config) ->
+    ?line process_flag(error_handler, ?MODULE),
+    ?line erts_debug:breakpoint({?MODULE,foobar,5}, true),
+    ?line Term = break_collect(1024),
+    ?line Term = binary_to_term(term_to_binary(Term)),
+    ?line 1024 = length(Term),
+    ?line [[a,b,c,{d,e},[f,g,h]]] = lists:usort(Term),
+    ?line erts_debug:breakpoint({?MODULE,foobar,5}, false),
+    ok.
+
+break_collect(0) ->
+    [];
+break_collect(N) ->
+    C = foobar(a, b, c, {id(d),e}, [f,g,id(h)]),
+    Res = break_collect(N-1),
+    [C|Res].
+
+breakpoint(?MODULE, foobar, Args) ->
+    Args.
+
+foobar(_, _, _, _, _) ->
+    exit(dont_execute_me).
+
+id(I) -> I.
+
+