| -- CXG1003.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 subprograms defined in the package Text_IO.Complex_IO |
| -- provide correct results. |
| -- |
| -- TEST DESCRIPTION: |
| -- The generic package Ada.Numerics.Generic_Complex_Types is instantiated |
| -- with a real type (new Float). The resulting new package is used as |
| -- the generic actual to package Complex_IO. |
| -- Two different versions of Put and Get are examined in this test, |
| -- those that input/output complex data values from/to Text_IO files, |
| -- and those that input/output complex data values from/to strings. |
| -- Two procedures are defined to perform the file data manipulations; |
| -- one to place complex data into the file, and one to retrieve the data |
| -- from the file and verify its correctness. |
| -- Complex data is also put into string variables using the Procedure |
| -- Put for strings, and this data is then retrieved and reconverted into |
| -- complex values using the Get procedure. |
| -- |
| -- |
| -- APPLICABILITY CRITERIA: |
| -- This test is only applicable to implementations that: |
| -- support Annex G, |
| -- support Text_IO and external files |
| -- |
| -- |
| -- CHANGE HISTORY: |
| -- 06 Dec 94 SAIC ACVC 2.0 |
| -- 29 Dec 94 SAIC Modified Width parameter in Get function calls. |
| -- 16 Nov 95 SAIC Corrected visibility problems for ACVC 2.0.1. |
| -- 29 Sep 96 SAIC Incorporated reviewer comments. |
| -- |
| --! |
| |
| with Ada.Text_IO.Complex_IO; |
| with Ada.Numerics.Generic_Complex_Types; |
| with Report; |
| |
| procedure CXG1003 is |
| begin |
| |
| Report.Test ("CXG1003", "Check that the subprograms defined in " & |
| "the package Text_IO.Complex_IO " & |
| "provide correct results"); |
| |
| Test_for_Text_IO_Support: |
| declare |
| use Ada; |
| |
| Data_File : Ada.Text_IO.File_Type; |
| Data_Filename : constant String := Report.Legal_File_Name; |
| |
| begin |
| |
| -- An application creates a text file in mode Out_File, with the |
| -- intention of entering complex data into the file as appropriate. |
| -- In the event that the particular environment where the application |
| -- is running does not support Text_IO, Use_Error or Name_Error will be |
| -- raised on calls to Text_IO operations. Either of these exceptions |
| -- will be handled to produce a Not_Applicable result. |
| |
| Text_IO.Create (File => Data_File, |
| Mode => Ada.Text_IO.Out_File, |
| Name => Data_Filename); |
| |
| Test_Block: |
| declare |
| |
| TC_Verbose : Boolean := False; |
| |
| type Real_Type is new Float; |
| |
| package Complex_Pack is new |
| Ada.Numerics.Generic_Complex_Types(Real_Type); |
| |
| package C_IO is new Ada.Text_IO.Complex_IO(Complex_Pack); |
| |
| use Ada.Text_IO, C_IO; |
| use type Complex_Pack.Complex; |
| |
| Number_Of_Complex_Items : constant := 6; |
| Number_Of_Error_Items : constant := 2; |
| |
| TC_Complex : Complex_Pack.Complex; |
| TC_Last_Character_Read : Positive; |
| |
| Complex_Array : array (1..Number_Of_Complex_Items) |
| of Complex_Pack.Complex := ( (3.0, 9.0), |
| (4.0, 7.0), |
| (5.0, 6.0), |
| (6.0, 3.0), |
| (2.0, 5.0), |
| (3.0, 7.0) ); |
| |
| |
| procedure Load_Data_File (The_File : in out Text_IO.File_Type) is |
| use Ada.Text_IO; |
| begin |
| -- This procedure does not create, open, or close the data file; |
| -- The_File file object must be Open at this point. |
| -- This procedure is designed to load complex data into a data |
| -- file twice, first using Text_IO, then Complex_IO. In this |
| -- first case, the complex data values are entered as strings, |
| -- assuming a variety of legal formats, as provided in the |
| -- reference manual. |
| |
| Put_Line(The_File, "(3.0, 9.0)"); |
| Put_Line(The_File, "+4. +7."); -- Relaxed real literal format. |
| Put_Line(The_File, "(5.0 6.)"); |
| Put_Line(The_File, "6., 3.0"); |
| Put_Line(The_File, " ( 2.0 , 5.0 ) "); |
| Put_Line(The_File, "("); -- Complex data separated over |
| Put_Line(The_File, "3.0"); -- several (5) lines. |
| Put_Line(The_File, " , "); |
| Put_Line(The_File, "7.0 "); |
| Put_Line(The_File, ")"); |
| |
| if TC_Verbose then |
| Report.Comment("Complex values entered into data file using " & |
| "Text_IO, Procedure Load_Data_File"); |
| end if; |
| |
| -- Use the Complex_IO procedure Put to enter Complex data items |
| -- into the data file. |
| -- Note: Data is being entered into the file for the *second* time |
| -- at this point. (Using Complex_IO here, Text_IO above) |
| |
| for i in 1..Number_Of_Complex_Items loop |
| C_IO.Put(File => The_File, |
| Item => Complex_Array(i), |
| Fore => 1, |
| Aft => 1, |
| Exp => 0); |
| end loop; |
| |
| if TC_Verbose then |
| Report.Comment("Complex values entered into data file using " & |
| "Complex_IO, Procedure Load_Data_File"); |
| end if; |
| |
| Put_Line(The_File, "(5A,3)"); -- data to raise Data_Error. |
| Put_Line(The_File, "(3.0,,8.0)"); -- data to raise Data_Error. |
| |
| end Load_Data_File; |
| |
| |
| |
| procedure Process_Data_File (The_File : in out Text_IO.File_Type) is |
| TC_Complex : Complex_Pack.Complex := (0.0, 0.0); |
| TC_Width : Integer := 0; |
| begin |
| -- This procedure does not create, open, or close the data file; |
| -- The_File file object must be Open at this point. |
| -- Use procedure Get (for Files) to extract the complex data from |
| -- the Text_IO file. This data was placed into the file using |
| -- Text_IO. |
| |
| |
| for i in 1..Number_Of_Complex_Items loop |
| |
| C_IO.Get(The_File, TC_Complex, TC_Width); |
| |
| if TC_Complex /= Complex_Array(i) then |
| Report.Failed("Incorrect complex data read from file " & |
| "when using Text_IO procedure Get, " & |
| "data item #" & Integer'Image(i)); |
| end if; |
| end loop; |
| |
| if TC_Verbose then |
| Report.Comment("First set of complex values extracted " & |
| "from data file using Complex_IO, " & |
| "Procedure Process_Data_File"); |
| end if; |
| |
| -- Use procedure Get (for Files) to extract the complex data from |
| -- the Text_IO file. This data was placed into the file using |
| -- procedure Complex_IO.Put. |
| -- Note: Data is being extracted from the file for the *second* |
| -- time at this point (Using Complex_IO here, Text_IO above) |
| |
| for i in 1..Number_Of_Complex_Items loop |
| |
| C_IO.Get(The_File, TC_Complex, TC_Width); |
| |
| if TC_Complex /= Complex_Array(i) then |
| Report.Failed("Incorrect complex data read from file " & |
| "when using Complex_IO procedure Get, " & |
| "data item #" & Integer'Image(i)); |
| end if; |
| end loop; |
| |
| if TC_Verbose then |
| Report.Comment("Second set of complex values extracted " & |
| "from data file using Complex_IO, " & |
| "Procedure Process_Data_File"); |
| end if; |
| |
| -- The final items in the Data_File are complex values with |
| -- incorrect syntax, which should raise Data_Error on an attempt |
| -- to read them from the file. |
| TC_Width := 10; |
| for i in 1..Number_Of_Error_Items loop |
| begin |
| C_IO.Get(The_File, TC_Complex, TC_Width); |
| Report.Failed |
| ("Exception Data_Error not raised when Complex_IO.Get " & |
| "was used to read complex data with incorrect " & |
| "syntax from the Data_File, data item #" & |
| Integer'Image(i)); |
| exception |
| when Ada.Text_IO.Data_Error => -- OK, expected exception. |
| Text_IO.Skip_Line(The_File); |
| when others => |
| Report.Failed |
| ("Unexpected exception raised when Complex_IO.Get " & |
| "was used to read complex data with incorrect " & |
| "syntax from the Data_File, data item #" & |
| Integer'Image(i)); |
| end; |
| end loop; |
| |
| if TC_Verbose then |
| Report.Comment("Erroneous set of complex values extracted " & |
| "from data file using Complex_IO, " & |
| "Procedure Process_Data_File"); |
| end if; |
| |
| |
| exception |
| when others => |
| Report.Failed |
| ("Unexpected exception raised in Process_Data_File"); |
| end Process_Data_File; |
| |
| |
| |
| begin -- Test_Block. |
| |
| -- Place complex values into data file. |
| |
| Load_Data_File(Data_File); |
| Text_IO.Close(Data_File); |
| |
| if TC_Verbose then |
| Report.Comment("Data file loaded with Complex values"); |
| end if; |
| |
| -- Read complex values from data file. |
| |
| Text_IO.Open(Data_File, Text_IO.In_File, Data_Filename); |
| Process_Data_File(Data_File); |
| |
| if TC_Verbose then |
| Report.Comment("Complex values extracted from data file"); |
| end if; |
| |
| |
| |
| -- Verify versions of Procedures Put and Get for Strings. |
| |
| declare |
| TC_String_Array : array (1..Number_Of_Complex_Items) |
| of String(1..15) := (others =>(others => ' ')); |
| begin |
| |
| -- Place complex values into strings using the Procedure Put. |
| |
| for i in 1..Number_Of_Complex_Items loop |
| C_IO.Put(To => TC_String_Array(i), |
| Item => Complex_Array(i), |
| Aft => 1, |
| Exp => 0); |
| end loop; |
| |
| if TC_Verbose then |
| Report.Comment("Complex values placed into string array"); |
| end if; |
| |
| -- Check the format of the strings containing a complex number. |
| -- The resulting strings are of 15 character length, with the |
| -- real component left justified within the string, followed by |
| -- a comma, and with the imaginary component and closing |
| -- parenthesis right justified in the string, with blank fill |
| -- for the balance of the string. |
| |
| if TC_String_Array(1) /= "(3.0, 9.0)" or |
| TC_String_Array(2) /= "(4.0, 7.0)" or |
| TC_String_Array(3) /= "(5.0, 6.0)" or |
| TC_String_Array(4) /= "(6.0, 3.0)" or |
| TC_String_Array(5) /= "(2.0, 5.0)" or |
| TC_String_Array(6) /= "(3.0, 7.0)" |
| then |
| Report.Failed("Incorrect format for complex values that " & |
| "have been placed into string variables " & |
| "using the Complex_IO.Put procedure for " & |
| "strings"); |
| end if; |
| |
| if TC_Verbose then |
| Report.Comment("String format of Complex values verified"); |
| end if; |
| |
| -- Get complex values from strings using the Procedure Get. |
| -- Compare with expected complex values. |
| |
| for i in 1..Number_Of_Complex_Items loop |
| |
| C_IO.Get(From => TC_String_Array(i), |
| Item => TC_Complex, |
| Last => TC_Last_Character_Read); |
| |
| if TC_Complex /= Complex_Array(i) then |
| Report.Failed("Incorrect complex data value obtained " & |
| "from String following use of Procedures " & |
| "Put and Get from Strings, Complex_Array " & |
| "item #" & Integer'Image(i)); |
| end if; |
| end loop; |
| |
| if TC_Verbose then |
| Report.Comment("Complex values removed from String array"); |
| end if; |
| |
| -- Verify that Layout_Error is raised if the given string is |
| -- too short to hold the formatted output. |
| Layout_Error_On_Put: |
| declare |
| Much_Too_Short : String(1..2); |
| Complex_Value : Complex_Pack.Complex := (5.0, 0.0); |
| begin |
| C_IO.Put(Much_Too_Short, Complex_Value); |
| Report.Failed("Layout_Error not raised by Procedure Put " & |
| "when the given string was too short to " & |
| "hold the formatted output"); |
| exception |
| when Layout_Error => null; -- OK, expected exception. |
| when others => |
| Report.Failed |
| ("Unexpected exception raised by Procedure Put when " & |
| "the given string was too short to hold the " & |
| "formatted output"); |
| end Layout_Error_On_Put; |
| |
| if TC_Verbose then |
| Report.Comment("Layout Errors verified"); |
| end if; |
| |
| exception |
| when others => |
| Report.Failed("Unexpected exception raised during the " & |
| "evaluation of Put and Get for Strings"); |
| end; |
| |
| |
| -- Place complex values into strings using a variety of legal |
| -- complex data formats. |
| declare |
| |
| type String_Ptr is access String; |
| |
| TC_Complex_String_Array : |
| array (1..Number_Of_Complex_Items) of String_Ptr := |
| (new String'( "(3.0, 9.0 )" ), |
| new String'( "+4.0 +7.0" ), |
| new String'( "(5.0 6.0)" ), |
| new String'( "6.0, 3.0" ), |
| new String'( " ( 2.0 , 5.0 ) " ), |
| new String'( "(3.0 7.0)" )); |
| |
| -- The following array contains Positive values that correspond |
| -- to the last character that will be read by Procedure Get when |
| -- given each of the above strings as input. |
| |
| TC_Last_Char_Array : array (1..Number_Of_Complex_Items) |
| of Positive := (12,10,9,8,20,22); |
| |
| begin |
| |
| -- Get complex values from strings using the Procedure Get. |
| -- Compare with expected complex values. |
| |
| for i in 1..Number_Of_Complex_Items loop |
| |
| C_IO.Get(TC_Complex_String_Array(i).all, |
| TC_Complex, |
| TC_Last_Character_Read); |
| |
| if TC_Complex /= Complex_Array(i) then |
| Report.Failed |
| ("Incorrect complex data value obtained from " & |
| "Procedure Get with complex data input of: " & |
| TC_Complex_String_Array(i).all); |
| end if; |
| |
| if TC_Last_Character_Read /= TC_Last_Char_Array(i) then |
| Report.Failed |
| ("Incorrect value returned as the last character of " & |
| "the input string processed by Procedure Get, " & |
| "string value : " & TC_Complex_String_Array(i).all & |
| " expected last character value read : " & |
| Positive'Image(TC_Last_Char_Array(i)) & |
| " last character value read : " & |
| Positive'Image(TC_Last_Character_Read)); |
| end if; |
| |
| end loop; |
| |
| if TC_Verbose then |
| Report.Comment("Complex values removed from strings and " & |
| "verified against expected values"); |
| end if; |
| |
| exception |
| when others => |
| Report.Failed("Unexpected exception raised during the " & |
| "evaluation of Get for Strings"); |
| end; |
| |
| exception |
| when others => Report.Failed ("Exception raised in Test_Block"); |
| end Test_Block; |
| |
| |
| -- Delete the external file. |
| if Ada.Text_IO.Is_Open(Data_File) then |
| Ada.Text_IO.Delete(Data_File); |
| else |
| Ada.Text_IO.Open(Data_File, |
| Ada.Text_IO.In_File, |
| Data_Filename); |
| Ada.Text_IO.Delete(Data_File); |
| end if; |
| |
| exception |
| |
| -- Since Use_Error can be raised if, for the specified mode, |
| -- the environment does not support Text_IO operations, the |
| -- following handlers are included: |
| |
| when Ada.Text_IO.Use_Error => |
| Report.Not_Applicable ("Use_Error raised on Text_IO Create"); |
| |
| when Ada.Text_IO.Name_Error => |
| Report.Not_Applicable ("Name_Error raised on Text_IO Create"); |
| |
| when others => |
| Report.Failed ("Unexpected exception raised on text file Create"); |
| |
| end Test_for_Text_IO_Support; |
| |
| Report.Result; |
| |
| end CXG1003; |
