Dead

[official-gcc.git] / gomp-20050608-branch / gcc / testsuite / ada / acats / tests / c9 / c954015.a

-- C954015.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 requeued calls to task entries may, in turn, be requeued.  
--      Check that the intermediate requeues are not blocked and that the
--      original caller remains blocked until the last requeue is complete.
--         This test uses: 
--                      Call with parameters
--                      Requeue with abort
--      
-- TEST DESCRIPTION
--      A call is placed on the input queue of the Distributor.  The
--      Distributor requeues to the Credit task; the Credit task requeues to a
--      secondary task which, in turn requeues to yet another task.  This
--      continues down the chain.  At the furthest point of the chain the
--      rendezvous is completed.  To verify the action, the furthest task
--      waits in the accept statement for a second message to arrive before
--      completing.  This second message can only arrive if none of the earlier
--      tasks in the chain are blocked waiting for completion.   Apart from
--      the two Credit messages which are used to check the requeue chain one
--      Debit message is sent to validate the mix.
--
--                                                    
--      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.
--
--
-- CHANGE HISTORY:
--      06 Dec 94   SAIC    ACVC 2.0
--
--!


with Report;
with ImpDef;
         
procedure C954015 is
 
   -- Arbitrary test values
   Credit_Return : constant := 1;
   Debit_Return  : constant := 2;

   -- Mechanism to count the number of Credit 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 := 3;


   -- Values added to the Return_Value indicating passage through the
   -- particular task
   TC_Credit_Value :  constant integer := 1;
   TC_Sub_1_Value  :  constant integer := 2;
   TC_Sub_2_Value  :  constant integer := 3;
   TC_Sub_3_Value  :  constant integer := 4;
   TC_Sub_4_Value  :  constant integer := 5;
   --
   TC_Full_Value   :  integer := TC_Credit_Value + TC_Sub_1_Value + 
                                 TC_Sub_2_Value  + TC_Sub_3_Value +
                                 TC_Sub_4_Value;

   type Transaction_Code is (Credit, Debit);

   type Transaction_Record;
   type acc_Transaction_Record is access Transaction_Record;
   type Transaction_Record is 
      record
         ID               : integer := 0;
         Code             : Transaction_Code := Debit;
         Account_Number   : integer := 0;
         Stock_Number     : integer := 0;
         Quantity         : integer := 0;
         Return_Value     : integer := 0;
         TC_Message_Count : integer := 0;
         TC_Thru_Distrib  : Boolean := false;
      end record;


   task type Message_Task is 
      entry Accept_Transaction (In_Transaction : acc_Transaction_Record);
   end Message_Task;
   type acc_Message_Task is access Message_Task;

   task Line_Driver is
      entry Start;
   end Line_Driver;   

   task Distributor is 
      entry Input(Transaction : acc_Transaction_Record);
   end Distributor;

   task Credit_Computation is
      entry Input(Transaction : acc_Transaction_Record);
   end Credit_Computation;

   task Debit_Computation is
      entry Input(Transaction : acc_Transaction_Record);
   end Debit_Computation;

   -- The following are almost identical for the purpose of the test
   task Credit_Sub_1 is
      entry Input(Transaction : acc_Transaction_Record);
   end Credit_Sub_1;
   --
   task Credit_Sub_2 is
      entry Input(Transaction : acc_Transaction_Record);
   end Credit_Sub_2;
   --
   task Credit_Sub_3 is
      entry Input(Transaction : acc_Transaction_Record);
   end Credit_Sub_3;

   -- This is the last in the chain
   task Credit_Sub_4 is
      entry Input(Transaction : acc_Transaction_Record);
   end Credit_Sub_4;
  
   
   -- Mechanism to count the number of Message tasks completed (Credit)
   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. The message tasks remain extant
   --   for the life of the messages in the system.
   --      The Line Driver task would normally be designed to loop continuously
   --      creating the messages as input is received.  Simulate this 
   --      but limit it to the number of dummy messages needed for this 
   --      test and allow it to terminate at that point. 
   --
   task body Line_Driver is
      Current_ID : integer := 1;
      TC_Last_was_for_credit : Boolean := false;

       -- Arbitrary limit for the number of messages sent for this test
      type TC_Trans_Range is range 1..3;

      procedure Build_Credit_Record 
                              ( Next_Transaction : acc_Transaction_Record ) is
         Dummy_Account : constant integer := 100;
      begin
         Next_Transaction.ID := Current_ID;
         Next_Transaction.Code := Credit; 
         Next_Transaction.Account_Number := Dummy_Account;
         Current_ID := Current_ID + 1;
      end Build_Credit_Record;     

      procedure Build_Debit_Record 
                              ( Next_Transaction : acc_Transaction_Record ) is
         Dummy_Account : constant integer := 200;
      begin
         Next_Transaction.ID := Current_ID;
         Next_Transaction.Code := Debit; 
         Next_Transaction.Account_Number := Dummy_Account;
         Current_ID := Current_ID + 1;
      end Build_Debit_Record;     


   begin

      accept Start;   -- wait for trigger from Main
      
      -- Arbitrarily limit the loop to the number needed for this test only
      for Transaction_Numb in TC_Trans_Range  loop
         declare 
            -- Create a task for the next message
            Next_Message_Task : acc_Message_Task := new Message_Task;
            -- Create a record for it
            Next_Transaction : acc_Transaction_Record := 
                                                new Transaction_Record;
         begin
            -- Artificially send out in the order required
            case Transaction_Numb is
               when 1 => 
                  Build_Credit_Record( Next_Transaction );
               when 2 =>
                  Build_Credit_Record( Next_Transaction );
               when 3 =>
                  Build_Debit_Record ( Next_Transaction );            
            end case;

            -- Present the record to the message task
            Next_Message_Task.Accept_Transaction ( Next_Transaction );  
         end;   -- declare
      end loop;

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



   task body Message_Task is

      TC_Original_Transaction_Code : Transaction_Code;  
      This_Transaction : acc_Transaction_Record := new Transaction_Record;

   begin
      
      accept Accept_Transaction (In_Transaction : acc_Transaction_Record) do
         This_Transaction.all := In_Transaction.all;
      end Accept_Transaction;

      -- Note the original code to ensure correct return
      TC_Original_Transaction_Code := This_Transaction.Code;
 
      -- Queue up on Distributor's Input queue
      Distributor.Input ( This_Transaction );
      -- This task will now wait for the requeued rendezvous 
      -- to complete before proceeding

      -- After the required computations have been performed
      -- return the Transaction_Record appropriately (probably to an output
      -- line driver)
      null;            -- stub

      
      -- The following is all Test Control Code

      -- Check that the return values are as expected
      if TC_Original_Transaction_Code /= This_Transaction.Code then
         -- Incorrect rendezvous
         Report.Failed ("Message Task: Incorrect code returned");
      end if;

      if This_Transaction.Code = Credit then
         if This_Transaction.Return_Value  /= TC_Full_Value or not  
            This_Transaction.TC_Thru_Distrib       then
               Report.Failed ("Expected path not traversed - CR");
         end if;
         if 
            This_Transaction.TC_Message_Count not in 1..2 then
               Report.Failed ("Incorrect Message Count");
         end if;
      else
         if This_Transaction.Return_Value  /= Debit_Return or   
            This_Transaction.TC_Message_Count /= 1            or not
            This_Transaction.TC_Thru_Distrib     then
               Report.Failed ("Expected path not traversed - DB");
         end if;
      end if;
      TC_Tasks_Completed.Increment;
   exception
      when others => 
         Report.Failed ("Unexpected exception in Message_Task");

   end Message_Task;



   -- Dispose each input Transaction_Record to the appropriate 
   -- computation tasks
   --
   task body Distributor is

   begin
      loop
         select
            accept Input (Transaction : acc_Transaction_Record) do
               -- Show that the message did pass through the Distributor Task
               Transaction.TC_Thru_Distrib := true;

               -- Pass this transaction on to the appropriate computation
               -- task
               case Transaction.Code is 
                  when Credit =>
                     requeue Credit_Computation.Input with abort;
                  when Debit => 
                     requeue Debit_Computation.Input with abort;
               end case;
            end Input;
         or
            terminate;
         end select;
      end loop;

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


                                                
   -- Computation task.
   --   Note:  After the computation is performed in this task the message is
   --   passed on for further processing to some subsidiary task.  The choice
   --   of subsidiary task is made according to criteria not specified in
   --   this test.  
   --                                           
   task body Credit_Computation is
      Message_Count   : integer := 0;   
   begin
      loop
         select 
            accept Input ( Transaction : acc_Transaction_Record) do
               -- Perform the computations required for this transaction
               null;      -- stub

               -- For the test: 
               if not Transaction.TC_Thru_Distrib then
                  Report.Failed 
                         ("Credit Task: Wrong queue, Distributor bypassed");
               end if;
               if Transaction.code /= Credit then
                  Report.Failed
                         ("Credit Task: Requeue delivered to the wrong queue");
               end if;

               -- for the test, plug a known value and count
               Transaction.Return_Value := TC_Credit_Value;
               Message_Count := Message_Count + 1;
               Transaction.TC_Message_Count := Message_Count;

               -- Depending on transaction content send it on to the
               -- some other task for further processing
               -- TC: Arbitrarily send the message on to Credit_Sub_1
               requeue Credit_Sub_1.Input with abort;
            end Input;            
         or
            terminate;
         end select;
      end loop;
   exception
      when others => 
         Report.Failed ("Unexpected exception in Credit_Computation");
   end Credit_Computation;



   task body Credit_Sub_1 is
   begin
      loop
         select
            accept Input(Transaction : acc_Transaction_Record) do
               -- Process this transaction
               null;   -- stub
            
               -- Add the value showing passage through this task
               Transaction.Return_Value := 
                                    Transaction.Return_Value + TC_Sub_1_Value;
               -- Depending on transaction content send it on to the
               -- some other task for further processing
               -- Arbitrarily send the message on to Credit_Sub_2
               requeue Credit_Sub_2.Input with abort;  
            end Input;
         or 
            terminate;
         end select;
      end loop;
   exception
      when others => 
         Report.Failed ("Unexpected exception in Credit_Sub_1");

   end Credit_Sub_1;

   task body Credit_Sub_2 is
   begin
      loop
         select
            accept Input(Transaction : acc_Transaction_Record) do
               -- Process this transaction
               null;   -- stub
            
               -- Add the value showing passage through this task
               Transaction.Return_Value := 
                                    Transaction.Return_Value + TC_Sub_2_Value;
               -- Depending on transaction content send it on to the
               -- some other task for further processing
               -- Arbitrarily send the message on to Credit_Sub_3
               requeue Credit_Sub_3.Input with abort;  
            end Input;
         or 
            terminate;
         end select;
      end loop;
   exception
      when others => 
         Report.Failed ("Unexpected exception in Credit_Sub_2");
   end Credit_Sub_2;

   task body Credit_Sub_3 is
   begin
      loop
         select
            accept Input(Transaction : acc_Transaction_Record) do
               -- Process this transaction
               null;   -- stub
            
               -- Add the value showing passage through this task
               Transaction.Return_Value := 
                                    Transaction.Return_Value + TC_Sub_3_Value;
               -- Depending on transaction content send it on to the
               -- some other task for further processing
               -- Arbitrarily send the message on to Credit_Sub_4
               requeue Credit_Sub_4.Input with abort;  
            end Input;
         or 
            terminate;
         end select;
      end loop;
   exception
      when others => 
         Report.Failed ("Unexpected exception in Credit_Sub_3");
   end Credit_Sub_3;

   -- This is the last in the chain of tasks to which transactions will
   -- be requeued
   --
   task body Credit_Sub_4 is
   
      TC_First_Message : Boolean := true;

   begin
      loop
         select
            accept Input(Transaction : acc_Transaction_Record) do
               -- Process this transaction
               null;   -- stub
            
               -- Add the value showing passage through this task
               Transaction.Return_Value := 
                                    Transaction.Return_Value + TC_Sub_4_Value;
               -- TC: stay in the accept body dealing with the first message
               -- until the second arrives.  If any of the requeues are 
               -- blocked the test will hang here indicating failure
               if TC_First_Message then
                  while Input'count = 0 loop
                     delay ImpDef.Minimum_Task_Switch;
                  end loop;
               TC_First_Message := false;
               end if;
               -- for the second message, just complete the rendezvous
            end Input;
         or 
            terminate;
         end select;
      end loop;
   exception
      when others => 
         Report.Failed ("Unexpected exception in Credit_Sub_4");
   end Credit_Sub_4;


                                                
   -- Computation task.
   --   Note:  After the computation is performed in this task and the 
   --          accept body is completed the rendezvous in the original
   --          message task is completed.                              
   --                                                
   task body Debit_Computation is
      Message_Count   : integer := 0;
   begin
      loop
         select
            accept Input (Transaction : acc_Transaction_Record) do
               -- Perform the computations required for this message
               null;      -- stub

               -- For the test: 
               if not Transaction.TC_Thru_Distrib then
                  Report.Failed 
                         ("Debit Task: Wrong queue, Distributor bypassed");
               end if;
               if Transaction.code /= Debit then
                  Report.Failed
                         ("Debit Task: Requeue delivered to the wrong queue");
               end if;

               -- for the test plug a known value and count
               Transaction.Return_Value := Debit_Return;
               -- one, and only one, message should pass through
               Message_Count := Message_Count + 1;
               Transaction.TC_Message_Count := Message_Count;
            end Input;            
         or
            terminate;
         end select;
      end loop;
   exception
      when others => 
         Report.Failed ("Unexpected exception in Debit_Computation");


   end Debit_Computation;


begin 

   Report.Test ("C954015", "Test multiple levels of requeue to task entry");

   Line_Driver.Start;  -- Start the test

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

   Report.Result;

end C954015;