| -- CXA4023.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 Delete, |
| -- Find_Token, Translate, Trim, 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. |
| -- |
| -- This test, when taken in conjunction with tests CXA4021-22, 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 and type |
| -- visibility problems for ACVC 2.0.1. |
| -- |
| --! |
| |
| with Ada.Characters.Handling; |
| with Ada.Strings; |
| |
| package CXA40230 is |
| |
| -- The following two functions are used to translate character and string |
| -- values to non-character "Wide" values. They will be applied to all the |
| -- Wide_Bounded subprogram character and string parameters to simulate the |
| -- use of 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 object used to supply mapping |
| -- capability to the appropriate versions of 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 CXA40230; |
| |
| |
| package body CXA40230 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 CXA40230; |
| |
| |
| with CXA40230; |
| with Report; |
| with Ada.Characters.Handling; |
| with Ada.Strings.Wide_Maps; |
| with Ada.Strings.Wide_Unbounded; |
| |
| procedure CXA4023 is |
| begin |
| |
| Report.Test ("CXA4023", "Check that the subprograms defined in " & |
| "package Ada.Strings.Wide_Unbounded are " & |
| "available, and that they produce correct " & |
| "results"); |
| |
| Test_Block: |
| declare |
| |
| use CXA40230; |
| |
| 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")); |
| |
| Cad_String : ASW.Unbounded_Wide_String := |
| ASW.To_Unbounded_Wide_String(Equiv("cad")); |
| |
| 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'); |
| |
| 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')); |
| AB_Set : Wide_Maps.Wide_Character_Set := |
| Wide_Maps."OR"(Wide_Maps.To_Set(Equiv('a')), B_Set); |
| |
| |
| AB_to_YZ_Map : Wide_Maps.Wide_Character_Mapping := |
| Wide_Maps.To_Mapping(From => Equiv("ab"), |
| To => Equiv("yz")); |
| Code_Map : Wide_Maps.Wide_Character_Mapping := |
| Wide_Maps.To_Mapping(Equiv("abcd"), Equiv("wxyz")); |
| Reverse_Code_Map : Wide_Maps.Wide_Character_Mapping := |
| Wide_Maps.To_Mapping(Equiv("wxyz"), Equiv("abcd")); |
| Non_Existent_Map : Wide_Maps.Wide_Character_Mapping := |
| Wide_Maps.To_Mapping(Equiv("jkl"), Equiv("mno")); |
| |
| |
| Token_Start : Positive; |
| Token_End : Natural := 0; |
| |
| Map_Ptr : Wide_Maps.Wide_Character_Mapping_Function := |
| AB_to_US_Mapping_Function'Access; |
| |
| |
| begin |
| |
| -- Find_Token |
| |
| ASW.Find_Token(Magic_String, -- Find location of first "ab" equiv. |
| AB_Set, -- Should be (1..2). |
| Ada.Strings.Inside, |
| Token_Start, |
| Token_End); |
| |
| if Natural(Token_Start) /= ASW.To_Wide_String(Magic_String)'First or |
| Token_End /= ASW.Index(Magic_String, B_Set) or |
| Token_End /= 2 |
| then |
| Report.Failed("Incorrect result from Procedure Find_Token - 1"); |
| end if; |
| |
| |
| ASW.Find_Token(Source => Magic_String, -- Find location of char 'r'equiv |
| Set => ABCD_Set, -- in wide str, 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; |
| |
| |
| ASW.Find_Token(Magic_String, -- No 'g' "equivalent in |
| Wide_Maps.To_Set(A_Small_G), -- the wide str, so the |
| Ada.Strings.Inside, -- result params should be |
| First => Token_Start, -- First = Source'First and |
| Last => Token_End); -- Last = 0. |
| |
| |
| if Token_Start /= ASW.To_Wide_String(Magic_String)'First or |
| Token_End /= 0 |
| then |
| Report.Failed("Incorrect result from Procedure Find_Token - 3"); |
| end if; |
| |
| |
| ASW.Find_Token(ASW.To_Unbounded_Wide_String(Equiv("abpqpqrttrcpqr")), |
| Wide_Maps.To_Set(Equiv("trpq")), |
| Ada.Strings.Inside, |
| Token_Start, |
| Token_End); |
| |
| if Token_Start /= 3 or |
| Token_End /= 10 |
| then |
| Report.Failed("Incorrect result from Procedure Find_Token - 4"); |
| end if; |
| |
| ASW.Find_Token(ASW.To_Unbounded_Wide_String(Equiv("abpqpqrttrcpqr")), |
| Wide_Maps.To_Set(Equiv("abpq")), |
| Ada.Strings.Outside, |
| Token_Start, |
| Token_End); |
| |
| if Token_Start /= 7 or |
| Token_End /= 11 |
| then |
| Report.Failed("Incorrect result from Procedure Find_Token - 5"); |
| end if; |
| |
| |
| |
| -- Translate |
| |
| -- Use a mapping ("abcd" -> "wxyz") to transform the contents of |
| -- the unbounded wide string. |
| -- Magic_String = "abracadabra" |
| |
| Incantation := ASW.Translate(Magic_String, Code_Map); |
| |
| if Incantation /= |
| ASW.To_Unbounded_Wide_String(Equiv("wxrwywzwxrw")) |
| then |
| Report.Failed("Incorrect result from Function Translate - 1"); |
| end if; |
| |
| -- (Note: See below for additional testing of Function Translate) |
| |
| -- Use the inverse mapping of the one above to return the "translated" |
| -- unbounded wide string to its original form. |
| |
| ASW.Translate(Incantation, Reverse_Code_Map); |
| |
| -- The map contained in the following call to Translate contains three |
| -- elements, and these elements are not found in the unbounded wide |
| -- string, so this call to Translate should have no effect on it. |
| |
| if Incantation /= ASW.Translate(Magic_String, Non_Existent_Map) then |
| Report.Failed("Incorrect result from Procedure Translate - 1"); |
| end if; |
| |
| -- Partial mapping of source. |
| |
| Test_String := ASW.To_Unbounded_Wide_String(Equiv("abcdeabcab")); |
| |
| ASW.Translate(Source => Test_String, Mapping => AB_to_YZ_Map); |
| |
| if Test_String /= ASW.To_Unbounded_Wide_String(Equiv("yzcdeyzcyz")) then |
| Report.Failed("Incorrect result from Procedure Translate - 2"); |
| end if; |
| |
| -- Total mapping of source. |
| |
| Test_String := ASW.To_Unbounded_Wide_String(Equiv("abbaaababb")); |
| |
| ASW.Translate(Source => Test_String, Mapping => AB_to_YZ_Map); |
| |
| if Test_String /= ASW.To_Unbounded_Wide_String(Equiv("yzzyyyzyzz")) then |
| Report.Failed("Incorrect result from Procedure Translate - 3"); |
| end if; |
| |
| -- No mapping of source. |
| |
| Test_String := ASW.To_Unbounded_Wide_String(Equiv("xyzsypcc")); |
| |
| ASW.Translate(Source => Test_String, Mapping => AB_to_YZ_Map); |
| |
| if Test_String /= ASW.To_Unbounded_Wide_String(Equiv("xyzsypcc")) then |
| Report.Failed("Incorrect result from Procedure Translate - 4"); |
| end if; |
| |
| -- Map > 2 characters, partial mapping. |
| |
| Test_String := ASW.To_Unbounded_Wide_String(Equiv("opabcdelmn")); |
| |
| ASW.Translate(Test_String, |
| Wide_Maps.To_Mapping(Equiv("abcde"), Equiv("lmnop"))); |
| |
| if Test_String /= ASW.To_Unbounded_Wide_String(Equiv("oplmnoplmn")) then |
| Report.Failed("Incorrect result from Procedure Translate - 5"); |
| end if; |
| |
| |
| |
| -- Various degrees of mapping of source (full, partial, none) used |
| -- with Function Translate. |
| |
| if ASW.Translate( |
| ASW.To_Unbounded_Wide_String(Equiv("abcdeabcabbbaaacaa")), |
| AB_to_YZ_Map) /= |
| ASW.To_Unbounded_Wide_String(Equiv("yzcdeyzcyzzzyyycyy")) or |
| |
| ASW.Translate( |
| ASW.To_Unbounded_Wide_String(Equiv("abbaaababbaaaaba")), |
| AB_to_YZ_Map) /= |
| ASW.To_Unbounded_Wide_String(Equiv("yzzyyyzyzzyyyyzy")) or |
| |
| ASW.Translate(ASW.To_Unbounded_Wide_String(Equiv("cABcABBAc")), |
| Mapping => AB_to_YZ_Map) /= |
| ASW.To_Unbounded_Wide_String(Equiv("cABcABBAc")) or |
| |
| ASW.Translate(ASW.To_Unbounded_Wide_String("opabcdelmnddeaccabec"), |
| Wide_Maps.To_Mapping("abcde", "lmnop")) /= |
| ASW.To_Unbounded_Wide_String("oplmnoplmnooplnnlmpn") |
| then |
| Report.Failed("Incorrect result from Function Translate - 2"); |
| end if; |
| |
| |
| |
| -- Procedure Translate using access-to-subprogram mapping. |
| -- Partial mapping of source. |
| |
| Map_Ptr := AB_to_Blank_Mapping_Function'Access; |
| |
| Test_String := ASW.To_Unbounded_Wide_String(Equiv("abABaABbaBAbba")); |
| |
| ASW.Translate(Source => Test_String, -- change equivalent of 'a' and |
| Mapping => Map_Ptr); -- 'b' to ' ' |
| |
| if Test_String /= |
| ASW.To_Unbounded_Wide_String(Equiv(" AB AB BA ")) |
| then |
| Report.Failed |
| ("Incorrect result from Proc Translate, w/ access value map - 1"); |
| end if; |
| |
| -- Total mapping of source to blanks. |
| |
| Test_String := ASW.To_Unbounded_Wide_String(Equiv("abbbab")); |
| |
| ASW.Translate(Source => Test_String, |
| Mapping => Map_Ptr); |
| |
| if Test_String /= |
| ASW.To_Unbounded_Wide_String(Equiv(" ")) |
| then |
| Report.Failed |
| ("Incorrect result from Proc Translate, w/ access value map - 2"); |
| end if; |
| |
| -- No mapping of source. |
| |
| Map_Ptr := AB_to_US_Mapping_Function'Access; |
| |
| Test_String := ASW.To_Unbounded_Wide_String(Equiv("xyzsypcc")); |
| |
| ASW.Translate(Source => Test_String, |
| Mapping => Map_Ptr); |
| |
| if Test_String /= |
| ASW.To_Unbounded_Wide_String(Equiv("xyzsypcc")) -- no change |
| then |
| Report.Failed |
| ("Incorrect result from Proc Translate, w/ access value map - 3"); |
| end if; |
| |
| |
| -- Function Translate using access-to-subprogram mapping value. |
| |
| Map_Ptr := AB_to_Blank_Mapping_Function'Access; |
| |
| Test_String := ASW.To_Unbounded_Wide_String(Equiv("abAbBBAabbacD")); |
| |
| if ASW.Translate(ASW.Translate(Test_String, Map_Ptr), Map_Ptr) /= |
| ASW.To_Unbounded_Wide_String(Equiv(" A BBA cD")) |
| then |
| Report.Failed |
| ("Incorrect result from Function Translate, access value map - 1"); |
| end if; |
| |
| if ASW.Translate(Source => ASW.To_Unbounded_Wide_String(Equiv("a")), |
| Mapping => Map_Ptr) /= |
| ASW.To_Unbounded_Wide_String(Equiv(" ")) or |
| ASW.Translate(ASW.To_Unbounded_Wide_String |
| (Equiv(" aa Aa A AAaaa a aA")), |
| Map_Ptr) /= |
| ASW.To_Unbounded_Wide_String(Equiv(" A A AA A")) or |
| ASW.Translate(Source => ASW.To_Unbounded_Wide_String(Equiv("a ")), |
| Mapping => Map_Ptr) /= |
| ASW.To_Unbounded_Wide_String(Equiv(" ")) or |
| ASW.Translate(Source => ASW.To_Unbounded_Wide_String(Equiv("xyz")), |
| Mapping => Map_Ptr) /= |
| ASW.To_Unbounded_Wide_String(Equiv("xyz")) |
| then |
| Report.Failed |
| ("Incorrect result from Function Translate, access value map - 2"); |
| end if; |
| |
| |
| |
| -- Trim |
| |
| Trim_Block: |
| declare |
| |
| XYZ_Set : Wide_Maps.Wide_Character_Set := |
| Wide_Maps.To_Set(Equiv("xyz")); |
| PQR_Set : Wide_Maps.Wide_Character_Set := |
| Wide_Maps.To_Set(Equiv("pqr")); |
| |
| Pad : constant ASW.Unbounded_Wide_String := |
| ASW.To_Unbounded_Wide_String(Equiv("Pad")); |
| |
| The_New_Ada : constant ASW.Unbounded_Wide_String := |
| ASW.To_Unbounded_Wide_String(Equiv("Ada9X")); |
| |
| Space_Array : array (1..4) of ASW.Unbounded_Wide_String := |
| (ASW.To_Unbounded_Wide_String(Equiv(" Pad ")), |
| ASW.To_Unbounded_Wide_String(Equiv("Pad ")), |
| ASW.To_Unbounded_Wide_String(Equiv(" Pad")), |
| Pad); |
| |
| String_Array : array (1..5) of ASW.Unbounded_Wide_String := |
| (ASW.To_Unbounded_Wide_String(Equiv("xyzxAda9Xpqr")), |
| ASW.To_Unbounded_Wide_String(Equiv("Ada9Xqqrp")), |
| ASW.To_Unbounded_Wide_String(Equiv("zxyxAda9Xqpqr")), |
| ASW.To_Unbounded_Wide_String(Equiv("xxxyAda9X")), |
| The_New_Ada); |
| |
| begin |
| |
| -- Examine the version of Trim that removes blanks from |
| -- the left and/or right of a wide string. |
| |
| for i in 1..4 loop |
| if ASW.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 wide string. |
| |
| for i in 1..5 loop |
| if ASW.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; |
| |
| -- No trimming. |
| |
| if ASW.Trim( |
| ASW.To_Unbounded_Wide_String(Equiv("prqqprAda9Xyzzxyzzyz")), |
| XYZ_Set, |
| PQR_Set) /= |
| ASW.To_Unbounded_Wide_String(Equiv("prqqprAda9Xyzzxyzzyz")) |
| then |
| Report.Failed |
| ("Incorrect result from Trim for set, no trimming"); |
| end if; |
| |
| end Trim_Block; |
| |
| |
| |
| -- Delete |
| |
| -- Use the Delete function to remove the first four and last four |
| -- characters from the wide string. |
| |
| if ASW.Delete(Source => ASW.Delete(Magic_String, |
| 8, |
| ASW.Length(Magic_String)), |
| From => ASW.To_Wide_String(Magic_String)'First, |
| Through => 4) /= |
| Cad_String |
| then |
| Report.Failed("Incorrect results from Function Delete"); |
| end if; |
| |
| |
| |
| -- Constructors ("*") |
| |
| Constructor_Block: |
| declare |
| |
| SOS : ASW.Unbounded_Wide_String; |
| |
| Dot : constant ASW.Unbounded_Wide_String := |
| ASW.To_Unbounded_Wide_String(Equiv("Dot_")); |
| Dash : constant Wide_String := Equiv("Dash_"); |
| |
| Distress : ASW.Unbounded_Wide_String := |
| ASW."&"(ASW.To_Unbounded_Wide_String |
| (Equiv("Dot_Dot_Dot_")), |
| ASW."&"(ASW.To_Unbounded_Wide_String |
| (Equiv("Dash_Dash_Dash_")), |
| ASW.To_Unbounded_Wide_String |
| (Equiv("Dot_Dot_Dot")))); |
| |
| Repeat : constant Natural := 3; |
| Separator : constant Wide_Character := Equiv('_'); |
| |
| Separator_Set : Wide_Maps.Wide_Character_Set := |
| Wide_Maps.To_Set(Separator); |
| |
| begin |
| |
| -- Use the following constructor forms to construct the wide string |
| -- "Dot_Dot_Dot_Dash_Dash_Dash_Dot_Dot_Dot". Note that the |
| -- trailing underscore in the wide string is removed in the call to |
| -- Trim in the If statement condition. |
| |
| SOS := ASW."*"(Repeat, Dot); -- "*"(#, W Unb Str) |
| |
| SOS := ASW."&"(SOS, |
| ASW."&"(ASW."*"(Repeat, Dash), -- "*"(#, W Str) |
| ASW."*"(Repeat, Dot))); -- "*"(#, W Unb Str) |
| |
| if ASW.Trim(SOS, Wide_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 CXA4023; |
