c954013.a

来自「linux下编程用 编译软件」· A 代码 · 共 522 行 · 第 1/2 页

-- C954013.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 is cancelled and that the requeuing task is
--      unaffected when the calling task is aborted. 
--      Specifically, check requeue to an entry in a different task,
--      requeue where the entry has parameters, and requeue with abort.
--
-- TEST DESCRIPTION:
--      Abort a task that has a call requeued to the entry queue of another
--      task.  We do this by sending two messages to the Distributor which 
--      requeues them to the Credit task.  In the accept body of the Credit 
--      task we wait for the second message to arrive then check that an 
--      abort of the second message task does result in the requeue being 
--      removed.  The Line Driver task which generates the messages and the 
--      Credit task communicate artificially in this test to arrange for the 
--      proper timing of the messages and the abort.  One extra message is 
--      sent to the Debit task to ensure that the Distributor is still viable
--      and has been unaffected by the abort.
--
--      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
--      25 Nov 95   SAIC    Fixed shared global variable problems for
--                          ACVC 2.0.1
--
--!

with Report;
with ImpDef;
         
procedure C954013 is
 

   -- Arbitrary test values
   Credit_Return : constant := 1;
   Debit_Return  : constant := 2;


   protected type Shared_Boolean (Initial_Value : Boolean := False) is
      procedure Set_True;
      procedure Set_False;
      function  Value return Boolean;
   private
      Current_Value : Boolean := Initial_Value;
   end Shared_Boolean;

   protected body Shared_Boolean is
      procedure Set_True is
      begin
         Current_Value := True;
      end Set_True;

      procedure Set_False is
      begin
         Current_Value := False;
      end Set_False;

      function Value return Boolean is
      begin
         return Current_Value;
      end Value;
   end Shared_Boolean;
 

   TC_Debit_Message_Complete  : Shared_Boolean (False);
   TC_Credit_Message_Complete : Shared_Boolean (False);


   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_Dist     : 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;

   -- This protected object is here for Test Control purposes only
   protected TC_Prt is 
      procedure Set_First_Has_Arrived;
      procedure Set_Second_Has_Arrived;
      procedure Set_Abort_Has_Completed;
      function  First_Has_Arrived   return Boolean;
      function  Second_Has_Arrived  return Boolean;
      function  Abort_Has_Completed return Boolean;
   private 
      First_Flag, Second_Flag, Abort_Flag : Boolean := false;
   end TC_Prt;

   protected body TC_Prt is

      Procedure Set_First_Has_Arrived is
      begin
         First_Flag := true;
      end Set_First_Has_Arrived;

      Procedure Set_Second_Has_Arrived is
      begin
         Second_Flag := true;
      end Set_Second_Has_Arrived;

      Procedure Set_Abort_Has_Completed is
      begin
         Abort_Flag := true;
      end Set_Abort_Has_Completed;
   
      Function First_Has_Arrived return boolean is
      begin
         return First_Flag;
      end First_Has_Arrived;

      Function Second_Has_Arrived return boolean is
      begin
         return Second_Flag;
      end Second_has_Arrived;

      Function Abort_Has_Completed return boolean is
      begin
         return Abort_Flag;
      end Abort_Has_Completed;
   
   end TC_PRT;

   -- 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.
   --      TC: The Line Driver task would normally be designed to loop
   --      continuously creating the messages as input is received.  Simulate
   --      this  but limit it to three dummy messages for this test and use
   --      special artificial checks to pace the messages out under controlled
   --      conditions for the test; allow it to terminate at the end
   --
   task body Line_Driver is
      Current_ID : integer := 1;
      TC_First_message_sent: Boolean := false;

      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

      for i in 1..3 loop  -- TC: arbitrarily limit to two credit messages
                          --     and one debit, then complete
         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
            if not TC_First_Message_Sent then
               -- send out the first message to start up the Credit task
               Build_Credit_Record ( Next_Transaction );            
               Next_Message_Task.Accept_Transaction ( Next_Transaction );  
               TC_First_Message_Sent := true;
            elsif not TC_Prt.Abort_Has_Completed then
               -- We have not yet processed the second message
               -- Wait to send the second message until we know the first
               -- has arrived at the Credit task and that task is in the 
               -- accept body 
               while not TC_Prt.First_Has_Arrived loop
                  delay ImpDef.Minimum_Task_Switch;   
               end loop;

               -- We can now send the second message
               Build_Credit_Record( Next_Transaction );
               Next_Message_Task.Accept_Transaction ( Next_Transaction );  
               
               -- Now wait for the second to arrive on the Credit input queue
               while not TC_Prt.Second_Has_Arrived loop
                  delay ImpDef.Minimum_Task_Switch;   
               end loop;
               
               -- At this point: The Credit task is in the accept block