Changeset 44

Timestamp:

10/11/08 13:42:55 (4 years ago)

Author:

charpi

Message:

#11 and #12

Location:

trunk

Files:

• fix/eg_test_of_code_failed.erl (added)
• src/shells.erl (modified) (2 diffs)
• src/tester.erl (modified) (3 diffs)
• src/tester_test.erl (modified) (3 diffs)

trunk/src/shells.erl

@@ +1 @@
+%%% Copyright (c) 2008 Dominic Williams, Nicolas Charpentier
+%%% All rights reserved.
+%%% See file COPYING.
 -module (shells).
 -export ([install/1]).
@@ -43 +46 @@
     ok = tester_test: deletes_a_test_module (Test_node),
     ok = tester_test: notifies_a_message (Test_node),
+    ok = tester_test: runs_new_tests_failed_then_successful (Test_node),
     Caller ! {Caller, done}.
     

trunk/src/tester.erl

@@ -21 +21 @@
         {delete, Modules} ->
             loop (test (unload (Modules, State)));
+        {runner_end, New_state} ->
+            loop (New_state);
         Modules ->
             loop (test (load (Modules, State)))
@@ -33 +35 @@
     Load_args = [Module, File_name, Binary],
     {module, Module} = rpc: call (Node, code, load_binary, Load_args),
-    New_tests = dict: store (Module, Tests, dict: fetch (tests, State)),
+    Time_stamped_tests = [{Test, new} || Test <- Tests],
+    Test_dict = dict: fetch (tests, State),
+    New_tests = dict: store (Module, Time_stamped_tests, Test_dict),
     dict: store (tests, New_tests, State).
 
 test (State) ->
-    Test_dict = dict: fetch (tests, State),
+    State_without_pid = stop_running_session (State),
+    Test_dict = dict: fetch (tests, State_without_pid),
     {Total, Tests} = flatten (Test_dict),
-    Notify = dict: fetch (notify, State),
+    Notify = dict: fetch (notify, State_without_pid),
     Notify ({Total, 0, 0}),
-    lists: foldl (test_fun (State, Total), {0, 0}, Tests),
-    State.
+    Self = self(),
+    Test_session_fun = fun () -> 
+                               launch_test (Self, Total, Tests, State_without_pid)
+                       end,
+    Test_session = spawn (Test_session_fun),
+    dict: store (test_session, Test_session, State_without_pid).
+
+stop_running_session (State) ->
+    case dict: find (test_session, State) of
+        {ok, Session} ->
+            exit(Session, kill),
+            dict: erase (test_session, State);
+        _ ->
+            State
+    end.
+
+launch_test (Parent, Total, Tests, State) ->
+    process_flag (trap_exit, true),
+    Run = lists: foldl (test_fun (State, Total), {State,{0, 0}}, Tests),
+    {New_state, _} = Run,
+    Parent ! {runner_end, New_state}.
 
 unload (Modules, State) ->
@@ -58 +82 @@
 flatten (Tests) ->
     F = fun (Module, Ts, {Count, List}) ->
-                {Count + length (Ts), [[{Module, T} || T <- Ts] | List]}
+                Tests_by_module = [{Module, T, Stamp} || {T, Stamp} <- Ts],
+                {Count + length (Ts), [ Tests_by_module | List]}
         end,
     {Total, All} = dict: fold (F, {0, []}, Tests),
-    {Total, lists: flatten (All)}.
+    Sorted_tests = lists: sort (fun new_tests_first/2, lists: flatten (All)),
+    {Total, Sorted_tests}.
 
+new_tests_first ({_, _ ,new}, {_, _, failed})  ->
+    true;
+new_tests_first ({_, _ ,failed}, {_, _, new})  ->
+    false;
+new_tests_first ({_, _ ,new}, _)  ->
+    true;
+new_tests_first ({_, _, failed}, _) ->
+    true;
+new_tests_first ({_,_,_},{_,_,new}) ->
+    false;
+new_tests_first ({_,_,_},{_,_,failed}) ->
+    false;
+new_tests_first (A,B) ->
+    A<B.
+    
 test_fun (State, Total) ->
     Node = dict: fetch (node, State),
     Notify = dict: fetch (notify, State),
-    fun ({Module, Function}, {Run, Passed}) ->
+    fun (Test_definition, {Tester_state, {Run, Passed}}) ->
+            {Module, Function, Stamp} = Test_definition,
             Pid = spawn_link (Node, Module, Function, []),
-            New_passed =
+            {New_passed, New_stamp} =
                 receive
                     {'EXIT', Pid, normal} ->
-                        Passed + 1;
+                        {Passed + 1, first_test_success (Stamp, now())};
                     {'EXIT', Pid, Reason} ->
                         Notify (Reason),
-                        Passed
+                        {Passed, failed}
                 end,
             New_run = Run + 1,
             Notify ({Total, New_run, New_passed}),
-            {New_run, New_passed}
+            New_state = update_state (Tester_state, Module, Function, New_stamp),
+            {New_state, {New_run, New_passed}}
     end.
 
+first_test_success (Before, Now) when is_atom (Before) ->
+    Now;
+first_test_success (Stamp, _) ->
+    Stamp.
+
+update_state (State, Module, Function, Stamp) ->
+    Test_dict = dict: fetch (tests, State),
+    Module_tests = dict:fetch (Module, Test_dict),
+    Filtered_tests = proplists: delete (Function, Module_tests),
+    Updated_tests = [{Function, Stamp} | Filtered_tests],
+    New_tests = dict: store (Module, Updated_tests, Test_dict),
+    dict: store (tests, New_tests, State).

trunk/src/tester_test.erl

@@ -10 +10 @@
 -export ([deletes_a_test_module /1]).
 -export ([notifies_a_message /1]).
+-export ([runs_new_tests_failed_then_successful /1]).
 
 start_tester (Node) ->
     Self = self (),
     Notify = fun (Event) -> Self ! Event end,
-    spawn_link (tester, init, [Notify, Node]).
+    extremeforge: start_tester (Node, Notify).
 
 fixture_path (Module) ->
@@ -45 +46 @@
     Tester = start_tester (Node),
     [{2, 0, 0}, {2, 1, 1}, _, {2, 2, 1}] = send ([eg_test], Tester),
-    [{2, 0, 0}, {2, 1, 1}, _, {2, 2, 1}] = send ([eg_code], Tester),
+    [{2, 0, 0}, _, {2, 1, 0}, {2, 2, 1}] = send ([eg_code], Tester),
     Result = send ([eg_test_of_code], Tester),
     [{3, 0, 0}, {3, 1, 1}, _, {3, 2, 1}, {3, 3, 2}] = Result,
@@ -94 +95 @@
     ok.
 
+runs_new_tests_failed_then_successful (Node) ->
+    Tester = start_tester (Node),
+    Modules = [eg_code, eg_test_of_code_failed],
+    Result = send (Modules, Tester),
+    [{1, 0, 0}, Error, {1, 1, 0}] = Result,
+    {{badmatch, bad_eg_code}, _} = Error,
+    
+    Result_after_new_test = send ([eg_test_not_exports], Tester),
+    [{2, 0, 0}, {2, 1, 1}, Error, {2, 2, 1}] = Result_after_new_test,
+
+    New_run = send ([eg_test_of_code], Tester),
+    [{3, 0, 0}, {3, 1, 1}, Error, {3, 2, 1}, {3, 3, 2}] = New_run,
+    ok.
+
 receive_something (Ms, Delay) ->
     receive