-- C954018.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 if a task is aborted while a requeued call is queued 
--      on one of its entries the original caller receives Tasking_Error
--      and the requeuing task is unaffected.
--         This test uses: Requeue to an entry in a different task
--                         Parameterless call
--                         Requeue with abort
--
-- TEST DESCRIPTION:
--      The Intermediate task requeues a call from the Original_Caller to the
--      Receiver on an entry with a guard that is always false.  While the 
--      Original_Caller is still queued the Receiver is aborted.
--      Check that Tasking_Error is raised in the Original_Caller, that the 
--      Receiver does, indeed, get aborted and the Intermediate task 
--      is undisturbed.
--      There are several delay loops in this test any one of which could 
--      cause it to hang and thus indicate failure.  
--      
--
-- CHANGE HISTORY:
--      06 Dec 94   SAIC    ACVC 2.0
--
--!


with Report;
with ImpDef;


procedure C954018 is


   -- Protected object to control the shared test variables
   --
   protected TC_State is
      function  On_Entry_Queue return Boolean;
      procedure Set_On_Entry_Queue; 
      function  Original_Caller_Complete return Boolean;
      procedure Set_Original_Caller_Complete;
      function  Intermediate_Complete return Boolean;
      procedure Set_Intermediate_Complete;
   private
      On_Entry_Queue_Flag           : Boolean := false;
      Original_Caller_Complete_Flag : Boolean := false;
      Intermediate_Complete_Flag    : Boolean := false;
   end TC_State;
   --
   --
   protected body TC_State is
      function On_Entry_Queue return Boolean is
      begin 
         return On_Entry_Queue_Flag;
      end On_Entry_Queue;
      
      procedure Set_On_Entry_Queue is
      begin
         On_Entry_Queue_Flag := true; 
      end Set_On_Entry_Queue; 

      function Original_Caller_Complete return Boolean is
      begin
         return Original_Caller_Complete_Flag;
      end Original_Caller_Complete;

      procedure Set_Original_Caller_Complete is
      begin
         Original_Caller_Complete_Flag := true;
      end Set_Original_Caller_Complete;

      function Intermediate_Complete return Boolean is
      begin
         return Intermediate_Complete_Flag;
      end Intermediate_Complete;

      procedure Set_Intermediate_Complete is
      begin
         Intermediate_Complete_Flag := true;
      end Set_Intermediate_Complete;

   end TC_State;

   --================================

   task Original_Caller is
      entry Start;
   end Original_Caller;

   task Intermediate is
      entry Input;
      entry TC_Abort_Process_Complete;
   end Intermediate;
   
   task Receiver is
      entry Input;
   end Receiver;

   
   task body Original_Caller is
   begin 
      accept Start;    -- wait for the trigger from Main

      Intermediate.Input;
      Report.Failed ("Tasking_Error not raised in Original_Caller task");

   exception
      when tasking_error => 
               TC_State.Set_Original_Caller_Complete; -- expected behavior
      when others        => 
               Report.Failed ("Unexpected Exception in Original_Caller task");
   end Original_Caller;
   
   
   task body Intermediate is
   begin
      accept Input do
         -- Within this accept call another task
         TC_State.Set_On_Entry_Queue;
         requeue Receiver.Input with abort;  
         Report.Failed ("Requeue did not complete the Accept");
      end Input;

      -- Wait for Main to ensure that the abort housekeeping is finished
      accept TC_Abort_Process_Complete;

      TC_State.Set_Intermediate_Complete;

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


   task body Receiver is
   begin
      loop
         select
            -- A call to Input will be placed on the queue and never serviced
            when Report.Equal (1,2) =>     -- Always false
            accept Input do
               Report.Failed ("Receiver in Accept");  
            end Input;
         or 
            delay ImpDef.Minimum_Task_Switch;
         end select;
      end loop;
   exception
      when others =>
            Report.Failed ("Unexpected Exception in Receiver Task");
                                                          
   end Receiver;
   
   
begin

   Report.Test ("C954018", "Requeue: abort the called task" &
                           " while Caller is still queued");

   Original_Caller.Start;


   -- This is the main part of the test  

   -- Wait for the requeue
   while not TC_State.On_Entry_Queue loop
      delay ImpDef.Minimum_Task_Switch;
   end loop;

   -- Delay long enough to ensure that the requeue has "arrived" on 
   -- the entry queue.  Note: TC_State.Set_On_Entry_Queue is called the
   -- statement before the requeue
   --
   delay ImpDef.Switch_To_New_Task;

   -- At this point the Receiver is guaranteed to have the requeue on
   -- the entry queue
   --
   abort Receiver;
   
   -- Wait for the whole of the abort process to complete
   while not ( Original_Caller'terminated and Receiver'terminated ) loop
      delay ImpDef.Minimum_Task_Switch;
   end loop;


   -- Inform the Intermediate task that the process is complete to allow
   -- it to continue to completion itself
   Intermediate.TC_Abort_Process_Complete;

   -- Wait for everything to settle before reporting the result
   while not ( Intermediate'terminated ) loop
      delay ImpDef.Minimum_Task_Switch;
   end loop;
   

   if not ( TC_State.Original_Caller_Complete and 
            TC_State.Intermediate_Complete )       then
      Report.Failed ("Proper paths not traversed");
   end if;

   Report.Result;

end C954018;