| -- 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; |
| |
| |
| |
| -- Function Index with non-Identity map. |
| -- Evaluate the function Index with a non-identity map |
| -- parameter which will cause mapping of the source parameter |
| -- prior to the evaluation of the index position search. |
| |
| Location := ASW.Index(Source => ASW.To_Unbounded_Wide_String |
| (Equiv("abcdefghij")), |
| Pattern => Equiv("xy"), |
| Going => Ada.Strings.Forward, |
| Mapping => CD_to_XY_Map); -- change "cd" to "xy" |
| |
| if Location /= 3 then |
| Report.Failed("Incorrect result from Index, non-Identity map - 1"); |
| end if; |
| |
| Location := ASW.Index(ASW.To_Unbounded_Wide_String(Equiv("abcdabcdab")), |
| Equiv("yz"), |
| Ada.Strings.Backward, |
| AB_to_YZ_Map); -- change all "ab" to "yz" |
| |
| if Location /= 9 then |
| Report.Failed("Incorrect result from Index, non-Identity map - 2"); |
| end if; |
| |
| -- A couple with identity maps (default) as well. |
| |
| if ASW.Index(ASW.To_Unbounded_Wide_String(Equiv("abcd")), -- Pat = Src |
| Equiv("abcd")) /= 1 or |
| ASW.Index(ASW.To_Unbounded_Wide_String(Equiv("abc")), -- Pat < Src |
| Equiv("abcd")) /= 0 or |
| ASW.Index(ASW.Null_Unbounded_Wide_String, -- Src = Null |
| Equiv("abc")) /= 0 |
| then |
| Report.Failed |
| ("Incorrect result from Index with wide string patterns"); |
| end if; |
| |
| |
| |
| -- Function Index (for Sets). |
| -- This version of Index uses Sets as the basis of the search. |
| |
| -- Test = Inside, Going = Forward (Default case). |
| Location := |
| ASW.Index(Source => ASW.To_Unbounded_Wide_String(Equiv("abcdeabcde")), |
| Set => CD_Set); -- set containing 'c' and 'd' |
| |
| if not (Location = 3) then -- position of first 'c' in source. |
| Report.Failed("Incorrect result from Index using Sets - 1"); |
| end if; |
| |
| -- Test = Inside, Going = Backward. |
| Location := |
| ASW.Index(Source => ASW."&"(AtoE_Str, AtoE_Str), |
| Set => CD_Set, -- set containing 'c' and 'd' |
| Test => Ada.Strings.Inside, |
| Going => Ada.Strings.Backward); |
| |
| if not (Location = 9) then -- position of last 'd' in source. |
| Report.Failed("Incorrect result from Index using Sets - 2"); |
| end if; |
| |
| -- Test = Outside, Going = Forward, Backward |
| if ASW.Index(ASW.To_Unbounded_Wide_String(Equiv("deddacd")), |
| Wide_Maps.To_Set(Equiv("xydcgf")), |
| Test => Ada.Strings.Outside, |
| Going => Ada.Strings.Forward) /= 2 or |
| ASW.Index(ASW.To_Unbounded_Wide_String(Equiv("deddacd")), |
| Wide_Maps.To_Set(Equiv("xydcgf")), |
| Test => Ada.Strings.Outside, |
| Going => Ada.Strings.Backward) /= 5 or |
| ASW.Index(ASW.To_Unbounded_Wide_String(Equiv("deddacd")), |
| CD_Set, |
| Ada.Strings.Outside, |
| Ada.Strings.Backward) /= 5 |
| then |
| Report.Failed("Incorrect result from Index using Sets - 3"); |
| end if; |
| |
| -- Default direction (forward) and mapping (identity). |
| |
| if ASW.Index(ASW.To_Unbounded_Wide_String(Equiv("cd")), -- Source = Set |
| CD_Set) /= 1 or |
| ASW.Index(ASW.To_Unbounded_Wide_String(Equiv("c")), -- Source < Set |
| CD_Set) /= 1 or |
| ASW.Index(ASW.Null_Unbounded_Wide_String, -- Source = Null |
| CD_Set) /= 0 or |
| ASW.Index(AtoE_Str, |
| Wide_Maps.Null_Set) /= 0 or -- Null set |
| ASW.Index(AtoE_Str, |
| Wide_Maps.To_Set(Equiv('x'))) /= 0 -- No match. |
| then |
| Report.Failed("Incorrect result from Index using Sets - 4"); |
| end if; |
| |
| |
| |
| -- Function Index using access-to-subprogram mapping. |
| -- Evaluate the function Index with an access value that supplies the |
| -- mapping function for this version of Index. |
| |
| Map_Ptr := AB_to_US_Mapping_Function'Access; |
| |
| Location := ASW.Index(Source => ASW.To_Unbounded_Wide_String |
| (Equiv("xAxabbxax xaax _cx")), |
| Pattern => Equiv("_x"), |
| Going => Ada.Strings.Forward, |
| Mapping => Map_Ptr); -- change 'a'or 'b' to '_' |
| |
| if Location /= 6 then -- location of "bx" substring |
| Report.Failed("Incorrect result from Index, access value map - 1"); |
| end if; |
| |
| Map_Ptr := AB_to_Blank_Mapping_Function'Access; |
| |
| Location := ASW.Index(ASW.To_Unbounded_Wide_String |
| (Equiv("ccacdcbbcdacc")), |
| Equiv("cd "), |
| Ada.Strings.Backward, |
| Map_Ptr); -- change 'a' or 'b' to ' ' |
| |
| if Location /= 9 then |
| Report.Failed("Incorrect result from Index, access value map - 2"); |
| end if; |
| |
| if ASW.Index(ASW.To_Unbounded_Wide_String(Equiv("abcd")), |
| Equiv(" cd"), |
| Ada.Strings.Forward, |
| Map_Ptr) /= 1 or |
| ASW.Index(ASW.To_Unbounded_Wide_String(Equiv("abc")), |
| Equiv(" c "), -- No match |
| Ada.Strings.Backward, |
| Map_Ptr) /= 0 |
| then |
| Report.Failed("Incorrect result from Index, access value map - 3"); |
| end if; |
| |
| |
| |
| -- Function Count |
| |
| -- Determine the number of characters in the unbounded wide string that |
| -- are contained in the set. |
| |
| Matching_Letters := ASW.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 wide |
| -- strings in the unbounded wide string Magic_String. |
| |
| if ASW.Count(Magic_String, Equiv("ab")) /= |
| (ASW.Count(Magic_String, Equiv("ac")) + |
| ASW.Count(Magic_String, Equiv("ad"))) or |
| ASW.Count(Magic_String, Equiv("ab")) /= 2 |
| then |
| Report.Failed |
| ("Incorrect result from Function Count, wide string parameter"); |
| end if; |
| |
| |
| |
| -- Function Count with non-Identity mapping. |
| -- Evaluate the function Count with a non-identity map |
| -- parameter which will cause mapping of the source parameter |
| -- prior to the evaluation of the number of matching patterns. |
| |
| Total_Count := |
| ASW.Count(ASW.To_Unbounded_Wide_String(Equiv("abbabbabbabba")), |
| Pattern => Equiv("yz"), |
| Mapping => AB_to_YZ_Map); |
| |
| if Total_Count /= 4 then |
| Report.Failed |
| ("Incorrect result from function Count, non-Identity map - 1"); |
| end if; |
| |
| if ASW.Count(ASW.To_Unbounded_Wide_String(Equiv("ADCBADABCD")), |
| Equiv("AB"), |
| Wide_Maps.To_Mapping(Equiv("CD"), Equiv("AB"))) /= 5 or |
| ASW.Count(ASW.To_Unbounded_Wide_String(Equiv("dcccddcdccdddccccd")), |
| Equiv("xxy"), |
| CD_to_XY_Map) /= 3 |
| then |
| Report.Failed |
| ("Incorrect result from function Count, non-Identity map - 2"); |
| end if; |
| |
| -- And a few with identity Wide_Maps as well. |
| |
| if ASW.Count(ASW.To_Unbounded_Wide_String(Equiv("ABABABABAB")), |
| Equiv("ABA"), |
| Wide_Maps.Identity) /= 2 or |
| ASW.Count(ASW.To_Unbounded_Wide_String(Equiv("aaaaaaaaaa")), |
| Equiv("aaa")) /= 3 or |
| ASW.Count(ASW.To_Unbounded_Wide_String(Equiv("XX")), -- Src < Pat |
| Equiv("XXX"), |
| Wide_Maps.Identity) /= 0 or |
| ASW.Count(AtoE_Str, -- Source = Pattern |
| Equiv("abcde")) /= 1 or |
| ASW.Count(ASW.Null_Unbounded_Wide_String, -- Source = Null |
| Equiv(" ")) /= 0 |
| then |
| Report.Failed |
| ("Incorrect result from function Count, w,w/o mapping"); |
| end if; |
| |
| |
| |
| -- Function Count using access-to-subprogram mapping. |
| -- Evaluate the function Count with an access value specifying the |
| -- mapping that is going to occur to Source. |
| |
| Map_Ptr := AB_to_US_Mapping_Function'Access; |
| |
| Total_Count := |
| ASW.Count(ASW.To_Unbounded_Wide_String(Equiv("abcbacbadbaAbbB")), |
| Pattern => Equiv("__"), |
| Mapping => Map_Ptr); -- change 'a' and 'b' to '_' |
| |
| if Total_Count /= 5 then |
| Report.Failed |
| ("Incorrect result from function Count, access value map - 1"); |
| end if; |
| |
| Map_Ptr := AB_to_Blank_Mapping_Function'Access; |
| |
| if ASW.Count(ASW.To_Unbounded_Wide_String(Equiv("cccaccBcbcaccacAc")), |
| Equiv("c c"), |
| Map_Ptr) /= 3 or |
| ASW.Count(ASW.To_Unbounded_Wide_String |
| (Equiv("aBBAAABaBBBBAaBABBABaBBbBB")), |
| Equiv(" BB"), |
| Map_Ptr) /= 4 or |
| ASW.Count(ASW.To_Unbounded_Wide_String(Equiv("aaaaaaaaaa")), |
| Equiv(" "), |
| Map_Ptr) /= 3 or |
| ASW.Count(ASW.To_Unbounded_Wide_String(Equiv("XX")), -- Src < Pat |
| Equiv("XX "), |
| Map_Ptr) /= 0 or |
| ASW.Count(AtoE_Str, -- Source'Length = Pattern'Length |
| Equiv(" cde"), |
| Map_Ptr) /= 1 |
| then |
| Report.Failed |
| ("Incorrect result from function Count, access value map - 3"); |
| end if; |
| |
| |
| |
| exception |
| when others => Report.Failed ("Exception raised in Test_Block"); |
| end Test_Block; |
| |
| |
| Report.Result; |
| |
| end CXA4022; |
