Subversion Repositories openrisc_me

-- CXAA017.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 Ada.Text_IO function Look_Ahead sets parameter End_Of_Line

--      to True if at the end of a line; otherwise check that it returns the

--      next character from a file (without consuming it), while setting

--      End_Of_Line to False.

--

--      Check that Ada.Text_IO function Get_Immediate will return the next

--      control or graphic character in parameter Item from the specified

--      file.  Check that the version of Ada.Text_IO function Get_Immediate

--      with the Available parameter will, if a character is available in the

--      specified file, return the character in parameter Item, and set

--      parameter Available to True.

--

-- TEST DESCRIPTION:

--      This test exercises specific capabilities of two Text_IO subprograms,

--      Look_Ahead and Get_Immediate.  A file is prepared that contains a

--      variety of graphic and control characters on several lines.

--      In processing this file, a call to Look_Ahead is performed to ensure

--      that characters are available, then individual characters are

--      extracted from the current line using Get_Immediate.  The characters

--      returned from both subprogram calls are compared with the expected

--      character result.  Processing on each file line continues until

--      Look_Ahead indicates that the end of the line is next.  Separate

--      verification is performed to ensure that all characters of each line

--      are processed, and that the Available and End_Of_Line parameters

--      of the subprograms are properly set in the appropriate instances.

--

-- APPLICABILITY CRITERIA:

--      This test is applicable to implementations capable of supporting

--      external Text_IO files.

--

--

-- CHANGE HISTORY:

--      30 May 95   SAIC    Initial prerelease version.

--      01 May 96   SAIC    Incorporated reviewer comments for ACVC 2.1.

--      26 Feb 97   PWB.CTA Allowed for non-support of some IO operations.

--!

with Ada.Text_IO;

package CXAA017_0 is

   User_Defined_Input_File : aliased Ada.Text_IO.File_Type;

end CXAA017_0;

with CXAA017_0; use CXAA017_0;

with Ada.Characters.Latin_1;

with Ada.Exceptions;

with Ada.Text_IO;

with Report;

procedure CXAA017 is

   use Ada.Characters.Latin_1;

   use Ada.Exceptions;

   use Ada.Text_IO;

   Non_Applicable_System : exception;

   No_Reset            : exception;

begin

   Report.Test ("CXAA017", "Check that Ada.Text_IO subprograms "         &

                           "Look_Ahead and Get_Immediate are available " &

                           "and produce correct results");

   Test_Block:

   declare

      User_Input_Ptr    : File_Access := User_Defined_Input_File'Access;

      UDLA_Char,          -- Acronym UDLA => "User Defined Look Ahead"

      UDGI_Char,          -- Acronym UDGI => "User Defined Get Immediate"

      TC_Char           : Character := Ada.Characters.Latin_1.NUL;

      UDLA_End_Of_Line,

      UDGI_Available    : Boolean   := False;

      Char_Pos          : Natural;

      -- This string contains five ISO 646 Control characters and six ISO 646

      -- Graphic characters:

      TC_String_1  : constant String := STX       &

                                        SI        &

                                        DC2       &

                                        CAN       &

                                        US        &

                                        Space     &

                                        Ampersand &

                                        Solidus   &

                                        'A'       &

                                        LC_X      &

                                        DEL;

      -- This string contains two ISO 6429 Control and six ISO 6429 Graphic

      -- characters:

      TC_String_2  : constant String := IS4                         &

                                        SCI                         &

                                        Yen_Sign                    &

                                        Masculine_Ordinal_Indicator &

                                        UC_I_Grave                  &

                                        Multiplication_Sign         &

                                        LC_C_Cedilla                &

                                        LC_Icelandic_Thorn;

      TC_Number_Of_Strings : constant := 2;

      type String_Access_Type    is access constant String;

      type String_Ptr_Array_Type is

        array (1..TC_Number_Of_Strings) of String_Access_Type;

      TC_String_Ptr_Array : String_Ptr_Array_Type :=

                              (new String'(TC_String_1),

                               new String'(TC_String_2));

      procedure Create_New_File (The_File : in out File_Type;

                                 Mode     : in     File_Mode;

                                 Next     : in     Integer) is

      begin

         Create (The_File, Mode, Report.Legal_File_Name(Next));

      exception

         -- The following two exceptions can be raised if a system is not

         -- capable of supporting external Text_IO files.  The handler will

         -- raise a user-defined exception which will result in a

         -- Not_Applicable result for the test.

         when Use_Error | Name_Error => raise Non_Applicable_System;

      end Create_New_File;

      procedure Load_File (The_File : in out File_Type) is

      -- This procedure will load several strings into the file denoted

      -- by the input parameter.  A call to New_Line will add line/page

      -- termination characters, which will be available  for processing

      -- along with the text in the file.

      begin

         Put_Line (The_File, TC_String_Ptr_Array(1).all);

         New_Line (The_File, Spacing => 1);

         Put_Line (The_File, TC_String_Ptr_Array(2).all);

      end Load_File;

   begin

      -- Create user-defined text file that will serve as the appropriate

      -- sources of input to the procedures under test.

      Create_New_File (User_Defined_Input_File, Out_File, 1);

      -- Enter several lines of text into the new input file.

      -- The characters that make up these text strings will be processed

      -- using the procedures being exercised in this test.

      Load_File (User_Defined_Input_File);

      -- Check that Mode_Error is raised by Look_Ahead and Get_Immedidate

      -- if the mode of the file object is not In_File.

      -- Currently, the file mode is Out_File.

      begin

         Look_Ahead(User_Defined_Input_File, UDLA_Char, UDLA_End_Of_Line);

         Report.Failed("Mode_Error not raised by Look_Ahead");

         Report.Comment("This char should never be printed: " & UDLA_Char);

      exception

         when Mode_Error => null;  -- OK, expected exception.

         when The_Error : others =>

            Report.Failed ("The following exception was raised during the " &

                           "check that Look_Ahead raised Mode_Error when "  &

                           "provided a file object that is not in In_File " &

                           "mode: " & Exception_Name(The_Error));

      end;

      begin

         Get_Immediate(User_Defined_Input_File, UDGI_Char);

         Report.Failed("Mode_Error not raised by Get_Immediate");

         Report.Comment("This char should never be printed: " & UDGI_Char);

      exception

         when Mode_Error => null;  -- OK, expected exception.

         when The_Error : others =>

            Report.Failed ("The following exception was raised during the " &

                           "check that Get_Immediate raised Mode_Error "    &

                           "when provided a file object that is not in "    &

                           "In_File mode: " & Exception_Name(The_Error));

      end;

      -- The file will then be reset to In_File mode to properly function as

      -- a source of input.

      Reset1:

      begin

         Reset (User_Defined_Input_File, In_File);

      exception

         when Ada.Text_IO.Use_Error =>

            Report.Not_Applicable

               ( "Reset to In_File not supported for Text_IO" );

            raise No_Reset;

      end Reset1;

      -- Process the input file, exercising various Text_IO

      -- functionality, and validating the results at each step.

      -- Note: The designated File_Access object is used in processing

      --       the New_Default_Input_File in the second loop below.

      -- Process characters in first line of text of each file.

      Char_Pos := 1;

      -- Check that the first line is not blank.

      Look_Ahead(User_Defined_Input_File, UDLA_Char, UDLA_End_Of_Line);

      while not UDLA_End_Of_Line loop

         -- Use the Get_Immediate procedure on the file to get the next

         -- available character on the current line.

         Get_Immediate(User_Defined_Input_File, UDGI_Char);

         -- Check that the characters returned by both procedures are the

         -- same, and that they match the expected character from the file.

         if UDLA_Char /= TC_String_Ptr_Array(1).all(Char_Pos) or

            UDGI_Char /= TC_String_Ptr_Array(1).all(Char_Pos)

         then

            Report.Failed("Incorrect retrieval of character " &

                          Integer'Image(Char_Pos) & " of first string");

         end if;

         -- Increment the character position counter.

         Char_Pos := Char_Pos + 1;

         -- Check the next character on the line.  If at the end of line,

         -- the processing flow will exit the While loop.

         Look_Ahead(User_Defined_Input_File, UDLA_Char, UDLA_End_Of_Line);

      end loop;

      -- Check to ensure that the "end of line" results returned from the

      -- Look_Ahead procedure (used to exit the above While loop) corresponds

      -- with the result of Function End_Of_Line.

      if not End_Of_Line(User_Defined_Input_File)

      then

         Report.Failed("Result of procedure Look_Ahead that indicated "    &

                       "being at the end of the line does not correspond " &

                       "with the result of function End_Of_Line");

      end if;

      -- Check that all characters in the string were processed.

      if Char_Pos-1 /= TC_String_1'Length then

         Report.Failed("Not all of the characters on the first line " &

                       "were processed");

      end if;

      -- Call procedure Skip_Line to advance beyond the end of the first line.

      Skip_Line(User_Defined_Input_File);

      -- Process the second line in the file (a blank line).

      Look_Ahead(User_Input_Ptr.all, UDLA_Char, UDLA_End_Of_Line);

      if not UDLA_End_Of_Line then

         Report.Failed("Incorrect end of line determination from procedure " &

                       "Look_Ahead when processing a blank line");

      end if;

      -- Call procedure Skip_Line to advance beyond the end of the second line.

      Skip_Line(User_Input_Ptr.all);

      -- Process characters in the third line of the file (second line

      -- of text)

      -- Note: The version of Get_Immediate used in processing this line has

      --       the Boolean parameter Available.

      Char_Pos := 1;

      -- Check whether the line is blank (i.e., at end of line, page, or file).

      Look_Ahead(User_Input_Ptr.all, UDLA_Char, UDLA_End_Of_Line);

      while not UDLA_End_Of_Line loop

         -- Use the Get_Immediate procedure on the file to get access to the

         -- next character on the current line.

         Get_Immediate(User_Input_Ptr.all, UDGI_Char, UDGI_Available);

         -- Check that the Available parameter of Get_Immediate was set

         -- to indicate that a character was available in the file.

         -- Check that the characters returned by both procedures are the

         -- same, and they all match the expected character from the file.

         if not UDGI_Available                                or

            UDLA_Char /= TC_String_Ptr_Array(2).all(Char_Pos) or

            UDGI_Char /= TC_String_Ptr_Array(2).all(Char_Pos)

         then

            Report.Failed("Incorrect retrieval of character " &

                          Integer'Image(Char_Pos) & " of second string");

         end if;

         -- Increment the character position counter.

         Char_Pos := Char_Pos + 1;

         -- Check the next character on the line.  If at the end of line,

         -- the processing flow will exit the While loop.

         Look_Ahead(User_Input_Ptr.all, UDLA_Char, UDLA_End_Of_Line);

      end loop;

      -- Check to ensure that the "end of line" results returned from the

      -- Look_Ahead procedure (used to exit the above While loop) corresponds

      -- with the result of Function End_Of_Line.

      if not End_Of_Line(User_Defined_Input_File)

      then

         Report.Failed("Result of procedure Look_Ahead that indicated "    &

                       "being at the end of the line does not correspond " &

                       "with the result of function End_Of_Line");

      end if;

      -- Check that all characters in the second string were processed.

      if Char_Pos-1 /= TC_String_2'Length then

         Report.Failed("Not all of the characters on the second line " &

                       "were processed");

      end if;

      Deletion:

      begin

         -- Delete the user defined file.

         if Is_Open(User_Defined_Input_File) then

            Delete(User_Defined_Input_File);

         else

            Open(User_Defined_Input_File, Out_File, Report.Legal_File_Name(1));

            Delete(User_Defined_Input_File);

         end if;

      exception

         when others =>

            Report.Failed

               ( "Delete not properly implemented for Text_IO" );

      end Deletion;

   exception

      when No_Reset =>

         null;

      when Non_Applicable_System =>

         Report.Not_Applicable("System not capable of supporting external " &

                               "text files -- Name_Error/Use_Error raised " &

                               "during text file creation");

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