poolparty 0.2.84 → 1.2.2

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

@@ -1,334 +0,0 @@
-%% 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

@@ -1,45 +0,0 @@
-%% 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

@@ -1,272 +0,0 @@
-%% 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).
-