OpenCores
URL https://opencores.org/ocsvn/openrisc_me/openrisc_me/trunk

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gcc-4.5.1/] [gcc/] [testsuite/] [ada/] [acats/] [tests/] [cxb/] [cxb3015.a] - Blame information for rev 294

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 294 jeremybenn
-- CXB3015.A
2
--
3
--                             Grant of Unlimited Rights
4
--
5
--     Under contracts F33600-87-D-0337, F33600-84-D-0280, MDA903-79-C-0687,
6
--     F08630-91-C-0015, and DCA100-97-D-0025, the U.S. Government obtained
7
--     unlimited rights in the software and documentation contained herein.
8
--     Unlimited rights are defined in DFAR 252.227-7013(a)(19).  By making
9
--     this public release, the Government intends to confer upon all
10
--     recipients unlimited rights  equal to those held by the Government.
11
--     These rights include rights to use, duplicate, release or disclose the
12
--     released technical data and computer software in whole or in part, in
13
--     any manner and for any purpose whatsoever, and to have or permit others
14
--     to do so.
15
--
16
--                                    DISCLAIMER
17
--
18
--     ALL MATERIALS OR INFORMATION HEREIN RELEASED, MADE AVAILABLE OR
19
--     DISCLOSED ARE AS IS.  THE GOVERNMENT MAKES NO EXPRESS OR IMPLIED
20
--     WARRANTY AS TO ANY MATTER WHATSOEVER, INCLUDING THE CONDITIONS OF THE
21
--     SOFTWARE, DOCUMENTATION OR OTHER INFORMATION RELEASED, MADE AVAILABLE
22
--     OR DISCLOSED, OR THE OWNERSHIP, MERCHANTABILITY, OR FITNESS FOR A
23
--     PARTICULAR PURPOSE OF SAID MATERIAL.
24
--*
25
--
26
-- OBJECTIVE:
27
--      Check that the "+" and "-" functions with Pointer and ptrdiff_t
28
--      parameters that return Pointer values produce correct results,
29
--      based on the size of the array elements.
30
--
31
--      Check that the "-" function with two Pointer parameters that
32
--      returns a ptrdiff_t type parameter produces correct results,
33
--      based on the size of the array elements.
34
--
35
--      Check that each of the "+" and "-" functions above will
36
--      propagate Pointer_Error if a Pointer parameter is null.
37
--
38
--      Check that the Increment and Decrement procedures provide the
39
--      correct "pointer arithmetic" operations.
40
--
41
-- TEST DESCRIPTION:
42
--      This test checks that the functions "+" and "-", and the procedures
43
--      Increment and Decrement in the generic package Interfaces.C.Pointers
44
--      will allow the user to perform "pointer arithmetic" operations on
45
--      Pointer values.
46
--      Package Interfaces.C.Pointers is instantiated three times, for
47
--      short values, chars, and arrays of arrays.  Pointers from each
48
--      instantiated package are then used to reference different elements
49
--      of array objects.  Pointer arithmetic operations are performed on
50
--      these pointers, and the results of these operations are verified
51
--      against expected pointer positions along the referenced arrays.
52
--      The propagation of Pointer_Error is checked for when the function
53
--      Pointer parameter is null.
54
--
55
--      The following chart indicates the combinations of subprograms and
56
--      parameter types used in this test.
57
--
58
--
59
--                                 Short    Char    Array
60
--                               --------------------------
61
--      "+" Pointer, ptrdiff_t  |   X    |        |   X    |
62
--                              |--------------------------|
63
--      "+" ptrdiff_t, Pointer  |   X    |        |   X    |
64
--                              |--------------------------|
65
--      "-" Pointer, ptrdiff_t  |        |   X    |   X    |
66
--                              |--------------------------|
67
--      "-" Pointer, Pointer    |        |   X    |   X    |
68
--                              |--------------------------|
69
--      Increment (Pointer)     |   X    |        |   X    |
70
--                              |--------------------------|
71
--      Decrement (Pointer)     |   X    |        |   X    |
72
--                               --------------------------
73
--
74
--      This test assumes that the following characters are all included
75
--      in the implementation defined type Interfaces.C.char:
76
--      ' ', and 'a'..'z'.
77
--
78
-- APPLICABILITY CRITERIA:
79
--      This test is applicable to all implementations that provide
80
--      package Interfaces.C.Pointers.  If an implementation provides
81
--      package Interfaces.C.Pointers, this test must compile, execute, and
82
--      report "PASSED".
83
--
84
--
85
-- CHANGE HISTORY:
86
--      26 Oct 95   SAIC    Initial prerelease version.
87
--      13 May 96   SAIC    Incorporated reviewer comments for ACVC 2.1.
88
--      26 Oct 96   SAIC    Incorporated reviewer comments.
89
--      06 Mar 00   RLB     Repaired so that array of arrays component
90
--                          type is statically constrained. (C does not have
91
--                          an analog to an array of dynamically constrained
92
--                          arrays.)
93
 
94
with Report;
95
with Ada.Exceptions;
96
with Interfaces.C.Pointers;                                   -- N/A => ERROR
97
 
98
procedure CXB3015 is
99
begin
100
 
101
   Report.Test ("CXB3015", "Check that +, -, Increment, and Decrement "    &
102
                           "subprograms in Package Interfaces.C.Pointers " &
103
                           "produce correct results");
104
 
105
   Test_Block:
106
   declare
107
 
108
      use Ada.Exceptions;
109
      use type Interfaces.C.short;
110
      use type Interfaces.C.size_t, Interfaces.C.ptrdiff_t;
111
      use type Interfaces.C.char,   Interfaces.C.char_array;
112
 
113
      TC_Count         : Interfaces.C.size_t;
114
      TC_Increment     : Interfaces.C.ptrdiff_t;
115
      TC_ptrdiff_t     : Interfaces.C.ptrdiff_t;
116
      TC_Short         : Interfaces.C.short  :=   0;
117
      TC_Verbose       : Boolean             := False;
118
      Constant_Min_Array_Size   : constant Interfaces.C.size_t :=   0;
119
      Constant_Max_Array_Size   : constant Interfaces.C.size_t :=  20;
120
      Min_Array_Size   : Interfaces.C.size_t :=  Interfaces.C.size_t(
121
                         Report.Ident_Int(Integer(Constant_Min_Array_Size)));
122
      Max_Array_Size   : Interfaces.C.size_t :=  Interfaces.C.size_t(
123
                         Report.Ident_Int(Integer(Constant_Max_Array_Size)));
124
      Min_size_t,
125
      Max_size_t       : Interfaces.C.size_t;
126
      Short_Terminator : Interfaces.C.short  := Interfaces.C.short'Last;
127
      Alphabet         : constant String     := "abcdefghijklmnopqrstuvwxyz";
128
 
129
 
130
      type Short_Array_Type is
131
        array (Interfaces.C.size_t range <>) of aliased Interfaces.C.short;
132
 
133
      type Constrained_Array_Type is
134
        array (Min_Array_Size..Max_Array_Size) of aliased Interfaces.C.short;
135
 
136
      type Static_Constrained_Array_Type is
137
        array (Constant_Min_Array_Size .. Constant_Max_Array_Size) of
138
          aliased Interfaces.C.short;
139
 
140
      type Array_of_Arrays_Type is
141
        array (Interfaces.C.size_t range <>) of aliased
142
        Static_Constrained_Array_Type;
143
 
144
 
145
      Short_Array       : Short_Array_Type(Min_Array_Size..Max_Array_Size);
146
 
147
      Constrained_Array : Constrained_Array_Type;
148
 
149
      Terminator_Array  : Static_Constrained_Array_Type :=
150
                            (others => Short_Terminator);
151
 
152
      Ch_Array          : Interfaces.C.char_array
153
                            (0..Interfaces.C.size_t(Alphabet'Length)) :=
154
                              Interfaces.C.To_C(Alphabet, True);
155
 
156
      Array_of_Arrays   : Array_of_Arrays_Type
157
                            (Min_Array_Size..Max_Array_Size);
158
 
159
 
160
      package Short_Pointers is new
161
        Interfaces.C.Pointers (Index              => Interfaces.C.size_t,
162
                               Element            => Interfaces.C.short,
163
                               Element_Array      => Short_Array_Type,
164
                               Default_Terminator => Short_Terminator);
165
 
166
      package Char_Pointers is new
167
        Interfaces.C.Pointers (Interfaces.C.size_t,
168
                               Interfaces.C.char,
169
                               Element_Array      => Interfaces.C.char_array,
170
                               Default_Terminator => Interfaces.C.nul);
171
 
172
      package Array_Pointers is new
173
        Interfaces.C.Pointers (Interfaces.C.size_t,
174
                               Static_Constrained_Array_Type,
175
                               Array_of_Arrays_Type,
176
                               Terminator_Array);
177
 
178
 
179
      use Short_Pointers, Char_Pointers, Array_Pointers;
180
 
181
      Short_Ptr       : Short_Pointers.Pointer := Short_Array(0)'Access;
182
      Char_Ptr        : Char_Pointers.Pointer  := Ch_Array(0)'Access;
183
      Start_Char_Ptr  : Char_Pointers.Pointer  := Ch_Array(1)'Access;
184
      End_Char_Ptr    : Char_Pointers.Pointer  := Ch_Array(10)'Access;
185
      Array_Ptr       : Array_Pointers.Pointer := Array_of_Arrays(0)'Access;
186
      Start_Array_Ptr : Array_Pointers.Pointer := Array_of_Arrays(1)'Access;
187
      End_Array_Ptr   : Array_Pointers.Pointer := Array_of_Arrays(10)'Access;
188
 
189
   begin
190
 
191
      -- Provide initial values for the arrays that hold short int values.
192
 
193
      for i in Min_Array_Size..Max_Array_Size-1 loop
194
         Short_Array(i) := Interfaces.C.short(i);
195
         for j in Min_Array_Size..Max_Array_Size loop
196
            -- Initialize this "array of arrays" so that element (i)(0)
197
            -- is different for each value of i.
198
            Array_of_Arrays(i)(j) := TC_Short;
199
            TC_Short := TC_Short + 1;
200
         end loop;
201
      end loop;
202
 
203
      -- Set the final element of each array object to be the "terminator"
204
      -- element used in the instantiations above.
205
 
206
      Short_Array(Max_Array_Size)     := Short_Terminator;
207
      Array_of_Arrays(Max_Array_Size) := Terminator_Array;
208
 
209
      -- Check starting pointer positions.
210
 
211
      if Short_Ptr.all /= 0           or
212
         Char_Ptr.all  /= Ch_Array(0) or
213
         Array_Ptr.all /= Array_of_Arrays(0)
214
      then
215
         Report.Failed("Incorrect initial value for the first " &
216
                       "Short_Array, Ch_Array, or Array_of_Array values");
217
      end if;
218
 
219
 
220
      -- Check that both versions of the "+" function with Pointer and
221
      -- ptrdiff_t parameters, that return a Pointer value, produce correct
222
      -- results, based on the size of the array elements.
223
 
224
      for i in Min_Array_Size + 1 .. Max_Array_Size loop
225
 
226
         if Integer(i)/2*2 /= Integer(i)  then -- Odd numbered loops.
227
            -- Pointer + ptrdiff_t, increment by 1.
228
            Short_Ptr := Short_Ptr + 1;
229
         else                                  -- Even numbered loops.
230
            -- ptrdiff_t + Pointer, increment by 1.
231
            Short_Ptr := 1 + Short_Ptr;
232
         end if;
233
 
234
         if Short_Ptr.all /= Short_Array(i) then
235
            Report.Failed("Incorrect value returned following use " &
236
                          "of the function +, incrementing by 1, "  &
237
                          "array position : " & Integer'Image(Integer(i)));
238
            if not TC_Verbose then
239
               exit;
240
            end if;
241
         end if;
242
      end loop;
243
 
244
      Array_Ptr    := Array_of_Arrays(Min_Array_Size)'Access;
245
      TC_Count     := Min_Array_Size;
246
      TC_Increment := 3;
247
      while TC_Count+Interfaces.C.size_t(TC_Increment) < Max_Array_Size loop
248
 
249
         if Integer(TC_Count)/2*2 /= Integer(TC_Count) then
250
            -- Odd numbered loops.
251
            -- Pointer + ptrdiff_t, increment by 3.
252
            Array_Ptr := Array_Pointers."+"(Array_Ptr, TC_Increment);
253
         else
254
            -- Odd numbered loops.
255
            -- ptrdiff_t + Pointer, increment by 3.
256
            Array_Ptr := Array_Pointers."+"(Left  => TC_Increment,
257
                                            Right => Array_Ptr);
258
         end if;
259
 
260
         if Array_Ptr.all /=
261
            Array_of_Arrays(TC_Count+Interfaces.C.size_t(TC_Increment))
262
         then
263
            Report.Failed("Incorrect value returned following use " &
264
                          "of the function +, incrementing by "     &
265
                          Integer'Image(Integer(TC_Increment))      &
266
                          ", array position : "                     &
267
                          Integer'Image(Integer(TC_Count) +
268
                                        Integer(TC_Increment)));
269
            if not TC_Verbose then
270
               exit;
271
            end if;
272
         end if;
273
 
274
         TC_Count := TC_Count + Interfaces.C.size_t(TC_Increment);
275
      end loop;
276
 
277
 
278
 
279
      -- Check that the "-" function with Pointer and ptrdiff_t parameters,
280
      -- that returns a Pointer result, produces correct results, based
281
      -- on the size of the array elements.
282
 
283
      -- Set the pointer to the last element in the char_array, which is a
284
      -- nul char.
285
      Char_Ptr := Ch_Array(Interfaces.C.size_t(Alphabet'Length))'Access;
286
 
287
      if Char_Ptr.all /= Interfaces.C.nul then
288
         Report.Failed("Incorrect initial value for the last " &
289
                       "Ch_Array value");
290
      end if;
291
 
292
      Min_size_t := 1;
293
      Max_size_t := Interfaces.C.size_t(Alphabet'Length);
294
 
295
      for i in reverse Min_size_t..Max_size_t loop
296
 
297
         -- Subtract 1 from the pointer; it should now point to the previous
298
         -- element in the array.
299
         Char_Ptr := Char_Ptr - 1;
300
 
301
         if Char_Ptr.all /= Ch_Array(i-1) then
302
            Report.Failed("Incorrect value returned following use "        &
303
                          "of the function '-' with char element values, " &
304
                          "array position : " & Integer'Image(Integer(i-1)));
305
            if not TC_Verbose then
306
               exit;
307
            end if;
308
         end if;
309
      end loop;
310
 
311
      Array_Ptr    := Array_of_Arrays(Max_Array_Size)'Access;
312
      TC_Count     := Max_Array_Size;
313
      TC_Increment := 3;
314
      while TC_Count > Min_Array_Size+Interfaces.C.size_t(TC_Increment) loop
315
 
316
         -- Decrement the pointer by 3.
317
         Array_Ptr := Array_Pointers."-"(Array_Ptr, Right => 3);
318
 
319
         if Array_Ptr.all /=
320
            Array_of_Arrays(TC_Count - Interfaces.C.size_t(TC_Increment))
321
         then
322
            Report.Failed("Incorrect value returned following use " &
323
                          "of the function -, decrementing by "     &
324
                          Integer'Image(Integer(TC_Increment))      &
325
                          ", array position : "                     &
326
                          Integer'Image(Integer(TC_Count-3)));
327
            if not TC_Verbose then
328
               exit;
329
            end if;
330
         end if;
331
 
332
         TC_Count := TC_Count - Interfaces.C.size_t(TC_Increment);
333
      end loop;
334
 
335
 
336
 
337
      -- Check that the "-" function with two Pointer parameters, that
338
      -- returns a ptrdiff_t type result, produces correct results,
339
      -- based on the size of the array elements.
340
 
341
      TC_ptrdiff_t := 9;
342
      if Char_Pointers."-"(Left  => End_Char_Ptr,
343
                           Right => Start_Char_Ptr) /= TC_ptrdiff_t
344
      then
345
         Report.Failed("Incorrect result from pointer-pointer " &
346
                       "subtraction - 1");
347
      end if;
348
 
349
      Start_Char_Ptr := Ch_Array(1)'Access;
350
      End_Char_Ptr   := Ch_Array(25)'Access;
351
 
352
      TC_ptrdiff_t := 24;
353
      if Char_Pointers."-"(End_Char_Ptr,
354
                           Right => Start_Char_Ptr) /= TC_ptrdiff_t
355
      then
356
         Report.Failed("Incorrect result from pointer-pointer " &
357
                       "subtraction - 2");
358
      end if;
359
 
360
      TC_ptrdiff_t := 9;
361
      if Array_Pointers."-"(End_Array_Ptr,
362
                            Start_Array_Ptr) /= TC_ptrdiff_t
363
      then
364
         Report.Failed("Incorrect result from pointer-pointer " &
365
                       "subtraction - 3");
366
      end if;
367
 
368
      Start_Array_Ptr := Array_of_Arrays(Min_Array_Size)'Access;
369
      End_Array_Ptr   := Array_of_Arrays(Max_Array_Size)'Access;
370
 
371
      TC_ptrdiff_t := Interfaces.C.ptrdiff_t(Max_Array_Size) -
372
                      Interfaces.C.ptrdiff_t(Min_Array_Size);
373
      if End_Array_Ptr - Start_Array_Ptr /= TC_ptrdiff_t then
374
         Report.Failed("Incorrect result from pointer-pointer " &
375
                       "subtraction - 4");
376
      end if;
377
 
378
 
379
 
380
      -- Check that the Increment procedure produces correct results,
381
      -- based upon the size of the array elements.
382
 
383
      Short_Ptr := Short_Array(0)'Access;
384
 
385
      for i in Min_Array_Size + 1 .. Max_Array_Size loop
386
         -- Increment the value of the Pointer; it should now point
387
         -- to the next element in the array.
388
         Increment(Ref => Short_Ptr);
389
 
390
         if Short_Ptr.all /= Short_Array(i) then
391
            Report.Failed("Incorrect value returned following use "      &
392
                          "of the Procedure Increment on pointer to an " &
393
                          "array of short values, array position : "     &
394
                          Integer'Image(Integer(i)));
395
            if not TC_Verbose then
396
               exit;
397
            end if;
398
         end if;
399
      end loop;
400
 
401
      Array_Ptr := Array_of_Arrays(0)'Access;
402
 
403
      for i in Min_Array_Size + 1 .. Max_Array_Size loop
404
         -- Increment the value of the Pointer; it should now point
405
         -- to the next element in the array.
406
         Increment(Array_Ptr);
407
 
408
         if Array_Ptr.all /= Array_of_Arrays(i) then
409
            Report.Failed("Incorrect value returned following use "    &
410
                          "of the Procedure Increment on an array of " &
411
                          "arrays, array position : "                  &
412
                          Integer'Image(Integer(i)));
413
            if not TC_Verbose then
414
               exit;
415
            end if;
416
         end if;
417
      end loop;
418
 
419
 
420
      -- Check that the Decrement procedure produces correct results,
421
      -- based upon the size of the array elements.
422
 
423
      Short_Ptr := Short_Array(Max_Array_Size)'Access;
424
 
425
      for i in reverse Min_Array_Size .. Max_Array_Size - 1 loop
426
         -- Decrement the value of the Pointer; it should now point
427
         -- to the previous element in the array.
428
         Decrement(Ref => Short_Ptr);
429
 
430
         if Short_Ptr.all /= Short_Array(i) then
431
            Report.Failed("Incorrect value returned following use "      &
432
                          "of the Procedure Decrement on pointer to an " &
433
                          "array of short values, array position : "     &
434
                          Integer'Image(Integer(i)));
435
            if not TC_Verbose then
436
               exit;
437
            end if;
438
         end if;
439
      end loop;
440
 
441
      Array_Ptr := Array_of_Arrays(Max_Array_Size)'Access;
442
 
443
      for i in reverse Min_Array_Size .. Max_Array_Size - 1 loop
444
         -- Decrement the value of the Pointer; it should now point
445
         -- to the previous array element.
446
         Decrement(Array_Ptr);
447
 
448
         if Array_Ptr.all /= Array_of_Arrays(i) then
449
            Report.Failed("Incorrect value returned following use "    &
450
                          "of the Procedure Decrement on an array of " &
451
                          "arrays, array position : "                  &
452
                          Integer'Image(Integer(i)));
453
            if not TC_Verbose then
454
               exit;
455
            end if;
456
         end if;
457
      end loop;
458
 
459
 
460
 
461
      -- Check that each of the "+" and "-" functions above will
462
      -- propagate Pointer_Error if a Pointer parameter is null.
463
 
464
      begin
465
         Short_Ptr := null;
466
         Short_Ptr := Short_Ptr + 4;
467
         Report.Failed("Pointer_Error not raised by Function + when " &
468
                       "the Pointer parameter is null");
469
         if Short_Ptr /= null then  -- To avoid optimization.
470
            Report.Comment("This should never be printed");
471
         end if;
472
      exception
473
         when Short_Pointers.Pointer_Error => null; -- OK, expected exception.
474
         when others =>
475
           Report.Failed("Unexpected exception raised by Function + " &
476
                         "when the Pointer parameter is null");
477
      end;
478
 
479
 
480
      begin
481
         Char_Ptr := null;
482
         Char_Ptr := Char_Ptr - 1;
483
         Report.Failed("Pointer_Error not raised by Function - when " &
484
                       "the Pointer parameter is null");
485
         if Char_Ptr /= null then  -- To avoid optimization.
486
            Report.Comment("This should never be printed");
487
         end if;
488
      exception
489
         when Char_Pointers.Pointer_Error => null; -- OK, expected exception.
490
         when others =>
491
           Report.Failed("Unexpected exception raised by Function - " &
492
                         "when the Pointer parameter is null");
493
      end;
494
 
495
 
496
      begin
497
         Array_Ptr := null;
498
         Decrement(Array_Ptr);
499
         Report.Failed("Pointer_Error not raised by Procedure Decrement " &
500
                       "when the Pointer parameter is null");
501
         if Array_Ptr /= null then  -- To avoid optimization.
502
            Report.Comment("This should never be printed");
503
         end if;
504
      exception
505
         when Array_Pointers.Pointer_Error => null; -- OK, expected exception.
506
         when others =>
507
           Report.Failed("Unexpected exception raised by Procedure " &
508
                         "Decrement when the Pointer parameter is null");
509
      end;
510
 
511
 
512
   exception
513
      when The_Error : others =>
514
         Report.Failed ("The following exception was raised in the " &
515
                        "Test_Block: " & Exception_Name(The_Error));
516
   end Test_Block;
517
 
518
   Report.Result;
519
 
520
end CXB3015;

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.