-- C954010.A
--
--                             Grant of Unlimited Rights
--
--     Under contracts F33600-87-D-0337, F33600-84-D-0280, MDA903-79-C-0687,
--     F08630-91-C-0015, and DCA100-97-D-0025, the U.S. Government obtained 
--     unlimited rights in the software and documentation contained herein.
--     Unlimited rights are defined in DFAR 252.227-7013(a)(19).  By making 
--     this public release, the Government intends to confer upon all 
--     recipients unlimited rights  equal to those held by the Government.  
--     These rights include rights to use, duplicate, release or disclose the 
--     released technical data and computer software in whole or in part, in 
--     any manner and for any purpose whatsoever, and to have or permit others 
--     to do so.
--
--                                    DISCLAIMER
--
--     ALL MATERIALS OR INFORMATION HEREIN RELEASED, MADE AVAILABLE OR
--     DISCLOSED ARE AS IS.  THE GOVERNMENT MAKES NO EXPRESS OR IMPLIED 
--     WARRANTY AS TO ANY MATTER WHATSOEVER, INCLUDING THE CONDITIONS OF THE
--     SOFTWARE, DOCUMENTATION OR OTHER INFORMATION RELEASED, MADE AVAILABLE 
--     OR DISCLOSED, OR THE OWNERSHIP, MERCHANTABILITY, OR FITNESS FOR A
--     PARTICULAR PURPOSE OF SAID MATERIAL.
--*
--
-- OBJECTIVE:
--      Check that a requeue within an accept statement does not block.
--      This test uses: Requeue to an entry in a different task
--                      Parameterless call
--                      Requeue with abort
--
-- TEST DESCRIPTION:
--      In the Distributor task, requeue two successive calls on the entries
--      of two separate target tasks.  Verify that the target tasks are
--      run in parallel proving that the first requeue does not block
--      while the first target rendezvous takes place.                 
--
--      This series of tests uses a simulation of a transaction driven 
--      processing system.  Line Drivers accept input from an external source
--      and build them into transaction records.  These records are then 
--      encapsulated in message tasks which remain extant for the life of the
--      transaction in the system. The message tasks put themselves on the 
--      input queue of a Distributor which, from information in the 
--      transaction and/or system load conditions forwards them to other 
--      operating tasks. These in turn might forward the transactions to yet 
--      other tasks for further action.  The  routing is, in real life, 
--      dynamic and unpredictable at the time of message generation. All 
--      rerouting in this  model is done by means of requeues.
--
--      This test is directed towards the BLOCKING of the REQUEUE only
--      If the original caller does not block, the outcome of the test will
--      not be affected.  If the original caller does not continue after
--      the return, the test will not pass.  
--      If the requeue gets placed on the wrong entry a failing test could
--      pass (eg. if the first message is delivered to the second
--      computation task and the second message to the first) - a check for
--      this condition is made in other tests
--
--
-- CHANGE HISTORY:
--      06 Dec 94   SAIC    ACVC 2.0
--
--!

with Report;
with ImpDef;

procedure C954010 is

   -- Mechanism to count the number of Message tasks completed
   protected TC_Tasks_Completed is
      procedure Increment;
      function  Count return integer;
   private
      Number_Complete : integer := 0;
   end TC_Tasks_Completed;
   --
   TC_Expected_To_Complete   : constant integer := 2;


   task type Message_Task;
   type acc_Message_Task is access Message_Task;

   task Line_Driver is
      entry Start;
   end Line_Driver;

   task Distributor is 
      entry Input;
   end Distributor;

   task Credit_Computation is
      entry Input;
   end Credit_Computation;

   task Debit_Computation is
      entry Input;
      entry TC_Artificial_Rendezvous_1;      -- test purposes only
      entry TC_Artificial_Rendezvous_2;      -- test purposes only
   end Debit_Computation;

   
   -- Mechanism to count the number of Message tasks completed
   protected body TC_Tasks_Completed is
      procedure Increment is
      begin
         Number_Complete := Number_Complete + 1;
      end Increment;

      function Count return integer is
      begin
         return Number_Complete;
      end Count;
   end TC_Tasks_Completed;



   -- Assemble messages received from an external source
   --   Creates a message task for each and sends this to a Distributor 
   --   for appropriate disposal around the network of tasks
   --      Such a task would normally be designed to loop continuously
   --      creating the messages as input is received.  Simulate this 
   --      but limit it to two dummy messages for this test and allow it
   --      to terminate at that point
   --
   task body Line_Driver is

   begin

      accept Start;      -- Wait for trigger from main

      for i in 1..2 loop
         declare
            -- create a new message task 
            N : acc_Message_Task := new Message_Task; 
         begin
            -- preparation code
            null; -- stub

         end;   -- declare
      end loop;

   exception
      when others => 
         Report.Failed ("Unexpected exception in Line_Driver");
   end Line_Driver;


   task body Message_Task is
   begin
      -- Queue up on Distributor's Input queue
      Distributor.Input;
      
      -- After the required computations have been performed
      -- return the message appropriately (probably to an output
      -- line driver
      null;            -- stub

      -- Increment to show completion of this task
      TC_Tasks_Completed.Increment;

   exception
      when others => 
         Report.Failed ("Unexpected exception in Message_Task");

   end Message_Task;


   -- Dispose each input message to the appropriate computation tasks
   --    Normally this would be according to some parameters in the entry
   --    but this simple test is using parameterless entries.  
   --
   task body Distributor is
     Last_was_for_Credit_Computation : Boolean := false;   -- switch
   begin
      loop
         select
            accept Input do
               -- Determine to which task the message should be 
               -- distributed
               --      For this test arbitrarily send the first to 
               --      Credit_Computation and the second to Debit_Computation
               if Last_was_for_Credit_Computation then
                  requeue Debit_Computation.Input with abort;
               else 
                  Last_was_for_Credit_Computation := true;
                  requeue Credit_Computation.Input with abort;
               end if;
            end Input;
         or
            terminate;
         end select;
      end loop;

   exception
      when others => 
         Report.Failed ("Unexpected exception in Distributor");
   end Distributor;
                                          
                                                
   -- Computation task.  After the computation is performed the rendezvous
   -- in the original message task is completed.                              
   task body Credit_Computation is
   begin
      loop
         select 
            accept Input do
               -- Perform the computations required for this message
               --
               null;     -- stub

               --   For the test:
               --   Artificially rendezvous with Debit_Computation.
               --   If the first requeue in Distributor has blocked 
               --   waiting for the current rendezvous to complete then the
               --   second message will not be sent to Debit_Computation 
               --   which will still be waiting on its Input accept.  
               --   This task will HANG
               --
               Debit_Computation.TC_Artificial_Rendezvous_1;
               --
            end Input;
         or
            terminate;
         end select;
      end loop;
   exception
      when others => 
         Report.Failed ("Unexpected exception in Credit_Computation");
   end Credit_Computation;

                                                
   -- Computation task.  After the computation is performed the rendezvous
   -- in the original message task is completed.                              
   task body Debit_Computation is
      Message_Count      : integer := 0;
      TC_AR1_is_complete : Boolean := false;
   begin
      loop
         select
            accept Input do
               -- Perform the computations required for this message
               null;    -- stub
            end Input;
            Message_Count := Message_Count + 1;
         or
            -- Guard until the rendezvous with the message for this task
            -- has completed
            when Message_Count > 0 =>
            accept TC_Artificial_Rendezvous_1;    -- see comments in
                                                  -- Credit_Computation above
            TC_AR1_is_complete := true; 
         or
            -- Completion rendezvous with the main procedure
            when TC_AR1_is_complete =>
            accept TC_Artificial_Rendezvous_2;
         or
            terminate;
         end select;
      end loop;
   exception
      when others => 
         Report.Failed ("Unexpected exception in Debit_Computation");


   end Debit_Computation;


begin -- c954010
   Report.Test ("C954010", "Requeue in an accept body does not block");

   Line_Driver.Start;

   -- Ensure that both messages were delivered to the computation tasks
   -- This shows that both requeues were effective.
   -- 
   Debit_Computation.TC_Artificial_Rendezvous_2;

   -- Ensure that the message tasks completed
   while (TC_Tasks_Completed.Count < TC_Expected_To_Complete) loop
      delay ImpDef.Minimum_Task_Switch;   
   end loop;

   Report.Result;

end C954010;