annotate gcc/testsuite/ada/acats/tests/c5/c52103a.ada @ 111:04ced10e8804

gcc 7
author kono
date Fri, 27 Oct 2017 22:46:09 +0900
parents
children
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
rev   line source
111
kono
parents:
diff changeset
1 -- C52103A.ADA
kono
parents:
diff changeset
2
kono
parents:
diff changeset
3 -- Grant of Unlimited Rights
kono
parents:
diff changeset
4 --
kono
parents:
diff changeset
5 -- Under contracts F33600-87-D-0337, F33600-84-D-0280, MDA903-79-C-0687,
kono
parents:
diff changeset
6 -- F08630-91-C-0015, and DCA100-97-D-0025, the U.S. Government obtained
kono
parents:
diff changeset
7 -- unlimited rights in the software and documentation contained herein.
kono
parents:
diff changeset
8 -- Unlimited rights are defined in DFAR 252.227-7013(a)(19). By making
kono
parents:
diff changeset
9 -- this public release, the Government intends to confer upon all
kono
parents:
diff changeset
10 -- recipients unlimited rights equal to those held by the Government.
kono
parents:
diff changeset
11 -- These rights include rights to use, duplicate, release or disclose the
kono
parents:
diff changeset
12 -- released technical data and computer software in whole or in part, in
kono
parents:
diff changeset
13 -- any manner and for any purpose whatsoever, and to have or permit others
kono
parents:
diff changeset
14 -- to do so.
kono
parents:
diff changeset
15 --
kono
parents:
diff changeset
16 -- DISCLAIMER
kono
parents:
diff changeset
17 --
kono
parents:
diff changeset
18 -- ALL MATERIALS OR INFORMATION HEREIN RELEASED, MADE AVAILABLE OR
kono
parents:
diff changeset
19 -- DISCLOSED ARE AS IS. THE GOVERNMENT MAKES NO EXPRESS OR IMPLIED
kono
parents:
diff changeset
20 -- WARRANTY AS TO ANY MATTER WHATSOEVER, INCLUDING THE CONDITIONS OF THE
kono
parents:
diff changeset
21 -- SOFTWARE, DOCUMENTATION OR OTHER INFORMATION RELEASED, MADE AVAILABLE
kono
parents:
diff changeset
22 -- OR DISCLOSED, OR THE OWNERSHIP, MERCHANTABILITY, OR FITNESS FOR A
kono
parents:
diff changeset
23 -- PARTICULAR PURPOSE OF SAID MATERIAL.
kono
parents:
diff changeset
24 --*
kono
parents:
diff changeset
25 -- CHECK THAT LENGTHS MUST MATCH IN ARRAY AND SLICE ASSIGNMENTS.
kono
parents:
diff changeset
26 -- MORE SPECIFICALLY, TEST THAT ARRAY ASSIGNMENTS WITH MATCHING
kono
parents:
diff changeset
27 -- LENGTHS DO NOT CAUSE CONSTRAINT_ERROR TO BE RAISED AND
kono
parents:
diff changeset
28 -- ARE PERFORMED CORRECTLY.
kono
parents:
diff changeset
29 -- (OVERLAPS BETWEEN THE OPERANDS OF THE ASSIGNMENT STATEMENT
kono
parents:
diff changeset
30 -- ARE TREATED ELSEWHERE.)
kono
parents:
diff changeset
31
kono
parents:
diff changeset
32 -- DIVISION A : STATICALLY-DETERMINABLE NON-NULL LENGTHS.
kono
parents:
diff changeset
33
kono
parents:
diff changeset
34
kono
parents:
diff changeset
35 -- RM 07/20/81
kono
parents:
diff changeset
36 -- SPS 2/18/83
kono
parents:
diff changeset
37
kono
parents:
diff changeset
38 WITH REPORT;
kono
parents:
diff changeset
39 PROCEDURE C52103A IS
kono
parents:
diff changeset
40
kono
parents:
diff changeset
41 USE REPORT ;
kono
parents:
diff changeset
42
kono
parents:
diff changeset
43 BEGIN
kono
parents:
diff changeset
44
kono
parents:
diff changeset
45 TEST( "C52103A" , "CHECK THAT IN ARRAY ASSIGNMENTS AND IN SLICE" &
kono
parents:
diff changeset
46 " ASSIGNMENTS THE LENGTHS MUST MATCH" );
kono
parents:
diff changeset
47
kono
parents:
diff changeset
48
kono
parents:
diff changeset
49 -- IN THIS TEST WE CAN'T USE AGGREGATE ASSIGNMENT (EXCEPT WHEN
kono
parents:
diff changeset
50 -- THE AGGREGATES ARE STRING LITERALS); THEREFORE:
kono
parents:
diff changeset
51 --
kono
parents:
diff changeset
52 -- (1) ARRAYS WILL BE INITIALIZED BY INDIVIDUAL ASSIGNMENTS;
kono
parents:
diff changeset
53 -- (2) CAN'T USE NON-NULL CONSTANT ARRAYS.
kono
parents:
diff changeset
54
kono
parents:
diff changeset
55
kono
parents:
diff changeset
56 -- WE ASSUME THAT IN AN ARRAY_TYPE_DEFINITION THE INDEX PORTION
kono
parents:
diff changeset
57 -- AND THE COMPONENT_TYPE PORTION ARE FUNCTIONALLY ORTHOGONAL
kono
parents:
diff changeset
58 -- ALSO AT THE IMPLEMENTATION LEVEL, I.E. THAT THE CORRECTNESS
kono
parents:
diff changeset
59 -- OF THE ACCESSING MECHANISM FOR ARRAYS DOES NOT DEPEND ON
kono
parents:
diff changeset
60 -- COMPONENT_TYPE. ACCORDINGLY WE ARE TESTING FOR SOME BUT
kono
parents:
diff changeset
61 -- NOT ALL KINDS OF COMPONENT_TYPE. (COMPONENT_TYPES INCLUDED:
kono
parents:
diff changeset
62 -- INTEGER , CHARACTER , BOOLEAN .)
kono
parents:
diff changeset
63
kono
parents:
diff changeset
64
kono
parents:
diff changeset
65 -- CASES DISTINGUISHED: ( 8 SELECTED CASES ARE IMPLEMENTED)
kono
parents:
diff changeset
66 --
kono
parents:
diff changeset
67 -- ( THE SELECTIONS ARE 7 , 8 , 9 ,
kono
parents:
diff changeset
68 -- AND PRECISELY 5 CASES FROM THE
kono
parents:
diff changeset
69 -- TWO 5-CASE SERIES 2-3-4-5-6 AND
kono
parents:
diff changeset
70 -- 10-11-12-13-14)
kono
parents:
diff changeset
71 --
kono
parents:
diff changeset
72 -- ( IN THE CURRENT DIVISION, THE 5
kono
parents:
diff changeset
73 -- FLOATING SELECTIONS ARE 2-11-4-
kono
parents:
diff changeset
74 -- -13-6 ; THUS THE 8 SELECTIONS ARE
kono
parents:
diff changeset
75 -- 2-11-4-13-6-7-8-9 (IN THIS ORDER)
kono
parents:
diff changeset
76 -- .)
kono
parents:
diff changeset
77 --
kono
parents:
diff changeset
78 --
kono
parents:
diff changeset
79 -- ( EACH DIVISION COMPRISES 3 FILES,
kono
parents:
diff changeset
80 -- COVERING RESPECTIVELY THE FIRST
kono
parents:
diff changeset
81 -- 3 , NEXT 2 , AND LAST 3 OF THE 8
kono
parents:
diff changeset
82 -- SELECTIONS FOR THE DIVISION.)
kono
parents:
diff changeset
83 --
kono
parents:
diff changeset
84 --
kono
parents:
diff changeset
85 -- (1) ARRAY OBJECTS DECLARED IN THE SAME DECLARATION.
kono
parents:
diff changeset
86 -- (TWO-DIMENSIONAL; NON-CONSTRAINABLE TYPEMARK.)
kono
parents:
diff changeset
87 --
kono
parents:
diff changeset
88 -- (THIS WILL BE THE ONLY CASE INVOLVING OBJECTS DECLARED
kono
parents:
diff changeset
89 -- IN THE SAME DECLARATION.)
kono
parents:
diff changeset
90 --
kono
parents:
diff changeset
91 --
kono
parents:
diff changeset
92 -- (2) MULTIDIMENSIONAL ARRAY OBJECTS WHOSE TYPEMARKS WERE
kono
parents:
diff changeset
93 -- DEFINED WITHOUT EVER USING THE "BOX" COMPOUND SYMBOL.
kono
parents:
diff changeset
94 -- (TWO-DIMENSIONAL ARRAYS OF INTEGERS.)
kono
parents:
diff changeset
95 --
kono
parents:
diff changeset
96 -- (SLICING IS ILLEGAL; SINCE IN THIS TEST WE ARE NEVER
kono
parents:
diff changeset
97 -- USING AGGREGATES
kono
parents:
diff changeset
98 -- (EXCEPT FOR ONE-DIMENSIONAL ARRAYS OF CHARACTERS;
kono
parents:
diff changeset
99 -- SEE (5) )
kono
parents:
diff changeset
100 -- AND WE ARE NOT USING CONVERSION-TO-CONSTRAINED-TYPEMARKS
kono
parents:
diff changeset
101 -- (AS IN T1(ARR) , WHERE ARR IS AN ARRAY
kono
parents:
diff changeset
102 -- OBJECT AND T1 IS AN ARRAY TYPEMARK SIMILAR
kono
parents:
diff changeset
103 -- -- AS MORE PRECISELY SPECIFIED IN RM 4.6(B) --
kono
parents:
diff changeset
104 -- TO THE TYPEMARK OF ARR ),
kono
parents:
diff changeset
105 -- THE ARRAY ASSIGNMENT CANNOT INVOLVE ANY SLIDING,
kono
parents:
diff changeset
106 -- AND THE TYPEMARKS ARE ESSENTIALLY THE SAME.)
kono
parents:
diff changeset
107 --
kono
parents:
diff changeset
108 --
kono
parents:
diff changeset
109 -- (3) UNSLICED ONE-DIMENSIONAL ARRAY OBJECTS WHOSE TYPEMARKS
kono
parents:
diff changeset
110 -- WERE DEFINED WITHOUT EVER USING THE "BOX" SYMBOL
kono
parents:
diff changeset
111 -- AND FOR WHICH THE COMPONENT TYPE IS NOT 'CHARACTER' .
kono
parents:
diff changeset
112 -- ((ONE-DIMENSIONAL) ARRAYS OF INTEGERS.)
kono
parents:
diff changeset
113 --
kono
parents:
diff changeset
114 -- (SINCE WE ARE NOT USING AGGREGATES
kono
parents:
diff changeset
115 -- AND WE ARE NOT USING CONVERSION-TO-CONSTRAINED-TYPEMARKS,
kono
parents:
diff changeset
116 -- THE ARRAY ASSIGNMENT CANNOT INVOLVE ANY SLIDING,
kono
parents:
diff changeset
117 -- AND THE TYPEMARKS ARE ESSENTIALLY THE SAME.)
kono
parents:
diff changeset
118 --
kono
parents:
diff changeset
119 --
kono
parents:
diff changeset
120 -- (4) SLICED ONE-DIMENSIONAL ARRAY OBJECTS WHOSE TYPEMARKS
kono
parents:
diff changeset
121 -- WERE DEFINED WITHOUT EVER USING THE "BOX" SYMBOL
kono
parents:
diff changeset
122 -- AND FOR WHICH THE COMPONENT TYPE IS NOT 'CHARACTER' .
kono
parents:
diff changeset
123 -- ((ONE-DIMENSIONAL) ARRAYS OF INTEGERS.)
kono
parents:
diff changeset
124 --
kono
parents:
diff changeset
125 -- (THE ASSIGNMENT MAY REQUIRE SLIDING.)
kono
parents:
diff changeset
126 --
kono
parents:
diff changeset
127 -- (MOST SUBSEQUENT SUBCASES IN THIS TEST (OTHER THAN NULL
kono
parents:
diff changeset
128 -- ASSIGNMENTS) WILL INVOLVE SLIDING; WE ASSUME THAT
kono
parents:
diff changeset
129 -- SUBCASES WHICH WORK IN CONJUNCTION WITH SLIDING WORK
kono
parents:
diff changeset
130 -- ALSO WHEN NO SLIDING IS INVOLVED.)
kono
parents:
diff changeset
131 --
kono
parents:
diff changeset
132 --
kono
parents:
diff changeset
133 -- (5) UNSLICED ONE-DIMENSIONAL ARRAY OBJECTS WHOSE TYPEMARKS
kono
parents:
diff changeset
134 -- WERE DEFINED WITHOUT EVER USING THE "BOX" SYMBOL
kono
parents:
diff changeset
135 -- AND FOR WHICH THE COMPONENT TYPE IS 'CHARACTER' .
kono
parents:
diff changeset
136 --
kono
parents:
diff changeset
137 -- (STRING LITERALS ARE THE ONLY AGGREGATES WE ARE USING
kono
parents:
diff changeset
138 -- IN THIS TEST. TO FORCE SLIDING, THE LOWER LIMIT IMPLIED
kono
parents:
diff changeset
139 -- BY THE TYPEMARK WILL NOT BE 1 .)
kono
parents:
diff changeset
140 --
kono
parents:
diff changeset
141 --
kono
parents:
diff changeset
142 -- (6) SLICED ONE-DIMENSIONAL ARRAY OBJECTS WHOSE TYPEMARKS
kono
parents:
diff changeset
143 -- WERE DEFINED WITHOUT EVER USING THE "BOX" SYMBOL
kono
parents:
diff changeset
144 -- AND FOR WHICH THE COMPONENT TYPE IS 'CHARACTER' .
kono
parents:
diff changeset
145 --
kono
parents:
diff changeset
146 --
kono
parents:
diff changeset
147 -- (7) UNSLICED OBJECTS OF THE PREDEFINED TYPE 'STRING' (BY
kono
parents:
diff changeset
148 -- THEMSELVES).
kono
parents:
diff changeset
149 --
kono
parents:
diff changeset
150 --
kono
parents:
diff changeset
151 -- (8) SLICED OBJECTS OF THE PREDEFINED TYPE 'STRING' , WITH
kono
parents:
diff changeset
152 -- STRING LITERALS.
kono
parents:
diff changeset
153 --
kono
parents:
diff changeset
154 --
kono
parents:
diff changeset
155 -- (9) SLICED OBJECTS OF THE PREDEFINED TYPE 'STRING' (BY
kono
parents:
diff changeset
156 -- THEMSELVES).
kono
parents:
diff changeset
157 --
kono
parents:
diff changeset
158 --
kono
parents:
diff changeset
159 -- (-) CONSTRAINABLE TYPES: ONLY SUBTESTS 2, 3, 4, 5, 6
kono
parents:
diff changeset
160 -- WILL BE REPLICATED -- AS SUBTESTS 10, 11, 12, 13, 14 .
kono
parents:
diff changeset
161 --
kono
parents:
diff changeset
162 --
kono
parents:
diff changeset
163 -- (10) MULTIDIMENSIONAL ARRAY OBJECTS WHOSE TYPEMARKS WERE
kono
parents:
diff changeset
164 -- DEFINED USING THE "BOX" COMPOUND SYMBOL.
kono
parents:
diff changeset
165 -- (TWO-DIMENSIONAL ARRAYS OF INTEGERS.)
kono
parents:
diff changeset
166 --
kono
parents:
diff changeset
167 --
kono
parents:
diff changeset
168 -- (11) UNSLICED ONE-DIMENSIONAL ARRAY OBJECTS WHOSE TYPEMARKS
kono
parents:
diff changeset
169 -- WERE DEFINED USING THE "BOX" SYMBOL
kono
parents:
diff changeset
170 -- AND FOR WHICH THE COMPONENT TYPE IS NOT 'CHARACTER' .
kono
parents:
diff changeset
171 -- ((ONE-DIMENSIONAL) ARRAYS OF INTEGERS.)
kono
parents:
diff changeset
172 --
kono
parents:
diff changeset
173 --
kono
parents:
diff changeset
174 -- (12) SLICED ONE-DIMENSIONAL ARRAY OBJECTS WHOSE TYPEMARKS
kono
parents:
diff changeset
175 -- WERE DEFINED USING THE "BOX" SYMBOL
kono
parents:
diff changeset
176 -- AND FOR WHICH THE COMPONENT TYPE IS NOT 'CHARACTER' .
kono
parents:
diff changeset
177 -- ((ONE-DIMENSIONAL) ARRAYS OF BOOLEANS.)
kono
parents:
diff changeset
178 --
kono
parents:
diff changeset
179 --
kono
parents:
diff changeset
180 -- (13) UNSLICED ONE-DIMENSIONAL ARRAY OBJECTS WHOSE TYPEMARKS
kono
parents:
diff changeset
181 -- WERE DEFINED USING THE "BOX" SYMBOL
kono
parents:
diff changeset
182 -- AND FOR WHICH THE COMPONENT TYPE IS 'CHARACTER' .
kono
parents:
diff changeset
183 --
kono
parents:
diff changeset
184 -- (STRING LITERALS ARE THE ONLY AGGREGATES WE ARE USING
kono
parents:
diff changeset
185 -- IN THIS TEST. TO FORCE SLIDING, THE LOWER LIMIT IMPLIED
kono
parents:
diff changeset
186 -- BY THE TYPEMARK WILL NOT BE 1 .)
kono
parents:
diff changeset
187 --
kono
parents:
diff changeset
188 --
kono
parents:
diff changeset
189 -- (14) SLICED ONE-DIMENSIONAL ARRAY OBJECTS WHOSE TYPEMARKS
kono
parents:
diff changeset
190 -- WERE DEFINED USING THE "BOX" SYMBOL
kono
parents:
diff changeset
191 -- AND FOR WHICH THE COMPONENT TYPE IS 'CHARACTER' .
kono
parents:
diff changeset
192 --
kono
parents:
diff changeset
193 --
kono
parents:
diff changeset
194 --
kono
parents:
diff changeset
195 -- (-) SPECIAL CASES: NULL ARRAYS....... TREATED IN DIVISION B.
kono
parents:
diff changeset
196 -- SUPERLONG ARRAYS.. (TREATED FOR DYNAMIC
kono
parents:
diff changeset
197 -- ARRAYS ONLY,
kono
parents:
diff changeset
198 -- DIVISIONS C AND D .)
kono
parents:
diff changeset
199 --
kono
parents:
diff changeset
200 --
kono
parents:
diff changeset
201 -- (-) THE DYNAMIC-ARRAY COUNTERPARTS OF THESE TESTS ARE IN DI-
kono
parents:
diff changeset
202 -- VISIONS C (FOR NON-NULL ARRAYS) AND D (FOR NULL ARRAYS).
kono
parents:
diff changeset
203 --
kono
parents:
diff changeset
204 --
kono
parents:
diff changeset
205
kono
parents:
diff changeset
206
kono
parents:
diff changeset
207 -------------------------------------------------------------------
kono
parents:
diff changeset
208
kono
parents:
diff changeset
209 -- (2) MULTIDIMENSIONAL ARRAY OBJECTS WHOSE TYPEMARKS WERE
kono
parents:
diff changeset
210 -- DEFINED WITHOUT EVER USING THE "BOX" COMPOUND SYMBOL.
kono
parents:
diff changeset
211 -- (TWO-DIMENSIONAL ARRAYS OF INTEGERS.)
kono
parents:
diff changeset
212
kono
parents:
diff changeset
213 DECLARE
kono
parents:
diff changeset
214
kono
parents:
diff changeset
215 TYPE TA21 IS ARRAY( INTEGER RANGE 1..5 , INTEGER RANGE 0..7
kono
parents:
diff changeset
216 ) OF INTEGER ;
kono
parents:
diff changeset
217
kono
parents:
diff changeset
218 SUBTYPE TA22 IS TA21 ;
kono
parents:
diff changeset
219
kono
parents:
diff changeset
220 ARR21 : TA21 ;
kono
parents:
diff changeset
221 ARR22 : TA22 ;
kono
parents:
diff changeset
222
kono
parents:
diff changeset
223 BEGIN
kono
parents:
diff changeset
224
kono
parents:
diff changeset
225 -- INITIALIZATION OF RHS ARRAY:
kono
parents:
diff changeset
226
kono
parents:
diff changeset
227 FOR I IN 1..5 LOOP
kono
parents:
diff changeset
228
kono
parents:
diff changeset
229 FOR J IN 0..7 LOOP
kono
parents:
diff changeset
230 ARR21( I , J ) := I * I * J ;
kono
parents:
diff changeset
231 END LOOP;
kono
parents:
diff changeset
232
kono
parents:
diff changeset
233 END LOOP;
kono
parents:
diff changeset
234
kono
parents:
diff changeset
235
kono
parents:
diff changeset
236 -- ARRAY ASSIGNMENT:
kono
parents:
diff changeset
237
kono
parents:
diff changeset
238 ARR22 := ARR21 ;
kono
parents:
diff changeset
239
kono
parents:
diff changeset
240 -- CHECKING THE VALUES AFTER THE ARRAY ASSIGNMENT:
kono
parents:
diff changeset
241
kono
parents:
diff changeset
242 FOR I IN 1..5 LOOP
kono
parents:
diff changeset
243
kono
parents:
diff changeset
244 FOR J IN 0..7 LOOP
kono
parents:
diff changeset
245
kono
parents:
diff changeset
246 IF ARR22( I , J ) /= ( I-0 ) * ( I-0 ) * ( J-0 )
kono
parents:
diff changeset
247 THEN
kono
parents:
diff changeset
248 FAILED( "ARRAY ASSIGNMENT NOT CORRECT" );
kono
parents:
diff changeset
249 END IF;
kono
parents:
diff changeset
250
kono
parents:
diff changeset
251 END LOOP;
kono
parents:
diff changeset
252
kono
parents:
diff changeset
253 END LOOP;
kono
parents:
diff changeset
254
kono
parents:
diff changeset
255
kono
parents:
diff changeset
256 EXCEPTION
kono
parents:
diff changeset
257
kono
parents:
diff changeset
258 WHEN OTHERS =>
kono
parents:
diff changeset
259 FAILED( "EXCEPTION RAISED - SUBTEST 2" );
kono
parents:
diff changeset
260
kono
parents:
diff changeset
261 END ;
kono
parents:
diff changeset
262
kono
parents:
diff changeset
263
kono
parents:
diff changeset
264 -------------------------------------------------------------------
kono
parents:
diff changeset
265
kono
parents:
diff changeset
266 -- (11) UNSLICED ONE-DIMENSIONAL ARRAY OBJECTS WHOSE TYPEMARKS
kono
parents:
diff changeset
267 -- WERE DEFINED USING THE "BOX" SYMBOL
kono
parents:
diff changeset
268 -- AND FOR WHICH THE COMPONENT TYPE IS NOT 'CHARACTER' .
kono
parents:
diff changeset
269 -- ((ONE-DIMENSIONAL) ARRAYS OF INTEGERS.)
kono
parents:
diff changeset
270
kono
parents:
diff changeset
271 DECLARE
kono
parents:
diff changeset
272
kono
parents:
diff changeset
273 TYPE TABOX1 IS ARRAY( INTEGER RANGE <> ) OF INTEGER ;
kono
parents:
diff changeset
274
kono
parents:
diff changeset
275 SUBTYPE TABOX11 IS TABOX1( 1..5 ) ;
kono
parents:
diff changeset
276
kono
parents:
diff changeset
277 ARRX11 : TABOX11 ;
kono
parents:
diff changeset
278 ARRX12 : TABOX1( 5..9 );
kono
parents:
diff changeset
279
kono
parents:
diff changeset
280 BEGIN
kono
parents:
diff changeset
281
kono
parents:
diff changeset
282 -- INITIALIZATION OF RHS ARRAY:
kono
parents:
diff changeset
283
kono
parents:
diff changeset
284 FOR I IN 1..5 LOOP
kono
parents:
diff changeset
285 ARRX11( I ) := I * I ;
kono
parents:
diff changeset
286 END LOOP;
kono
parents:
diff changeset
287
kono
parents:
diff changeset
288
kono
parents:
diff changeset
289 -- ARRAY ASSIGNMENT:
kono
parents:
diff changeset
290
kono
parents:
diff changeset
291 ARRX12 := ARRX11 ;
kono
parents:
diff changeset
292
kono
parents:
diff changeset
293 -- CHECKING THE VALUES AFTER THE ARRAY ASSIGNMENT:
kono
parents:
diff changeset
294
kono
parents:
diff changeset
295 FOR I IN 5..9 LOOP
kono
parents:
diff changeset
296
kono
parents:
diff changeset
297 IF ARRX12( I ) /= ( I-4 ) * ( I-4 )
kono
parents:
diff changeset
298 THEN
kono
parents:
diff changeset
299 FAILED( "ARRAY ASSIGNMENT NOT CORRECT (11)" );
kono
parents:
diff changeset
300 END IF;
kono
parents:
diff changeset
301
kono
parents:
diff changeset
302 END LOOP;
kono
parents:
diff changeset
303
kono
parents:
diff changeset
304
kono
parents:
diff changeset
305 EXCEPTION
kono
parents:
diff changeset
306
kono
parents:
diff changeset
307 WHEN OTHERS =>
kono
parents:
diff changeset
308 FAILED( "EXCEPTION RAISED - SUBTEST 11" );
kono
parents:
diff changeset
309
kono
parents:
diff changeset
310 END ;
kono
parents:
diff changeset
311
kono
parents:
diff changeset
312
kono
parents:
diff changeset
313 -------------------------------------------------------------------
kono
parents:
diff changeset
314
kono
parents:
diff changeset
315 -- (4) SLICED ONE-DIMENSIONAL ARRAY OBJECTS WHOSE TYPEMARKS
kono
parents:
diff changeset
316 -- WERE DEFINED WITHOUT EVER USING THE "BOX" SYMBOL
kono
parents:
diff changeset
317 -- AND FOR WHICH THE COMPONENT TYPE IS NOT 'CHARACTER' .
kono
parents:
diff changeset
318 -- ((ONE-DIMENSIONAL) ARRAYS OF BOOLEANS.)
kono
parents:
diff changeset
319
kono
parents:
diff changeset
320 DECLARE
kono
parents:
diff changeset
321
kono
parents:
diff changeset
322 TYPE TA42 IS ARRAY( INTEGER RANGE 1..5 ) OF BOOLEAN ;
kono
parents:
diff changeset
323
kono
parents:
diff changeset
324 SUBTYPE TA41 IS TA42 ;
kono
parents:
diff changeset
325
kono
parents:
diff changeset
326 ARR41 : TA41 ;
kono
parents:
diff changeset
327 ARR42 : TA42 ;
kono
parents:
diff changeset
328
kono
parents:
diff changeset
329 BEGIN
kono
parents:
diff changeset
330
kono
parents:
diff changeset
331 -- INITIALIZATION OF RHS ARRAY:
kono
parents:
diff changeset
332
kono
parents:
diff changeset
333 FOR I IN 1..5 LOOP
kono
parents:
diff changeset
334 ARR41( I ) := FALSE ; -- VALUES WILL BE: F T F F T
kono
parents:
diff changeset
335 END LOOP;
kono
parents:
diff changeset
336
kono
parents:
diff changeset
337 ARR41(2) := TRUE ;
kono
parents:
diff changeset
338
kono
parents:
diff changeset
339 ARR41(5) := TRUE ; -- RHS VALUES ARE: F T F F T
kono
parents:
diff changeset
340
kono
parents:
diff changeset
341
kono
parents:
diff changeset
342 -- INITIALIZATION OF UNUSED COMPONENT OF LHS ARRAY:
kono
parents:
diff changeset
343
kono
parents:
diff changeset
344 ARR42( 1 ) := TRUE ;
kono
parents:
diff changeset
345
kono
parents:
diff changeset
346
kono
parents:
diff changeset
347 -- SLICE ASSIGNMENT:
kono
parents:
diff changeset
348
kono
parents:
diff changeset
349 ARR42(2..5) := ARR41(1..4) ;
kono
parents:
diff changeset
350
kono
parents:
diff changeset
351
kono
parents:
diff changeset
352 -- CHECKING THE VALUES AFTER THE SLICE ASSIGNMENT:
kono
parents:
diff changeset
353
kono
parents:
diff changeset
354 FOR I IN 2..5 LOOP
kono
parents:
diff changeset
355
kono
parents:
diff changeset
356 IF ARR42( I ) /= FALSE AND I /= 3
kono
parents:
diff changeset
357 THEN
kono
parents:
diff changeset
358 FAILED( "SLICE ASSIGNMENT NOT CORRECT (VALUES)" );
kono
parents:
diff changeset
359 ELSIF ARR42( I ) /= TRUE AND I = 3
kono
parents:
diff changeset
360 THEN
kono
parents:
diff changeset
361 FAILED( "SLICE ASSIGNMENT NOT CORRECT (VALUES)" );
kono
parents:
diff changeset
362 END IF;
kono
parents:
diff changeset
363
kono
parents:
diff changeset
364 END LOOP;
kono
parents:
diff changeset
365
kono
parents:
diff changeset
366 IF ARR42( 1 ) /= TRUE
kono
parents:
diff changeset
367 THEN
kono
parents:
diff changeset
368 FAILED( "SLICE ASSIGNMENT NOT CORRECT (SLIDING)" );
kono
parents:
diff changeset
369 END IF;
kono
parents:
diff changeset
370
kono
parents:
diff changeset
371 EXCEPTION
kono
parents:
diff changeset
372
kono
parents:
diff changeset
373 WHEN OTHERS =>
kono
parents:
diff changeset
374 FAILED( "EXCEPTION RAISED - SUBTEST 4" );
kono
parents:
diff changeset
375
kono
parents:
diff changeset
376 END ;
kono
parents:
diff changeset
377
kono
parents:
diff changeset
378
kono
parents:
diff changeset
379 -------------------------------------------------------------------
kono
parents:
diff changeset
380
kono
parents:
diff changeset
381
kono
parents:
diff changeset
382 RESULT ;
kono
parents:
diff changeset
383
kono
parents:
diff changeset
384
kono
parents:
diff changeset
385 END C52103A;