| -- C954019.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 when a requeue is to the same entry the items go to the |
| -- right queue and that they are placed back on the end of the queue. |
| -- |
| -- TEST DESCRIPTION: |
| -- Simulate part of a message handling application where the messages are |
| -- composed of several segments. The sequence of the segments within the |
| -- message is specified by Seg_Sequence_No. The segments are handled by |
| -- different tasks and finally forwarded to an output driver. The |
| -- segments can arrive in any order but must be assembled into the proper |
| -- sequence for final output. There is a Sequencer task interposed |
| -- before the Driver. This takes the segments of the message off the |
| -- Ordering_Queue and those that are in the right order it sends on to |
| -- the driver; those that are out of order it places back on the end of |
| -- the queue. |
| -- |
| -- The test just simulates the arrival of the segments at the Sequencer. |
| -- The task generating the segments handshakes with the Sequencer during |
| -- the "Await Arrival" phase ensuring that the three segments of a |
| -- message arrive in REVERSE order (the End-of-Message segment arrives |
| -- first and the Header last). In the first cycle the sequencer pulls |
| -- segments off the queue and puts them back on the end till it |
| -- encounters the header. It checks the sequence of the ones it pulls |
| -- off in case the segments are being put back on in the wrong part of |
| -- the queue. Having cycled once through it no longer verifies the |
| -- sequence - it just executes the "application" code for the correct |
| -- order for dispatch to the driver. |
| -- |
| -- In this simple example no attempt is made to address segments of |
| -- another message arriving or any other error conditions (such as |
| -- missing segments, timing etc.) |
| -- |
| -- |
| -- CHANGE HISTORY: |
| -- 06 Dec 94 SAIC ACVC 2.0 |
| -- 19 Dec 94 SAIC Remove parameter from requeue statement |
| -- |
| --! |
| |
| with Report; |
| with ImpDef; |
| |
| procedure C954019 is |
| begin |
| |
| |
| Report.Test ("C954019", "Check Requeue to the same Accept"); |
| |
| declare -- encapsulate the test |
| |
| type Segment_Sequence is range 1..8; |
| Header : constant Segment_Sequence := Segment_Sequence'first; |
| |
| type Message_Segment is record |
| ID : integer; -- Message ID |
| Seg_Sequence_No : Segment_Sequence; -- Within the message |
| Alpha : string (1..128); |
| EOM : Boolean := false; -- true for final msg segment |
| end record; |
| type acc_Message_Segment is access Message_Segment; |
| |
| task TC_Simulate_Arrival; |
| |
| task type Carrier_Task is |
| entry Input ( Segment : acc_Message_Segment ); |
| end Carrier_Task; |
| type acc_Carrier_Task is access Carrier_Task; |
| |
| task Sequencer is |
| entry Ordering_Queue ( Segment : acc_Message_Segment ); |
| entry TC_Handshake_1; |
| entry TC_Handshake_2; |
| end Sequencer; |
| |
| task Output_Driver is |
| entry Input ( Segment : acc_Message_Segment ); |
| end Output_Driver; |
| |
| |
| -- Simulate the arrival of three message segments in REVERSE order |
| -- |
| task body TC_Simulate_Arrival is |
| begin |
| |
| for i in 1..3 loop |
| declare |
| -- Create a task for the next message segment |
| Next_Segment_Task : acc_Carrier_Task := new Carrier_Task; |
| -- Create a record for the next segment |
| Next_Segment : acc_Message_Segment := new Message_Segment; |
| begin |
| if i = 1 then |
| -- Build the EOM segment as the first to "send" |
| Next_Segment.Seg_Sequence_No := Header + 2; |
| Next_Segment.EOM := true; |
| elsif i = 2 then |
| -- Wait for the first segment to arrive at the Sequencer |
| -- before "sending" the second |
| Sequencer.TC_Handshake_1; |
| -- Build the segment |
| Next_Segment.Seg_Sequence_No := Header + 1; |
| else |
| -- Wait for the second segment to arrive at the Sequencer |
| -- before "sending" the third |
| Sequencer.TC_Handshake_2; |
| -- Build the segment. The last segment in order to |
| -- arrive will be the "header" segment |
| Next_Segment.Seg_Sequence_No := Header; |
| end if; |
| -- pass the record to its carrier |
| Next_Segment_Task.Input ( Next_Segment ); |
| end; |
| end loop; |
| exception |
| when others => |
| Report.Failed ("Unexpected Exception in TC_Simulate_Arrival"); |
| end TC_Simulate_Arrival; |
| |
| |
| -- One of these is generated for each message segment and the flow |
| -- of the segments through the system is controlled by the calls the |
| -- task makes and the requeues of those calls |
| -- |
| task body Carrier_Task is |
| This_Segment : acc_Message_Segment := new Message_Segment; |
| begin |
| accept Input ( Segment : acc_Message_Segment ) do |
| This_Segment.all := Segment.all; |
| end Input; |
| null; --:: stub. Pass the segment around the application as needed |
| |
| -- Now output the segment to the Output_Driver. First we have to |
| -- go through the Sequencer. |
| Sequencer.Ordering_Queue ( This_Segment ); |
| exception |
| when others => |
| Report.Failed ("Unexpected Exception in Carrier_Task"); |
| end Carrier_Task; |
| |
| |
| -- Pull segments off the Ordering_Queue and deliver them in the correct |
| -- sequence to the Output_Driver. |
| -- |
| task body Sequencer is |
| Next_Needed : Segment_Sequence := Header; |
| |
| TC_Await_Arrival : Boolean := true; |
| TC_First_Cycle : Boolean := true; |
| TC_Expected_Sequence : Segment_Sequence := Header+2; |
| begin |
| loop |
| select |
| accept Ordering_Queue ( Segment : acc_Message_Segment ) do |
| |
| --===================================================== |
| -- This part is all Test_Control code |
| |
| if TC_Await_Arrival then |
| -- We have to arrange that the segments arrive on the |
| -- queue in the right order, so we handshake with the |
| -- TC_Simulate_Arrival task to "send" only one at |
| -- a time |
| accept TC_Handshake_1; -- the first has arrived |
| -- and has been pulled off the |
| -- queue |
| |
| -- Wait for the second to arrive (the first has already |
| -- been pulled off the queue |
| while Ordering_Queue'count < 1 loop |
| delay ImpDef.Minimum_Task_Switch; |
| end loop; |
| -- |
| accept TC_Handshake_2; -- the second has arrived |
| |
| -- Wait for the third to arrive |
| while Ordering_Queue'count < 2 loop |
| delay ImpDef.Minimum_Task_Switch; |
| end loop; |
| |
| -- Subsequent passes through the loop, bypass this code |
| TC_Await_Arrival := false; |
| |
| |
| end if; -- await arrival |
| |
| if TC_First_Cycle then |
| -- Check the order of the original three |
| if Segment.Seg_Sequence_No /= TC_Expected_Sequence then |
| -- The segments are not being pulled off in the |
| -- expected sequence. This could occur if the |
| -- requeue is not putting them back on the end. |
| Report.Failed ("Sequencer: Segment out of sequence"); |
| end if; -- sequence check |
| -- Decrement the expected sequence |
| if TC_Expected_Sequence /= Header then |
| TC_Expected_Sequence := TC_Expected_Sequence - 1; |
| else |
| TC_First_Cycle := false; -- This is the Header - the |
| -- first two segments are |
| -- back on the queue |
| |
| end if; -- decrementing |
| end if; -- first pass |
| --===================================================== |
| |
| -- And this is the Application code |
| if Segment.Seg_Sequence_No = Next_Needed then |
| if Segment.EOM then |
| Next_Needed := Header; -- reset for next message |
| else |
| Next_Needed := Next_Needed + 1; |
| end if; |
| requeue Output_Driver.Input with abort; |
| Report.Failed ("Requeue did not complete accept body"); |
| else |
| -- Not the next needed - put it back on the queue |
| requeue Sequencer.Ordering_Queue; |
| Report.Failed ("Requeue did not complete accept body"); |
| end if; |
| end Ordering_Queue; |
| or |
| terminate; |
| end select; |
| end loop; |
| exception |
| when others => |
| Report.Failed ("Unexpected Exception in Sequencer"); |
| end Sequencer; |
| |
| |
| task body Output_Driver is |
| This_Segment : acc_Message_Segment := new Message_Segment; |
| |
| TC_Expected_Sequence : Segment_Sequence := Segment_Sequence'first; |
| TC_Segment_Total : integer := 0; |
| TC_Expected_Total : integer := 3; |
| begin |
| loop |
| -- Note: normally we would expect this Accept to be in a select |
| -- with terminate. For the test we exit the loop on completion |
| -- to give better control |
| accept Input ( Segment : acc_Message_Segment ) do |
| This_Segment.all := Segment.all; |
| end Input; |
| |
| null; --::: stub - output the next segment of the message |
| |
| -- The following is all test control code |
| -- |
| if This_Segment.Seg_Sequence_No /= TC_Expected_Sequence then |
| Report.Failed ("Output_Driver: Segment out of sequence"); |
| end if; |
| TC_Expected_Sequence := TC_Expected_Sequence + 1; |
| |
| -- Now count the number of segments |
| TC_Segment_Total := TC_Segment_Total + 1; |
| |
| -- Check the number and exit loop when complete |
| -- There must be exactly TC_Expected_Total in number and |
| -- the last one must be EOM |
| -- (test will hang if < TC_Expected_Total arrive |
| -- without EOM) |
| if This_Segment.EOM then |
| -- This is the last segment. |
| if TC_Segment_Total /= TC_Expected_Total then |
| Report.Failed ("EOM and wrong number of segments"); |
| end if; |
| exit; -- the loop and terminate the task |
| elsif TC_Segment_Total = TC_Expected_Total then |
| Report.Failed ("No EOM found"); |
| exit; |
| end if; |
| end loop; |
| exception |
| when others => |
| Report.Failed ("Unexpected Exception in Output_Driver"); |
| end Output_Driver; |
| |
| |
| |
| begin |
| |
| null; |
| |
| end; -- encapsulation |
| |
| Report.Result; |
| |
| end C954019; |
