eunit: Do not call erlang:get_stacktrace()

1 files changed, 27 insertions, 24 deletions

diff --git a/lib/eunit/src/eunit_test.erl b/lib/eunit/src/eunit_test.erl
index 6036537178..6fe85ae70a 100644
--- a/lib/eunit/src/eunit_test.erl
+++ b/lib/eunit/src/eunit_test.erl
@@ -39,11 +39,11 @@
 %% somewhat, but you can't have everything.) Note that we assume that
 %% this particular module is the boundary between eunit and user code.
 
-get_stacktrace() ->
-    get_stacktrace([]).
+get_stacktrace(Trace) ->
+    get_stacktrace(Trace, []).
 
-get_stacktrace(Ts) ->
-    eunit_lib:uniq(prune_trace(erlang:get_stacktrace(), Ts)).
+get_stacktrace(Trace, Ts) ->
+    eunit_lib:uniq(prune_trace(Trace, Ts)).
 
 -dialyzer({no_match, prune_trace/2}).
 prune_trace([{eunit_data, _, _} | Rest], Tail) ->
@@ -75,8 +75,8 @@ run_testfun(F) ->
 	{eunit_internal, Term} ->
 	    %% Internally generated: re-throw Term (lose the trace)
 	    throw(Term);
-	Class:Reason ->
-	    {error, {Class, Reason, get_stacktrace()}}
+	Class:Reason:Trace ->
+	    {error, {Class, Reason, Trace}}
     end.
 
 
@@ -272,7 +272,7 @@ mf_wrapper(M, F) ->
     fun () ->
  	    try M:F()
  	    catch
- 		error:undef ->
+ 		error:undef:Trace ->
  		    %% Check if it was M:F/0 that was undefined
  		    case erlang:module_loaded(M) of
  			false ->
@@ -282,14 +282,14 @@ mf_wrapper(M, F) ->
  				false ->
  				    fail({no_such_function, {M,F,0}});
  				true ->
- 				    rethrow(error, undef, [{M,F,0}])
+ 				    rethrow(error, undef, Trace, [{M,F,0}])
  			    end
  		    end
  	    end
     end.
 
-rethrow(Class, Reason, Trace) ->
-    erlang:raise(Class, Reason, get_stacktrace(Trace)).
+rethrow(Class, Reason, Trace, Ts) ->
+    erlang:raise(Class, Reason, get_stacktrace(Trace, Ts)).
 
 fail(Term) ->
     throw({eunit_internal, Term}).				   
@@ -332,12 +332,14 @@ enter_context(Setup, Cleanup, Instantiate, Callback) ->
 		T ->
                     case eunit_lib:is_not_test(T) of
                         true ->
-                            catch throw(error),  % generate a stack trace
+                            {_, Stacktrace} =
+                                erlang:process_info(self(),
+                                                    current_stacktrace),
                             {module,M} = erlang:fun_info(Instantiate, module),
                             {name,N} = erlang:fun_info(Instantiate, name),
                             {arity,A} = erlang:fun_info(Instantiate, arity),
                             context_error({bad_instantiator, {{M,N,A},T}},
-                                          error, badarg);
+                                          error, Stacktrace, badarg);
                         false ->
                             ok
                     end,
@@ -346,21 +348,22 @@ enter_context(Setup, Cleanup, Instantiate, Callback) ->
 			%% Always run cleanup; client may be an idiot
 			try Cleanup(R)
 			catch
-			    Class:Term ->
-				context_error(cleanup_failed, Class, Term)
+			    Class:Term:Trace ->
+				context_error(cleanup_failed,
+                                              Class, Trace, Term)
 			end
 		    end
 	    catch
-		Class:Term ->
-		    context_error(instantiation_failed, Class, Term)
+		Class:Term:Trace ->
+		    context_error(instantiation_failed, Class, Trace, Term)
 	    end
     catch
-	Class:Term ->
-	    context_error(setup_failed, Class, Term)
+	Class:Term:Trace ->
+	    context_error(setup_failed, Class, Trace, Term)
     end.
 
-context_error(Type, Class, Term) ->
-    throw({context_error, Type, {Class, Term, get_stacktrace()}}).
+context_error(Type, Class, Trace, Term) ->
+    throw({context_error, Type, {Class, Term, get_stacktrace(Trace)}}).
 
 %% This generates single setup/cleanup functions from a list of tuples
 %% on the form {Tag, Setup, Cleanup}, where the setup function always
@@ -378,8 +381,8 @@ multi_setup([{Tag, S, C} | Es], CleanupPrev) ->
 		      try C(R) of
 			  _ -> CleanupPrev(Rs)
 		      catch
-			  Class:Term ->
-			      throw({Tag, {Class, Term, get_stacktrace()}})
+			  Class:Term:Trace ->
+			      throw({Tag, {Class, Term, Trace}})
 		      end
 	      end,
     {SetupRest, CleanupAll} = multi_setup(Es, Cleanup),
@@ -388,9 +391,9 @@ multi_setup([{Tag, S, C} | Es], CleanupPrev) ->
 		 R ->
 		     SetupRest([R|Rs])
 	     catch
-		 Class:Term ->
+		 Class:Term:Trace ->
 		     CleanupPrev(Rs),
-		     throw({Tag, {Class, Term, get_stacktrace()}})
+		     throw({Tag, {Class, Term, Trace}})
 	     end
      end,
      CleanupAll};