-- C960004.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:
--      With the triggering statement being a delay and with the Asynchronous
--      Select statement being in a tasking situation complete the abortable
--      part before the delay expires.  Check that the delay is cancelled 
--      and that the optional statements in the triggering part are not
--      executed.
--
-- TEST DESCRIPTION:
--      Simulate the creation of a carrier task to control the output of 
--      a message via a line driver.  If the message sending process is 
--      not complete (the completion of the rendezvous) within a
--      specified time the carrier task is designed to take corrective action.
--      Use an asynchronous select to control the timing; arrange that
--      the abortable part (the rendezvous) completes almost immediately.
--      Check that the optional statements are not executed and that the
--      test completes well before the time of the trigger delay request thus
--      showing that it has been cancelled.
--                 
--
-- CHANGE HISTORY:
--      06 Dec 94   SAIC    ACVC 2.0
--
--!
         
                   
with Report;
with Ada.Calendar;
         
procedure C960004 is

   function "-" (Left, Right : Ada.Calendar.Time)
                                    return Duration  renames Ada.Calendar."-";
   TC_Start_Time      : Ada.Calendar.Time := Ada.Calendar.Clock;
   TC_Elapsed_Time    : duration;

   -- Note: a properly executing test will complete immediately.   
   Allowable_ACK_Time : duration := 600.0;         

begin

   Report.Test ("C960004", "ATC: When abortable part completes before " &
                             "a triggering delay, check that the delay " &
                             "is cancelled & optional statements " &
                             "are not performed. Tasking situation"); 

   declare  -- To get the Report.Result after all has completed

      type Sequence_Number is range 1..1_999_999;   -- Message Number
      subtype S_length_subtype  is integer range 1..80;

      type Message_Type (Max_String : S_length_subtype := 1) is
         record
            Message_Number    : Sequence_Number;
            Alpha             : string(1..Max_String);
         end record;

      -- TC:  Dummy message for the test
      Dummy_Alpha     : constant string := "This could be printed";
      Message_to_Send : Message_Type (Max_string => Dummy_Alpha'length);


      -- This is the carrier task.  One of these is created for each
      -- message that requires ACK
      --
      task type Require_ACK_task is 
         entry Message_In (Message_to_Send: Message_Type);
      end Require_ACK_task;      
      type acc_Require_ACK_task is access Require_ACK_task;


      --:::::::::::::::::::::::::::::::::
      -- There would also be another task type "No_ACK_Task" which would
      -- be the carrier task for those messages not requiring an ACK. 
      -- This task would call Send_Message.ACK_Not_Required.  It is not
      -- shown in this test as it is not used.
      --:::::::::::::::::::::::::::::::::


   
      task Send_Message is 
         entry ACK_Required     (Message_to_Send: Message_Type);
         entry ACK_Not_Required (Message_to_Send: Message_Type);
      end Send_Message;


      -- This is the carrier task.  One of these is created for each
      -- message that requires ACK
      --
      task body Require_ACK_task is 
         Hold_Message : Message_Type;

         procedure Time_Out (Failed_Message_Number : Sequence_Number) is
         begin
            -- Take remedial action on the timed-out message
            null;    -- stub

            Report.Failed ("Optional statements in triggering part" &
                                    " were performed");
         end Time_out;

      begin   
         accept Message_In (Message_to_Send: Message_Type) do
            Hold_Message := Message_to_Send;    -- to release caller
         end Message_In;

         -- Now put the message out to the Send_Message task and 
         -- wait (no more than Allowable_Ack_Time) for its completion
         --
         select
            delay Allowable_ACK_Time;
            -- ACK not received in specified time
            Time_out (Hold_Message.Message_Number);
         then abort
            -- If the rendezvous is not completed in the above time, this
            -- call is cancelled
            --    Note: for this test this call will complete immediately
            --          and thus the trigger should be cancelled
            Send_Message.ACK_Required (Hold_Message);
         end select;

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


      -- This is the Line Driver task
      --
      task body Send_Message is
         Hold_Non_ACK_Message : Message_Type;   
      begin
         loop
            select
               accept ACK_Required (Message_to_Send: Message_Type) do
                  -- Here send the message from within the rendezvous 
                  -- waiting for full transmission to complete
                  null;  -- stub
                  -- Note: In this test this accept will complete immediately
               end ACK_Required;
            or
               accept ACK_Not_Required (Message_to_Send: Message_Type) do
                  Hold_Non_ACK_Message := Message_to_Send;
               end ACK_Not_Required;
               -- Here send the message from outside the rendezvous
               null;  -- stub
            or 
               terminate;
            end select;
         end loop;
      exception
         when others => Report.Failed ("Unexpected exception in Send_Message");
      end Send_Message;

   begin -- declare
      -- Build a dummy message 
      Message_to_Send.Alpha          := Dummy_Alpha;
      Message_to_Send.Message_Number := 110_693;

      declare
         New_Require_ACK_task : acc_Require_ACK_task := 
                                             new Require_ACK_task;
      begin
         -- Create a carrier task for this message and pass the latter in
         New_Require_ACK_task.Message_In (Message_to_Send);
      end; -- declare

   end; -- declare

   --Once we are out of the above declarative region, all tasks have completed

   TC_Elapsed_Time := Ada.Calendar.Clock - TC_Start_Time;
   
   -- Check that the test has completed well before the time of the requested
   -- delay to ensure the delay was cancelled
   --
   if (TC_Elapsed_Time > Allowable_ACK_Time/2) then
      Report.Failed ("Triggering delay statement was not cancelled");
   end if;

   Report.Result;
end C960004;