Changeset 30 for trunk

Timestamp:

06/17/08 13:58:49 (4 years ago)

Author:

dom

Message:

Tester re-runs tests when receiving a second module

Location:

trunk/src

Files:

• shells.erl (modified) (2 diffs)
• tester.erl (modified) (1 diff)
• tester_test.erl (modified) (2 diffs)

trunk/src/shells.erl

@@ -3 +3 @@
 
 install ([Test_node]) ->
-    process_flag(trap_exit, false), % called with erl -s shells install
+%xs    process_flag(trap_exit, false),  % called with erl -s shells install
     try
-        tests (Test_node)
+        Self = self (),
+        spawn_link (fun () -> tests (Test_node, Self) end),
+        receive {Self, done} -> ok;
+                M -> io:fwrite ("tests_crash: ~p~n", [M])
+        end
 
     catch C:E->
@@ -14 +18 @@
       rpc: call (Test_node, init, stop, [])
     end,
-    receive_all(),
+    receive_all (),
     io: fwrite ("done~n", []).
 
-tests (Test_node) ->
+tests (Test_node, Caller) ->
     io: fwrite ("Running local developer tests~n", []),
     ok = tests_test: filter_by_attribute (),
     io: fwrite ("Running developer tests on test node: ~p~n", [Test_node]),
-    ok = tester_test: runs_given_tests (Test_node).
+    ok = tester_test: runs_a_test (Test_node),
+    ok = tester_test: runs_given_tests (Test_node),
+    Caller ! {Caller, done}.
     
-receive_all() ->
-    receive M ->
+receive_all () ->
+    receive
+        {'EXIT', _, normal} ->
+            receive_all ();
+        M ->
             io:fwrite("Received ~p~n", [M]),
-            receive_all()
+            receive_all ()
     after 500 ->
            done

trunk/src/tester.erl

@@ -8 +8 @@
 init (Notify, Node) ->
     process_flag (trap_exit, true),
-    loop (Notify, Node).
+    With_notify = dict: store (notify, Notify, dict: new ()),
+    With_tests = dict: store (tests, dict: new (), With_notify),
+    State = dict: store (node, Node, With_tests),
+    loop (State).
 
-loop (Notify, Node) ->
+loop (State) ->
     receive
-        {File_name, Binary} ->
-            test (File_name, Binary, Notify, Node);
+        {_, _} = Module ->
+            loop (test (load (Module, State)));
         _ ->
-            loop (Notify, Node)
+            loop (State)
     end.
 
-test (File_name, Binary, Notify, Node) ->
-    {Module, Tests} = tests: filter_by_attribute (Binary),
-    {module, Module} = rpc: call (Node, code, load_binary, [Module, File_name, Binary]),
-    Total = length (Tests),
+load ({File_name, Binary}, State) ->
+    {Module, Functions} = tests: filter_by_attribute (Binary),
+    Node = dict: fetch (node, State),
+    Load_args = [Module, File_name, Binary],
+    {module, Module} = rpc: call (Node, code, load_binary, Load_args),
+    New_tests = dict: store (Module, Functions, dict: fetch (tests, State)),
+    dict: store (tests, New_tests, State).
+
+test (State) ->
+    {Total, Tests} = flatten (dict: fetch (tests, State)),
+    Notify = dict: fetch (notify, State),
     Notify ({Total, 0, 0}),
-    test (Total, 0, 0, Tests, Notify, Node).
+    lists: foldl (test_fun (State, Total), {0, 0}, Tests),
+    State.
 
-test (Total, Run, Passed, [{M, F, A} | Tests], Notify, Node) ->
-    Pid = spawn_link (Node, M, F, A),
-    New_passed =
-        receive
-            {'EXIT', Pid, normal} ->
-                Passed + 1;
-            {'EXIT', Pid, Reason} ->
-                Notify (Reason),
-                Passed
+flatten (Tests) ->
+    F = fun (_, Ts, {Count, List}) ->
+                {Count + length (Ts), [Ts | List]}
         end,
-    New_run = Run + 1,
-    Notify ({Total, New_run, New_passed}),
-    test (Total, New_run, New_passed, Tests, Notify, Node);
-test (_, _, _, [], _, _) ->
-    bye.
+    {Total, All} = dict: fold (F, {0, []}, Tests),
+    {Total, lists: flatten (All)}.
+
+test_fun (State, Total) ->
+    Node = dict: fetch (node, State),
+    Notify = dict: fetch (notify, State),
+    fun ({M, F, A}, {Run, Passed}) ->
+            Pid = spawn_link (Node, M, F, A),
+            New_passed =
+                receive
+                    {'EXIT', Pid, normal} ->
+                        Passed + 1;
+                    {'EXIT', Pid, Reason} ->
+                        Notify (Reason),
+                        Passed
+                end,
+            New_run = Run + 1,
+            Notify ({Total, New_run, New_passed}),
+            {New_run, New_passed}
+    end.
+

trunk/src/tester_test.erl

@@ -4 +4 @@
 
 -module (tester_test).
--export ([runs_given_tests/1]).
--test ([{nodes_fix, test_node, [runs_given_tests]}]).
+-export ([runs_a_test/1, runs_given_tests/1]).
+-test ([{nodes_fix, test_node, [runs_a_test, runs_given_tests]}]).
 
-runs_given_tests (Node) ->
+runs_a_test (Node) ->
     Self = self (),
     Notify = fun (Event) -> Self ! Event end,
@@ -14 +14 @@
     false = code: is_loaded (eg_test),
     Tester ! {"../fix/eg_test.erl", Binary},
-    [{2, 0, 0}, {2, 1, 1}, Error, {2, 2, 1}] = tests: receive_all (),
+    [{2, 0, 0}, {2, 1, 1}, Error, {2, 2, 1}] = receive_all ([]),
     {{badmatch, nok}, [{eg_test, nok, 0} | _]} = Error, 
     false = code: is_loaded (eg_test),
     ok.
+
+runs_given_tests (Node) ->
+    Self = self (),
+    Notify = fun (Event) -> Self ! Event end,
+    Tester = spawn_link (tester, init, [Notify, Node]),
+    Test_binary = modules: to_binary ("../fix/eg_test_of_code.erl"),
+    Code_binary = modules: to_binary ("../fix/eg_code.erl"),
+    false = code: is_loaded (eg_test_of_code),
+    false = code: is_loaded (eg_code),
+    Tester ! {"../fix/eg_test_of_code.erl", Test_binary},
+    [{1, 0, 0}, Error, {1, 1, 0}] = receive_all ([]),
+    {undef, [{eg_code, ok, []}, {eg_test_of_code, ok, 0} | _]} = Error,
+    false = code: is_loaded (eg_test),
+    Tester ! {"../fix/eg_code.erl", Code_binary},
+    [{1, 0, 0}, {1, 1, 1}] = receive_all ([]),
+    ok.
     
-    
+receive_all (Ms) ->
+    receive
+        {Run, Run, Passed} ->
+            lists: reverse ([{Run, Run, Passed} | Ms]);
+        M ->
+            receive_all ([M | Ms])
+    end.
+
 %%% Test to be added:
 %%% with several modules, including non-test ones