cxa4022.a

xml大全 可读写调用率很高 xml大全 可读写调用率很高

-- CXA4022.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_Unbounded are available, and that they produce 
--      correct results. Specifically, check the subprograms Count, Element,
--      Index, Replace_Element, To_Unbounded_Wide_String, and "&", ">", "<".
--      
-- TEST DESCRIPTION:
--      This test demonstrates the uses of many of the subprograms defined
--      in package Ada.Strings.Wide_Unbounded for use with unbounded wide 
--      strings.  The test simulates how unbounded wide strings 
--      will be processed in a user environment, using the subprograms 
--      provided in this package.
--
--      Taken in conjunction with tests CXA4021 and CXA4023, this test will 
--      constitute a test of the functionality contained in package
--      Ada.Strings.Wide Unbounded.  This test uses a variety
--      of the subprograms defined in the unbounded wide string package
--      in ways typical of common usage, with different combinations of
--      available subprograms being used to accomplish similar 
--      unbounded wide string processing goals.
--      
--       
-- CHANGE HISTORY:
--      06 Dec 94   SAIC    ACVC 2.0
--      08 Nov 95   SAIC    Corrected accessibility level, type visibility,
--                          and subtest acceptance criteria problems for 
--                          ACVC 2.0.1
--
--!

with Ada.Characters.Handling;
with Ada.Strings;

package CXA40220 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 character and string parameters to simulate the use of non-
   -- character Wide_Characters and Wide_Strings in actual practice.
   -- Note: These functions do not actually return "equivalent" wide
   --       characters to their character inputs, just "non-character"
   --       wide characters.

   function Equiv (Ch : Character) return Wide_Character;

   function Equiv (Str : String) return Wide_String;


   -- Functions and access-to-subprogram value used to supply mapping
   -- capability to the appropriate versions of Count, Index, and 
   -- Translate.

   function AB_to_US_Mapping_Function (From : Wide_Character) 
     return Wide_Character;

   function AB_to_Blank_Mapping_Function (From : Wide_Character) 
     return Wide_Character;

end CXA40220;

package body CXA40220 is

   function Equiv (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 Equiv;


   function Equiv (Str : String) return Wide_String is
      WS : Wide_String(Str'First..Str'Last);
   begin
      for i in Str'First..Str'Last loop
         WS(i) := Equiv(Str(i));
      end loop;
      return WS;
   end Equiv;


   function AB_to_US_Mapping_Function (From : Wide_Character) 
     return Wide_Character is
      UnderScore : constant Wide_Character := Equiv('_');
   begin
      if From = Equiv('a')  or  From = Equiv('b')  then
         return UnderScore;
      else
         return From;
      end if;
   end AB_to_US_Mapping_Function;


   function AB_to_Blank_Mapping_Function (From : Wide_Character) 
     return Wide_Character is
   begin
      if From = Equiv('a')  or  From = Equiv('b') then
         return Ada.Strings.Wide_Space;
      else
         return From;
      end if;
   end AB_to_Blank_Mapping_Function;

end CXA40220;


with CXA40220;
with Report;
with Ada.Characters.Handling;
with Ada.Strings.Wide_Maps;
with Ada.Strings.Wide_Unbounded;

procedure CXA4022 is
begin

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

   Test_Block:
   declare

      use CXA40220;

      package ASW renames Ada.Strings.Wide_Unbounded;
      use Ada.Strings;
      use type Wide_Maps.Wide_Character_Set;
      use type ASW.Unbounded_Wide_String;

      Test_String       : ASW.Unbounded_Wide_String;
      AtoE_Str          : ASW.Unbounded_Wide_String :=
                            ASW.To_Unbounded_Wide_String(Equiv("abcde"));

      Complete_String   : ASW.Unbounded_Wide_String := 
            ASW."&"(ASW.To_Unbounded_Wide_String(Equiv("Incomplete")),
                    ASW."&"(Ada.Strings.Wide_Space,
                            ASW.To_Unbounded_Wide_String(Equiv("String"))));

      Incomplete_String  : ASW.Unbounded_Wide_String :=
                             ASW.To_Unbounded_Wide_String
                               (Equiv("ncomplete Strin"));

      Incorrect_Spelling : ASW.Unbounded_Wide_String :=
                             ASW.To_Unbounded_Wide_String(Equiv("Guob Dai"));

      Magic_String       : ASW.Unbounded_Wide_String :=
           ASW.To_Unbounded_Wide_String(Equiv("abracadabra"));

      Incantation        : ASW.Unbounded_Wide_String := Magic_String;


      A_Small_G    : Wide_Character := Equiv('g');
      A_Small_D    : Wide_Character := Equiv('d');

      ABCD_Set     : Wide_Maps.Wide_Character_Set := 
                       Wide_Maps.To_Set(Equiv("abcd"));
      B_Set        : Wide_Maps.Wide_Character_Set := 
                       Wide_Maps.To_Set(Equiv('b'));
      CD_Set       : Wide_Maps.Wide_Character_Set := 
                       Wide_Maps.To_Set(Equiv("cd"));

      CD_to_XY_Map : Wide_Maps.Wide_Character_Mapping := 
                       Wide_Maps.To_Mapping(From => Equiv("cd"), 
                                            To   => Equiv("xy"));
      AB_to_YZ_Map : Wide_Maps.Wide_Character_Mapping := 
                       Wide_Maps.To_Mapping(Equiv("ab"), Equiv("yz"));


      Matching_Letters : Natural := 0;
      Location,
      Total_Count      : Natural := 0;


      Map_Ptr : Wide_Maps.Wide_Character_Mapping_Function :=
                  AB_to_US_Mapping_Function'Access;


   begin


      -- Function "&"

      -- Prepend an 'I' and append a 'g' to the wide string.
      Incomplete_String := ASW."&"(Equiv('I'), 
                                   Incomplete_String);       -- Ch & W Unb
      Incomplete_String := ASW."&"(Incomplete_String, 
                                   A_Small_G);               -- W Unb & Ch

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



      -- Function Element

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

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


      -- Procedure Replace_Element

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

      ASW.Replace_Element(Incorrect_Spelling, 2, Equiv('o'));

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

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

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