auser-poolparty 0.2.66 → 0.2.67

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

@@ -0,0 +1,243 @@
+%% 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:$ 
+%%
+%% @private (for now)
+%% @author Richard Carlsson <richardc@it.uu.se>
+%% @copyright 2006 Richard Carlsson
+%% @doc Erlang code monitoring service
+
+-module(code_monitor).
+
+-export([start/0, start/1, stop/0, stop/1, monitor/1, monitor/2,
+	 demonitor/1, demonitor/2, install_codespy/1, wiretap/3]).
+
+-export([main/1]).    %% private
+
+
+-define(SERVER, code_monitor).
+
+monitor(Pid) ->
+    monitor(?SERVER, Pid).
+
+monitor(Server, Pid) when is_pid(Pid) ->
+    ensure_started(Server),
+    Server ! {monitor, Pid},
+    ok.
+
+demonitor(Pid) ->
+    demonitor(?SERVER, Pid).
+
+demonitor(Server, Pid) when is_pid(Pid) ->
+    ensure_started(Server),
+    Server ! {demonitor, Pid},
+    ok.
+
+stop() ->
+    stop(?SERVER).
+
+stop(Server) ->
+    Server ! stop,
+    ok.
+	    
+ensure_started(Name) when is_atom(Name) ->
+    start(Name);
+ensure_started(Pid) when is_pid(Pid) ->
+    Pid.
+
+start() ->
+    start(?SERVER).
+
+start(Name) ->
+    case whereis(Name) of
+	undefined ->
+	    Parent = self(),
+	    Pid = spawn(fun () -> server_init(Name, Parent) end),
+	    receive
+		{Pid, ok} -> Pid;
+		{Pid, error} -> throw(no_server)
+	    end;
+	Pid -> Pid
+    end.
+
+server_init(undefined = Name, Parent) ->
+    %% anonymous server
+    server_init_1(Name, Parent);
+server_init(Name, Parent) ->
+    case catch register(Name, self()) of
+	true ->
+	    server_init_1(Name, Parent);
+	_ ->
+	    init_failure(Parent)
+    end.
+
+server_init_1(Name, Parent) ->
+    case install_codespy(self()) of
+	{ok, _Spy} ->
+	    Parent ! {self(), ok},
+	    server(Name, sets:new());
+	{error, _} ->
+	    init_failure(Parent)
+    end.
+
+init_failure(Parent) ->
+    Parent ! {self(), error},
+    exit(failed).
+
+server(Name, Listeners) ->
+    ?MODULE:main({Name, Listeners}).
+
+%% @private
+main({Name, Listeners}) ->
+    receive
+	{code_server, {module, M}} ->
+	    cast({loaded, M, erlang:now()}, Listeners),
+	    server(Name, Listeners);
+	{monitor, Pid} when is_pid(Pid) ->
+	    server(Name, sets:add_element(Pid, Listeners));
+	{demonitor, Pid} ->
+	    server(Name, sets:del_element(Pid, Listeners));
+	stop ->
+	    exit(normal);
+	_ ->
+	    server(Name, Listeners)
+    end.
+
+cast(M, Listeners) ->
+    sets:fold(fun (L, M) -> L ! M end, {code_monitor, M}, Listeners).
+
+
+%% code server spy process using generic wiretap functionality
+
+install_codespy(To) ->
+    wiretap(code_server, To, fun code_spy/3).
+
+code_spy({code_call,From,{load_file,_}=Req}, Server, To) ->
+    handle_load(Req, From, Req, Server, To);
+code_spy({code_call,From,{ensure_loaded,M}=Req}=Msg, Server, To) ->
+    case erlang:module_loaded(M) of
+	true -> Server ! Msg;
+	false -> handle_load(Req, From, Req, Server, To)
+    end;
+code_spy({code_call,From,{load_abs,_,_}=Req}, Server, To) ->
+    handle_load(Req, From, Req, Server, To);
+code_spy({code_call,From,{load_binary,_,_,_}=Req}, Server, To) ->
+    handle_load(Req, From, Req, Server, To);
+code_spy({code_call,From,{load_native_partial,_,_}=Req}, Server, To) ->
+    handle_load(Req, From, Req, Server, To);
+code_spy({code_call,From,{load_native_sticky,_,_,_}=Req}, Server, To) ->
+    handle_load(Req, From, Req, Server, To);
+code_spy(Msg, Server, _To) ->
+    Server ! Msg.
+
+handle_load(Req, From, Req, Server, To) ->
+    ReplyTo = spawn(fun () -> reply_handler(Server, From, To) end),
+    Server ! {code_call, ReplyTo, Req}.
+
+%% one-shot processes - receive, pass on and die
+reply_handler(Server, Client, To) ->
+    link(Server),
+    receive
+	{code_server, _Reply} = M ->
+	    To ! Client ! M
+    end.
+
+%% basic wiretapping of registered processes (it should be possible to
+%% have several wiretaps attached to the same registered name; they will
+%% transparently form a chain, without knowing about each other)
+
+wiretap(Name, To, F) when is_atom(Name), is_pid(To), is_function(F) ->
+    Parent = self(),
+    Pid = spawn(fun () -> wiretap_init(Name, To, F, Parent) end),
+    receive
+	{Pid, Result} -> Result
+    end.
+
+wiretap_init(Name, To, F, Parent) ->
+    case whereis(Name) of
+	undefined ->
+	    Parent ! {self(), {error, undefined}},
+	    exit(error);
+	Pid ->
+	    catch unregister(Name),
+	    catch register(Name, self()),
+	    Self = self(),
+	    case whereis(Name) of
+		Self ->
+		    process_flag(trap_exit, true),
+		    link(Pid),
+		    link(To),
+		    Parent ! {self(), {ok, self()}},
+		    wiretap_loop(Name, To, Pid, F);
+		_ ->
+		    Parent ! {self(), {error, register_failed}},
+		    exit(error)
+	    end
+    end.
+
+wiretap_loop(Name, To, Pid, F) ->
+    receive
+	{'EXIT', Pid, _} ->
+	    wiretap_dropped(Name, To, F);
+	{'EXIT', To, _} ->
+	    wiretap_exit(Name, Pid);
+	Msg ->
+	    F(Msg, Pid, To),
+	    wiretap_loop(Name, To, Pid, F)
+    end.
+
+%% note that the registered name might get stolen from the spy process,
+%% e.g., by another active wiretap
+
+wiretap_exit(Name, Pid) ->
+    %% the receiver died - restore things and go away invisibly
+    unlink(Pid),
+    Self = self(),
+    %% sadly, this is not atomic...
+    case whereis(Name) of
+	Self ->
+	    catch unregister(Name),
+	    catch register(Name, Pid);
+	_ -> ok
+    end,
+    exit(normal).
+
+%% if the real server goes away, make sure to unregister, and keep watch
+%% in order to restart the wiretap when the server comes up again
+
+wiretap_dropped(Name, To, F) ->
+    Self = self(),
+    case whereis(Name) of
+	Self -> (catch unregister(Name));
+	_ -> ok
+    end,
+    wiretap_watch(Name, To, F).
+
+wiretap_watch(Name, To, F) ->
+    receive
+	{'EXIT', To, _} ->
+	    exit(normal)
+    after 1000 ->
+	case whereis(Name) of
+	    Pid when is_pid(Pid) ->
+		%% this process will terminate after starting the
+		%% new wiretap (even it that call fails)
+		wiretap(Name, To, F),
+		exit(normal);
+	    _ -> 
+		wiretap_watch(Name, To, F)
+	end
+    end.

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

@@ -0,0 +1,21 @@
+% This is an -*- erlang -*- file.
+
+{application, eunit,
+ [{description, "EUnit"},
+  {vsn, "%VSN%"},
+  {modules, [eunit,
+	     eunit_autoexport,
+	     eunit_striptests,
+	     eunit_server,
+	     eunit_proc,
+	     eunit_serial,
+	     eunit_test,
+	     eunit_lib,
+	     eunit_data,
+	     eunit_tty,
+	     code_monitor,
+	     file_monitor,
+	     autoload]},
+  {registered,[]},
+  {applications, [stdlib]},
+  {env, []}]}.

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

@@ -0,0 +1 @@
+{"%VSN%",[],[]}.

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

@@ -0,0 +1,196 @@
+%% 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$
+%%
+%% @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/]
+%% @version {@version}, {@date} {@time}
+%% @doc This module is the normal EUnit user interface.
+
+-module(eunit).
+
+-include("eunit.hrl").
+-include("eunit_internal.hrl").
+
+
+-export([start/0, start/1, stop/0, stop/1, test/1, test/2, test/3,
+	 list/1, submit/1, submit/2, submit/3, watch/1, watch/2,
+	 watch/3, watch_path/1, watch_path/2, watch_path/3,
+	 watch_regexp/1, watch_regexp/2, watch_regexp/3, watch_app/1,
+	 watch_app/2, watch_app/3]).
+
+-export([testp/1]). %% for development testing, not official
+
+
+%% EUnit entry points
+
+start() ->
+    start(?SERVER).
+
+start(Server) ->
+    eunit_server:start(Server).
+
+stop() ->
+    stop(?SERVER).
+
+stop(Server) ->
+    eunit_server:stop(Server).
+
+watch(Target) ->
+    watch(Target, []).
+
+watch(Target, Options) ->
+    watch(?SERVER, Target, Options).
+
+watch(Server, Target, Options) ->
+    eunit_server:watch(Server, Target, Options).
+
+watch_path(Target) ->
+    watch_path(Target, []).
+
+watch_path(Target, Options) ->
+    watch_path(?SERVER, Target, Options).
+
+watch_path(Server, Target, Options) ->
+    eunit_server:watch_path(Server, Target, Options).
+
+watch_regexp(Target) ->
+    watch_regexp(Target, []).
+
+watch_regexp(Target, Options) ->
+    watch_regexp(?SERVER, Target, Options).
+
+watch_regexp(Server, Target, Options) ->
+    eunit_server:watch_regexp(Server, Target, Options).
+
+watch_app(Name) ->
+    watch_app(Name, []).
+
+watch_app(Name, Options) ->
+    watch_app(?SERVER, Name, Options).
+
+watch_app(Server, Name, Options) ->
+    case code:lib_dir(Name) of
+	Path when is_list(Path) ->
+	    watch_path(Server, filename:join(Path, "ebin"), Options);
+	_ ->
+	    error
+    end.
+
+list(T) ->
+    try eunit_data:list(T)
+    catch
+	{error, R} -> {error, R}
+    end.
+
+test(T) ->
+    test(T, [{order, inorder}]).
+
+testp(T) ->
+    test(T, [{order, inparallel}]).
+
+test(T, Options) ->
+    test(?SERVER, T, Options).
+
+test(Server, T, Options) ->
+    %% TODO: try to eliminate call to list/1
+    try eunit_data:list(T) of
+	List ->
+	    Listeners = [eunit_tty:start(List, Options)
+			 | listeners(Options)],
+	    Serial = eunit_serial:start(Listeners),
+	    case eunit_server:start_test(Server, Serial, T, Options) of
+		{ok, Reference} -> test_run(Reference, Listeners);
+		{error, R} -> {error, R}
+	    end
+    catch
+	{error, R} ->
+	    io:put_chars(eunit_lib:format_error(R)),
+	    {error, R}
+    end.
+
+test_run(Reference, Listeners) ->
+    receive
+	{start, Reference} ->
+	    cast(Listeners, {start, Reference})
+    end,
+    receive
+	{done, Reference} ->
+	    cast(Listeners, {stop, Reference, self()}),
+	    receive 
+		{result, Reference, Result} ->
+		    Result
+	    end
+    end.
+
+cast([P | Ps], Msg) ->
+    P ! Msg,
+    cast(Ps, Msg);
+cast([], Msg) ->
+    Msg.
+
+%% TODO: functions that run tests on a given node, not a given server
+%% TODO: maybe some functions could check for a globally registered server?
+%% TODO: some synchronous but completely quiet interface function
+
+submit(T) ->
+    submit(T, []).
+
+submit(T, Options) ->
+    submit(?SERVER, T, Options).
+
+submit(Server, T, Options) ->
+    Dummy = spawn(fun devnull/0),
+    eunit_server:start_test(Server, Dummy, T, Options).
+
+listeners(Options) ->
+    case proplists:get_value(event_log, Options) of
+	undefined ->
+	    [];
+	LogFile ->
+	    [spawn(fun () -> event_logger(LogFile) end)]
+    end.
+
+%% TODO: make this report file errors
+event_logger(LogFile) ->
+    case file:open(LogFile, [write]) of
+	{ok, FD} ->
+	    receive
+		{start, Reference} ->
+		    event_logger_loop(Reference, FD)
+	    end;
+	Error ->
+	    exit(Error)
+    end.
+
+event_logger_loop(Reference, FD) ->
+    receive
+	{status, _Id, _Info}=Msg ->
+	    io:fwrite(FD, "~w.\n", [Msg]),
+	    event_logger_loop(Reference, FD);
+	{stop, Reference, _ReplyTo} ->
+	    %% no need to reply, just exit
+	    file:close(FD),
+	    exit(normal)
+    end.
+
+%% TODO: make a proper logger for asynchronous execution with submit/3
+
+devnull() ->
+    receive _ -> devnull() end.