poolparty 0.2.69 → 0.2.84

data/lib/erlang/messenger/lib/eunit/src/.svn/text-base/eunit_data.erl.svn-base

@@ -1,798 +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$ 
-%%
-%% @author Richard Carlsson <richardc@it.uu.se>
-%% @copyright 2006 Richard Carlsson
-%% @private
-%% @see eunit
-%% @doc Interpretation of symbolic test representation
-
--module(eunit_data).
-
--include("eunit.hrl").
--include("eunit_internal.hrl").
-
--include_lib("kernel/include/file.hrl").
-
--export([list/1, iter_init/2, iter_next/2, iter_prev/2, iter_id/1, 
-	 list_size/1, enter_context/3]).
-
--import(lists, [foldr/3]).
-
--define(TICKS_PER_SECOND, 1000).
-
-%% @type tests() =
-%%            SimpleTest
-%%          | [tests()]
-%%          | moduleName()
-%%          | {module, moduleName()}
-%%          | {application, appName()}
-%%          | {application, appName(), [term()]}
-%%          | fileName()
-%%          | {file, fileName()}
-%%          | {string(), tests()}
-%%          | {generator, () -> tests()}
-%%          | {generator, M::moduleName(), F::functionName()}
-%%          | {spawn, tests()}
-%%          | {spawn, Node::atom(), tests()}
-%%          | {timeout, T::number(), tests()}
-%%          | {inorder, tests()}
-%%          | {inparallel, tests()}
-%%          | {inparallel, N::integer(), tests()}
-%%          | {with, X::any(), [AbstractTestFunction]}
-%%          | {setup, Where::local | spawn | {spawn, Node::atom()},
-%%                    Setup::() -> (R::any()),
-%%                    Cleanup::(R::any()) -> any(),
-%%                    tests() | Instantiator
-%%            }
-%%          | {setup, Setup, Cleanup, tests() | Instantiator}
-%%          | {setup, Where, Setup, tests() | Instantiator}
-%%          | {setup, Setup, tests() | Instantiator}
-%%          | {foreach, Where::local | spawn | {spawn, Node::atom()},
-%%                      Setup::() -> (R::any()),
-%%                      Cleanup::(R::any()) -> any(),
-%%                      [tests() | Instantiator]
-%%            }
-%%          | {foreach, Setup, Cleanup, [tests() | Instantiator]}
-%%          | {foreach, Where, Setup, [tests() | Instantiator]}
-%%          | {foreach, Setup, [tests() | Instantiator]}
-%%          | {foreachx, Where::local | spawn | {spawn, Node::atom()},
-%%                       SetupX::(X::any()) -> (R::any()),
-%%                       CleanupX::(X::any(), R::any()) -> any(),
-%%                       Pairs::[{X::any(),
-%%                                (X::any(), R::any()) -> tests()}]
-%%            }
-%%          | {foreachx, SetupX, CleanupX, Pairs}
-%%          | {foreachx, Where, SetupX, Pairs}
-%%          | {foreachx, SetupX, Pairs}
-%%          | {node, Node::atom(), tests() | Instantiator}
-%%          | {node, Node, Args::string(), tests() | Instantiator}
-%%
-%% SimpleTest = TestFunction | {Line::integer(), SimpleTest}
-%%
-%% TestFunction = () -> any()
-%%              | {M::moduleName(), F::functionName()}.
-%%
-%% AbstractTestFunction = (X::any()) -> any()
-%%
-%% Instantiator = (R::any()) -> tests()
-%%              | {with, [AbstractTestFunction]}
-%%
-%% Note that `{string(), ...}' is a short-hand for `{string(), {...}}'
-%% if the tuple contains more than two elements.
-%%
-%% @type moduleName() = atom()
-%% @type functionName() = atom()
-%% @type appName() = atom()
-%% @type fileName() = string()
-
-%% ---------------------------------------------------------------------
-%% Abstract test set iterator
-
--record(iter,
-	{prev = [],
-	 next = [],
-	 tests = [],
-	 pos = 0,
-	 parent = []}).
-
-%% @spec (tests(), [integer()]) -> testIterator()
-%% @type testIterator()
-
-iter_init(Tests, ParentID) ->
-    #iter{tests = Tests, parent = lists:reverse(ParentID)}.
-
-%% @spec (testIterator()) -> [integer()]
-
-iter_id(#iter{pos = N, parent = Ns}) ->
-    lists:reverse(Ns, [N]).
-
-%% @spec (testIterator(), Handler) -> none | {testItem(), testIterator()}
-%%    Handler = (term()) -> term()
-
-iter_next(I, H) ->
-    iter_do(fun iter_next/1, I, H).
-
-iter_do(F, I, H) ->
-    try F(I)
-    catch
-	throw:R -> H(R)
-    end.
-
-iter_next(I = #iter{next = []}) ->
-    case next(I#iter.tests) of
-	{T, Tests} ->
-	    {T, I#iter{prev = [T | I#iter.prev],
-		       tests = Tests,
-		       pos = I#iter.pos + 1}};
-	none ->
-	    none
-    end;
-iter_next(I = #iter{next = [T | Ts]}) ->
-    {T, I#iter{next = Ts,
-	       prev = [T | I#iter.prev],
-	       pos = I#iter.pos + 1}}.
-
-%% @spec (testIterator(), Handler) -> none | {testItem(), testIterator()}
-%%    Handler = (term()) -> term()
-
-iter_prev(I, H) ->
-    iter_do(fun iter_prev/1, I, H).
-
-iter_prev(#iter{prev = []}) ->
-    none;
-iter_prev(#iter{prev = [T | Ts]} = I) ->
-    {T, I#iter{prev = Ts,
-	       next = [T | I#iter.next],
-		       pos = I#iter.pos - 1}}.
-
-
-%% ---------------------------------------------------------------------
-%% Concrete test set representation iterator
-
-%% @spec (tests()) -> none | {testItem(), tests()}
-%% @type testItem() = #test{} | #group{}
-%% @throws {bad_test, term()}
-%%       | {generator_failed, exception()}
-%%       | {no_such_function, eunit_lib:mfa()}
-%%       | {module_not_found, moduleName()}
-%%       | {application_not_found, appName()}
-%%       | {file_read_error, {Reason::atom(), Message::string(),
-%%                            fileName()}}
-
-next(Tests) ->
-    case eunit_lib:dlist_next(Tests) of
-	[T | Ts] ->
-	    case parse(T) of
-		{data, T1} ->
-		    next([T1 | Ts]);
-		T1 ->
-		    {T1, Ts}
-	    end;
-	[] ->
-	    none
-    end.
-
-%% this returns either a #test{} or #group{} record, or {data, T} to
-%% signal that T has been substituted for the given representation
-
-parse({foreach, S, Fs}) when is_function(S), is_list(Fs) ->
-    parse({foreach, S, fun ok/1, Fs});
-parse({foreach, S, C, Fs})
-  when is_function(S), is_function(C), is_list(Fs) ->
-    parse({foreach, ?DEFAULT_SETUP_PROCESS, S, C, Fs});
-parse({foreach, P, S, Fs})
-  when is_function(S), is_list(Fs) ->
-    parse({foreach, P, S, fun ok/1, Fs});
-parse({foreach, P, S, C, Fs} = T)
-  when is_function(S), is_function(C), is_list(Fs) ->
-    check_arity(S, 0, T),
-    check_arity(C, 1, T),
-    case Fs of
-	[F | Fs1] ->
-	    {data, [{setup, P, S, C, F}, {foreach, P, S, C, Fs1}]};
-	[] ->
-	    {data, []}
-    end;
-parse({foreachx, S1, Ps}) when is_function(S1), is_list(Ps) ->
-    parse({foreachx, S1, fun ok/2, Ps});
-parse({foreachx, S1, C1, Ps})
-  when is_function(S1), is_function(C1), is_list(Ps) ->
-    parse({foreachx, ?DEFAULT_SETUP_PROCESS, S1, C1, Ps});
-parse({foreachx, P, S1, Ps})
-  when is_function(S1), is_list(Ps) ->
-    parse({foreachx, P, S1, fun ok/2, Ps});
-parse({foreachx, P, S1, C1, Ps} = T) 
-  when is_function(S1), is_function(C1), is_list(Ps) ->
-    check_arity(S1, 1, T),
-    check_arity(C1, 2, T),
-    case Ps of
-	[{X, F1} | Ps1] when is_function(F1) ->
-	    check_arity(F1, 2, T),
-	    S = fun () -> S1(X) end,
-	    C = fun (R) -> C1(X, R) end,
-	    F = fun (R) -> F1(X, R) end,
-	    {data, [{setup, P, S, C, F}, {foreachx, P, S1, C1, Ps1}]};
-	[_|_] ->
-	    bad_test(T);
-	[] ->
-	    {data, []}
-    end;
-parse({generator, F} = T) when is_function(F) ->
-    check_arity(F, 0, T),
-    %% use run_testfun/1 to handle wrapper exceptions
-    case eunit_test:run_testfun(F) of
-	{ok, T1} ->
-	    {data, T1};
-	{error, {Class, Reason, Trace}} ->
-	    throw({generator_failed, {Class, Reason, Trace}})
-    end;
-parse({generator, M, F}) when is_atom(M), is_atom(F) ->
-    parse({generator, eunit_test:function_wrapper(M, F)});
-parse({inorder, T}) ->
-    group(#group{tests = T, order = inorder});
-parse({inparallel, T}) ->
-    parse({inparallel, 0, T});
-parse({inparallel, N, T}) when is_integer(N), N >= 0 ->
-    group(#group{tests = T, order = {inparallel, N}});
-parse({timeout, N, T}) when is_number(N), N >= 0 ->
-    group(#group{tests = T, timeout = round(N * ?TICKS_PER_SECOND)});
-parse({spawn, T}) ->
-    group(#group{tests = T, spawn = local});
-parse({spawn, N, T}) when is_atom(N) ->
-    group(#group{tests = T, spawn = {remote, N}});
-parse({setup, S, I}) when is_function(S); is_list(S) ->
-    parse({setup, ?DEFAULT_SETUP_PROCESS, S, I});
-parse({setup, S, C, I}) when is_function(S), is_function(C) ->
-    parse({setup, ?DEFAULT_SETUP_PROCESS, S, C, I});
-parse({setup, P, S, I}) when is_function(S) ->
-    parse({setup, P, S, fun ok/1, I});
-parse({setup, P, L, I} = T) when is_list(L) ->
-    check_setup_list(L, T),
-    {S, C} = eunit_test:multi_setup(L),
-    parse({setup, P, S, C, I});
-parse({setup, P, S, C, I} = T)
-  when is_function(S), is_function(C), is_function(I) ->
-    check_arity(S, 0, T),
-    check_arity(C, 1, T),
-    case erlang:fun_info(I, arity) of
-	{arity, 0} ->
-	    %% if I is nullary, it is a plain test
-	    parse({setup, S, C, fun (_) -> I end});
-	_ ->
-	    %% otherwise, I must be an instantiator function
-	    check_arity(I, 1, T),
-	    case P of
-		local -> ok;
-		spawn -> ok;
-		{spawn, N} when is_atom(N) -> ok;
-		_ -> bad_test(T)
-	    end,
-	    group(#group{tests = I,
-			 context = #context{setup = S, cleanup = C,
-					    process = P}})
-    end;
-parse({setup, P, S, C, {with, As}}) when is_list(As) ->
-    parse({setup, P, S, C, fun (X) -> {with, X, As} end});
-parse({setup, P, S, C, T}) when is_function(S), is_function(C) ->
-    parse({setup, P, S, C, fun (_) -> T end});
-parse({node, N, T}) when is_atom(N) ->
-    parse({node, N, "", T});
-parse({node, N, A, T1}=T) when is_atom(N) ->
-    case eunit_lib:is_string(A) of
-	true ->
-	    %% TODO: better stack traces for internal funs like these
-	    parse({setup,
-		   fun () ->
-			   %% TODO: auto-start net_kernel if needed
- 			   StartedNet = false,
-%% The following is commented out because of problems when running
-%% eunit as part of the init sequence (from the command line):
-%% 			   StartedNet =
-%% 			       case whereis(net_kernel) of
-%% 				   undefined ->
-%% 				       M = list_to_atom(atom_to_list(N)
-%% 							++ "_master"),
-%% 				       case net_kernel:start([M]) of
-%% 					   {ok, _} ->
-%% 					       true;
-%% 					   {error, E} ->
-%% 					       throw({net_kernel_start, E})
-%% 				       end;
-%% 				   _ -> false
-%% 			       end,
-%% 			   ?debugVal({started, StartedNet}),
-			   {Name, Host} = eunit_lib:split_node(N),
-			   {ok, Node} = slave:start_link(Host, Name, A),
-			   {Node, StartedNet}
-		   end,
-		   fun ({Node, StopNet}) ->
-%% 			   ?debugVal({stop, StopNet}),
-			   slave:stop(Node),
-			   case StopNet of
-			       true -> net_kernel:stop();
-			       false -> ok
-			   end
-		   end,
-		   T1});
-	false ->
-	    bad_test(T)
-    end;
-parse({module, M}) when is_atom(M) ->
-    {data, {"module '" ++ atom_to_list(M) ++ "'", get_module_tests(M)}};
-parse({application, A}) when is_atom(A) ->
-    try parse({file, atom_to_list(A)++".app"})
-    catch
-	{file_read_error,{enoent,_,_}} ->
-	    case code:lib_dir(A) of
-		Dir when is_list(Dir) ->
-		    %% add "ebin" if it exists, like code_server does
-		    BinDir = filename:join(Dir, "ebin"),
-		    case file:read_file_info(BinDir) of
-			{ok, #file_info{type=directory}} ->
-			    parse({dir, BinDir});
-			_ ->
-			    parse({dir, Dir})
-		    end;
-		_ ->
-		    throw({application_not_found, A})
-	    end
-    end;
-parse({application, A, Info}=T) when is_atom(A) ->
-    case proplists:get_value(modules, Info) of
-	Ms when is_list(Ms) ->
-	    case [M || M <- Ms, not is_atom(M)] of
-		[] ->
-		    {data, {"application '" ++ atom_to_list(A) ++ "'", Ms}};
-		_ ->
-		    bad_test(T)
-	    end;
-	_ ->
-	    bad_test(T)
-    end;
-parse({file, F} = T) when is_list(F) ->
-    case eunit_lib:is_string(F) of
-	true ->
-	    {data, {"file \"" ++ F ++ "\"", get_file_tests(F)}};
-	false ->
-	    bad_test(T)
-    end;
-parse({dir, D}=T) when is_list(D) ->
-    case eunit_lib:is_string(D) of
-	true ->
-	    {data, {"directory \"" ++ D ++ "\"", get_directory_modules(D)}};
-	false ->
-	    bad_test(T)
-    end;
-parse({with, X, As}=T) when is_list(As) ->
-    case As of
-	[A | As1] ->
-	    check_arity(A, 1, T),
-	    {data, [fun () -> A(X) end, {with, X, As1}]};
-	[] ->
-	    {data, []}
-    end;
-parse({S, T1} = T) when is_list(S) ->
-    case eunit_lib:is_string(S) of
-	true ->
-	    group(#group{tests = T1, desc = S});
-	false ->
-	    bad_test(T)
-    end;
-parse(T) when is_tuple(T), size(T) > 2, is_list(element(1, T)) ->
-    [S | Es] = tuple_to_list(T),
-    parse({S, list_to_tuple(Es)});
-parse(M) when is_atom(M) ->
-    parse({module, M});
-parse(T) when is_list(T) ->
-    case eunit_lib:is_string(T) of
-	true ->
-	    try parse({dir, T})
-	    catch
-		{file_read_error,{R,_,_}}
-		  when R =:= enotdir; R =:= enoent ->
-		    parse({file, T})
-	    end;
-	false ->
-	    bad_test(T)
-    end;
-parse(T) ->
-    parse_simple(T).
-
-%% parse_simple always produces a #test{} record
-
-parse_simple({L, F}) when is_integer(L), L >= 0 ->
-    (parse_simple(F))#test{line = L};
-parse_simple(F) ->
-    parse_function(F).
-
-parse_function(F) when is_function(F) ->
-    check_arity(F, 0, F),
-    {module, M} = erlang:fun_info(F, module),
-    #test{f = F, module = M, name = eunit_lib:fun_parent(F)};
-parse_function({M,F}) when is_atom(M), is_atom(F) ->
-    #test{f = eunit_test:function_wrapper(M, F), module = M, name = F};
-parse_function(F) ->
-    bad_test(F).
-
-check_arity(F, N, T) when is_function(F) ->
-    case erlang:fun_info(F, arity) of
-	{arity, N} ->
-	    ok;
-	_ ->
-	    bad_test(T) 
-    end;
-check_arity(_, _, T) ->
-    bad_test(T).
-
-check_setup_list([{Tag, S, C} | Es], T)
-  when is_atom(Tag), is_function(S), is_function(C) ->
-    check_arity(S, 0, T),
-    check_arity(C, 1, T),
-    check_setup_list(Es, T);
-check_setup_list([{Tag, S} | Es], T)
-  when is_atom(Tag), is_function(S) ->
-    check_arity(S, 0, T),
-    check_setup_list(Es, T);
-check_setup_list([], _T) ->
-    ok;
-check_setup_list(_, T) ->
-    bad_test(T).
-
-bad_test(T) ->
-    throw({bad_test, T}).
-
-ok(_) -> ok.
-ok(_, _) -> ok.
-
-%% This does some look-ahead and folds nested groups and tests where
-%% possible. E.g., {String, Test} -> Test#test{desc = String}.
-
-group(#group{context = #context{}} = G) ->
-    %% leave as it is - the test body is an instantiator, which is not
-    %% suitable for lookahead (and anyway, properties of the setup
-    %% should not be merged with properties of its body, e.g. spawn)
-    G;
-group(#group{tests = T0, desc = Desc, order = Order, context = Context,
-	     spawn = Spawn, timeout = Timeout} = G) ->
-    {T1, Ts} = lookahead(T0),
-    {T2, _} = lookahead(Ts),
-    case T1 of
-	#test{desc = Desc1, timeout = Timeout1}
-	when T2 =:= none, Spawn =:= undefined, Context =:= undefined,
-	     ((Desc =:= undefined) or (Desc1 =:= undefined)),
-	     ((Timeout =:= undefined) or (Timeout1 =:= undefined)) ->
-	    %% a single test within a non-spawn/setup group: put the
-	    %% information directly on the test; drop the order
-	    T1#test{desc = join_properties(Desc, Desc1),
-		    timeout = join_properties(Timeout, Timeout1)};
-
-	#test{timeout = undefined}
-	when T2 =:= none, Timeout =/= undefined, Context =:= undefined ->
-	    %% a single test without timeout, within a non-joinable
-	    %% group with a timeout and no fixture: push the timeout to
-	    %% the test
-	    G#group{tests = {timeout, (Timeout div ?TICKS_PER_SECOND), T0},
-		    timeout = undefined};
-
-	#group{desc = Desc1, order = Order1, context = Context1,
-	       spawn = Spawn1, timeout = Timeout1}
-	when T2 =:= none,
-	     ((Desc =:= undefined) or (Desc1 =:= undefined)),
-	     ((Order =:= undefined) or (Order1 =:= undefined)),
-	     ((Context =:= undefined) or (Context1 =:= undefined)),
-	     ((Spawn =:= undefined) or (Spawn1 =:= undefined)),
-	     ((Timeout =:= undefined) or (Timeout1 =:= undefined)) ->
-	    %% two nested groups with non-conflicting properties
-	    group(T1#group{desc = join_properties(Desc, Desc1),
-			   order = join_properties(Order, Order1),
-			   context = join_properties(Context, Context1),
-			   spawn = join_properties(Spawn, Spawn1),
-			   timeout = join_properties(Timeout, Timeout1)});
-
-	#group{order = Order1, timeout = Timeout1}
-	when T2 =:= none ->
-	    %% two nested groups that cannot be joined: try to push the
-	    %% timeout and ordering properties to the inner group
-	    push_order(Order, Order1, push_timeout(Timeout, Timeout1, G));
-
-	_ ->
-	    %% leave the group as it is and discard the lookahead
-	    G
-    end.
-
-lookahead(T) ->
-    case next(T) of
-	{T1, Ts} -> {T1, Ts};
-	none -> {none, []}
-    end.
-
-join_properties(undefined, X) -> X;    
-join_properties(X, undefined) -> X.
-
-push_timeout(Timeout, undefined, G=#group{context=undefined})
-  when Timeout =/= undefined ->
-    %% A timeout on a context (fixture) includes the setup/cleanup time
-    %% and must not be propagated into the body
-    G#group{tests = {timeout, (Timeout div ?TICKS_PER_SECOND), G#group.tests},
-	    timeout = undefined};
-push_timeout(_, _, G) ->
-    G.
-
-push_order(inorder, undefined, G) ->
-    G#group{tests = {inorder, G#group.tests}, order = undefined};
-push_order({inparallel, N}, undefined, G) ->
-    G#group{tests = {inparallel, N, G#group.tests}, order = undefined};
-push_order(_, _, G) ->
-    G.
-
-%% ---------------------------------------------------------------------
-%% Extracting test funs from a module
-
-%% @throws {module_not_found, moduleName()}
-
-get_module_tests(M) ->
-    TestSuffix = ?DEFAULT_TEST_SUFFIX,
-    GeneratorSuffix = ?DEFAULT_GENERATOR_SUFFIX,
-    try M:module_info(exports) of
-	Es ->
-	    Fs = testfuns(Es, M, TestSuffix, GeneratorSuffix),
-	    Name = atom_to_list(M),
-	    case lists:suffix(?DEFAULT_TESTMODULE_SUFFIX, Name) of
-		false ->
-		    Name1 = Name ++ ?DEFAULT_TESTMODULE_SUFFIX,
-		    M1 = list_to_atom(Name1),
-		    try get_module_tests(M1) of
-			Fs1 ->
-			    Fs ++ [{"module '" ++ Name1 ++ "'", Fs1}]
-		    catch
-			{module_not_found, M1} ->
-			    Fs
-		    end;
-		true ->
-		    Fs
-	    end
-    catch
-	error:undef -> 
-	    throw({module_not_found, M})
-    end.
-
-testfuns(Es, M, TestSuffix, GeneratorSuffix) ->
-    foldr(fun ({F, 0}, Fs) ->
-		  N = atom_to_list(F),
-		  case lists:suffix(TestSuffix, N) of
-		      true ->
-			  [{M,F} | Fs];
-		      false ->
-			  case lists:suffix(GeneratorSuffix, N) of
-			      true ->
-				  [{generator, M, F} | Fs];
-			      false ->
-				  Fs
-			  end
-		  end;
-	      (_, Fs) ->
-		  Fs
-	  end,
-	  [],
-	  Es).    
-
-
-%% ---------------------------------------------------------------------
-%% Getting a test set from a file
-
-%% @throws {file_read_error, {Reason::atom(), Message::string(),
-%%                            fileName()}}
-
-get_file_tests(F) ->
-    case is_module_filename(F) of
-	true ->
-	    %% look relative to current dir first
-	    case file:read_file_info(F) of
-		{ok, #file_info{type=file}} ->
-		    objfile_test(F);
-		_ ->
-		    %% (where_is_file/1 does not take a path argument)
-		    case code:where_is_file(F) of
-			non_existing ->
-			    %% this will produce a suitable error message
-			    objfile_test(F);
-			Path ->
-			    objfile_test(Path)
-		    end
-	    end;
-	false ->
-	    eunit_lib:consult_file(F)
-    end.
-
-is_module_filename(F) ->
-    filename:extension(F) =:= code:objfile_extension().
-
-objfile_test(File) ->
-    try
-	{value, {module, M}} =
-	lists:keysearch(module, 1, beam_lib:info(File)),
-	{setup,
-	 fun () ->
-		 %% TODO: better error/stacktrace for this internal fun
-		 code:purge(M),
-		 {module,M} = code:load_abs(filename:rootname(File)),
-		 ok
-	 end,
-	 {module, M}}
-    catch
-	_:_ ->
-	    throw({file_read_error,
-		   {undefined, "extracting module name failed", File}})
-    end.
-
-
-%% ---------------------------------------------------------------------
-%% Getting a list of module names from object files in a directory
-
-%% @throws {file_read_error, {Reason::atom(), Message::string(),
-%%                            fileName()}}
-
-%% TODO: handle packages (recursive search for files)
-
-get_directory_modules(D) ->
-    [objfile_test(filename:join(D, F))
-     || F <- eunit_lib:list_dir(D), is_module_filename(F)].
-
-
-
-%% ---------------------------------------------------------------------
-%% Entering a setup-context, with guaranteed cleanup.
-
-%% @spec (Tests::#context{}, Instantiate, Callback) -> any()
-%%    Instantiate = (any()) -> tests()
-%%    Callback = (tests()) -> any()
-%% @throws {context_error, Error, eunit_lib:exception()}
-%% Error = setup_failed | instantiation_failed | cleanup_failed
-
-enter_context(#context{setup = S, cleanup = C, process = P}, I, F) ->
-    F1 = case P of
-	     local -> F;
-	     spawn -> fun (X) -> F({spawn, X}) end;
-	     {spawn, N} -> fun (T) -> F({spawn, N, T}) end
-	 end,
-    eunit_test:enter_context(S, C, I, F1).
-
-
-%% ---------------------------------------------------------------------
-%% Returns a symbolic listing of a set of tests
-%%
-%% @type testInfoList() = [Entry]
-%%   Entry = {item, testId(), Description, testName()}
-%%         | {group, testId(), Description, testInfoList}
-%%   Description = string()
-%% @type testId() = [integer()]
-%% @type testName() = {moduleName(), functionName()}
-%%		    | {moduleName(), functionName(), lineNumber()}
-%% @type lineNumber() = integer().  Proper line numbers are always >= 1.
-%%
-%% @throws {bad_test, term()}
-%%       | {generator_failed, exception()}
-%%       | {no_such_function, eunit_lib:mfa()}
-%%       | {module_not_found, moduleName()}
-%%       | {application_not_found, appName()}
-%%       | {file_read_error, {Reason::atom(), Message::string(),
-%%                            fileName()}}
-%%       | {context_error, instantiation_failed, eunit_lib:exception()}
-
-list(T) ->
-    list(T, []).
-
-list(T, ParentID) ->
-    list_loop(iter_init(T, ParentID)).
-
-list_loop(I) ->
-    case iter_next(I, fun (R) -> throw({error, R}) end) of
- 	{T, I1} ->
-	    Id = iter_id(I1),
- 	    case T of
-		#test{} ->
-		    Name = case T#test.line of
-			       0 -> {T#test.module, T#test.name};
-			       Line -> {T#test.module, T#test.name, Line}
-			   end,
-		    [{item, Id, desc_string(T#test.desc), Name}
-		     | list_loop(I1)];
-		#group{context = Context} ->
-		    [{group, Id, desc_string(T#group.desc),
-		      list_context(Context, T#group.tests, Id)}
-		     | list_loop(I1)]
-	    end;
- 	none ->
- 	    []
-    end.
-
-desc_string(undefined) -> "";
-desc_string(S) -> S.
-
-list_context(undefined, T, ParentId) ->
-    list(T, ParentId);
-list_context(#context{process = local}, T, ParentId) ->
-    browse_context(T, fun (T) -> list(T, ParentId) end);
-list_context(#context{process = spawn}, T, ParentId) ->
-    browse_context(T, fun (T) -> list({spawn, T}, ParentId) end);
-list_context(#context{process = {spawn, N}}, T, ParentId) ->
-    browse_context(T, fun (T) -> list({spawn, N, T}, ParentId) end).
-
-browse_context(T, F) ->
-    eunit_test:browse_context(T, F).
-
-list_size({item, _, _, _}) -> 1;
-list_size({group, _, _, Es}) -> list_size(Es);    
-list_size(Es) when is_list(Es) ->
-    lists:foldl(fun (E, N) -> N + list_size(E) end, 0, Es).
-
--ifdef(TEST).
-generator_exported_() ->
-    generator().
-
-generator() ->
-    T = ?_test(ok),
-    [T, T, T].
-
-echo_proc() ->
-    receive {P,X} -> P ! X, echo_proc() end.
-
-ping(P) ->
-    P ! {self(),ping}, receive ping -> ok end.    
-
-data_test_() ->
-    Setup = fun () -> spawn(fun echo_proc/0) end,
-    Cleanup = fun (Pid) -> exit(Pid, kill) end,
-    Fail = ?_test(throw(eunit)),
-    T = ?_test(ok),
-    Tests = [T,T,T],
-    [?_assertMatch(ok, eunit:test(T)),
-     ?_assertMatch(error, eunit:test(Fail)),
-     ?_assertMatch(ok, eunit:test({generator, fun () -> Tests end})),
-     ?_assertMatch(ok, eunit:test({generator, fun generator/0})),
-     ?_assertMatch(ok, eunit:test({generator, ?MODULE, generator_exported_})),
-     ?_assertMatch(ok, eunit:test({inorder, Tests})),
-     ?_assertMatch(ok, eunit:test({inparallel, Tests})),
-     ?_assertMatch(ok, eunit:test({timeout, 10, Tests})),
-     ?_assertMatch(ok, eunit:test({spawn, Tests})),
-     ?_assertMatch(ok, eunit:test({setup, Setup, Cleanup,
-				   fun (P) -> ?_test(ok = ping(P)) end})),
-     %%?_assertMatch(ok, eunit:test({node, test@localhost, Tests})),
-     ?_assertMatch(ok, eunit:test({module, eunit_lib})),
-     ?_assertMatch(ok, eunit:test(eunit_lib)),
-     ?_assertMatch(ok, eunit:test("examples/tests.txt"))
-
-     %%?_test({foreach, Setup, [T, T, T]})
-    ].
-
-lazy_test_() ->
-    {spawn, [?_test(undefined = put(count, 0)),
-	     lazy_gen(7),
-	     ?_assertMatch(7, get(count))]}.
-
-lazy_gen(N) ->
-    {generator,
-     fun () ->
-	     if N > 0 ->
-		     [?_test(put(count,1+get(count)))
-		      | lazy_gen(N-1)];
-		true ->
-		     []
-	     end
-     end}.
--endif.