Subversion Repositories openrisc

-- CXA4026.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.Strings.Fixed procedures Head, Tail, and Trim, as well

--      as the versions of subprograms Translate (procedure and function),

--      Index, and Count, available in the package which use a

--      Maps.Character_Mapping_Function input parameter, produce correct

--      results.

--

-- TEST DESCRIPTION:

--      This test examines the operation of several subprograms contained in

--      the Ada.Strings.Fixed package.

--      This includes procedure versions of Head, Tail, and Trim, as well as

--      four subprograms that use a Character_Mapping_Function as a parameter

--      to provide the mapping capability.

--

--      Two functions are defined to provide the mapping.  Access values

--      are defined to refer to these functions.  One of the functions will

--      map upper case characters in the range 'A'..'Z' to their lower case

--      counterparts, while the other function will map lower case characters

--      ('a'..'z', or a character whose position is in one of the ranges

--      223..246 or 248..255, provided the character has an upper case form)

--      to their upper case form.

--

--      Function Index uses the mapping function access value to map the input

--      string prior to searching for the appropriate index value to return.

--      Function Count uses the mapping function access value to map the input

--      string prior to counting the occurrences of the pattern string.

--      Both the Procedure and Function version of Translate use the mapping

--      function access value to perform the translation.

--

--      Results of all subprograms are compared with expected results.

--

--

-- CHANGE HISTORY:

--      10 Feb 95   SAIC    Initial prerelease version

--      21 Apr 95   SAIC    Modified definition of string variable Str_2.

--

--!

package CXA4026_0 is

   -- Function Map_To_Lower_Case will return the lower case form of

   -- Characters in the range 'A'..'Z' only, and return the input

   -- character otherwise.

   function Map_To_Lower_Case (From : Character) return Character;

   -- Function Map_To_Upper_Case will return the upper case form of

   -- Characters in the range 'a'..'z', or whose position is in one

   -- of the ranges 223..246 or 248..255, provided the character has

   -- an upper case form.

   function Map_To_Upper_Case (From : Character) return Character;

end CXA4026_0;

with Ada.Characters.Handling;

package body CXA4026_0 is

   function Map_To_Lower_Case (From : Character) return Character is

   begin

      if From in 'A'..'Z' then

         return Character'Val(Character'Pos(From) -

                             (Character'Pos('A') - Character'Pos('a')));

      else

         return From;

      end if;

   end Map_To_Lower_Case;

   function Map_To_Upper_Case (From : Character) return Character is

   begin

      return Ada.Characters.Handling.To_Upper(From);

   end Map_To_Upper_Case;

end CXA4026_0;

with CXA4026_0;

with Ada.Strings.Fixed;

with Ada.Strings.Maps;

with Ada.Characters.Handling;

with Ada.Characters.Latin_1;

with Report;

procedure CXA4026 is

begin

   Report.Test ("CXA4026", "Check that procedures Trim, Head, and Tail, " &

                           "as well as the versions of subprograms "      &

                           "Translate, Index, and Count, which use the "  &

                           "Character_Mapping_Function input parameter,"  &

                           "produce correct results");

   Test_Block:

   declare

      use Ada.Strings, CXA4026_0;

      -- The following strings are used in examination of the Translation

      -- subprograms.

      New_Character_String : String(1..10) :=

                               Ada.Characters.Latin_1.LC_A_Grave          &

                               Ada.Characters.Latin_1.LC_A_Ring           &

                               Ada.Characters.Latin_1.LC_AE_Diphthong     &

                               Ada.Characters.Latin_1.LC_C_Cedilla        &

                               Ada.Characters.Latin_1.LC_E_Acute          &

                               Ada.Characters.Latin_1.LC_I_Circumflex     &

                               Ada.Characters.Latin_1.LC_Icelandic_Eth    &

                               Ada.Characters.Latin_1.LC_N_Tilde          &

                               Ada.Characters.Latin_1.LC_O_Oblique_Stroke &

                               Ada.Characters.Latin_1.LC_Icelandic_Thorn;

      TC_New_Character_String : String(1..10) :=

                               Ada.Characters.Latin_1.UC_A_Grave          &

                               Ada.Characters.Latin_1.UC_A_Ring           &

                               Ada.Characters.Latin_1.UC_AE_Diphthong     &

                               Ada.Characters.Latin_1.UC_C_Cedilla        &

                               Ada.Characters.Latin_1.UC_E_Acute          &

                               Ada.Characters.Latin_1.UC_I_Circumflex     &

                               Ada.Characters.Latin_1.UC_Icelandic_Eth    &

                               Ada.Characters.Latin_1.UC_N_Tilde          &

                               Ada.Characters.Latin_1.UC_O_Oblique_Stroke &

                               Ada.Characters.Latin_1.UC_Icelandic_Thorn;

      -- Functions used to supply mapping capability.

      -- Access objects that will be provided as parameters to the

      -- subprograms.

      Map_To_Lower_Case_Ptr : Maps.Character_Mapping_Function :=

                                Map_To_Lower_Case'Access;

      Map_To_Upper_Case_Ptr : Maps.Character_Mapping_Function :=

                                Map_To_Upper_Case'Access;

   begin

      -- Function Index, Forward direction search.

      -- Note: Several of the following cases use the default value

      --       Forward for the Going parameter.

      if Fixed.Index(Source => "The library package Strings.Fixed",

                     Pattern => "fix",

                     Going   => Ada.Strings.Forward,

                     Mapping => Map_To_Lower_Case_Ptr)    /= 29   or

         Fixed.Index("THE RAIN IN SPAIN FALLS MAINLY ON THE PLAIN",

                     "ain",

                     Mapping => Map_To_Lower_Case_Ptr)    /= 6    or

         Fixed.Index("maximum number",

                     "um",

                     Ada.Strings.Forward,

                     Map_To_Lower_Case_Ptr)               /= 6    or

         Fixed.Index("CoMpLeTeLy MiXeD CaSe StRiNg",

                     "MIXED CASE STRING",

                     Ada.Strings.Forward,

                     Map_To_Upper_Case_Ptr)               /= 12   or

         Fixed.Index("STRING WITH NO MATCHING PATTERNS",

                     "WITH",

                     Ada.Strings.Forward,

                     Map_To_Lower_Case_Ptr)               /= 0    or

         Fixed.Index("THIS STRING IS IN UPPER CASE",

                     "IS",

                     Ada.Strings.Forward,

                     Map_To_Upper_Case_Ptr)               /= 3    or

         Fixed.Index("",  -- Null string.

                     "is",

                     Mapping => Map_To_Lower_Case_Ptr)    /= 0    or

         Fixed.Index("AAABBBaaabbb",

                     "aabb",

                     Mapping => Map_To_Lower_Case_Ptr)    /= 2

      then

         Report.Failed("Incorrect results from Function Index, going "    &

                       "in Forward direction, using a Character Mapping " &

                       "Function parameter");

      end if;

      -- Function Index, Backward direction search.

      if Fixed.Index("Case of a Mixed Case String",

                     "case",

                     Ada.Strings.Backward,

                     Map_To_Lower_Case_Ptr)               /= 17   or

         Fixed.Index("Case of a Mixed Case String",

                     "CASE",

                     Ada.Strings.Backward,

                     Map_To_Upper_Case_Ptr)               /= 17   or

         Fixed.Index("rain, Rain, and more RAIN",

                     "rain",

                     Ada.Strings.Backward,

                     Map_To_Lower_Case_Ptr)               /= 22   or

         Fixed.Index("RIGHT place, right time",

                     "RIGHT",

                     Ada.Strings.Backward,

                     Map_To_Upper_Case_Ptr)               /= 14   or

         Fixed.Index("WOULD MATCH BUT FOR THE CASE",

                     "WOULD MATCH BUT FOR THE CASE",

                     Ada.Strings.Backward,

                     Map_To_Lower_Case_Ptr)               /= 0

      then

         Report.Failed("Incorrect results from Function Index, going "     &

                       "in Backward direction, using a Character Mapping " &

                       "Function parameter");

      end if;

      -- Function Index, Pattern_Error if Pattern = Null_String

      declare

         use Ada.Strings.Fixed;

         Null_Pattern_String : constant String := "";

         TC_Natural          : Natural         := 1000;

      begin

         TC_Natural := Index("A Valid String",

                             Null_Pattern_String,

                             Ada.Strings.Forward,

                             Map_To_Lower_Case_Ptr);

         Report.Failed("Pattern_Error not raised by Function Index when " &

                       "given a null pattern string");

      exception

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

         when others        =>

            Report.Failed("Incorrect exception raised by Function Index " &

                          "using a Character Mapping Function parameter " &

                          "when given a null pattern string");

      end;

      -- Function Count.

      if Fixed.Count(Source  => "ABABABA",

                     Pattern => "aba",

                     Mapping => Map_To_Lower_Case_Ptr)        /=  2   or

         Fixed.Count("ABABABA", "ABA", Map_To_Lower_Case_Ptr) /=  0   or

         Fixed.Count("This IS a MISmatched issue",

                     "is",

                     Map_To_Lower_Case_Ptr)                   /=  4   or

         Fixed.Count("ABABABA", "ABA", Map_To_Upper_Case_Ptr) /=  2   or

         Fixed.Count("This IS a MISmatched issue",

                     "is",

                     Map_To_Upper_Case_Ptr)                   /=  0   or

         Fixed.Count("She sells sea shells by the sea shore",

                     "s",

                     Map_To_Lower_Case_Ptr)                   /=  8   or

         Fixed.Count("",                       -- Null string.

                     "match",

                     Map_To_Upper_Case_Ptr)                   /=  0

      then

         Report.Failed("Incorrect results from Function Count, using " &

                       "a Character Mapping Function parameter");

      end if;

      -- Function Count, Pattern_Error if Pattern = Null_String

      declare

         use Ada.Strings.Fixed;

         Null_Pattern_String : constant String := "";

         TC_Natural          : Natural         := 1000;

      begin

         TC_Natural := Count("A Valid String",

                             Null_Pattern_String,

                             Map_To_Lower_Case_Ptr);

         Report.Failed("Pattern_Error not raised by Function Count using " &

                       "a Character Mapping Function parameter when "      &

                       "given a null pattern string");

      exception

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

         when others        =>

            Report.Failed("Incorrect exception raised by Function Count " &

                          "using a Character Mapping Function parameter " &

                          "when given a null pattern string");

      end;

      -- Function Translate.

      if Fixed.Translate(Source  => "A Sample Mixed Case String",

                         Mapping => Map_To_Lower_Case_Ptr) /=

         "a sample mixed case string"                         or

         Fixed.Translate("ALL LOWER CASE",

                         Map_To_Lower_Case_Ptr)            /=

         "all lower case"                                     or

         Fixed.Translate("end with lower case",

                         Map_To_Lower_Case_Ptr)            /=

         "end with lower case"                                or

         Fixed.Translate("", Map_To_Lower_Case_Ptr)        /=

         ""                                                   or

         Fixed.Translate("start with lower case",

                         Map_To_Upper_Case_Ptr)            /=

         "START WITH LOWER CASE"                              or

         Fixed.Translate("ALL UPPER CASE STRING",

                         Map_To_Upper_Case_Ptr)            /=

         "ALL UPPER CASE STRING"                              or

         Fixed.Translate("LoTs Of MiXeD CaSe ChArAcTeRs",

                         Map_To_Upper_Case_Ptr)            /=

         "LOTS OF MIXED CASE CHARACTERS"                      or

         Fixed.Translate("", Map_To_Upper_Case_Ptr)        /=

         ""                                                   or

         Fixed.Translate(New_Character_String,

                         Map_To_Upper_Case_Ptr)            /=

         TC_New_Character_String

      then

         Report.Failed("Incorrect results from Function Translate, using " &

                       "a Character Mapping Function parameter");

      end if;

      -- Procedure Translate.

      declare

         use Ada.Strings.Fixed;

         Str_1    : String(1..24)   := "AN ALL UPPER CASE STRING";

         Str_2    : String(1..19)   := "A Mixed Case String";

         Str_3    : String(1..32)   := "a string with lower case letters";

         TC_Str_1 : constant String := Str_1;

         TC_Str_3 : constant String := Str_3;

      begin

         Translate(Source => Str_1, Mapping => Map_To_Lower_Case_Ptr);

         if Str_1 /= "an all upper case string" then

            Report.Failed("Incorrect result from Procedure Translate - 1");

         end if;

         Translate(Source => Str_1, Mapping => Map_To_Upper_Case_Ptr);

         if Str_1 /= TC_Str_1 then

            Report.Failed("Incorrect result from Procedure Translate - 2");

         end if;

         Translate(Source => Str_2, Mapping => Map_To_Lower_Case_Ptr);

         if Str_2 /= "a mixed case string" then

            Report.Failed("Incorrect result from Procedure Translate - 3");

         end if;

         Translate(Source => Str_2, Mapping => Map_To_Upper_Case_Ptr);

         if Str_2 /= "A MIXED CASE STRING" then

            Report.Failed("Incorrect result from Procedure Translate - 4");

         end if;

         Translate(Source => Str_3, Mapping => Map_To_Lower_Case_Ptr);

         if Str_3 /= TC_Str_3 then

            Report.Failed("Incorrect result from Procedure Translate - 5");

         end if;

         Translate(Source => Str_3, Mapping => Map_To_Upper_Case_Ptr);

         if Str_3 /= "A STRING WITH LOWER CASE LETTERS" then

            Report.Failed("Incorrect result from Procedure Translate - 6");

         end if;

         Translate(New_Character_String, Map_To_Upper_Case_Ptr);

         if New_Character_String /= TC_New_Character_String then

            Report.Failed("Incorrect result from Procedure Translate - 6");

         end if;

      end;

      -- Procedure Trim.

      declare

         Use Ada.Strings.Fixed;

         Trim_String : String(1..30) := "    A string of characters    ";

      begin

         Trim(Source  => Trim_String,

              Side    => Ada.Strings.Left,

              Justify => Ada.Strings.Right,

              Pad     => 'x');

         if Trim_String /= "xxxxA string of characters    " then

            Report.Failed("Incorrect result from Procedure Trim, trim " &

                          "side = left, justify = right, pad = x");

         end if;

         Trim(Trim_String, Ada.Strings.Right, Ada.Strings.Center);

         if Trim_String /= "  xxxxA string of characters  " then

            Report.Failed("Incorrect result from Procedure Trim, trim " &

                          "side = right, justify = center, default pad");

         end if;

         Trim(Trim_String, Ada.Strings.Both, Pad => '*');

         if Trim_String /= "xxxxA string of characters****" then

            Report.Failed("Incorrect result from Procedure Trim, trim " &

                          "side = both, default justify, pad = *");

         end if;

      end;

      -- Procedure Head.

      declare

         Fixed_String : String(1..20) := "A sample test string";

      begin

         Fixed.Head(Source  => Fixed_String,

                    Count   => 14,

                    Justify => Ada.Strings.Center,

                    Pad     => '$');

         if Fixed_String /= "$$$A sample test $$$" then

            Report.Failed("Incorrect result from Procedure Head, " &

                          "justify = center, pad = $");

         end if;

         Fixed.Head(Fixed_String, 11, Ada.Strings.Right);

         if Fixed_String /= "         $$$A sample" then

            Report.Failed("Incorrect result from Procedure Head, " &

                          "justify = right, default pad");

         end if;

         Fixed.Head(Fixed_String, 9, Pad => '*');

         if Fixed_String /= "         ***********" then

            Report.Failed("Incorrect result from Procedure Head, " &

                          "default justify, pad = *");

         end if;

      end;

      -- Procedure Tail.

      declare

         Use Ada.Strings.Fixed;

         Tail_String : String(1..20) := "ABCDEFGHIJKLMNOPQRST";

      begin

         Tail(Source => Tail_String, Count => 10, Pad => '-');

         if Tail_String /= "KLMNOPQRST----------" then

            Report.Failed("Incorrect result from Procedure Tail, " &

                          "default justify, pad = -");

         end if;

         Tail(Tail_String, 6, Justify => Ada.Strings.Center, Pad => 'a');

         if Tail_String /= "aaaaaaa------aaaaaaa" then

            Report.Failed("Incorrect result from Procedure Tail, " &

                          "justify = center, pad = a");

         end if;

         Tail(Tail_String, 1, Ada.Strings.Right);

         if Tail_String /= "                   a" then

            Report.Failed("Incorrect result from Procedure Tail, " &

                          "justify = right, default pad");

         end if;

         Tail(Tail_String, 19, Ada.Strings.Right, 'A');

         if Tail_String /= "A                  a" then

            Report.Failed("Incorrect result from Procedure Tail, " &

                          "justify = right, pad = A");

         end if;

      end;

   exception

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

   end Test_Block;

   Report.Result;

end CXA4026;