poolparty 0.2.6 → 0.2.18

data/lib/erlang/messenger/lib/eunit/src/eunit_test.erl

@@ -0,0 +1,334 @@
+%% This library is free software; you can redistribute it and/or modify
+%% it under the terms of the GNU Lesser General Public License as
+%% published by the Free Software Foundation; either version 2 of the
+%% License, or (at your option) any later version.
+%%
+%% This library is distributed in the hope that it will be useful, but
+%% WITHOUT ANY WARRANTY; without even the implied warranty of
+%% MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+%% Lesser General Public License for more details.
+%%
+%% You should have received a copy of the GNU Lesser General Public
+%% License along with this library; if not, write to the Free Software
+%% Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
+%% USA
+%%
+%% $Id: eunit_test.erl 238 2007-11-15 10:23:54Z mremond $ 
+%%
+%% @author Richard Carlsson <richardc@it.uu.se>
+%% @copyright 2006 Richard Carlsson
+%% @private
+%% @see eunit
+%% @doc Test running functionality
+
+-module(eunit_test).
+
+-export([run_testfun/1, function_wrapper/2, enter_context/4,
+	 browse_context/2, multi_setup/1]).
+
+
+-include("eunit.hrl").
+-include("eunit_internal.hrl").
+
+
+%% ---------------------------------------------------------------------
+%% Getting a cleaned up stack trace. (We don't want it to include
+%% eunit's own internal functions. This complicates self-testing
+%% 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(Ts) ->
+    eunit_lib:uniq(prune_trace(erlang:get_stacktrace(), Ts)).
+
+prune_trace([{?MODULE, _, _} | _Rest], Tail) ->
+    Tail;
+prune_trace([T | Ts], Tail) ->
+    [T | prune_trace(Ts, Tail)];
+prune_trace([], Tail) ->
+    Tail.
+
+
+%% ---------------------------------------------------------------------
+%% Test runner
+
+%% @spec ((any()) -> any()) -> {ok, Value} | {error, eunit_lib:exception()}
+%% @throws wrapperError()
+
+run_testfun(F) ->
+    try
+	F()
+    of Value ->
+	    {ok, Value}
+    catch
+	{eunit_internal, Term} ->
+	    %% Internally generated: re-throw Term (lose the trace)
+	    throw(Term);
+	Class:Reason ->
+	    {error, {Class, Reason, get_stacktrace()}}
+    end.
+
+
+-ifdef(TEST).
+macro_test_() ->
+    {"macro definitions",
+     [{?LINE, fun () ->
+ 		      {?LINE, F} = ?_test(undefined),
+ 		      {ok, undefined} = run_testfun(F)
+ 	      end},
+      ?_test(begin
+ 		 {?LINE, F} = ?_assert(true),
+ 		 {ok, ok} = run_testfun(F)
+ 	     end),
+      ?_test(begin
+ 		 {?LINE, F} = ?_assert(false),
+ 		 {error,{error,{assertion_failed,
+				[{module,_},
+				 {line,_},
+				 {expression,_},
+				 {expected,true},
+				 {value,false}]},
+			 _}}
+		     = run_testfun(F)
+ 	     end),
+      ?_test(begin
+ 		 {?LINE, F} = ?_assert([]),
+ 		 {error,{error,{assertion_failed,
+				[{module,_},
+				 {line,_},
+				 {expression,_},
+				 {expected,true},
+				 {value,{not_a_boolean,[]}}]},
+			 _}}
+		     = run_testfun(F)
+ 	     end),
+      ?_test(begin
+ 		 {?LINE, F} = ?_assertNot(false),
+ 		 {ok, ok} = run_testfun(F)
+ 	     end),
+      ?_test(begin
+ 		 {?LINE, F} = ?_assertNot(true),
+ 		 {error,{error,{assertion_failed,
+				[{module,_},
+				 {line,_},
+				 {expression,_},
+				 {expected,true},
+				 {value,false}]},
+			 _}}
+		     = run_testfun(F)
+ 	     end),
+      ?_test(begin
+ 		 {?LINE, F} = ?_assertMatch(ok, ok),
+ 		 {ok, ok} = run_testfun(F)
+ 	     end),
+      ?_test(begin
+ 		 {?LINE, F} = ?_assertMatch([_], []),
+ 		 {error,{error,{assertMatch_failed,
+				[{module,_},
+				 {line,_},
+				 {expression,_},
+				 {expected,"[ _ ]"},
+				 {value,[]}]},
+			 _}}
+		     = run_testfun(F)
+ 	     end),
+      ?_test(begin
+ 		 {?LINE, F} = ?_assertEqual(ok, ok),
+ 		 {ok, ok} = run_testfun(F)
+ 	     end),
+      ?_test(begin
+ 		 {?LINE, F} = ?_assertEqual(3, 1+1),
+ 		 {error,{error,{assertEqual_failed,
+				[{module,_},
+				 {line,_},
+				 {expression,_},
+				 {expected,3},
+				 {value,2}]},
+			 _}}
+		     = run_testfun(F)
+ 	     end),
+      ?_test(begin
+ 		 {?LINE, F} = ?_assertException(error, badarith,
+ 						erlang:error(badarith)),
+ 		 {ok, ok} = run_testfun(F)
+ 	     end),
+      ?_test(begin
+ 		 {?LINE, F} = ?_assertException(error, badarith, ok),
+ 		 {error,{error,{assertException_failed,
+				[{module,_},
+				 {line,_},
+				 {expression,_},
+				 {expected,_},
+				 {unexpected_success,ok}]},
+			 _}}
+		     = run_testfun(F)
+ 	     end),
+      ?_test(begin
+ 		 {?LINE, F} = ?_assertException(error, badarg,
+ 						erlang:error(badarith)),
+ 		 {error,{error,{assertException_failed,
+				[{module,_},
+				 {line,_},
+				 {expression,_},
+				 {expected,_},
+				 {unexpected_exception,
+				  {error,badarith,_}}]},
+			 _}}
+		     = run_testfun(F)
+ 	     end)
+     ]}.
+-endif.
+
+
+%% ---------------------------------------------------------------------
+%% Wrapper for simple "named function" tests ({M,F}), which provides
+%% better error reporting when the function is missing at test time.
+%%
+%% Note that the wrapper fun is usually called by run_testfun/1, and the
+%% special exceptions thrown here are expected to be handled there.
+%%
+%% @throws {eunit_internal, wrapperError()}
+%%
+%% @type wrapperError() = {no_such_function, mfa()}
+%%                      | {module_not_found, moduleName()}
+
+function_wrapper(M, F) ->
+    fun () ->
+ 	    try M:F()
+ 	    catch
+ 		error:undef ->
+ 		    %% Check if it was M:F/0 that was undefined
+ 		    case erlang:module_loaded(M) of
+ 			false ->
+ 			    fail({module_not_found, M});
+ 			true ->
+ 			    case erlang:function_exported(M, F, 0) of
+ 				false ->
+ 				    fail({no_such_function, {M,F,0}});
+ 				true ->
+ 				    rethrow(error, undef, [{M,F,0}])
+ 			    end
+ 		    end
+ 	    end
+    end.
+
+rethrow(Class, Reason, Trace) ->
+    erlang:raise(Class, Reason, get_stacktrace(Trace)).
+
+fail(Term) ->
+    throw({eunit_internal, Term}).				   
+
+
+-ifdef(TEST).
+wrapper_test_() ->
+    {"error handling in function wrapper",
+     [?_assertException(throw, {module_not_found, eunit_nonexisting},
+  			run_testfun(function_wrapper(eunit_nonexisting,test))),
+      ?_assertException(throw,
+  			{no_such_function, {?MODULE,nonexisting_test,0}},
+  			run_testfun(function_wrapper(?MODULE,nonexisting_test))),
+      ?_test({error, {error, undef, _T}}
+  	     = run_testfun(function_wrapper(?MODULE,wrapper_test_exported_)))
+     ]}.
+
+%% this must be exported (done automatically by the autoexport transform)
+wrapper_test_exported_() ->
+    {ok, ?MODULE:nonexisting_function()}.
+-endif.
+
+
+%% ---------------------------------------------------------------------
+%% Entering a setup-context, with guaranteed cleanup.
+
+%% @spec (Setup, Cleanup, Instantiate, Callback) -> any()
+%%    Setup = () -> any()
+%%    Cleanup = (any()) -> any()
+%%    Instantiate = (any()) -> tests()
+%%    Callback = (tests()) -> any()
+%% @throws {context_error, Error, eunit_lib:exception()}
+%% Error = setup_failed | instantiation_failed | cleanup_failed
+
+enter_context(Setup, Cleanup, Instantiate, Callback) ->
+    try Setup() of
+	R ->
+	    try Instantiate(R) of
+		T ->
+		    try Callback(T)  %% call back to client code
+		    after
+			%% Always run cleanup; client may be an idiot
+			try Cleanup(R)
+			catch
+			    Class:Term ->
+				context_error(cleanup_failed, Class, Term)
+			end
+		    end
+	    catch
+		Class:Term ->
+		    context_error(instantiation_failed, Class, Term)
+	    end
+    catch
+	Class:Term ->
+	    context_error(setup_failed, Class, Term)
+    end.
+
+context_error(Type, Class, Term) ->
+    throw({context_error, Type, {Class, Term, get_stacktrace()}}).
+
+%% Instantiates a context with dummy values to make browsing possible
+%% @throws {context_error, instantiation_failed, eunit_lib:exception()}
+
+browse_context(I, F) ->
+    %% Browse: dummy setup/cleanup and a wrapper for the instantiator
+    I1 = fun (_) ->
+		try eunit_lib:browse_fun(I) of
+		    {_, T} -> T
+		catch
+		    Class:Term ->
+			context_error(instantiation_failed, Class, Term)
+		end
+	 end,
+    enter_context(fun ok/0, fun ok/1, I1, F).
+
+ok() -> ok.
+ok(_) -> ok.
+
+%% This generates single setup/cleanup functions from a list of tuples
+%% on the form {Tag, Setup, Cleanup}, where the setup function always
+%% backs out correctly from partial completion.
+
+multi_setup(List) ->
+    {SetupAll, CleanupAll} = multi_setup(List, fun ok/1),
+    %% must reverse back and forth here in order to present the list in
+    %% "natural" order to the test instantiation function
+    {fun () -> lists:reverse(SetupAll([])) end,
+     fun (Rs) -> CleanupAll(lists:reverse(Rs)) end}.
+
+multi_setup([{Tag, S, C} | Es], CleanupPrev) ->
+    Cleanup = fun ([R | Rs]) ->
+		      try C(R) of
+			  _ -> CleanupPrev(Rs)
+		      catch
+			  Class:Term ->
+			      throw({Tag, {Class, Term,
+					   eunit_test:get_stacktrace()}})
+		      end
+	      end,
+    {SetupRest, CleanupAll} = multi_setup(Es, Cleanup),
+    {fun (Rs) ->
+	     try S() of
+		 R ->
+		     SetupRest([R|Rs])
+	     catch
+		 Class:Term ->
+		     CleanupPrev(Rs),
+		     throw({Tag, {Class, Term,
+				  eunit_test:get_stacktrace()}})
+	     end
+     end,
+     CleanupAll};
+multi_setup([{Tag, S} | Es], CleanupPrev) ->
+    multi_setup([{Tag, S, fun ok/1} | Es], CleanupPrev);
+multi_setup([], CleanupAll) ->
+    {fun (Rs) -> Rs end, CleanupAll}.

data/lib/erlang/messenger/lib/eunit/src/eunit_tests.erl

@@ -0,0 +1,45 @@
+%% This library is free software; you can redistribute it and/or modify
+%% it under the terms of the GNU Lesser General Public License as
+%% published by the Free Software Foundation; either version 2 of the
+%% License, or (at your option) any later version.
+%%
+%% This library is distributed in the hope that it will be useful, but
+%% WITHOUT ANY WARRANTY; without even the implied warranty of
+%% MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+%% Lesser General Public License for more details.
+%%
+%% You should have received a copy of the GNU Lesser General Public
+%% License along with this library; if not, write to the Free Software
+%% Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
+%% USA
+%%
+%% $Id: eunit_tests.erl 238 2007-11-15 10:23:54Z mremond $ 
+%%
+%% @author Richard Carlsson <richard@it.uu.se>
+%% @copyright 2007 Richard Carlsson
+%% @private
+%% @see eunit
+%% @doc External tests for eunit.erl
+
+-module(eunit_tests).
+
+-include("eunit.hrl").
+
+-ifdef(TEST).
+%% Cause all the other modules to be tested as well as this one.
+full_test_() ->
+    %%{application, eunit}.    % this currently causes a loop
+    %% We use the below until loop detection is implemented
+    [eunit_autoexport,
+     eunit_striptests,
+     eunit_server,
+     eunit_proc,
+     eunit_serial,
+     eunit_test,
+     eunit_lib,
+     eunit_data,
+     eunit_tty,
+     code_monitor,
+     file_monitor,
+     autoload].
+-endif.

data/lib/erlang/messenger/lib/eunit/src/eunit_tty.erl

@@ -0,0 +1,272 @@
+%% This library is free software; you can redistribute it and/or modify
+%% it under the terms of the GNU Lesser General Public License as
+%% published by the Free Software Foundation; either version 2 of the
+%% License, or (at your option) any later version.
+%%
+%% This library is distributed in the hope that it will be useful, but
+%% WITHOUT ANY WARRANTY; without even the implied warranty of
+%% MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+%% Lesser General Public License for more details.
+%%
+%% You should have received a copy of the GNU Lesser General Public
+%% License along with this library; if not, write to the Free Software
+%% Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
+%% USA
+%%
+%% $Id: eunit_tty.erl 238 2007-11-15 10:23:54Z mremond $ 
+%%
+%% @author Richard Carlsson <richardc@it.uu.se>
+%% @copyright 2006 Richard Carlsson
+%% @private
+%% @see eunit
+%% @doc Text-based frontend for EUnit
+
+-module(eunit_tty).
+
+-include("eunit.hrl").
+-include("eunit_internal.hrl").
+
+-export([start/1, start/2]).
+
+
+-record(state, {verbose = false,
+		succeed = 0,
+		fail = 0,
+		abort = 0,
+		skip = 0,
+		indent = 0}).
+
+start(List) ->
+    start(List, []).
+
+start(List, Options) ->
+    St = #state{verbose = proplists:get_bool(verbose, Options)},
+    Id = [],
+    spawn(fun () -> init(Id, List, St) end).
+
+init(Id, List, St0) ->
+    receive
+	{start, Reference} ->
+	    if St0#state.verbose -> print_header();
+	       true -> ok
+	    end,
+	    St = group_begin(Id, "", List, St0),
+	    receive
+		{stop, Reference, ReplyTo} ->
+		    Result = if St#state.fail == 0, St#state.abort == 0,
+				St#state.skip == 0 ->
+				     ok;
+				true ->
+				     error
+			     end,
+		    report(Result, St),
+		    ReplyTo ! {result, Reference, Result},
+		    ok
+	    end
+    end.
+
+report(ok, St) ->
+    if St#state.succeed == 0 ->
+	    io:fwrite("  There were no tests to run.\n");
+       true ->
+	    if St#state.verbose -> print_bar();
+	       true -> ok
+	    end,
+	    if St#state.succeed == 1 ->
+		    io:fwrite("  Test successful.\n");
+	       true ->
+		    io:fwrite("  All ~w tests successful.\n",
+			      [St#state.succeed])
+	    end
+    end;
+report(error, St) ->
+    print_bar(),
+    io:fwrite("  Failed: ~w.  Aborted: ~w."
+	      "  Skipped: ~w.  Succeeded: ~w.\n",
+	      [St#state.fail, St#state.abort,
+	       St#state.skip, St#state.succeed]).
+
+print_header() ->
+    io:fwrite("======================== EUnit "
+	      "========================\n").
+
+print_bar() ->
+    io:fwrite("============================"
+	      "===========================\n").    
+
+wait(Id, St) ->
+    receive
+	{status, Id, Data} -> {Data, St}
+    end.
+
+entry({item, Id, Desc, Test}, St) ->
+    test_begin(Id, Desc, Test, St);
+entry({group, Id, Desc, Es}, St) ->
+    group_begin(Id, Desc, Es, St).
+
+tests([E | Es], St) ->
+    tests(Es, entry(E, St));
+tests([], St) ->
+    St.
+
+test_begin(Id, Desc, {Module, Name}, St) ->
+    test_begin(Id, Desc, {Module, Name, 0}, St);
+test_begin(Id, Desc, {Module, Name, Line}, St) ->
+    Text = format_test_begin(Module, Name, Line, Desc),
+    if St#state.verbose -> print_test_begin(St#state.indent, Text);
+       true -> ok
+    end,
+    case wait(Id, St) of
+	{{progress, 'begin', test}, St1} ->
+	    test_end(Id, Text, St1);
+	{{cancel, Reason}, St1} ->
+	    if St#state.verbose -> print_test_cancel(Reason);
+	       Reason /= undefined ->
+		    print_test_begin(St#state.indent, Text),
+		    print_test_cancel(Reason);
+	       true -> ok
+	    end,
+	    St1#state{skip = St1#state.skip + 1}
+    end.
+
+test_end(Id, Text, St) ->
+    case wait(Id, St) of
+	{{progress, 'end', {Result, Time, _Output}}, St1} ->
+	    if Result == ok ->
+		    if St#state.verbose -> print_test_end(Time);
+		       true -> ok
+		    end,
+		    St1#state{succeed = St1#state.succeed + 1};
+	       true ->
+		    if St#state.verbose -> ok;
+		       true -> print_test_begin(St#state.indent, Text)
+		    end,
+		    print_test_error(Result),
+		    St1#state{fail = St1#state.fail + 1}
+	    end;
+	{{cancel, Reason}, St1} ->
+	    if St#state.verbose -> ok;
+	       true -> print_test_begin(St#state.indent, Text)
+	    end,
+	    print_test_cancel(Reason),
+	    St1#state{abort = St1#state.abort + 1}
+    end.
+
+group_begin(Id, Desc, Es, St0) ->
+    I = St0#state.indent,
+    St = if Desc /= "", St0#state.verbose ->
+		 print_group_start(I, Desc),
+		 St0#state{indent = I + 1};
+	    true ->
+		 St0
+	 end,
+    case wait(Id, St) of
+	{{progress, 'begin', group}, St1} ->
+	    group_end(Id, I, Desc, tests(Es, St1));
+	{{cancel, Reason}, St1} ->
+	    if Desc /= "", St1#state.verbose ->
+		    print_group_cancel(I, Reason);
+	       Desc /= "" ->
+		    print_group_start(I, Desc),
+		    print_group_cancel(I, Reason);
+	       true ->
+		    ok
+	    end,
+	    %% TODO: eliminate this size calculation if possible
+	    Size = eunit_data:list_size(Es),
+	    St1#state{indent = I, skip = St1#state.skip + Size}
+    end.
+
+group_end(Id, I, Desc, St) ->
+    (case wait(Id, St) of
+	 {{progress, 'end', {_Count, Time, _Output}}, St1} ->
+	     if Desc /= "", St#state.verbose ->
+		     print_group_end(St1#state.indent, Time);
+		true ->
+		     ok
+	     end,
+	     St1;
+	 {{cancel, undefined}, St1} ->
+	     St1;  %% "skipped" message is not interesting here
+	 {{cancel, Reason}, St1} ->
+	     if Desc /= "", St1#state.verbose ->
+		     print_group_cancel(I, Reason);
+		true ->
+		     print_group_start(I, Desc),
+		     print_group_cancel(I, Reason)
+	     end,
+	     St1
+     end)#state{indent = I}.
+
+indent(N) when is_integer(N), N >= 1 ->
+    io:put_chars(lists:duplicate(N * 2, $\s));
+indent(_) ->
+    ok.
+
+print_group_start(I, Desc) ->
+    indent(I),
+    io:fwrite("~s\n", [Desc]).
+
+print_group_end(I, Time) ->
+    if Time > 0 ->
+	    indent(I),
+	    io:fwrite("[done in ~.3f s]\n", [Time/1000]);
+       true ->
+	    ok
+    end.
+
+format_test_begin(Module, Name, Line, Desc) ->
+    L = if Line == 0 -> "";
+	   true -> io_lib:fwrite("~w:", [Line])
+	end,
+    D = if Desc == "" -> "";
+	   true -> io_lib:fwrite(" (~s)", [Desc])
+	end,
+    io_lib:fwrite("~s:~s~s~s...", [Module, L, Name, D]).
+
+print_test_begin(I, Text) ->
+    indent(I),
+    io:put_chars(Text).
+
+print_test_end(Time) ->
+    T = if Time > 0 -> io_lib:fwrite("[~.3f s] ", [Time/1000]);
+	   true -> ""
+	end,
+    io:fwrite("~sok\n", [T]).
+
+print_test_error({error, Exception}) ->
+    io:fwrite("*failed*\n::~s\n\n",
+	      [eunit_lib:format_exception(Exception)]);
+print_test_error({skipped, Reason}) ->
+    io:fwrite("*did not run*\n::~s\n\n",
+	      [format_skipped(Reason)]).
+
+format_skipped({module_not_found, M}) ->
+    io_lib:format("missing module: ~w", [M]);
+format_skipped({no_such_function, {M,F,A}}) ->
+    io_lib:format("no such function: ~w:~w/~w", [M,F,A]).    
+
+print_test_cancel(Reason) ->
+    io:fwrite(format_cancel(Reason)).
+
+print_group_cancel(_I, {blame, _}) ->
+    ok;
+print_group_cancel(I, Reason) ->
+    indent(I),
+    io:fwrite(format_cancel(Reason)).
+
+format_cancel(undefined) ->
+    "*skipped*\n";
+format_cancel(timeout) ->
+    "*timed out*\n";
+format_cancel({startup, Reason}) ->
+    io_lib:fwrite("*could not start test process*\n::~P\n\n",
+		  [Reason, 15]);
+format_cancel({blame, _SubId}) ->
+    "*cancelled because of subtask*\n";
+format_cancel({exit, Reason}) ->
+    io_lib:fwrite("*unexpected termination of test process*\n::~P\n\n",
+		  [Reason, 15]);
+format_cancel({abort, Reason}) ->
+    eunit_lib:format_error(Reason).
+