-- C954A03.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 statement in an accept_statement with -- parameters may requeue the entry call to a protected entry with no -- parameters. Check that, if the call is queued on the new entry's -- queue, the original caller remains blocked after the requeue, but -- the accept_statement containing the requeue is completed. -- -- Note that this test uses a requeue "with abort," although it does not -- check that such a requeued caller can be aborted; that feature is -- tested elsewhere. -- -- TEST DESCRIPTION: -- Declare a protected type which simulates a printer device driver -- (foundation code). -- -- Declare a task which simulates a printer server for multiple printers. -- -- For the protected type, declare an entry with a barrier that is set -- false by a protected procedure (which simulates starting a print job -- on the printer), and is set true by a second protected procedure (which -- simulates a handler called when the printer interrupts, indicating -- that printing is done). -- -- For the task, declare an entry whose corresponding accept statement -- contains a call to first protected procedure of the protected type -- (which sets the barrier of the protected entry to false), followed by -- a requeue with abort to the protected entry. Declare a second entry -- which does nothing. -- -- Declare a "requesting" task which calls the printer server task entry -- (and thus executes the requeue). Verify that, following the requeue, -- the requesting task remains blocked. Call the second entry of the -- printer server task (the acceptance of this entry call verifies that -- the requeue statement completed the entry call by the requesting task. -- Call the second protected procedure of the protected type (the -- interrupt handler) and verify that the protected entry completes for -- the requesting task (which verifies that the requeue statement queued -- the first task object to the protected entry). -- -- TEST FILES: -- This test depends on the following foundation code: -- -- F954A00.A -- -- -- CHANGE HISTORY: -- 06 Dec 94 SAIC ACVC 2.0 -- 10 Oct 96 SAIC Added pragma elaborate. -- --! package C954A03_0 is -- Printer server abstraction. -- Simulate a system with multiple printers. The entry Print requests -- that data be printed on the next available printer. The entry call -- is accepted when a printer is available, and completes when printing -- is done. task Printer_Server is entry Print (File_Name : String); -- Test the requeue statement. entry Verify_Results; -- Artifice for test purposes. end Printer_Server; end C954A03_0; --==================================================================-- with Report; with ImpDef; with F954A00; -- Printer device abstraction. use F954A00; pragma Elaborate(F954a00); package body C954A03_0 is -- Printer server abstraction. task body Printer_Server is Printers_Busy : Boolean := True; Index : Printer_ID := 1; Print_Accepted : Boolean := False; begin loop -- Wait for a printer to become available: while Printers_Busy loop Printers_Busy := False; -- Exit loop if -- entry accepted. select Printer(Index).Done_Printing; -- Accepted immed. -- when printer is -- available. else Index := 1 + (Index mod Number_Of_Printers);-- Entry not immed. Printers_Busy := True; -- accepted; keep end select; -- looping. -- Allow other tasks to get control delay ImpDef.Minimum_Task_Switch; end loop; -- Value of Index -- at loop exit -- identifies the -- avail. printer. -- Wait for a print request or terminate: select accept Print (File_Name : String) do Print_Accepted := True; -- Allow -- Verify_Results -- to be accepted. Printer(Index).Start_Printing (File_Name); -- Begin printing on -- the available -- -- -- printer. -- Requeue is tested here -- -- -- -- Requeue caller so requeue Printer(Index).Done_Printing -- server task free with abort; -- to accept other end Print; -- requests. or -- Guard ensures that Verify_Results cannot be accepted -- until after Print has been accepted. This avoids a -- race condition in the main program. when Print_Accepted => accept Verify_Results; -- Artifice for -- testing purposes. or terminate; end select; end loop; exception when others => Report.Failed ("Exception raised in Printer_Server task"); end Printer_Server; end C954A03_0; --==================================================================-- with Report; with ImpDef; with F954A00; -- Printer device abstraction. with C954A03_0; -- Printer server abstraction. use C954A03_0; use F954A00; procedure C954A03 is Long_Enough : constant Duration := ImpDef.Clear_Ready_Queue; --==============================================-- Task_Completed : Boolean := False; -- Testing flag. protected Interlock is -- Artifice for test purposes. entry Wait; -- Wait for lock to be released. procedure Release; -- Release the lock. private Locked : Boolean := True; end Interlock; protected body Interlock is entry Wait when not Locked is -- Calls are queued until after -- -- Release is called. begin Task_Completed := True; end Wait; procedure Release is -- Called by Print_Request. begin Locked := False; end Release; end Interlock; --==============================================-- task Print_Request is -- Send a print request. end Print_Request; task body Print_Request is My_File : constant String := "MYFILE.DAT"; begin Printer_Server.Print (My_File); -- Invoke requeue statement. Interlock.Release; -- Allow main to continue. exception when others => Report.Failed ("Exception raised in Print_Request task"); end Print_Request; --==============================================-- begin -- Main program. Report.Test ("C954A03", "Requeue from an Accept with parameters" & " to a Protected Entry without parameters"); -- To pass this test, the following must be true: -- -- (A) The Print entry call made by the task Print_Request must be -- completed by the requeue statement. -- (B) Print_Request must remain blocked following the requeue. -- (C) Print_Request must be queued on the Done_Printing queue of -- Printer(1). -- (D) Print_Request must continue execution after Done_Printing is -- complete. -- -- First, verify (A): that the Print entry call is complete. -- -- Call the entry Verify_Results. If the requeue statement completed the -- entry call to Print, the entry call to Verify_Results should be -- accepted. Since the main will hang if this is NOT the case, make this -- a timed entry call. select Printer_Server.Verify_Results; -- Accepted if requeue completed -- entry call to Print. or delay Long_Enough; -- Time out otherwise. Report.Failed ("Requeue did not complete entry call"); end select; -- Now verify (B): that Print_Request remains blocked following the -- requeue. Also verify that Done_Printing (the entry to which -- Print_Request should have been queued) has not yet executed. if Printer(1).Is_Done then Report.Failed ("Target entry of requeue executed prematurely"); elsif Print_Request'Terminated then Report.Failed ("Caller did not remain blocked after the requeue"); else -- Verify (C): that Print_Request is queued on the -- Done_Printing queue of Printer(1). -- -- Set the barrier for Printer(1).Done_Printing to true. Check -- that the Done flag is updated and that Print_Request terminates. Printer(1).Handle_Interrupt; -- Simulate a printer interrupt, -- signaling that printing is -- done. -- The Done_Printing entry body will complete before the next -- protected action is called (Printer(1).Is_Done). if not Printer(1).Is_Done then Report.Failed ("Caller was not requeued on target entry"); end if; -- Finally, verify (D): that Print_Request continues after Done_Printing -- completes. -- -- After Done_Printing completes, there is a potential race condition -- between the main program and Print_Request. The protected object -- Interlock is provided to ensure that the check of whether -- Print_Request continued is made *after* it has had a chance to do so. -- The main program waits until the statement in Print_Request following -- the requeue-causing statement has executed, then checks to see -- whether Print_Request did in fact continue executing. -- -- Note that the test will hang here if Print_Request does not continue -- executing following the completion of the requeued entry call. Interlock.Wait; -- Wait until Print_Request is -- done. if not Task_Completed then Report.Failed ("Caller remained blocked after target " & "entry released"); end if; -- Wait for Print_Request to finish before calling Report.Result. while not Print_Request'Terminated loop delay ImpDef.Minimum_Task_Switch; end loop; end if; Report.Result; end C954A03;