| 1 |
-- CXAC001.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 attribute T'Write will, for any specific non-limited |
| 28 |
-- type T, write an item of the subtype to the stream. |
| 29 |
-- |
| 30 |
-- Check that the attribute T'Read will, for a specific non-limited |
| 31 |
-- type T, read a value of the subtype from the stream. |
| 32 |
-- |
| 33 |
-- TEST DESCRIPTION: |
| 34 |
-- The scenario depicted in this test is that of an environment where |
| 35 |
-- product data is stored in stream form, then reconstructed into the |
| 36 |
-- appropriate data structures. Several records of product information |
| 37 |
-- are stored in an array; the array is passed as a parameter to a |
| 38 |
-- procedure for storage in the stream. A header is created based on the |
| 39 |
-- number of data records stored in the array. The header is then written |
| 40 |
-- to the stream, followed by each record maintained in the array. |
| 41 |
-- In order to retrieve data from the stream, the header information is |
| 42 |
-- read from the stream, and the data stored in the header is used to |
| 43 |
-- perform the appropriate number of read operations of record data from |
| 44 |
-- the stream. All data read from the stream is validated against the |
| 45 |
--- values that were written to the stream. |
| 46 |
-- |
| 47 |
-- APPLICABILITY CRITERIA: |
| 48 |
-- Applicable to all systems capable of supporting IO operations on |
| 49 |
-- external Stream_IO files. |
| 50 |
-- |
| 51 |
-- |
| 52 |
-- CHANGE HISTORY: |
| 53 |
-- 06 Dec 94 SAIC ACVC 2.0 |
| 54 |
-- 08 Nov 95 SAIC Corrected call to Read in Procedure Retrieve_Data |
| 55 |
-- for ACVC 2.0.1. |
| 56 |
-- 27 Feb 08 PWB.CTA Allowed for non-support of certain IO operations. |
| 57 |
--! |
| 58 |
|
| 59 |
with Ada.Streams.Stream_IO; |
| 60 |
with Report; |
| 61 |
|
| 62 |
procedure CXAC001 is |
| 63 |
|
| 64 |
package Strm_Pack renames Ada.Streams.Stream_IO; |
| 65 |
The_File : Strm_Pack.File_Type; |
| 66 |
The_Filename : constant String := |
| 67 |
Report.Legal_File_Name ( Nam => "CXAC001" ); |
| 68 |
Incomplete : exception; |
| 69 |
|
| 70 |
|
| 71 |
begin |
| 72 |
|
| 73 |
Report.Test ("CXAC001", "Check that the 'Read and 'Write attributes " & |
| 74 |
"will transfer an object of a specific, " & |
| 75 |
"non-limited type to/from a stream"); |
| 76 |
|
| 77 |
Test_for_Stream_IO_Support: |
| 78 |
begin |
| 79 |
|
| 80 |
-- If an implementation does not support Stream_IO in a particular |
| 81 |
-- environment, the exception Use_Error or Name_Error will be raised on |
| 82 |
-- calls to various Stream_IO operations. This block statement |
| 83 |
-- encloses a call to Create, which should produce an exception in a |
| 84 |
-- non-supportive environment. These exceptions will be handled to |
| 85 |
-- produce a Not_Applicable result. |
| 86 |
|
| 87 |
Strm_Pack.Create (The_File, Strm_Pack.Out_File, The_Filename); |
| 88 |
|
| 89 |
exception |
| 90 |
|
| 91 |
when Ada.Streams.Stream_IO.Use_Error | |
| 92 |
Ada.Streams.Stream_IO.Name_Error => |
| 93 |
Report.Not_Applicable |
| 94 |
( "Files not supported - Create as Out_File for Stream_IO" ); |
| 95 |
raise Incomplete; |
| 96 |
|
| 97 |
end Test_for_Stream_IO_Support; |
| 98 |
|
| 99 |
Operational_Test_Block: |
| 100 |
declare |
| 101 |
|
| 102 |
The_Stream : Strm_Pack.Stream_Access; |
| 103 |
Todays_Date : String (1 .. 6) := "271193"; |
| 104 |
|
| 105 |
type ID_Type is range 1 .. 100; |
| 106 |
type Size_Type is (Small, Medium, Large, XLarge); |
| 107 |
|
| 108 |
type Header_Type is record |
| 109 |
Number_of_Elements : Natural := 0; |
| 110 |
Origination_Date : String (1 .. 6); |
| 111 |
end record; |
| 112 |
|
| 113 |
type Data_Type is record |
| 114 |
ID : ID_Type; |
| 115 |
Size : Size_Type; |
| 116 |
end record; |
| 117 |
|
| 118 |
type Data_Array_Type is array (Positive range <>) of Data_Type; |
| 119 |
|
| 120 |
Product_Information_1 : Data_Array_Type (1 .. 3) := ((20, Large), |
| 121 |
(55, Small), |
| 122 |
(89, XLarge)); |
| 123 |
|
| 124 |
Product_Information_2 : Data_Array_Type (1 .. 4) := (( 5, XLarge), |
| 125 |
(27, Small), |
| 126 |
(79, Medium), |
| 127 |
(93, XLarge)); |
| 128 |
|
| 129 |
procedure Store_Data ( The_Stream : in Strm_Pack.Stream_Access; |
| 130 |
The_Array : in Data_Array_Type ) is |
| 131 |
Header : Header_Type; |
| 132 |
begin |
| 133 |
|
| 134 |
-- Fill in header info. |
| 135 |
Header.Number_of_Elements := The_Array'Length; |
| 136 |
Header.Origination_Date := Todays_Date; |
| 137 |
|
| 138 |
-- Write header to stream. |
| 139 |
Header_Type'Write (The_Stream, Header); |
| 140 |
|
| 141 |
-- Write each record in the array to the stream. |
| 142 |
for I in 1 .. Header.Number_of_Elements loop |
| 143 |
Data_Type'Write (The_Stream, The_Array (I)); |
| 144 |
end loop; |
| 145 |
|
| 146 |
end Store_Data; |
| 147 |
|
| 148 |
procedure Retrieve_Data (The_Stream : in Strm_Pack.Stream_Access; |
| 149 |
The_Header : out Header_Type; |
| 150 |
The_Array : out Data_Array_Type ) is |
| 151 |
begin |
| 152 |
|
| 153 |
-- Read header from the stream. |
| 154 |
Header_Type'Read (The_Stream, The_Header); |
| 155 |
|
| 156 |
-- Read the records from the stream into the array. |
| 157 |
for I in 1 .. The_Header.Number_of_Elements loop |
| 158 |
Data_Type'Read (The_Stream, The_Array (I)); |
| 159 |
end loop; |
| 160 |
|
| 161 |
end Retrieve_Data; |
| 162 |
|
| 163 |
begin |
| 164 |
|
| 165 |
-- Assign access value. |
| 166 |
The_Stream := Strm_Pack.Stream (The_File); |
| 167 |
|
| 168 |
-- Product information is to be stored in the stream file. These |
| 169 |
-- data arrays are of different sizes (actually, the records |
| 170 |
-- are stored individually, not as a single array). Prior to the |
| 171 |
-- record data being written, a header record is initialized with |
| 172 |
-- information about the data to be written, then itself is written |
| 173 |
-- to the stream. |
| 174 |
|
| 175 |
Store_Data (The_Stream, Product_Information_1); |
| 176 |
Store_Data (The_Stream, Product_Information_2); |
| 177 |
|
| 178 |
Test_Verification_Block: |
| 179 |
declare |
| 180 |
Product_Header_1 : Header_Type; |
| 181 |
Product_Header_2 : Header_Type; |
| 182 |
Product_Array_1 : Data_Array_Type (1 .. 3); |
| 183 |
Product_Array_2 : Data_Array_Type (1 .. 4); |
| 184 |
begin |
| 185 |
|
| 186 |
Reset1: |
| 187 |
begin |
| 188 |
Strm_Pack.Reset (The_File, Strm_Pack.In_File); |
| 189 |
exception |
| 190 |
when Ada.Streams.Stream_IO.Use_Error => |
| 191 |
Report.Not_Applicable |
| 192 |
( "Reset to In_File not supported for Stream_IO" ); |
| 193 |
raise Incomplete; |
| 194 |
end Reset1; |
| 195 |
|
| 196 |
-- Data is read from the stream, first the appropriate header, |
| 197 |
-- then the associated data records, which are then reconstructed |
| 198 |
-- into a data array of product information. |
| 199 |
|
| 200 |
Retrieve_Data (The_Stream, Product_Header_1, Product_Array_1); |
| 201 |
|
| 202 |
-- Validate a field in the header. |
| 203 |
if (Product_Header_1.Origination_Date /= Todays_Date) or |
| 204 |
(Product_Header_1.Number_of_Elements /= 3) |
| 205 |
then |
| 206 |
Report.Failed ("Incorrect Header_1 info read from stream"); |
| 207 |
end if; |
| 208 |
|
| 209 |
-- Validate the data records read from the file. |
| 210 |
for I in 1 .. Product_Header_1.Number_of_Elements loop |
| 211 |
if (Product_Array_1(I) /= Product_Information_1(I)) then |
| 212 |
Report.Failed ("Incorrect Product 1 info read from" & |
| 213 |
" record: " & Integer'Image (I)); |
| 214 |
end if; |
| 215 |
end loop; |
| 216 |
|
| 217 |
-- Repeat this read and verify operation for the next parcel of |
| 218 |
-- data. Again, header and data record information are read from |
| 219 |
-- the same stream file. |
| 220 |
Retrieve_Data (The_Stream, Product_Header_2, Product_Array_2); |
| 221 |
|
| 222 |
if (Product_Header_2.Origination_Date /= Todays_Date) or |
| 223 |
(Product_Header_2.Number_of_Elements /= 4) |
| 224 |
then |
| 225 |
Report.Failed ("Incorrect Header_2 info read from stream"); |
| 226 |
end if; |
| 227 |
|
| 228 |
for I in 1 .. Product_Header_2.Number_of_Elements loop |
| 229 |
if (Product_Array_2(I) /= Product_Information_2(I)) then |
| 230 |
Report.Failed ("Incorrect Product_2 info read from" & |
| 231 |
" record: " & Integer'Image (I)); |
| 232 |
end if; |
| 233 |
end loop; |
| 234 |
|
| 235 |
exception |
| 236 |
|
| 237 |
when Incomplete => |
| 238 |
raise; |
| 239 |
|
| 240 |
when Strm_Pack.End_Error => -- If correct number of |
| 241 |
-- items not in file (data |
| 242 |
-- overwritten), then fail. |
| 243 |
Report.Failed ("Incorrect number of record elements in file"); |
| 244 |
if not Strm_Pack.Is_Open (The_File) then |
| 245 |
Strm_Pack.Open (The_File, Strm_Pack.Out_File, The_Filename); |
| 246 |
end if; |
| 247 |
|
| 248 |
when others => |
| 249 |
Report.Failed ("Exception raised in Data Verification Block"); |
| 250 |
if not Strm_Pack.Is_Open (The_File) then |
| 251 |
Strm_Pack.Open (The_File, Strm_Pack.Out_File, The_Filename); |
| 252 |
end if; |
| 253 |
|
| 254 |
end Test_Verification_Block; |
| 255 |
|
| 256 |
exception |
| 257 |
|
| 258 |
when Incomplete => |
| 259 |
raise; |
| 260 |
|
| 261 |
when others => |
| 262 |
Report.Failed ("Exception raised in Operational Test Block"); |
| 263 |
|
| 264 |
end Operational_Test_Block; |
| 265 |
|
| 266 |
Deletion: |
| 267 |
begin |
| 268 |
-- Delete the file. |
| 269 |
if Strm_Pack.Is_Open (The_File) then |
| 270 |
Strm_Pack.Delete (The_File); |
| 271 |
else |
| 272 |
Strm_Pack.Open (The_File, Strm_Pack.Out_File, The_Filename); |
| 273 |
Strm_Pack.Delete (The_File); |
| 274 |
end if; |
| 275 |
|
| 276 |
exception |
| 277 |
|
| 278 |
when others => |
| 279 |
Report.Failed |
| 280 |
( "Delete not properly implemented for Stream_IO" ); |
| 281 |
end Deletion; |
| 282 |
|
| 283 |
Report.Result; |
| 284 |
|
| 285 |
exception |
| 286 |
when Incomplete => |
| 287 |
Report.Result; |
| 288 |
when others => |
| 289 |
Report.Failed ( "Unexpected exception" ); |
| 290 |
Report.Result; |
| 291 |
|
| 292 |
end CXAC001; |