| -- C57003A.ADA |
| |
| -- 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. |
| --* |
| -- CHECK THAT THE EXIT STATEMENT IS EVALUATED EACH TIME THROUGH A LOOP, |
| -- AND THAT IT IS EVALUATED CORRECTLY WHETHER POSITIONED AT THE |
| -- BEGINNING, MIDDLE, OR END OF THE LOOP. |
| |
| |
| |
| -- EACH TEST IS A LOOP ON J WHERE THE EXIT CONDITIONS ARE TO EVALUATE |
| -- TO 'FALSE' A CERTAIN NUMBER OF TIMES UNTIL, AT THE APPROPRIATE |
| -- TIME, ONE OF THEM EVALUATES TO 'TRUE' AND CAUSES THE LOOP TO BE |
| -- EXITED. |
| -- |
| -- |
| -- THE TEST IS PERFORMED 30 TIMES FOR EACH OF THE FIRST TWO |
| -- DATA TYPES CONSIDERED ('INTEGER', USER-DEFINED ENUMERATION) |
| -- AND 26 TIMES FOR 'CHARACTER' (THUS 86 TIMES ALTOGETHER). |
| -- |
| -- |
| -- EACH DATA TYPE HAS ITS OWN SEPARATE SECTION OF CODE. ALL SECTIONS |
| -- FOLLOW THE SAME TESTING ALGORITHM (MUTATIS MUTANDIS). THE CALCU- |
| -- LATIONS WHICH KEEP TRACK OF THE FLOW OF CONTROL ARE ALL DONE IN |
| -- INTEGER ARITHMETIC. THERE ARE THREE DATA TYPES, THUS THREE |
| -- SECTIONS. |
| -- |
| -- |
| -- FOR EACH DATA TYPE, THE 30 TESTS ARE DIVIDED INTO 3 "SEGMENTS" |
| -- |
| -- << NOTE: THE NUMBER OF SEGMENTS IS WRITTEN " 3 " , |
| -- THE NUMBER OF SECTIONS IS WRITTEN "THREE" >> |
| -- |
| -- (OF 10 TESTS EACH, EXCEPT 10,10,6 FOR 'CHARACTER'), NUMBERED |
| -- 0 , 1 , 2 AND CORRESPONDING TO THE 3 SIGNIFICANTLY DIFFERENT |
| -- POSITIONS OF AN EXIT STATEMENT WITH RESPECT TO THE LOOP IT IS IN |
| -- ( "AT THE VERY TOP" , "AT THE VERY BOTTOM" , "ANYWHERE IN BETWEEN" |
| -- ). AT THE BEGINNING OF EACH TEST, THE VARIABLE WHICH_SEGMENT |
| -- IS UPDATED TO CONTAIN THE NEW VALUE OF THIS IDENTIFYING NUMBER |
| -- (FOR THE TEST ABOUT TO BEGIN): |
| -- |
| -- EXIT AT THE TOP ........ WHICH_SEGMENT = 0 |
| -- EXIT FROM THE MIDDLE ........ WHICH_SEGMENT = 1 |
| -- EXIT AT THE BOTTOM ........ WHICH_SEGMENT = 2 . |
| -- |
| -- |
| -- WITHIN EACH SECTION, THE TESTS ARE NUMBERED FROM 1 TO 30 |
| -- (26 FOR 'CHARACTER'). THIS NUMBER IS STORED IN THE INTEGER |
| -- VARIABLE INT_I (EQUAL TO THE CURRENT VALUE OF THE OUTER-LOOP |
| -- INDEX WHEN THAT INDEX IS OF INTEGER TYPE), WHOSE APPROPRIATE VALUE |
| -- FOR EACH TEST IS SET AT THE BEGINNING OF THE TEST. |
| -- |
| -- |
| -- AS PART OF THE EVALUATION PROCESS, THE PROGRAM COMPUTES FOR EACH |
| -- TEST (I.E. FOR EACH VALUE OF I , OR OF INT_I ) THE APPROPRIATE |
| -- NUMBER OF INNER-LOOP ITERATIONS REQUIRED BEFORE EXIT; THIS IS |
| -- THE EXPECTED VALUE OF J (EXPRESSED AS AN INTEGER IN THE RANGE |
| -- 1..10 ) AND STORES IT IN EXPECTED_J . FOR EACH OF THE THREE |
| -- SECTIONS, THE TIME SEQUENCE OF THESE 30 VALUES IS |
| -- |
| -- 1 2 3 4 5 6 7 8 9 10 << SEGMENT 1 >> |
| -- 6 6 7 7 8 8 9 9 10 10 << SEGMENT 2 >> |
| -- 7 8 8 8 9 9 9 10 10 10 << SEGMENT 3 >> |
| -- |
| -- (EACH SECTION GETS ALL 3 ROWS, NOT ONE ROW PER SECTION; |
| -- FOR 'CHARACTER', WHERE ONLY 26 VALUES ARE REQUIRED, THE LAST 4 |
| -- VALUES ARE OMITTED). THIS NUMBER IS COMPARED WITH THE ACTUAL |
| -- VALUE OF J (ACTUAL NUMBER OF INNER-LOOP ITERATIONS BEFORE THE |
| -- EXECUTION OF THE EXIT STATEMENT) AS SAVED JUST BEFORE THE EXIT |
| -- FROM THE LOOP (AGAIN IN THE FORM OF AN INTEGER IN THE RANGE |
| -- 1..30 , IRRESPECTIVE OF THE DATA TYPE BEING TESTED), I F |
| -- SUCH SAVED VALUE IS AVAILABLE. |
| -- |
| -- |
| -- THE ACTUAL VALUE OF INNER-LOOP ITERATIONS (AS SAVED IMMEDIATELY |
| -- BEFORE THE EXIT, AS OPPOSED TO A VALUE LEFT OVER FROM SOME |
| -- PREVIOUS ITERATION) IS AVAILABLE ONLY IF WHICH_SEGMENT /= 0 , |
| -- AND IS THEN STORED IN SAVE_J . |
| -- |
| -- |
| -- FOR THE CASE WHICH_SEGMENT = 0 , THE ITERATIONS ARE COUNTED IN |
| -- THE VARIABLE COUNT , WHOSE VALUE AT THE COMPLETION OF THE |
| -- I-TH TEST ( I IN 1..10 ) MUST BE EQUAL TO EXPECTED_J - 1 , |
| -- AND THUS TO I - 1 (METHODOLOGICALLY AS WELL AS COMPUTATIONALLY |
| -- THIS IS NO DIFFERENT FROM USING THE MOST RECENT VALUE OF SAVE_J |
| -- WHEN A CURRENT ONE CANNOT BE OBTAINED). AFTER BEING INCREMENTED |
| -- BY 1 , COUNT IS CHECKED AGAINST EXPECTED_J . |
| -- |
| -- |
| -- THIS CONCLUDES THE DESCRIPTION OF THE CASE WHICH_SEGMENT = 0 , |
| -- AND THUS OF THE ALGORITHM. THE ONLY REASON FOR SPLITTING THE |
| -- CASE WHICH_SEGMENT /= 0 INTO TWO IS THE DESIRE TO PROVIDE FOR |
| -- DISTINCT MESSAGES. |
| |
| |
| |
| -- RM 04/23/81 |
| -- SPS 3/7/83 |
| |
| WITH REPORT; |
| PROCEDURE C57003A IS |
| |
| USE REPORT ; |
| |
| BEGIN |
| |
| TEST( "C57003A" , "TEST THAT THE EXIT STATEMENT IS EVALUATED" & |
| " EACH TIME THROUGH THE LOOP" ); |
| |
| DECLARE |
| |
| WHICH_SEGMENT : INTEGER RANGE 0..2 ; -- BOUNDS ARE TIGHT |
| SAVE_J : INTEGER RANGE 1..10 ; |
| EXPECTED_J : INTEGER RANGE 1..10 ; |
| COUNT : INTEGER RANGE 0..100 := 0 ; |
| INT_I : INTEGER RANGE 1..30 ; |
| |
| TYPE ENUM IS ( CHANGE_THE_ORIGIN_FROM_0_TO_1 , |
| |
| A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , |
| A11, A12, A13, A14, A15, A16, A17, A18, A19, A20 , |
| A21, A22, A23, A24, A25, A26, A27, A28, A29, A30 ); |
| |
| BEGIN |
| |
| |
| -------------------------------------------------------------- |
| ----------------------- INTEGER ---------------------------- |
| |
| |
| FOR I IN INTEGER RANGE 1..30 LOOP |
| |
| |
| WHICH_SEGMENT := ( I - 1 ) / 10 ; |
| EXPECTED_J := ( I + WHICH_SEGMENT ) / |
| ( WHICH_SEGMENT + 1 ) ; |
| |
| COUNT := 0 ; |
| |
| |
| FOR J IN INTEGER RANGE 1..10 LOOP |
| |
| -- J NOT SAVED HERE (SO THAT 'EXIT' BE FIRST STMT) |
| |
| EXIT WHEN WHICH_SEGMENT = 0 AND |
| 1*J >= I ;--COUNT+:=1 ON NXT LINE INSTEAD |
| COUNT := COUNT + 1 ; |
| |
| NULL ; |
| NULL ; |
| NULL ; |
| SAVE_J := J ; |
| EXIT WHEN WHICH_SEGMENT = 1 AND |
| 2*J >= I ; |
| |
| NULL ; |
| NULL ; |
| NULL ; |
| SAVE_J := J ; |
| EXIT WHEN WHICH_SEGMENT = 2 AND |
| 3*J >= I ; |
| |
| END LOOP; |
| |
| |
| COUNT := COUNT + 1 ; -- SEE HEADER |
| |
| CASE WHICH_SEGMENT IS |
| WHEN 0 => |
| IF COUNT /= EXPECTED_J THEN |
| FAILED( "WRONG COUNT; INT, EXIT AT TOP" ); |
| END IF; |
| WHEN 1 => -- WOULD WORK ALSO FOR 0 |
| IF SAVE_J /= EXPECTED_J THEN |
| FAILED( "WRONG COUNT; I,EXIT AT MIDDLE" ); |
| END IF; |
| WHEN 2 => |
| IF SAVE_J /= EXPECTED_J THEN |
| FAILED( "WRONG COUNT; I,EXIT AT BOTTOM" ); |
| END IF; |
| END CASE; |
| |
| END LOOP; |
| |
| |
| |
| -------------------------------------------------------------- |
| ---------------------- CHARACTER --------------------------- |
| |
| |
| FOR I IN CHARACTER RANGE 'A'..'Z' LOOP |
| |
| INT_I := CHARACTER'POS(I) - CHARACTER'POS('A') + 1; |
| |
| WHICH_SEGMENT := ( INT_I - 1 ) / 10 ; |
| EXPECTED_J := ( INT_I + WHICH_SEGMENT ) / |
| ( WHICH_SEGMENT + 1 ) ; |
| |
| COUNT := 0 ; |
| |
| |
| FOR J IN CHARACTER RANGE 'A'..'J' LOOP |
| |
| -- J NOT SAVED HERE (SO THAT 'EXIT' BE FIRST STMT) |
| |
| EXIT WHEN WHICH_SEGMENT = 0 AND |
| J >= I ; -- COUNT+:=1 ON NXT LINE INSTEAD |
| COUNT := COUNT + 1 ; |
| |
| NULL ; |
| NULL ; |
| NULL ; |
| SAVE_J := CHARACTER'POS(J) - CHARACTER'POS('A') + 1; |
| EXIT WHEN WHICH_SEGMENT = 1 AND |
| 2 * SAVE_J >= INT_I ; |
| |
| NULL ; |
| NULL ; |
| NULL ; |
| EXIT WHEN WHICH_SEGMENT = 2 AND |
| 3 * SAVE_J >= INT_I ; |
| |
| END LOOP; |
| |
| |
| COUNT := COUNT + 1 ; |
| |
| CASE WHICH_SEGMENT IS |
| WHEN 0 => |
| IF COUNT /= EXPECTED_J THEN |
| FAILED( "WRONG COUNT;CHAR, EXIT AT TOP" ); |
| END IF; |
| WHEN 1 => -- WOULD WORK ALSO FOR 0 |
| IF SAVE_J /= EXPECTED_J THEN |
| FAILED( "WRONG COUNT; C,EXIT AT MIDDLE" ); |
| END IF; |
| WHEN 2 => |
| IF SAVE_J /= EXPECTED_J THEN |
| FAILED( "WRONG COUNT; C,EXIT AT BOTTOM" ); |
| END IF; |
| END CASE; |
| |
| END LOOP; |
| |
| |
| |
| -------------------------------------------------------------- |
| --------------------- ENUMERATION -------------------------- |
| |
| |
| FOR I IN ENUM RANGE A1..A30 LOOP |
| |
| |
| INT_I := ENUM'POS(I) ; |
| |
| WHICH_SEGMENT := ( INT_I - 1 ) / 10 ; |
| EXPECTED_J := ( INT_I + WHICH_SEGMENT ) / |
| ( WHICH_SEGMENT + 1 ) ; |
| |
| COUNT := 0 ; |
| |
| |
| FOR J IN ENUM RANGE A1..A10 LOOP |
| |
| -- J NOT SAVED HERE (SO THAT 'EXIT' BE FIRST STMT) |
| |
| EXIT WHEN WHICH_SEGMENT = 0 AND |
| J >= I ; -- COUNT+:=1 ON NXT LINE INSTEAD |
| COUNT := COUNT + 1 ; |
| |
| NULL ; |
| NULL ; |
| NULL ; |
| SAVE_J := ENUM'POS(J) ; |
| EXIT WHEN WHICH_SEGMENT = 1 AND |
| 2 * SAVE_J >= INT_I ; |
| |
| NULL ; |
| NULL ; |
| NULL ; |
| EXIT WHEN WHICH_SEGMENT = 2 AND |
| 3 * SAVE_J >= INT_I ; |
| |
| END LOOP; |
| |
| |
| COUNT := COUNT + 1 ; |
| |
| CASE WHICH_SEGMENT IS |
| WHEN 0 => |
| IF COUNT /= EXPECTED_J THEN |
| FAILED( "WRONG COUNT;ENUM, EXIT AT TOP" ); |
| END IF; |
| WHEN 1 => -- WOULD WORK ALSO FOR 0 |
| IF SAVE_J /= EXPECTED_J THEN |
| FAILED( "WRONG COUNT; E,EXIT AT MIDDLE" ); |
| END IF; |
| WHEN 2 => |
| IF SAVE_J /= EXPECTED_J THEN |
| FAILED( "WRONG COUNT; E,EXIT AT BOTTOM" ); |
| END IF; |
| END CASE; |
| |
| END LOOP; |
| |
| -------------------------------------------------------------- |
| |
| END ; |
| |
| |
| RESULT ; |
| |
| |
| END C57003A ; |
