Subversion Repositories openrisc_me

-- 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;