| -- CXB3015.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 the "+" and "-" functions with Pointer and ptrdiff_t |
| -- parameters that return Pointer values produce correct results, |
| -- based on the size of the array elements. |
| -- |
| -- Check that the "-" function with two Pointer parameters that |
| -- returns a ptrdiff_t type parameter produces correct results, |
| -- based on the size of the array elements. |
| -- |
| -- Check that each of the "+" and "-" functions above will |
| -- propagate Pointer_Error if a Pointer parameter is null. |
| -- |
| -- Check that the Increment and Decrement procedures provide the |
| -- correct "pointer arithmetic" operations. |
| -- |
| -- TEST DESCRIPTION: |
| -- This test checks that the functions "+" and "-", and the procedures |
| -- Increment and Decrement in the generic package Interfaces.C.Pointers |
| -- will allow the user to perform "pointer arithmetic" operations on |
| -- Pointer values. |
| -- Package Interfaces.C.Pointers is instantiated three times, for |
| -- short values, chars, and arrays of arrays. Pointers from each |
| -- instantiated package are then used to reference different elements |
| -- of array objects. Pointer arithmetic operations are performed on |
| -- these pointers, and the results of these operations are verified |
| -- against expected pointer positions along the referenced arrays. |
| -- The propagation of Pointer_Error is checked for when the function |
| -- Pointer parameter is null. |
| -- |
| -- The following chart indicates the combinations of subprograms and |
| -- parameter types used in this test. |
| -- |
| -- |
| -- Short Char Array |
| -- -------------------------- |
| -- "+" Pointer, ptrdiff_t | X | | X | |
| -- |--------------------------| |
| -- "+" ptrdiff_t, Pointer | X | | X | |
| -- |--------------------------| |
| -- "-" Pointer, ptrdiff_t | | X | X | |
| -- |--------------------------| |
| -- "-" Pointer, Pointer | | X | X | |
| -- |--------------------------| |
| -- Increment (Pointer) | X | | X | |
| -- |--------------------------| |
| -- Decrement (Pointer) | X | | X | |
| -- -------------------------- |
| -- |
| -- This test assumes that the following characters are all included |
| -- in the implementation defined type Interfaces.C.char: |
| -- ' ', and 'a'..'z'. |
| -- |
| -- APPLICABILITY CRITERIA: |
| -- This test is applicable to all implementations that provide |
| -- package Interfaces.C.Pointers. If an implementation provides |
| -- package Interfaces.C.Pointers, this test must compile, execute, and |
| -- report "PASSED". |
| -- |
| -- |
| -- CHANGE HISTORY: |
| -- 26 Oct 95 SAIC Initial prerelease version. |
| -- 13 May 96 SAIC Incorporated reviewer comments for ACVC 2.1. |
| -- 26 Oct 96 SAIC Incorporated reviewer comments. |
| -- 06 Mar 00 RLB Repaired so that array of arrays component |
| -- type is statically constrained. (C does not have |
| -- an analog to an array of dynamically constrained |
| -- arrays.) |
| |
| with Report; |
| with Ada.Exceptions; |
| with Interfaces.C.Pointers; -- N/A => ERROR |
| |
| procedure CXB3015 is |
| begin |
| |
| Report.Test ("CXB3015", "Check that +, -, Increment, and Decrement " & |
| "subprograms in Package Interfaces.C.Pointers " & |
| "produce correct results"); |
| |
| Test_Block: |
| declare |
| |
| use Ada.Exceptions; |
| use type Interfaces.C.short; |
| use type Interfaces.C.size_t, Interfaces.C.ptrdiff_t; |
| use type Interfaces.C.char, Interfaces.C.char_array; |
| |
| TC_Count : Interfaces.C.size_t; |
| TC_Increment : Interfaces.C.ptrdiff_t; |
| TC_ptrdiff_t : Interfaces.C.ptrdiff_t; |
| TC_Short : Interfaces.C.short := 0; |
| TC_Verbose : Boolean := False; |
| Constant_Min_Array_Size : constant Interfaces.C.size_t := 0; |
| Constant_Max_Array_Size : constant Interfaces.C.size_t := 20; |
| Min_Array_Size : Interfaces.C.size_t := Interfaces.C.size_t( |
| Report.Ident_Int(Integer(Constant_Min_Array_Size))); |
| Max_Array_Size : Interfaces.C.size_t := Interfaces.C.size_t( |
| Report.Ident_Int(Integer(Constant_Max_Array_Size))); |
| Min_size_t, |
| Max_size_t : Interfaces.C.size_t; |
| Short_Terminator : Interfaces.C.short := Interfaces.C.short'Last; |
| Alphabet : constant String := "abcdefghijklmnopqrstuvwxyz"; |
| |
| |
| type Short_Array_Type is |
| array (Interfaces.C.size_t range <>) of aliased Interfaces.C.short; |
| |
| type Constrained_Array_Type is |
| array (Min_Array_Size..Max_Array_Size) of aliased Interfaces.C.short; |
| |
| type Static_Constrained_Array_Type is |
| array (Constant_Min_Array_Size .. Constant_Max_Array_Size) of |
| aliased Interfaces.C.short; |
| |
| type Array_of_Arrays_Type is |
| array (Interfaces.C.size_t range <>) of aliased |
| Static_Constrained_Array_Type; |
| |
| |
| Short_Array : Short_Array_Type(Min_Array_Size..Max_Array_Size); |
| |
| Constrained_Array : Constrained_Array_Type; |
| |
| Terminator_Array : Static_Constrained_Array_Type := |
| (others => Short_Terminator); |
| |
| Ch_Array : Interfaces.C.char_array |
| (0..Interfaces.C.size_t(Alphabet'Length)) := |
| Interfaces.C.To_C(Alphabet, True); |
| |
| Array_of_Arrays : Array_of_Arrays_Type |
| (Min_Array_Size..Max_Array_Size); |
| |
| |
| package Short_Pointers is new |
| Interfaces.C.Pointers (Index => Interfaces.C.size_t, |
| Element => Interfaces.C.short, |
| Element_Array => Short_Array_Type, |
| Default_Terminator => Short_Terminator); |
| |
| package Char_Pointers is new |
| Interfaces.C.Pointers (Interfaces.C.size_t, |
| Interfaces.C.char, |
| Element_Array => Interfaces.C.char_array, |
| Default_Terminator => Interfaces.C.nul); |
| |
| package Array_Pointers is new |
| Interfaces.C.Pointers (Interfaces.C.size_t, |
| Static_Constrained_Array_Type, |
| Array_of_Arrays_Type, |
| Terminator_Array); |
| |
| |
| use Short_Pointers, Char_Pointers, Array_Pointers; |
| |
| Short_Ptr : Short_Pointers.Pointer := Short_Array(0)'Access; |
| Char_Ptr : Char_Pointers.Pointer := Ch_Array(0)'Access; |
| Start_Char_Ptr : Char_Pointers.Pointer := Ch_Array(1)'Access; |
| End_Char_Ptr : Char_Pointers.Pointer := Ch_Array(10)'Access; |
| Array_Ptr : Array_Pointers.Pointer := Array_of_Arrays(0)'Access; |
| Start_Array_Ptr : Array_Pointers.Pointer := Array_of_Arrays(1)'Access; |
| End_Array_Ptr : Array_Pointers.Pointer := Array_of_Arrays(10)'Access; |
| |
| begin |
| |
| -- Provide initial values for the arrays that hold short int values. |
| |
| for i in Min_Array_Size..Max_Array_Size-1 loop |
| Short_Array(i) := Interfaces.C.short(i); |
| for j in Min_Array_Size..Max_Array_Size loop |
| -- Initialize this "array of arrays" so that element (i)(0) |
| -- is different for each value of i. |
| Array_of_Arrays(i)(j) := TC_Short; |
| TC_Short := TC_Short + 1; |
| end loop; |
| end loop; |
| |
| -- Set the final element of each array object to be the "terminator" |
| -- element used in the instantiations above. |
| |
| Short_Array(Max_Array_Size) := Short_Terminator; |
| Array_of_Arrays(Max_Array_Size) := Terminator_Array; |
| |
| -- Check starting pointer positions. |
| |
| if Short_Ptr.all /= 0 or |
| Char_Ptr.all /= Ch_Array(0) or |
| Array_Ptr.all /= Array_of_Arrays(0) |
| then |
| Report.Failed("Incorrect initial value for the first " & |
| "Short_Array, Ch_Array, or Array_of_Array values"); |
| end if; |
| |
| |
| -- Check that both versions of the "+" function with Pointer and |
| -- ptrdiff_t parameters, that return a Pointer value, produce correct |
| -- results, based on the size of the array elements. |
| |
| for i in Min_Array_Size + 1 .. Max_Array_Size loop |
| |
| if Integer(i)/2*2 /= Integer(i) then -- Odd numbered loops. |
| -- Pointer + ptrdiff_t, increment by 1. |
| Short_Ptr := Short_Ptr + 1; |
| else -- Even numbered loops. |
| -- ptrdiff_t + Pointer, increment by 1. |
| Short_Ptr := 1 + Short_Ptr; |
| end if; |
| |
| if Short_Ptr.all /= Short_Array(i) then |
| Report.Failed("Incorrect value returned following use " & |
| "of the function +, incrementing by 1, " & |
| "array position : " & Integer'Image(Integer(i))); |
| if not TC_Verbose then |
| exit; |
| end if; |
| end if; |
| end loop; |
| |
| Array_Ptr := Array_of_Arrays(Min_Array_Size)'Access; |
| TC_Count := Min_Array_Size; |
| TC_Increment := 3; |
| while TC_Count+Interfaces.C.size_t(TC_Increment) < Max_Array_Size loop |
| |
| if Integer(TC_Count)/2*2 /= Integer(TC_Count) then |
| -- Odd numbered loops. |
| -- Pointer + ptrdiff_t, increment by 3. |
| Array_Ptr := Array_Pointers."+"(Array_Ptr, TC_Increment); |
| else |
| -- Odd numbered loops. |
| -- ptrdiff_t + Pointer, increment by 3. |
| Array_Ptr := Array_Pointers."+"(Left => TC_Increment, |
| Right => Array_Ptr); |
| end if; |
| |
| if Array_Ptr.all /= |
| Array_of_Arrays(TC_Count+Interfaces.C.size_t(TC_Increment)) |
| then |
| Report.Failed("Incorrect value returned following use " & |
| "of the function +, incrementing by " & |
| Integer'Image(Integer(TC_Increment)) & |
| ", array position : " & |
| Integer'Image(Integer(TC_Count) + |
| Integer(TC_Increment))); |
| if not TC_Verbose then |
| exit; |
| end if; |
| end if; |
| |
| TC_Count := TC_Count + Interfaces.C.size_t(TC_Increment); |
| end loop; |
| |
| |
| |
| -- Check that the "-" function with Pointer and ptrdiff_t parameters, |
| -- that returns a Pointer result, produces correct results, based |
| -- on the size of the array elements. |
| |
| -- Set the pointer to the last element in the char_array, which is a |
| -- nul char. |
| Char_Ptr := Ch_Array(Interfaces.C.size_t(Alphabet'Length))'Access; |
| |
| if Char_Ptr.all /= Interfaces.C.nul then |
| Report.Failed("Incorrect initial value for the last " & |
| "Ch_Array value"); |
| end if; |
| |
| Min_size_t := 1; |
| Max_size_t := Interfaces.C.size_t(Alphabet'Length); |
| |
| for i in reverse Min_size_t..Max_size_t loop |
| |
| -- Subtract 1 from the pointer; it should now point to the previous |
| -- element in the array. |
| Char_Ptr := Char_Ptr - 1; |
| |
| if Char_Ptr.all /= Ch_Array(i-1) then |
| Report.Failed("Incorrect value returned following use " & |
| "of the function '-' with char element values, " & |
| "array position : " & Integer'Image(Integer(i-1))); |
| if not TC_Verbose then |
| exit; |
| end if; |
| end if; |
| end loop; |
| |
| Array_Ptr := Array_of_Arrays(Max_Array_Size)'Access; |
| TC_Count := Max_Array_Size; |
| TC_Increment := 3; |
| while TC_Count > Min_Array_Size+Interfaces.C.size_t(TC_Increment) loop |
| |
| -- Decrement the pointer by 3. |
| Array_Ptr := Array_Pointers."-"(Array_Ptr, Right => 3); |
| |
| if Array_Ptr.all /= |
| Array_of_Arrays(TC_Count - Interfaces.C.size_t(TC_Increment)) |
| then |
| Report.Failed("Incorrect value returned following use " & |
| "of the function -, decrementing by " & |
| Integer'Image(Integer(TC_Increment)) & |
| ", array position : " & |
| Integer'Image(Integer(TC_Count-3))); |
| if not TC_Verbose then |
| exit; |
| end if; |
| end if; |
| |
| TC_Count := TC_Count - Interfaces.C.size_t(TC_Increment); |
| end loop; |
| |
| |
| |
| -- Check that the "-" function with two Pointer parameters, that |
| -- returns a ptrdiff_t type result, produces correct results, |
| -- based on the size of the array elements. |
| |
| TC_ptrdiff_t := 9; |
| if Char_Pointers."-"(Left => End_Char_Ptr, |
| Right => Start_Char_Ptr) /= TC_ptrdiff_t |
| then |
| Report.Failed("Incorrect result from pointer-pointer " & |
| "subtraction - 1"); |
| end if; |
| |
| Start_Char_Ptr := Ch_Array(1)'Access; |
| End_Char_Ptr := Ch_Array(25)'Access; |
| |
| TC_ptrdiff_t := 24; |
| if Char_Pointers."-"(End_Char_Ptr, |
| Right => Start_Char_Ptr) /= TC_ptrdiff_t |
| then |
| Report.Failed("Incorrect result from pointer-pointer " & |
| "subtraction - 2"); |
| end if; |
| |
| TC_ptrdiff_t := 9; |
| if Array_Pointers."-"(End_Array_Ptr, |
| Start_Array_Ptr) /= TC_ptrdiff_t |
| then |
| Report.Failed("Incorrect result from pointer-pointer " & |
| "subtraction - 3"); |
| end if; |
| |
| Start_Array_Ptr := Array_of_Arrays(Min_Array_Size)'Access; |
| End_Array_Ptr := Array_of_Arrays(Max_Array_Size)'Access; |
| |
| TC_ptrdiff_t := Interfaces.C.ptrdiff_t(Max_Array_Size) - |
| Interfaces.C.ptrdiff_t(Min_Array_Size); |
| if End_Array_Ptr - Start_Array_Ptr /= TC_ptrdiff_t then |
| Report.Failed("Incorrect result from pointer-pointer " & |
| "subtraction - 4"); |
| end if; |
| |
| |
| |
| -- Check that the Increment procedure produces correct results, |
| -- based upon the size of the array elements. |
| |
| Short_Ptr := Short_Array(0)'Access; |
| |
| for i in Min_Array_Size + 1 .. Max_Array_Size loop |
| -- Increment the value of the Pointer; it should now point |
| -- to the next element in the array. |
| Increment(Ref => Short_Ptr); |
| |
| if Short_Ptr.all /= Short_Array(i) then |
| Report.Failed("Incorrect value returned following use " & |
| "of the Procedure Increment on pointer to an " & |
| "array of short values, array position : " & |
| Integer'Image(Integer(i))); |
| if not TC_Verbose then |
| exit; |
| end if; |
| end if; |
| end loop; |
| |
| Array_Ptr := Array_of_Arrays(0)'Access; |
| |
| for i in Min_Array_Size + 1 .. Max_Array_Size loop |
| -- Increment the value of the Pointer; it should now point |
| -- to the next element in the array. |
| Increment(Array_Ptr); |
| |
| if Array_Ptr.all /= Array_of_Arrays(i) then |
| Report.Failed("Incorrect value returned following use " & |
| "of the Procedure Increment on an array of " & |
| "arrays, array position : " & |
| Integer'Image(Integer(i))); |
| if not TC_Verbose then |
| exit; |
| end if; |
| end if; |
| end loop; |
| |
| |
| -- Check that the Decrement procedure produces correct results, |
| -- based upon the size of the array elements. |
| |
| Short_Ptr := Short_Array(Max_Array_Size)'Access; |
| |
| for i in reverse Min_Array_Size .. Max_Array_Size - 1 loop |
| -- Decrement the value of the Pointer; it should now point |
| -- to the previous element in the array. |
| Decrement(Ref => Short_Ptr); |
| |
| if Short_Ptr.all /= Short_Array(i) then |
| Report.Failed("Incorrect value returned following use " & |
| "of the Procedure Decrement on pointer to an " & |
| "array of short values, array position : " & |
| Integer'Image(Integer(i))); |
| if not TC_Verbose then |
| exit; |
| end if; |
| end if; |
| end loop; |
| |
| Array_Ptr := Array_of_Arrays(Max_Array_Size)'Access; |
| |
| for i in reverse Min_Array_Size .. Max_Array_Size - 1 loop |
| -- Decrement the value of the Pointer; it should now point |
| -- to the previous array element. |
| Decrement(Array_Ptr); |
| |
| if Array_Ptr.all /= Array_of_Arrays(i) then |
| Report.Failed("Incorrect value returned following use " & |
| "of the Procedure Decrement on an array of " & |
| "arrays, array position : " & |
| Integer'Image(Integer(i))); |
| if not TC_Verbose then |
| exit; |
| end if; |
| end if; |
| end loop; |
| |
| |
| |
| -- Check that each of the "+" and "-" functions above will |
| -- propagate Pointer_Error if a Pointer parameter is null. |
| |
| begin |
| Short_Ptr := null; |
| Short_Ptr := Short_Ptr + 4; |
| Report.Failed("Pointer_Error not raised by Function + when " & |
| "the Pointer parameter is null"); |
| if Short_Ptr /= null then -- To avoid optimization. |
| Report.Comment("This should never be printed"); |
| end if; |
| exception |
| when Short_Pointers.Pointer_Error => null; -- OK, expected exception. |
| when others => |
| Report.Failed("Unexpected exception raised by Function + " & |
| "when the Pointer parameter is null"); |
| end; |
| |
| |
| begin |
| Char_Ptr := null; |
| Char_Ptr := Char_Ptr - 1; |
| Report.Failed("Pointer_Error not raised by Function - when " & |
| "the Pointer parameter is null"); |
| if Char_Ptr /= null then -- To avoid optimization. |
| Report.Comment("This should never be printed"); |
| end if; |
| exception |
| when Char_Pointers.Pointer_Error => null; -- OK, expected exception. |
| when others => |
| Report.Failed("Unexpected exception raised by Function - " & |
| "when the Pointer parameter is null"); |
| end; |
| |
| |
| begin |
| Array_Ptr := null; |
| Decrement(Array_Ptr); |
| Report.Failed("Pointer_Error not raised by Procedure Decrement " & |
| "when the Pointer parameter is null"); |
| if Array_Ptr /= null then -- To avoid optimization. |
| Report.Comment("This should never be printed"); |
| end if; |
| exception |
| when Array_Pointers.Pointer_Error => null; -- OK, expected exception. |
| when others => |
| Report.Failed("Unexpected exception raised by Procedure " & |
| "Decrement when the Pointer parameter is null"); |
| end; |
| |
| |
| exception |
| when The_Error : others => |
| Report.Failed ("The following exception was raised in the " & |
| "Test_Block: " & Exception_Name(The_Error)); |
| end Test_Block; |
| |
| Report.Result; |
| |
| end CXB3015; |
