Subversion Repositories openrisc_me

-- CXF3A02.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 function Ada.Text_IO.Editing.To_Picture raises

--      Picture_Error if the picture string provided as input parameter does

--      not conform to the composition constraints defined for picture

--      strings.

--      Check that when Pic_String is applied to To_Picture, the result

--      is equivalent to the actual string parameter of To_Picture;

--      Check that when Blank_When_Zero is applied to To_Picture, the result

--      is the same value as the Blank_When_Zero parameter of To_Picture.

--

-- TEST DESCRIPTION:

--      This test validates that function Editing.To_Picture returns a

--      Picture result when provided a valid picture string, and raises a

--      Picture_Error exception when provided an invalid picture string

--      input parameter.  In addition, the Picture result of To_Picture is

--      converted back to a picture string value using function Pic_String,

--      and the result of function Blank_When_Zero is validated based on the

--      value of parameter Blank_When_Zero used in the formation of the Picture

--      by function To_Picture.

--

-- TEST FILES:

--      The following files comprise this test:

--

--         FXF3A00.A   (foundation code)

--      => CXF3A02.A

--

--

-- CHANGE HISTORY:

--      06 Dec 94   SAIC    ACVC 2.0

--      11 Mar 97   PWB.CTA Corrected invalid picture string and uppercase

--                          problem.

--!

with FXF3A00;

with Ada.Text_IO.Editing;

with Ada.Strings.Maps;

with Ada.Strings.Fixed;

with Report;

procedure CXF3A02 is

   Lower_Alpha : constant String := "abcdefghijklmnopqrstuvwxyz";

   Upper_Alpha : constant String := "ABCDEFGHIJKLMNOPQRSTUVWXYZ";

   function UpperCase ( Source : String ) return String is

   begin

      return

         Ada.Strings.Fixed.Translate

            ( Source  => Source,

              Mapping => Ada.Strings.Maps.To_Mapping

                            ( From => Lower_Alpha,

                              To => Upper_Alpha ) );

   end UpperCase;

begin

   Report.Test ("CXF3A02", "Check that the function "                       &

                           "Ada.Text_IO.Editing.To_Picture raises "         &

                           "Picture_Error if the picture string provided "  &

                           "as input parameter does not conform to the "    &

                           "composition constraints defined for picture "   &

                           "strings");

   Test_Block:

   declare

      use Ada.Text_IO;

      use FXF3A00;

      TC_Picture         : Editing.Picture;

      TC_Blank_When_Zero : Boolean;

   begin

      -- Validate that function To_Picture does not raise Picture_Error when

      -- provided a valid picture string as an input parameter.

      for i in 1..FXF3A00.Number_Of_Valid_Strings loop

         begin

            TC_Picture :=

              Editing.To_Picture(Pic_String      => Valid_Strings(i).all,

                                 Blank_When_Zero => False );

         exception

            when Editing.Picture_Error =>

              Report.Failed

              ("Picture_Error raised by function To_Picture "     &

               "with a valid picture string as input parameter, " &

               "Valid_String = " & FXF3A00.Valid_Strings(i).all);

            when others =>

              Report.Failed("Unexpected exception raised - 1, " &

                            "Valid_String = " & FXF3A00.Valid_Strings(i).all);

         end;

      end loop;

      -- Validate that function To_Picture raises Picture_Error when an

      -- invalid picture string is provided as an input parameter.

      -- Default value used for parameter Blank_When_Zero.

      for i in 1..FXF3A00.Number_Of_Invalid_Strings loop

         begin

            TC_Picture :=

              Editing.To_Picture(Pic_String => FXF3A00.Invalid_Strings(i).all);

            Report.Failed

              ("Picture_Error not raised by function To_Picture "    &

               "with an invalid picture string as input parameter, " &

               "Invalid_String = " & FXF3A00.Invalid_Strings(i).all);

         exception

            when Editing.Picture_Error => null;  -- OK, expected exception.

            when others                =>

              Report.Failed("Unexpected exception raised, " &

                            "Invalid_String = "             &

                            FXF3A00.Invalid_Strings(i).all);

         end;

      end loop;

      -- Validate that To_Picture and Pic_String/Blank_When_Zero provide

      -- "inverse" results.

      -- Use the default value of the Blank_When_Zero parameter (False) for

      -- these evaluations (some valid strings have the '*' zero suppression

      -- character, which would result in an invalid string if used with a

      -- True value for the Blank_When_Zero parameter).

      for i in 1..FXF3A00.Number_Of_Valid_Strings loop

         begin

            -- Format a picture string using function To_Picture.

            TC_Picture := Editing.To_Picture(FXF3A00.Valid_Strings(i).all);

            -- Reconvert the Picture result from To_Picture to a string value

            -- using function Pic_String, and compare to the original string.

            if Editing.Pic_String(Pic => TC_Picture) /=

               Uppercase (FXF3A00.Valid_Strings(i).all)

            then

               Report.Failed

                 ("Inverse result incorrect from Editing.Pic_String, " &

                  "Valid_String = " & FXF3A00.Valid_Strings(i).all);

            end if;

            -- Ensure that function Blank_When_Zero returns the correct value

            -- of the Blank_When_Zero parameter used in forming the Picture

            -- (default parameter value False used in call to To_Picture

            -- above).

            if Editing.Blank_When_Zero(Pic => TC_Picture) then

               Report.Failed

                 ("Inverse result incorrect from Editing.Blank_When_Zero, " &

                  "Valid_String = " & FXF3A00.Valid_Strings(i).all);

            end if;

         exception

            when others =>

              Report.Failed("Unexpected exception raised - 2, " &

                            "Valid_String = " & FXF3A00.Valid_Strings(i).all);

         end;

      end loop;

      -- Specifically check that any lower case letters in the original

      -- picture string have been converted to upper case form following

      -- the To_Picture/Pic_String conversion (as shown in previous loop).

      declare

         The_Picture         : Editing.Picture;

         The_Picture_String  : constant String := "+bBbZz_zZz_Zz9.99";

         The_Expected_Result : constant String := "+BBBZZ_ZZZ_ZZ9.99";

      begin

         -- Convert Picture String to Picture.

         The_Picture := Editing.To_Picture(Pic_String => The_Picture_String);

         declare

            -- Reconvert the Picture to a Picture String.

            The_Result : constant String := Editing.Pic_String(The_Picture);

         begin

            if The_Result /= The_Expected_Result then

               Report.Failed("Conversion to Picture/Reconversion to String " &

                             "did not produce expected result when Picture " &

                             "String had lower case letters");

            end if;

         end;

      end;

      -- Use a value of True for the Blank_When_Zero parameter for the

      -- following evaluations (picture strings that do not have the '*' zero

      -- suppression character, which would result in an invalid string when

      -- used here with a True value for the Blank_When_Zero parameter).

      for i in 3..24 loop

         begin

            -- Format a picture string using function To_Picture.

            TC_Picture :=

              Editing.To_Picture(Pic_String      => Valid_Strings(i).all,

                                 Blank_When_Zero => True);

            -- Reconvert the Picture result from To_Picture to a string value

            -- using function Pic_String, and compare to the original string.

            if Editing.Pic_String(Pic => TC_Picture) /=

               UpperCase (FXF3A00.Valid_Strings(i).all)

            then

               Report.Failed

                 ("Inverse result incorrect from Editing.Pic_String, used "   &

                  "on Picture formed with parameter Blank_When_Zero = True, " &

                  "Valid_String = " & FXF3A00.Valid_Strings(i).all);

            end if;

            -- Ensure that function Blank_When_Zero returns the correct value

            -- of the Blank_When_Zero parameter used in forming the Picture

            -- (default parameter value False overridden in call to

            -- To_Picture above).

            if not Editing.Blank_When_Zero(Pic => TC_Picture) then

               Report.Failed

                 ("Inverse result incorrect from Editing.Blank_When_Zero, "  &

                  "used on a Picture formed with parameter Blank_When_Zero " &

                  "= True, Valid_String = " & FXF3A00.Valid_Strings(i).all);

            end if;

         exception

            when others =>

              Report.Failed("Unexpected exception raised - 3, " &

                            "Valid_String = " & FXF3A00.Valid_Strings(i).all);

         end;

      end loop;

   exception

      when others => Report.Failed ("Exception raised in Test_Block");

   end Test_Block;

   Report.Result;

end CXF3A02;