--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/gcc/testsuite/ada/acats/tests/c9/c954021.a	Fri Oct 27 22:46:09 2017 +0900
@@ -0,0 +1,524 @@
+-- C954021.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 a protected entry to an entry in a
+--     different protected object is queued correctly.
+--
+-- TEST DESCRIPTION: 
+--      One transaction is sent through to check the paths. After processing
+--      this the Credit task sets the "overloaded" indicator.  Once this
+--      indicator is set the Distributor (a protected object) queues low
+--      priority transactions on a Wait_for_Underload queue in another
+--      protected object using a requeue. The Distributor still delivers high
+--      priority transactions.  After two high priority transactions have been
+--      processed by the Credit task it clears the overload condition.  The
+--      low priority transactions should now be delivered. 
+--     
+--      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
+--      26 Nov 95   SAIC    Fixed shared global variable for ACVC 2.0.1
+--
+--!
+
+with Report;
+with ImpDef;
+         
+procedure C954021 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_Credit_Messages_Expected  : constant integer := 5;
+
+   protected TC_Handshake is
+      procedure Set;
+      function First_Message_Arrived return Boolean;
+   private
+      Arrived_Flag : Boolean := false;
+   end TC_Handshake;
+
+   -- Handshaking mechanism between the Line Driver and the Credit task
+   -- 
+   protected body TC_Handshake is
+      --
+      procedure Set is
+      begin 
+         Arrived_Flag := true;
+      end Set;
+      --
+      function First_Message_Arrived return Boolean is
+      begin
+         return Arrived_Flag;
+      end First_Message_Arrived;
+      -- 
+   end TC_Handshake;
+
+
+   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);
+
+   type Transaction_Code is (Credit, Debit);
+   type Transaction_Priority is (High, Low);
+
+   type Transaction_Record;
+   type acc_Transaction_Record is access Transaction_Record;
+   type Transaction_Record is 
+      record
+         ID               : integer := 0;
+         Code             : Transaction_Code := Debit;
+         Priority         : Transaction_Priority := High;
+         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;
+
+   protected Distributor is
+      procedure Set_Credit_Overloaded;
+      procedure Clear_Credit_Overloaded;
+      function  Credit_is_Overloaded return Boolean;
+      entry     Input (Transaction : acc_Transaction_Record);
+   private
+      Credit_Overloaded : Boolean := false;
+   end Distributor;
+
+   protected Hold is
+      procedure Underloaded;
+      entry Wait_for_Underload (Transaction : acc_Transaction_Record);
+   private
+      Release_All : Boolean := false;
+   end Hold;
+
+   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;
+
+   --
+   -- Dispose each input Transaction_Record to the appropriate
+   -- computation tasks
+   --
+   protected body Distributor is
+
+      procedure Set_Credit_Overloaded is
+      begin
+         Credit_Overloaded := true;
+      end Set_Credit_Overloaded;
+
+      procedure Clear_Credit_Overloaded is
+      begin
+         Credit_Overloaded := false;
+         Hold.Underloaded;       -- Release all held messages
+      end Clear_Credit_Overloaded;
+  
+      function  Credit_is_Overloaded return Boolean is
+      begin
+         return Credit_Overloaded;
+      end Credit_is_Overloaded;
+
+
+      entry Input (Transaction : acc_Transaction_Record) when true is
+                                                     -- barrier is always open
+      begin
+         -- Test Control: Set the indicator in the message to show it has
+         -- passed through the Distributor object
+         Transaction.TC_thru_Dist := true;
+ 
+         -- Pass this transaction on to the appropriate computation
+         -- task but temporarily hold low-priority transactions under
+         -- overload conditions
+         case Transaction.Code is
+            when Credit =>
+               if Credit_Overloaded and Transaction.Priority = Low then
+                  requeue Hold.Wait_for_Underload with abort;
+               else
+                  requeue Credit_Computation.Input with abort;
+              end if;
+            when Debit =>
+              requeue Debit_Computation.Input with abort;
+         end case;
+      end Input;
+   end Distributor;
+
+
+   -- Low priority Message tasks are held on the Wait_for_Underload queue
+   -- while the Credit computation system is overloaded.  Once the Credit
+   -- system reached underload send all queued messages immediately
+   --
+   protected body Hold is
+      
+      -- Once this is executed the barrier condition for the entry is 
+      -- evaluated 
+      procedure Underloaded is
+      begin 
+         Release_All := true;
+      end Underloaded;
+
+      entry Wait_for_Underload (Transaction : acc_Transaction_Record)
+                                                     when Release_All is
+      begin
+         requeue Credit_Computation.Input with abort;
+         if Wait_for_Underload'count = 0 then
+            -- Queue is purged.  Set up to hold next batch
+            Release_All := false;
+         end if; 
+      end Wait_for_Underload;
+
+   end Hold;
+   
+   -- 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 required number of dummy messages needed for
+   --      this test and allow it to terminate at that point.  Artificially
+   --      alternate High and Low priority Credit transactions for this test.
+   --
+   task body Line_Driver is
+      Current_ID       : integer := 1;
+      Current_Priority : Transaction_Priority := High;      
+
+      -- Artificial: number of messages required for this test
+      type TC_Trans_Range is range 1..6;
+
+      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.Priority := Current_Priority;
+
+            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 Transaction_Numb in TC_Trans_Range loop  -- TC: limit the 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
+            if Transaction_Numb = TC_Trans_Range'first then
+               -- Send the first Credit message
+               Build_Credit_Record ( Next_Transaction );
+               Next_Message_Task.Accept_Transaction ( Next_Transaction );  
+               -- TC: Wait until the first message has been received by the
+               -- Credit task and it has set the Overload indicator for the 
+               -- Distributor
+               while not TC_Handshake.First_Message_Arrived loop
+                  delay ImpDef.Minimum_Task_Switch;   
+               end loop;
+            elsif Transaction_Numb = TC_Trans_Range'last then
+               -- For this test send the last transaction to the Debit task
+               -- to improve the mix
+               Build_Debit_Record( Next_Transaction );
+               Next_Message_Task.Accept_Transaction ( Next_Transaction );  
+            else
+               -- TC: Alternate high and low priority transactions
+               if Current_Priority = High then
+                  Current_Priority := Low;
+               else
+                  Current_Priority := High;
+               end if;
+               Build_Credit_Record( Next_Transaction );
+               Next_Message_Task.Accept_Transaction ( Next_Transaction );  
+            end if;
+         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
+      
+      -- For the test 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  /= Credit_Return   or
+         not This_Transaction.TC_thru_Dist                    then
+            Report.Failed ("Expected path not traversed - Credit");
+         end if;
+         TC_Tasks_Completed.Increment;
+      else
+         if This_Transaction.Return_Value  /= Debit_Return or   
+            This_Transaction.TC_Message_Count /= 1         or
+            not This_Transaction.TC_thru_Dist               then
+               Report.Failed ("Expected path not traversed - Debit");
+         end if;
+         TC_Debit_Message_Complete.Set_True;
+      end if;
+
+   exception
+      when others => 
+         Report.Failed ("Unexpected exception in Message_Task");
+   end Message_Task;
+
+
+
+
+  
+   -- Computation task.  After the computation is performed the rendezvous
+   -- in the original message task is completed.                              
+   task body Credit_Computation is
+
+      Message_Count   : integer := 0;
+      
+   begin
+      loop
+         select 
+            accept Input ( Transaction : acc_Transaction_Record) do
+               if Distributor.Credit_is_Overloaded
+                                    and Transaction.Priority = Low  then 
+                  -- We should not be getting any Low Priority messages. They
+                  -- should be waiting on the Hold.Wait_for_Underload 
+                  -- queue
+                  Report.Failed 
+                     ("Credit Task: Low priority transaction during overload");
+               end if;
+               -- Perform the computations required for this transaction
+               null; -- stub
+
+               -- For the test: 
+               if not Transaction.TC_thru_Dist 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;
+
+               -- The following is all Test Control code:
+               Transaction.Return_Value := Credit_Return;
+               Message_Count := Message_Count + 1;
+               --
+               -- Now take special action depending on which Message
+               if Message_Count = 1 then 
+                  -- After the first message :
+                  Distributor.Set_Credit_Overloaded;
+                  -- Now flag the Line_Driver that the second and subsequent
+                  -- messages may now be sent
+                  TC_Handshake.Set;
+               end if;
+               if Message_Count = 3 then
+                  -- The two high priority transactions created subsequent
+                  -- to the overload have now been processed
+                  Distributor.Clear_Credit_Overloaded;
+               end if;
+            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;
+   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_Dist 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 ("C954021", "Requeue from one entry body to an entry in" &
+                                       " another protected object");
+
+   Line_Driver.Start;  -- Start the test
+
+
+   -- Ensure that the message tasks have completed before reporting result
+   while (TC_Tasks_Completed.Count < TC_Credit_Messages_Expected) 
+         and not TC_Debit_Message_Complete.Value loop
+      delay ImpDef.Minimum_Task_Switch;   
+   end loop;
+
+   Report.Result;
+
+end C954021;