fairchild-poolparty 1.1.4 → 1.1.5

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

@@ -1,682 +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_lib.erl 238 2007-11-15 10:23:54Z mremond $
-%%
-%% @copyright 2004-2007 Micka�l R�mond, Richard Carlsson
-%% @author Micka�l R�mond <mickael.remond@process-one.net>
-%%   [http://www.process-one.net/]
-%% @author Richard Carlsson <richardc@it.uu.se>
-%%   [http://user.it.uu.se/~richardc/]
-%% @private
-%% @see eunit
-%% @doc Utility functions for eunit
-
--module(eunit_lib).
-
--include("eunit.hrl").
--include("eunit_internal.hrl").
-
-
--export([dlist_next/1, uniq/1, fun_parent/1, is_string/1, browse_fun/1,
-	 command/1, command/2, command/3, trie_new/0, trie_store/2,
-	 trie_match/2, split_node/1, consult_file/1, list_dir/1,
-	 format_exit_term/1, format_exception/1, format_error/1]).
-
-
-%% Type definitions for describing exceptions
-%%
-%% @type exception() = {exceptionClass(), Reason::term(), stackTrace()}
-%%
-%% @type exceptionClass() = error | exit | throw
-%%
-%% @type stackTrace() = [{moduleName(), functionName(),
-%%			  arity() | argList()}]
-%%
-%% @type moduleName() = atom()
-%% @type functionName() = atom()
-%% @type arity() = integer()
-%% @type mfa() = {moduleName(), functionName(), arity()}
-%% @type argList() = [term()]
-%% @type fileName() = string()
-
-
-%% ---------------------------------------------------------------------
-%% Formatting of error descriptors
-
-format_exception({Class,Term,Trace})
-  when is_atom(Class), is_list(Trace) ->
-    case is_stacktrace(Trace) of
-	true ->
-	    io_lib:format("~w:~P\n~s",
-			  [Class, Term, 15, format_stacktrace(Trace)]);
-	false ->
-	    format_term(Term)
-    end;
-format_exception(Term) ->
-    format_term(Term).
-
-format_term(Term) ->
-    io_lib:format("~P\n", [Term, 15]).
-
-format_exit_term(Term) ->
-    {Reason, Trace} = analyze_exit_term(Term),
-    io_lib:format("~P~s", [Reason, 15, Trace]).
-
-analyze_exit_term({Reason, [_|_]=Trace}=Term) ->
-    case is_stacktrace(Trace) of
-	true ->
-	    {Reason, format_stacktrace(Trace)};
-	false ->
-	    {Term, ""}
-    end;
-analyze_exit_term(Term) ->
-    {Term, ""}.
-
-is_stacktrace([]) ->
-    true;
-is_stacktrace([{M,F,A}|Fs]) when is_atom(M), is_atom(F), is_integer(A) ->
-    is_stacktrace(Fs);
-is_stacktrace([{M,F,As}|Fs]) when is_atom(M), is_atom(F), is_list(As) ->
-    is_stacktrace(Fs);
-is_stacktrace(_) ->
-    false.
-
-format_stacktrace(Trace) ->
-    format_stacktrace(Trace, "in function", "in call from").
-
-format_stacktrace([{M,F,A}|Fs], Pre, Pre1) when is_integer(A) ->
-    [io_lib:fwrite("  ~s ~w:~w/~w\n", [Pre, M, F, A])
-     | format_stacktrace(Fs, Pre1, Pre1)];
-format_stacktrace([{M,F,As}|Fs], Pre, Pre1) when is_list(As) ->
-    A = length(As),
-    C = case is_op(M,F,A) of
-	    true when A == 1 ->
-		[A1] = As,
-		io_lib:fwrite("~s ~s", [F,format_arg(A1)]);
-	    true when A == 2 ->
-		[A1, A2] = As,
-		io_lib:fwrite("~s ~s ~s",
-			      [format_arg(A1),F,format_arg(A2)]);
-	    false ->
-		io_lib:fwrite("~w(~s)", [F,format_arglist(As)])
-	end,
-    [io_lib:fwrite("  ~s ~w:~w/~w\n    called as ~s\n",
-		   [Pre,M,F,A,C])
-     | format_stacktrace(Fs,Pre1,Pre1)];
-format_stacktrace([],_Pre,_Pre1) ->
-    "".
-
-format_arg(A) ->
-    io_lib:format("~P",[A,15]).
-
-format_arglist([A]) ->
-    format_arg(A);
-format_arglist([A|As]) ->
-    [io_lib:format("~P,",[A,15]) | format_arglist(As)];
-format_arglist([]) ->
-    "".
-
-is_op(erlang, F, A) ->
-    erl_internal:arith_op(F, A)
-	orelse erl_internal:bool_op(F, A)
-	orelse erl_internal:comp_op(F, A)
-	orelse erl_internal:list_op(F, A)
-	orelse erl_internal:send_op(F, A);
-is_op(_M, _F, _A) ->
-    false.
-
-format_error({bad_test, Term}) ->
-    error_msg("bad test descriptor", "~P", [Term, 15]);
-format_error({generator_failed, Exception}) ->
-    error_msg("test generator failed", "~s",
-	      [format_exception(Exception)]);
-format_error({no_such_function, {M,F,A}})
-  when is_atom(M), is_atom(F), is_integer(A) ->
-    error_msg(io_lib:format("no such function: ~w:~w/~w", [M,F,A]),
-	      "", []);
-format_error({module_not_found, M}) ->
-    error_msg("test module not found", "~p", [M]);
-format_error({application_not_found, A}) when is_atom(A) ->
-    error_msg("application not found", "~w", [A]);
-format_error({file_read_error, {_R, Msg, F}}) ->
-    error_msg("error reading file", "~s: ~s", [Msg, F]);
-format_error({context_error, setup_failed, Exception}) ->
-    error_msg("context setup failed", "~s",
-	      [format_exception(Exception)]);
-format_error({context_error, cleanup_failed, Exception}) ->
-    error_msg("context cleanup failed", "~s",
-	      [format_exception(Exception)]);
-format_error({context_error, instantiation_failed, Exception}) ->
-    error_msg("instantiation of subtests failed", "~s",
-	      [format_exception(Exception)]).
-
-error_msg(Title, Fmt, Args) ->
-    Msg = io_lib:format("::"++Fmt, Args),    % gets indentation right
-    io_lib:fwrite("*** ~s ***\n~s\n\n", [Title, Msg]).
-
-
-%% ---------------------------------------------------------------------
-%% Deep list iterator; accepts improper lists/sublists, and also accepts
-%% non-lists on the top level. Nonempty strings (not deep strings) are
-%% recognized as separate elements, even on the top level. (It is not
-%% recommended to include integers in the deep list, since a list of
-%% integers is likely to be interpreted as a string.). The result is
-%% always presented as a list (which may be improper), which is either
-%% empty or otherwise has a non-list head element.
-
-dlist_next([X | Xs] = Xs0) when is_list(X) ->
-    case is_nonempty_string(X) of
-	true -> Xs0;
-	false -> dlist_next(X, Xs)
-    end;
-dlist_next([_|_] = Xs) ->
-    case is_nonempty_string(Xs) of
-	true -> [Xs];
-	false -> Xs
-    end;
-dlist_next([]) ->
-    [];
-dlist_next(X) ->
-    [X].
-
-%% the first two clauses avoid pushing empty lists on the stack
-dlist_next([X], Ys) when is_list(X) ->
-    case is_nonempty_string(X) of
-	true -> [X | Ys];
-	false -> dlist_next(X, Ys)
-    end;
-dlist_next([X], Ys) ->
-    [X | Ys];
-dlist_next([X | Xs], Ys) when is_list(X) ->
-    case is_nonempty_string(X) of
-	true -> [X | [Xs | Ys]];
-	false -> dlist_next(X, [Xs | Ys])
-    end;
-dlist_next([X | Xs], Ys) ->
-    [X | [Xs | Ys]];
-dlist_next([], Xs) ->
-    dlist_next(Xs).
-
-
--ifdef(TEST).
-dlist_test_() ->
-    {"deep list traversal",
-     [{"non-list term -> singleton list",
-       ?_test([any] = dlist_next(any))},
-      {"empty list -> empty list",
-       ?_test([] = dlist_next([]))},
-      {"singleton list -> singleton list",
-       ?_test([any] = dlist_next([any]))},
-      {"taking the head of a flat list",
-       ?_test([a,b,c] = dlist_next([a,b,c]))},
-      {"skipping an initial empty list",
-       ?_test([a,b,c] = dlist_next([[],a,b,c]))},
-      {"skipping nested initial empty lists",
-       ?_test([a,b,c] = dlist_next([[[[]]],a,b,c]))},
-      {"skipping a final empty list",
-       ?_test([] = dlist_next([[]]))},
-      {"skipping nested final empty lists",
-       ?_test([] = dlist_next([[[[]]]]))},
-      {"the first element is in a sublist",
-       ?_test([a,b,c] = dlist_next([[a],b,c]))},
-      {"recognizing a naked string",
-       ?_test(["abc"] = dlist_next("abc"))},
-      {"recognizing a wrapped string",
-       ?_test(["abc"] = dlist_next(["abc"]))},
-      {"recognizing a leading string",
-       ?_test(["abc",a,b,c] = dlist_next(["abc",a,b,c]))},
-      {"recognizing a nested string",
-       ?_test(["abc"] = dlist_next([["abc"]]))},
-      {"recognizing a leading string in a sublist",
-       ?_test(["abc",a,b,c] = dlist_next([["abc"],a,b,c]))},
-      {"traversing an empty list",
-       ?_test([] = dlist_flatten([]))},
-      {"traversing a flat list",
-       ?_test([a,b,c] = dlist_flatten([a,b,c]))},
-      {"traversing a deep list",
-       ?_test([a,b,c] = dlist_flatten([[],[a,[b,[]],c],[]]))},
-      {"traversing a deep but empty list",
-       ?_test([] = dlist_flatten([[],[[[]]],[]]))}
-     ]}.
-
-%% test support
-dlist_flatten(Xs) ->
-    case dlist_next(Xs) of
-	[X | Xs1] -> [X | dlist_flatten(Xs1)];
-	[] -> []
-    end.
--endif.
-
-
-%% ---------------------------------------------------------------------
-%% Check for proper Unicode-stringness.
-
-is_string([C | Cs]) when is_integer(C), C >= 0, C =< 16#10ffff ->
-    is_string(Cs);
-is_string([_ | _]) ->
-    false;
-is_string([]) ->
-    true;
-is_string(_) ->
-    false.
-
-is_nonempty_string([]) -> false;
-is_nonempty_string(Cs) -> is_string(Cs).
-
--ifdef(TEST).
-is_string_test_() ->
-    {"is_string",
-     [{"no non-lists", ?_assert(not is_string($A))},
-      {"no non-integer lists", ?_assert(not is_string([true]))},
-      {"empty string", ?_assert(is_string(""))},
-      {"ascii string", ?_assert(is_string(lists:seq(0, 127)))},
-      {"latin-1 string", ?_assert(is_string(lists:seq(0, 255)))},
-      {"unicode string",
-       ?_assert(is_string([0, $A, 16#10fffe, 16#10ffff]))},
-      {"not above unicode range",
-       ?_assert(not is_string([0, $A, 16#110000]))},
-      {"no negative codepoints", ?_assert(not is_string([$A, -1, 0]))}
-     ]}.
--endif.
-
-
-%% ---------------------------------------------------------------------
-%% Splitting a full node name into basename and hostname,
-%% using 'localhost' as the default hostname
-
-split_node(N) when is_atom(N) -> split_node(atom_to_list(N));
-split_node(Cs) -> split_node_1(Cs, []).
-
-split_node_1([$@ | Cs], As) -> split_node_2(As, Cs);
-split_node_1([C | Cs], As) -> split_node_1(Cs, [C | As]);
-split_node_1([], As) ->  split_node_2(As, "localhost").
-
-split_node_2(As, Cs) ->
-    {list_to_atom(lists:reverse(As)), list_to_atom(Cs)}.
-
-%% ---------------------------------------------------------------------
-%% Get the name of the containing function for a fun. (This is encoded
-%% in the name of the generated function that implements the fun.)
-
-fun_parent(F) ->
-    {name, N} = erlang:fun_info(F, name),
-    case erlang:fun_info(F, type) of
-	{type, external} ->
-	    N;
-	{type, local} ->
-	    S = atom_to_list(N),
-	    list_to_atom(string:sub_string(S, 2, string:chr(S, $/) - 1))
-    end.
-
--ifdef(TEST).
-fun_parent_test() ->
-    fun_parent_test = fun_parent(fun () -> ok end).
--endif.
-
-
-%% ---------------------------------------------------------------------
-%% Ye olde uniq function
-
-uniq([X, X | Xs]) -> uniq([X | Xs]);    
-uniq([X | Xs]) -> [X | uniq(Xs)];
-uniq([]) -> [].
-
--ifdef(TEST).
-uniq_test_() ->
-    {"uniq",
-     [?_assertError(function_clause, uniq(ok)),
-      ?_assertError(function_clause, uniq([1|2])),
-      ?_test([] = uniq([])),
-      ?_test([1,2,3] = uniq([1,2,3])),
-      ?_test([1,2,3] = uniq([1,2,2,3])),
-      ?_test([1,2,3,2,1] = uniq([1,2,2,3,2,2,1])),
-      ?_test([1,2,3] = uniq([1,1,1,2,2,2,3,3,3])),
-      ?_test(["1","2","3"] = uniq(["1","1","2","2","3","3"]))
-     ]}.
--endif.
-
-
-%% ---------------------------------------------------------------------
-%% Apply arbitrary unary function F with dummy arguments "until it
-%% works". (F must be side effect free! It will be called repeatedly.)
-%% No exceptions will be thrown unless the function actually crashes for
-%% some other reason than being unable to match the argument.
-
-%% @spec (F::(any()) -> any()) -> {Value::any(), Result::any()}
-
-browse_fun(F) ->
-    browse_fun(F, arg_values()).
-
-browse_fun(F, Next) ->
-    case Next() of
-	[V | Next1] ->
-	    case try_apply(F, V) of
-		{ok, Result} ->
-		    {V, Result};
-		{error, function_clause} ->
-		    browse_fun(F, Next1);
-		{error, badarity} ->
-		    erlang:error({badarity, {F, 1}});
-		{error, {Class, Reason, Trace}} ->
-		    erlang:raise(Class, Reason, Trace)
-	    end;
-	[] ->
-	    %% tried everything - this ought to provoke an error
-	    F(undefined)
-    end.
-
-%% Apply argument to function and report whether it succeeded (and with
-%% what return value), or failed due to bad arity or a simple top-level
-%% function_clause error, or if it crashed in some other way.
-
-%% @spec (F::(any()) -> any(), V::any()) -> 
-%%     {ok, Result::any()}
-%%   | {error, function_clause | badarity | eunit_test:exception()}
-
-try_apply(F, Arg) ->
-    case erlang:fun_info(F, arity) of
-	{arity, 1} ->
-	    {module, M} = erlang:fun_info(F, module),
-	    {name, N} = erlang:fun_info(F, name),
-	    try_apply(F, Arg, M, N);
-	_ ->
-	    {error, badarity}
-    end.
-
-try_apply(F, Arg, M, N) ->
-    try F(Arg) of
-	X -> {ok, X}
-    catch
-	error:function_clause ->
-	    case erlang:get_stacktrace() of
-		[{M, N, _Args} | _] ->
-		    {error, function_clause};
-		Trace ->
-		    {error, {error, function_clause, Trace}}
-	    end;
-	  Class:Reason ->
-	    {error, {Class, Reason, erlang:get_stacktrace()}}
-    end.
-
-%% test value producers for function browsing
-
-arg_values() ->
-    Vs = [undefined, ok, true, false, 0, 1],
-    fun () -> arg_values(Vs) end.
-
-arg_values([V | Vs]) ->
-    [V | fun () -> arg_values(Vs) end];
-arg_values(_) ->
-    (arg_tuples())().
-
-arg_tuples() ->
-    fun () -> arg_tuples(0) end.
-
-arg_tuples(N) when N >= 0, N =< 12 ->
-    [erlang:make_tuple(N, undefined) | fun () -> arg_tuples(N + 1) end];
-arg_tuples(_) ->
-    (arg_lists())().
-
-arg_lists() ->
-    fun () -> arg_lists(0) end.
-
-arg_lists(N) when N >= 0, N =< 12 ->
-    [lists:duplicate(N, undefined) | fun () -> arg_lists(N + 1) end];
-arg_lists(_) ->
-    [].
-
--ifdef(TEST).
-browse_fun_test_() ->
-    {"browsing funs",
-     [?_assertError({badarity, {_, 1}}, browse_fun(fun () -> ok end)),
-      ?_assertError({badarity, {_, 1}}, browse_fun(fun (_,_) -> ok end)),
-      ?_assertError(function_clause, browse_fun(fun (42) -> ok end)),
-      ?_test({_, 17} = browse_fun(fun (_) -> 17 end)),
-      ?_test({_, 17} = browse_fun(fun (undefined) -> 17 end)),
-      ?_test({_, 17} = browse_fun(fun (ok) -> 17 end)),
-      ?_test({_, 17} = browse_fun(fun (true) -> 17 end)),
-      ?_test({_, 17} = browse_fun(fun ({}) -> 17 end)),
-      ?_test({_, 17} = browse_fun(fun ({_}) -> 17 end)),
-      ?_test({_, 17} = browse_fun(fun ({_,_}) -> 17 end)),
-      ?_test({_, 17} = browse_fun(fun ({_,_,_}) -> 17 end)),
-      ?_test({_, 17} = browse_fun(fun ([]) -> 17 end)),
-      ?_test({_, 17} = browse_fun(fun ([_]) -> 17 end)),
-      ?_test({_, 17} = browse_fun(fun ([_,_]) -> 17 end)),
-      ?_test({_, 17} = browse_fun(fun ([_,_,_]) -> 17 end))
-     ]}.
--endif.
-
-
-%% ---------------------------------------------------------------------
-%% Replacement for os:cmd
-
-command(Cmd) ->
-    command(Cmd, "").
-
-command(Cmd, Dir) ->
-    command(Cmd, Dir, []).
-
-command(Cmd, Dir, Env) ->
-    CD = if Dir == "" -> [];
-	    true -> [{cd, Dir}]
-	 end,
-    SetEnv = if Env == [] -> []; 
-		true -> [{env, Env}]
-	     end,
-    Opt = CD ++ SetEnv ++ [stream, exit_status, use_stdio,
-			   stderr_to_stdout, in, eof],
-    P = open_port({spawn, Cmd}, Opt),
-    get_data(P, []).
-
-get_data(P, D) ->
-    receive
-	{P, {data, D1}} ->
-	    get_data(P, [D1|D]);
-	{P, eof} ->
-	    port_close(P),    
-	    receive
-		{P, {exit_status, N}} ->
-		    {N, normalize(lists:flatten(lists:reverse(D)))}
-	    end
-    end.
-
-normalize([$\r, $\n | Cs]) ->
-    [$\n | normalize(Cs)];
-normalize([$\r | Cs]) ->
-    [$\n | normalize(Cs)];
-normalize([C | Cs]) ->
-    [C | normalize(Cs)];
-normalize([]) ->
-    [].
-
--ifdef(TEST).
-
-cmd_test_() ->
-    ([?_test({0, "hello\n"} = ?_cmd_("echo hello"))]
-     ++ case os:type() of
-	    {unix, _} ->
-		unix_cmd_tests();
-	    {win32, _} ->
-		win32_cmd_tests();
-	    _ ->
-		[]
-	end).
-
-unix_cmd_tests() ->
-    [{"command execution, status, and output",
-      [?_cmd("echo hello"),
-       ?_assertCmdStatus(0, "true"),
-       ?_assertCmdStatus(1, "false"),
-       ?_assertCmd("true"),
-       ?_assertCmdOutput("hello\n", "echo hello"),
-       ?_assertCmdOutput("hello", "echo -n hello")
-      ]},
-     {"file setup and cleanup",
-      setup,
-      fun () -> ?cmd("mktemp tmp.XXXXXXXX") end,
-      fun (File) -> ?cmd("rm " ++ File) end,
-      fun (File) ->
-	      [?_assertCmd("echo xyzzy >" ++ File),
-	       ?_assertCmdOutput("xyzzy\n", "cat " ++ File)]
-      end}
-    ].
-
-win32_cmd_tests() ->
-    [{"command execution, status, and output",
-      [?_cmd("echo hello"),
-       ?_assertCmdOutput("hello\n", "echo hello")
-      ]}
-    ].
-
--endif. % TEST
-
-
-%% ---------------------------------------------------------------------
-%% Wrapper around file:path_consult
-
-%% @throws {file_read_error, {Reason::atom(), Message::string(),
-%%                            fileName()}}
-
-consult_file(File) ->
-    case file:path_consult(["."]++code:get_path(), File) of
-	{ok, Data, _Path} ->
-	    Data;
-	{error, Reason} ->
-	    Msg = file:format_error(Reason),
-	    throw({file_read_error, {Reason, Msg, File}})
-    end.
-
-%% ---------------------------------------------------------------------
-%% Wrapper around file:list_dir
-
-%% @throws {file_read_error, {Reason::atom(), Message::string(),
-%%                            fileName()}}
-
-list_dir(Dir) ->
-    case file:list_dir(Dir) of
-	{ok, Fs} ->
-	    Fs;
-	{error, Reason} ->
-	    Msg = file:format_error(Reason),
-	    throw({file_read_error, {Reason, Msg, Dir}})
-    end.
-
-%% ---------------------------------------------------------------------
-%% A trie for remembering and checking least specific cancelled events
-%% (an empty list `[]' simply represents a stored empty list, i.e., all
-%% events will match, while an empty tree means that no events match).
-
-trie_new() ->
-    gb_trees:empty().
-
-trie_store([_ | _], []) ->
-    [];
-trie_store([E | Es], T) ->
-    case gb_trees:lookup(E, T) of
-	none ->
-	    if Es == [] ->
-		    gb_trees:insert(E, [], T);
-	       true ->
-		    gb_trees:insert(E, trie_store(Es, gb_trees:empty()),
-				    T)
-	    end;
-	{value, []} ->
-	    T;  %% prefix already stored
-	{value, T1} ->
-	    gb_trees:update(E, trie_store(Es, T1), T)
-    end;
-trie_store([], _T) ->
-    [].
-
-trie_match([_ | _], []) ->
-    prefix;
-trie_match([E | Es], T) ->
-    case gb_trees:lookup(E, T) of
-	none ->
-	    no;
-	{value, []} ->
-	    if Es == [] -> exact;
-	       true -> prefix
-	    end;
-	{value, T1} ->
-	    trie_match(Es, T1)
-    end;
-trie_match([], []) ->
-    exact;
-trie_match([], _T) ->
-    no.
-
--ifdef(TEST).
-
-trie_test_() ->
-    [{"basic representation",
-      [?_assert(trie_new() == gb_trees:empty()),
-       ?_assert(trie_store([1], trie_new())
-		== gb_trees:insert(1, [], gb_trees:empty())),
-       ?_assert(trie_store([1,2], trie_new())
-		== gb_trees:insert(1,
-				   gb_trees:insert(2, [],
-						   gb_trees:empty()),
-				   gb_trees:empty())),
-       ?_assert([] == trie_store([1], [])),
-       ?_assert([] == trie_store([], gb_trees:empty()))
-      ]},
-     {"basic storing and matching",
-      [?_test(no = trie_match([], trie_new())),
-       ?_test(exact = trie_match([], trie_store([], trie_new()))),
-       ?_test(no = trie_match([], trie_store([1], trie_new()))),
-       ?_test(exact = trie_match([1], trie_store([1], trie_new()))),
-       ?_test(prefix = trie_match([1,2], trie_store([1], trie_new()))),
-       ?_test(no = trie_match([1], trie_store([1,2], trie_new()))),
-       ?_test(no = trie_match([1,3], trie_store([1,2], trie_new()))),
-       ?_test(exact = trie_match([1,2,3,4,5],
-				 trie_store([1,2,3,4,5], trie_new()))),
-       ?_test(prefix = trie_match([1,2,3,4,5],
-				  trie_store([1,2,3], trie_new()))),
-       ?_test(no = trie_match([1,2,2,4,5],
-			       trie_store([1,2,3], trie_new())))
-      ]},
-     {"matching with partially overlapping patterns",
-      setup,
-      fun () ->
-	      trie_store([1,3,2], trie_store([1,2,3], trie_new()))
-      end,
-      fun (T) ->
-	      [?_test(no = trie_match([], T)),
-	       ?_test(no = trie_match([1], T)),
-	       ?_test(no = trie_match([1,2], T)),
-	       ?_test(no = trie_match([1,3], T)),
-	       ?_test(exact = trie_match([1,2,3], T)),
-	       ?_test(exact = trie_match([1,3,2], T)),
-	       ?_test(no = trie_match([1,2,2], T)),
-	       ?_test(no = trie_match([1,3,3], T)),
-	       ?_test(prefix = trie_match([1,2,3,4], T)),
-	       ?_test(prefix = trie_match([1,3,2,1], T))]
-      end},
-     {"matching with more general pattern overriding less general",
-      setup,
-      fun () -> trie_store([1], trie_store([1,2,3], trie_new())) end,
-      fun (_) -> ok end,
-      fun (T) ->
-   	      [?_test(no = trie_match([], T)),
-	       ?_test(exact = trie_match([1], T)),
- 	       ?_test(prefix = trie_match([1,2], T)),
- 	       ?_test(prefix = trie_match([1,2,3], T)),
- 	       ?_test(prefix = trie_match([1,2,3,4], T))]
-      end}
-    ].
-
--endif.  % TEST