Subversion Repositories openrisc

-- CXA4018.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.Wide_Bounded are available, and that they produce

--      correct results. Specifically, check the subprograms Append,

--      Count, Element, Find_Token, Head, Index_Non_Blank, Replace_Element,

--      Replicate, Tail, To_Bounded_Wide_String, "&", ">", "<", ">=", "<=",

--      and "*".

--

-- TEST DESCRIPTION:

--      This test, when taken in conjunction with test CXA40[17,19,20], will

--      constitute a test of all the functionality contained in package

--      Ada.Strings.Wide_Bounded.  This test uses a variety of the

--      subprograms defined in the wide bounded string package in ways typical

--      of common usage.  Different combinations of available subprograms

--      are used to accomplish similar wide bounded string processing goals.

--

--

-- CHANGE HISTORY:

--      06 Dec 94   SAIC    ACVC 2.0

--      22 Dec 94   SAIC    Changed obsolete constant to Strings.Wide_Space.

--      06 Nov 95   SAIC    Corrected evaluation string used in Head/Tail

--                          subtests for ACVC 2.0.1.

--

--!

with Ada.Strings;

with Ada.Strings.Wide_Bounded;

with Ada.Characters.Handling;

with Ada.Strings.Wide_Maps;

with Report;

procedure CXA4018 is

   -- The following two functions are used to translate character and string

   -- values to "Wide" values.  They will be applied to all the Wide_Bounded

   -- subprogram parameters to simulate the use of Wide_Characters and

   -- Wide_Strings in actual practice. Blanks are translated to Wide_Character

   -- blanks and all other characters are translated into Wide_Characters with

   -- position values 256 greater than their (narrow) character position

   -- values.

   function Translate (Ch : Character) return Wide_Character is

      C : Character := Ch;

   begin

      if Ch = ' ' then

         return Ada.Characters.Handling.To_Wide_Character(C);

      else

         return Wide_Character'Val(Character'Pos(Ch) +

                                   Character'Pos(Character'Last) + 1);

      end if;

   end Translate;

   function Translate (Str : String) return Wide_String is

      WS : Wide_String(Str'First..Str'Last);

   begin

      for i in Str'First..Str'Last loop

         WS(i) := Translate(Str(i));

      end loop;

      return WS;

   end Translate;

begin

   Report.Test ("CXA4018", "Check that the subprograms defined in package " &

                           "Ada.Strings.Wide_Bounded are available, and "   &

                           "that they produce correct results");

   Test_Block:

   declare

      package BS80 is new Ada.Strings.Wide_Bounded.Generic_Bounded_Length(80);

      use type BS80.Bounded_Wide_String;

      Part1 : constant Wide_String     := Translate("Rum");

      Part2 : Wide_Character           := Translate('p');

      Part3 : BS80.Bounded_Wide_String :=

                BS80.To_Bounded_Wide_String(Translate("el"));

      Part4 : Wide_Character           := Translate('s');

      Part5 : BS80.Bounded_Wide_String :=

                BS80.To_Bounded_Wide_String(Translate("tilt"));

      Part6 : Wide_String(1..3)        := Translate("ski");

      Full_Catenate_String,

      Full_Append_String,

      Constructed_String,

      Drop_String,

      Replicated_String,

      Token_String         : BS80.Bounded_Wide_String;

      CharA : Wide_Character := Translate('A');

      CharB : Wide_Character := Translate('B');

      CharC : Wide_Character := Translate('C');

      CharD : Wide_Character := Translate('D');

      CharE : Wide_Character := Translate('E');

      CharF : Wide_Character := Translate('F');

      ABStr : Wide_String(1..15) := Translate("AAAAABBBBBBBBBB");

      StrB  : Wide_String(1..2)  := Translate("BB");

      StrE  : Wide_String(1..2)  := Translate("EE");

   begin

      -- Evaluation of the overloaded forms of the "&" operator.

      Full_Catenate_String :=

        BS80."&"(Part2,                            -- WChar & Bnd WStr

                 BS80."&"(Part3,                   -- Bnd WStr & Bnd WStr

                          BS80."&"(Part4,          -- WChar & Bnd WStr

                                   BS80."&"(Part5, -- Bnd WStr & Bnd WStr

                                            BS80.To_Bounded_Wide_String

                                              (Part6)))));

      Full_Catenate_String :=

        BS80."&"(Part1, Full_Catenate_String);     -- WStr & Bnd WStr

      Full_Catenate_String :=

        BS80."&"(Left  => Full_Catenate_String,

                 Right => Translate('n'));         -- Bnd WStr & WChar

      -- Evaluation of the overloaded forms of function Append.

      Full_Append_String :=

        BS80.Append(Part2,                               -- WChar,Bnd WStr

          BS80.Append(Part3,                             -- Bnd WStr, Bnd WStr

            BS80.Append(Part4,                           -- WChar,Bnd WStr

              BS80.Append(BS80.To_Wide_String(Part5),    -- WStr,Bnd WStr

                BS80.To_Bounded_Wide_String(Part6)))));

      Full_Append_String :=

        BS80.Append(BS80.To_Bounded_Wide_String(Part1),  -- Bnd WStr, WStr

                    BS80.To_Wide_String(Full_Append_String));

      Full_Append_String :=

        BS80.Append(Left  => Full_Append_String,

                    Right => Translate('n'));             -- Bnd WStr, WChar

      -- Validate the resulting bounded wide strings.

      if BS80."<"(Full_Catenate_String, Full_Append_String) or

         BS80.">"(Full_Catenate_String, Full_Append_String) or

         not (Full_Catenate_String  = Full_Append_String and

              BS80."<="(Full_Catenate_String, Full_Append_String) and

              BS80.">="(Full_Catenate_String, Full_Append_String))

      then

         Report.Failed

           ("Incorrect results from bounded wide string catenation" &

            " and comparison");

      end if;

      -- Evaluate the overloaded forms of the Constructor function "*" and

      -- the Replicate function.

      Constructed_String :=

        BS80."*"(2,CharA) &                     -- "AA"

        BS80."*"(2,StrB) &                      -- "AABBBB"

        BS80."*"(3, BS80."*"(2, CharC)) &       -- "AABBBBCCCCCC"

        BS80.Replicate(3,

                   BS80.Replicate(2, CharD)) &  -- "AABBBBCCCCCCDDDDDD"

        BS80.Replicate(2, StrE) &               -- "AABBBBCCCCCCDDDDDDEEEE"

        BS80.Replicate(2, CharF);               -- "AABBBBCCCCCCDDDDDDEEEEFF"

      -- Use of Function Replicate that involves dropping wide characters.

      -- The attempt to replicate the 15 character wide string six times will

      -- exceed the 80 wide character bound of the wide string.  Therefore,

      -- the result should be the catenation of 5 copies of the 15 character

      -- wide string, followed by 5 'A' wide characters (the first five wide

      -- characters of the 6th replication) with the remaining wide

      -- characters of the 6th replication dropped.

      Drop_String :=

         BS80.Replicate(Count => 6,

                        Item  => ABStr,              -- "AAAAABBBBBBBBBB"

                        Drop  => Ada.Strings.Right);

      if BS80.Element(Drop_String, 1)  /= Translate('A') or

         BS80.Element(Drop_String, 6)  /= Translate('B') or

         BS80.Element(Drop_String, 76) /= Translate('A') or

         BS80.Element(Drop_String, 80) /= Translate('A')

      then

         Report.Failed("Incorrect result from Replicate with Drop");

      end if;

      -- Use function Index_Non_Blank in the evaluation of the

      -- Constructed_String.

      if BS80.Index_Non_Blank(Constructed_String, Ada.Strings.Forward)  /=

         BS80.To_Wide_String(Constructed_String)'First                    or

         BS80.Index_Non_Blank(Constructed_String, Ada.Strings.Backward) /=

         BS80.Length(Constructed_String)

      then

         Report.Failed("Incorrect results from constructor functions");

      end if;

      declare

         -- Define wide character set objects for use with the Count function.

         -- Constructed_String = "AABBBBCCCCCCDDDDDDEEEEFF" from above.

         A_Set : Ada.Strings.Wide_Maps.Wide_Character_Set :=

                 Ada.Strings.Wide_Maps.To_Set(BS80.Element(Constructed_String,

                                                           1));

         B_Set : Ada.Strings.Wide_Maps.Wide_Character_Set :=

                 Ada.Strings.Wide_Maps.To_Set(BS80.Element(Constructed_String,

                                                           3));

         C_Set : Ada.Strings.Wide_Maps.Wide_Character_Set :=

                 Ada.Strings.Wide_Maps.To_Set(BS80.Element(Constructed_String,

                                                           7));

         D_Set : Ada.Strings.Wide_Maps.Wide_Character_Set :=

                 Ada.Strings.Wide_Maps.To_Set(BS80.Element(Constructed_String,

                                                           13));

         E_Set : Ada.Strings.Wide_Maps.Wide_Character_Set :=

                 Ada.Strings.Wide_Maps.To_Set(BS80.Element(Constructed_String,

                                                           19));

         F_Set : Ada.Strings.Wide_Maps.Wide_Character_Set :=

                 Ada.Strings.Wide_Maps.To_Set(BS80.Element(Constructed_String,

                                                           23));

         Start : Positive;

         Stop  : Natural  := 0;

      begin

         -- Evaluate the results from function Count by comparing the number

         -- of A's to the number of F's, B's to E's, and C's to D's in the

         -- Constructed_String.

         -- There should be an equal number of each of the wide characters that

         -- are being compared (i.e., 2 A's and F's, 4 B's and E's, etc)

         if BS80.Count(Constructed_String, A_Set)      /=

            BS80.Count(Constructed_String, F_Set)        or

            BS80.Count(Constructed_String, B_Set)      /=

            BS80.Count(Constructed_String, E_Set)        or

            not (BS80.Count(Constructed_String, C_Set)  =

                 BS80.Count(Constructed_String, D_Set))

         then

            Report.Failed("Incorrect result from function Count");

         end if;

         -- Evaluate the functions Head, Tail, and Find_Token.

         -- Create the Token_String from the Constructed_String above.

         Token_String :=

           BS80.Tail(BS80.Head(Constructed_String,  3), 2) &     -- "AB" &

           BS80.Head(BS80.Tail(Constructed_String, 13), 2) &     -- "CD" &

           BS80.Head(BS80.Tail(Constructed_String,  3), 2);      -- "EF"

         if Token_String /=

            BS80.To_Bounded_Wide_String(Translate("ABCDEF")) then

            Report.Failed("Incorrect result from Catenation of Token_String");

         end if;

         -- Find the starting/ending position of the first A in the

         -- Token_String (both should be 1, only one A appears in string).

         -- The Function Head uses the default pad character to return a

         -- bounded wide string longer than its input parameter bounded

         -- wide string.

         BS80.Find_Token(BS80.Head(Token_String, 10),  -- Default pad.

                         A_Set,

                         Ada.Strings.Inside,

                         Start,

                         Stop);

         if Start /= 1 and Stop /= 1 then

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

         end if;

         -- Find the starting/ending position of the first non-AB slice in

         -- the "head" five wide characters of Token_String (slice CDE at

         -- positions 3-5)

         BS80.Find_Token(BS80.Head(Token_String, 5),               -- "ABCDE"

                         Ada.Strings.Wide_Maps."OR"(A_Set, B_Set), -- Set (AB)

                         Ada.Strings.Outside,

                         Start,

                         Stop);

         if Start /= 3 and Stop /= 5 then

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

         end if;

         -- Find the starting/ending position of the first CD slice in

         -- the "tail" eight wide characters (including two pad wide

         -- characters) of Token_String (slice CD at positions 5-6 of

         -- the tail portion specified)

         BS80.Find_Token(BS80.Tail(Token_String, 8,

                                   Ada.Strings.Wide_Space),

                         Ada.Strings.Wide_Maps."OR"(C_Set, D_Set),

                         Ada.Strings.Inside,

                         Start,

                         Stop);

         if Start /= 5 and Stop /= 6 then

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

         end if;

         -- Evaluate the Replace_Element function.

         -- Token_String = "ABCDEF"

         BS80.Replace_Element(Token_String, 3, BS80.Element(Token_String,4));

         -- Token_String = "ABDDEF"

         BS80.Replace_Element(Source => Token_String,

                              Index  => 2,

                              By     => BS80.Element(Token_String, 5));

         -- Token_String = "AEDDEF"

         BS80.Replace_Element(Token_String,

                              1,

                              BS80.Element(BS80.Tail(Token_String, 2), 2));

         -- Token_String = "FEDDEF"

         -- Evaluate this result.

         if BS80.Element(Token_String,

                         BS80.To_Wide_String(Token_String)'First)  /=

            BS80.Element(Token_String,

                         BS80.To_Wide_String(Token_String)'Last)     or

            BS80.Count(Token_String, D_Set)                        /=

            BS80.Count(Token_String, E_Set)                          or

            BS80.Index_Non_Blank(BS80.Head(Token_String,6))        /=

            BS80.Index_Non_Blank(BS80.Tail(Token_String,6))          or

            BS80.Head(Token_String, 1)                             /=

            BS80.Tail(Token_String, 1)

         then

            Report.Failed("Incorrect result from operations in combination");

         end if;

      end;

   exception

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

   end Test_Block;

   Report.Result;

end CXA4018;