Subversion Repositories openrisc_me

-- CXA4011.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 package Ada.Strings.Unbounded
--      are available, and that they produce correct results. Specifically, 
--      check the subprograms To_Unbounded_String, "&", ">", "<", Element, 
--      Replace_Element, Count, Find_Token, Translate, Trim, Delete, and
--      "*".
--      
-- TEST DESCRIPTION:
--      This test demonstrates the uses of many of the subprograms defined
--      in package Ada.Strings.Unbounded for use with unbounded strings.
--      The test simulates how unbounded strings could be processed in a
--      user environment, using the subprograms provided in this package.
--
--      This test uses a variety of the subprograms defined in the unbounded 
--      string package in ways typical of common usage, with different 
--      combinations of available subprograms being used to accomplish 
--      similar unbounded string processing goals.
--      
--       
-- CHANGE HISTORY:
--      06 Dec 94   SAIC    ACVC 2.0
--      27 Feb 95   SAIC    Test description modification.
--      01 Nov 95   SAIC    Update and repair for ACVC 2.0.1.
--
--!

with Report;
with Ada.Strings.Maps;
with Ada.Strings.Unbounded;

procedure CXA4011 is
begin

   Report.Test ("CXA4011", "Check that the subprograms defined in "        &
                           "package Ada.Strings.Unbounded are available, " &
                           "and that they produce correct results");

   Test_Block:
   declare

      package ASUnb renames Ada.Strings.Unbounded;
      use Ada.Strings;
      use type Maps.Character_Set;
      use type ASUnb.Unbounded_String;

      Cad_String        : ASUnb.Unbounded_String := 
                            ASUnb.To_Unbounded_String("cad");

      Complete_String   : ASUnb.Unbounded_String := 
                            ASUnb.To_Unbounded_String("Incomplete") &
                            Ada.Strings.Space &
                            ASUnb.To_Unbounded_String("String");

      Incomplete_String  : ASUnb.Unbounded_String :=
                             ASUnb.To_Unbounded_String("ncomplete Strin");

      Incorrect_Spelling : ASUnb.Unbounded_String :=
                             ASUnb.To_Unbounded_String("Guob Dai");

      Magic_String       : ASUnb.Unbounded_String :=
                             ASUnb.To_Unbounded_String("abracadabra");

      Incantation        : ASUnb.Unbounded_String := Magic_String;


      A_Small_G : Character := 'g';
      A_Small_D : Character := 'd';

      ABCD_Set : Maps.Character_Set := Maps.To_Set("abcd");
      B_Set    : Maps.Character_Set := Maps.To_Set('b');
      AB_Set   : Maps.Character_Set := Maps."OR"(Maps.To_Set('a'), B_Set);

      Code_Map         : Maps.Character_Mapping := 
                           Maps.To_Mapping(From => "abcd", To => "wxyz");
      Reverse_Code_Map : Maps.Character_Mapping :=
                           Maps.To_Mapping(From => "wxyz", To => "abcd");
      Non_Existent_Map : Maps.Character_Mapping :=
                           Maps.To_Mapping(From => "jkl",  To => "mno");


      Token_Start      : Positive;
      Token_End        : Natural := 0;
      Matching_Letters : Natural := 0;


   begin

      -- "&"

      -- Prepend an 'I' and append a 'g' to the string.
      Incomplete_String := ASUnb."&"('I', Incomplete_String);  -- Char & Unb
      Incomplete_String := ASUnb."&"(Incomplete_String, 
                                     A_Small_G);               -- Unb & Char

      if Incomplete_String  < Complete_String  or
         Incomplete_String  > Complete_String  or
         Incomplete_String /= Complete_String
      then
         Report.Failed("Incorrect result from use of ""&"" operator");
      end if;


      -- Element

      -- Last element of the unbounded string should be a 'g'.
      if ASUnb.Element(Incomplete_String, ASUnb.Length(Incomplete_String)) /=
         A_Small_G
      then
         Report.Failed("Incorrect result from use of Function Element - 1");
      end if;

      if ASUnb.Element(Incomplete_String, 2)                 /=
         ASUnb.Element(ASUnb.Tail(Incomplete_String, 2), 1)     or
         ASUnb.Element(ASUnb.Head(Incomplete_String, 4), 2)  /=
         ASUnb.Element(ASUnb.To_Unbounded_String("wnqz"), 2)
      then
         Report.Failed("Incorrect result from use of Function Element - 2");
      end if;
    

      -- Replace_Element

      -- The unbounded string Incorrect_Spelling starts as "Guob Dai", and
      -- is transformed by the following three procedure calls to "Good Day".

      ASUnb.Replace_Element(Incorrect_Spelling, 2, 'o');

      ASUnb.Replace_Element(Incorrect_Spelling, 
                            ASUnb.Index(Incorrect_Spelling, B_Set),
                            A_Small_D);

      ASUnb.Replace_Element(Source => Incorrect_Spelling,
                            Index  => ASUnb.Length(Incorrect_Spelling),
                            By     => 'y');

      if Incorrect_Spelling /= ASUnb.To_Unbounded_String("Good Day") then
         Report.Failed("Incorrect result from Procedure Replace_Element");
      end if;


      -- Count

      -- Determine the number of characters in the unbounded string that
      -- are contained in the set.

      Matching_Letters := ASUnb.Count(Source => Magic_String,
                                      Set    => ABCD_Set);

      if Matching_Letters /= 9 then
         Report.Failed
            ("Incorrect result from Function Count with Set parameter");
      end if;

      -- Determine the number of occurrences of the following pattern strings
      -- in the unbounded string Magic_String.

      if ASUnb.Count(Magic_String, "ab") /=
         (ASUnb.Count(Magic_String, "ac") + ASUnb.Count(Magic_String, "ad")) or
         ASUnb.Count(Magic_String, "ab") /= 2
      then
         Report.Failed
            ("Incorrect result from Function Count with String parameter");
      end if;


      -- Find_Token

      ASUnb.Find_Token(Magic_String,      -- Find location of first "ab".
                       AB_Set,            -- Should be (1..2).
                       Ada.Strings.Inside,
                       Token_Start,
                       Token_End);

      if Natural(Token_Start) /= ASUnb.To_String(Magic_String)'First  or
         Token_End            /= ASUnb.Index(Magic_String, B_Set)
      then 
         Report.Failed("Incorrect result from Procedure Find_Token - 1");
      end if;


      ASUnb.Find_Token(Source => Magic_String, -- Find location of char 'r'
                       Set    => ABCD_Set,     -- in string, should be (3..3)
                       Test   => Ada.Strings.Outside,
                       First  => Token_Start,
                       Last   => Token_End);

      if Natural(Token_Start) /= 3 or
         Token_End            /= 3 then
         Report.Failed("Incorrect result from Procedure Find_Token - 2");
      end if;


      ASUnb.Find_Token(Magic_String,           -- No 'g' is in the string, so
                       Maps.To_Set(A_Small_G), -- the result parameters should
                       Ada.Strings.Inside,     -- be First = Source'First and
                       First => Token_Start,   -- Last = 0.
                       Last  => Token_End);

      if Token_Start /= ASUnb.To_String(Magic_String)'First  or
         Token_End   /= 0
      then
         Report.Failed("Incorrect result from Procedure Find_Token - 3");
      end if;
 

      -- Translate

      -- Use a mapping ("abcd" -> "wxyz") to transform the contents of 
      -- the unbounded string.
      -- Magic_String = "abracadabra"

      Incantation := ASUnb.Translate(Magic_String, Code_Map); 

      if Incantation /= ASUnb.To_Unbounded_String("wxrwywzwxrw") then
         Report.Failed("Incorrect result from Function Translate");
      end if;

      -- Use the inverse mapping of the one above to return the "translated"
      -- unbounded string to its original form.

      ASUnb.Translate(Incantation, Reverse_Code_Map);

      -- The map contained in the following call to Translate contains one
      -- element, and this element is not found in the unbounded string, so
      -- this call to Translate should have no effect on the unbounded string.

      if Incantation /= ASUnb.Translate(Magic_String, Non_Existent_Map) then
         Report.Failed("Incorrect result from Procedure Translate");
      end if;

    
      -- Trim

      Trim_Block:
      declare

         XYZ_Set     : Maps.Character_Set := Maps.To_Set("xyz");
         PQR_Set     : Maps.Character_Set := Maps.To_Set("pqr");

         Pad         : constant ASUnb.Unbounded_String := 
                                  ASUnb.To_Unbounded_String("Pad");

         The_New_Ada : constant ASUnb.Unbounded_String :=
                                  ASUnb.To_Unbounded_String("Ada9X");

         Space_Array : array (1..4) of ASUnb.Unbounded_String :=
                         (ASUnb.To_Unbounded_String("  Pad    "),
                          ASUnb.To_Unbounded_String("Pad   "),
                          ASUnb.To_Unbounded_String("     Pad"),
                          Pad);

         String_Array : array (1..5) of ASUnb.Unbounded_String := 
                          (ASUnb.To_Unbounded_String("xyzxAda9Xpqr"),
                           ASUnb.To_Unbounded_String("Ada9Xqqrp"),
                           ASUnb.To_Unbounded_String("zxyxAda9Xqpqr"),
                           ASUnb.To_Unbounded_String("xxxyAda9X"),
                           The_New_Ada);
           
      begin

         -- Examine the version of Trim that removes blanks from
         -- the left and/or right of a string.

         for i in 1..4 loop
            if ASUnb.Trim(Space_Array(i), Ada.Strings.Both) /= Pad then
               Report.Failed("Incorrect result from Trim for spaces - " &
                             Integer'Image(i));
            end if;
         end loop;   

         -- Examine the version of Trim that removes set characters from
         -- the left and right of a string.

         for i in 1..5 loop
            if ASUnb.Trim(String_Array(i),
                          Left   => XYZ_Set,
                          Right  => PQR_Set) /= The_New_Ada then
               Report.Failed
                 ("Incorrect result from Trim for set characters - " &
                  Integer'Image(i));
            end if;
         end loop;   

      end Trim_Block;


      -- Delete

      -- Use the Delete function to remove the first four and last four
      -- characters from the string.

      if ASUnb.Delete(Source  => ASUnb.Delete(Magic_String,
                                              8,
                                              ASUnb.Length(Magic_String)),
                      From    => ASUnb.To_String(Magic_String)'First,
                      Through => 4)   /= 
         Cad_String
      then
         Report.Failed("Incorrect results from Function Delete");
      end if;


      -- Constructors ("*")

      Constructor_Block:
      declare
      
         SOS      : ASUnb.Unbounded_String;

         Dot      : constant ASUnb.Unbounded_String := 
                               ASUnb.To_Unbounded_String("Dot_");
         Dash     : constant String := "Dash_";

         Distress : ASUnb.Unbounded_String := 
                      ASUnb.To_Unbounded_String("Dot_Dot_Dot_")    &
                      ASUnb.To_Unbounded_String("Dash_Dash_Dash_") &
                      ASUnb.To_Unbounded_String("Dot_Dot_Dot");
                      
         Repeat        : constant Natural   := 3;
         Separator     : constant Character := '_';

         Separator_Set : Maps.Character_Set := Maps.To_Set(Separator);

      begin

         -- Use the following constructor forms to construct the string
         -- "Dot_Dot_Dot_Dash_Dash_Dash_Dot_Dot_Dot".  Note that the 
         -- trailing underscore in the string is removed in the call to 
         -- Trim in the If statement condition.

         SOS := ASUnb."*"(Repeat, Dot);        -- "*"(#, Unb Str)

         SOS := SOS                     &
                ASUnb."*"(Repeat, Dash) &      -- "*"(#, Str)
                ASUnb."*"(Repeat, Dot);        -- "*"(#, Unb Str)

         if ASUnb.Trim(SOS, Maps.Null_Set, Separator_Set) /= Distress then
            Report.Failed("Incorrect results from Function ""*""");
         end if;

      end Constructor_Block;
      

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


   Report.Result;

end CXA4011;