Debian Codegraph @

gcc/testsuite/ada/acats/tests/cxa/cxa4018.a

raw
1 -- CXA4018.A
2 --
3 -- Grant of Unlimited Rights
4 --
5 -- Under contracts F33600-87-D-0337, F33600-84-D-0280, MDA903-79-C-0687,
6 -- F08630-91-C-0015, and DCA100-97-D-0025, the U.S. Government obtained
7 -- unlimited rights in the software and documentation contained herein.
8 -- Unlimited rights are defined in DFAR 252.227-7013(a)(19). By making
9 -- this public release, the Government intends to confer upon all
10 -- recipients unlimited rights equal to those held by the Government.
11 -- These rights include rights to use, duplicate, release or disclose the
12 -- released technical data and computer software in whole or in part, in
13 -- any manner and for any purpose whatsoever, and to have or permit others
14 -- to do so.
15 --
16 -- DISCLAIMER
17 --
18 -- ALL MATERIALS OR INFORMATION HEREIN RELEASED, MADE AVAILABLE OR
19 -- DISCLOSED ARE AS IS. THE GOVERNMENT MAKES NO EXPRESS OR IMPLIED
20 -- WARRANTY AS TO ANY MATTER WHATSOEVER, INCLUDING THE CONDITIONS OF THE
21 -- SOFTWARE, DOCUMENTATION OR OTHER INFORMATION RELEASED, MADE AVAILABLE
22 -- OR DISCLOSED, OR THE OWNERSHIP, MERCHANTABILITY, OR FITNESS FOR A
23 -- PARTICULAR PURPOSE OF SAID MATERIAL.
24 --*
25 --
26 -- OBJECTIVE:
27 -- Check that the subprograms defined in package
28 -- Ada.Strings.Wide_Bounded are available, and that they produce
29 -- correct results. Specifically, check the subprograms Append,
30 -- Count, Element, Find_Token, Head, Index_Non_Blank, Replace_Element,
31 -- Replicate, Tail, To_Bounded_Wide_String, "&", ">", "<", ">=", "<=",
32 -- and "*".
33 --
34 -- TEST DESCRIPTION:
35 -- This test, when taken in conjunction with test CXA40[17,19,20], will
36 -- constitute a test of all the functionality contained in package
37 -- Ada.Strings.Wide_Bounded. This test uses a variety of the
38 -- subprograms defined in the wide bounded string package in ways typical
39 -- of common usage. Different combinations of available subprograms
40 -- are used to accomplish similar wide bounded string processing goals.
41 --
42 --
43 -- CHANGE HISTORY:
44 -- 06 Dec 94 SAIC ACVC 2.0
45 -- 22 Dec 94 SAIC Changed obsolete constant to Strings.Wide_Space.
46 -- 06 Nov 95 SAIC Corrected evaluation string used in Head/Tail
47 -- subtests for ACVC 2.0.1.
48 --
49 --!
50
51 with Ada.Strings;
52 with Ada.Strings.Wide_Bounded;
53 with Ada.Characters.Handling;
54 with Ada.Strings.Wide_Maps;
55 with Report;
56
57 procedure CXA4018 is
58
59 -- The following two functions are used to translate character and string
60 -- values to "Wide" values. They will be applied to all the Wide_Bounded
61 -- subprogram parameters to simulate the use of Wide_Characters and
62 -- Wide_Strings in actual practice. Blanks are translated to Wide_Character
63 -- blanks and all other characters are translated into Wide_Characters with
64 -- position values 256 greater than their (narrow) character position
65 -- values.
66
67 function Translate (Ch : Character) return Wide_Character is
68 C : Character := Ch;
69 begin
70 if Ch = ' ' then
71 return Ada.Characters.Handling.To_Wide_Character(C);
72 else
73 return Wide_Character'Val(Character'Pos(Ch) +
74 Character'Pos(Character'Last) + 1);
75 end if;
76 end Translate;
77
78 function Translate (Str : String) return Wide_String is
79 WS : Wide_String(Str'First..Str'Last);
80 begin
81 for i in Str'First..Str'Last loop
82 WS(i) := Translate(Str(i));
83 end loop;
84 return WS;
85 end Translate;
86
87
88 begin
89
90 Report.Test ("CXA4018", "Check that the subprograms defined in package " &
91 "Ada.Strings.Wide_Bounded are available, and " &
92 "that they produce correct results");
93
94 Test_Block:
95 declare
96
97 package BS80 is new Ada.Strings.Wide_Bounded.Generic_Bounded_Length(80);
98 use type BS80.Bounded_Wide_String;
99
100 Part1 : constant Wide_String := Translate("Rum");
101 Part2 : Wide_Character := Translate('p');
102 Part3 : BS80.Bounded_Wide_String :=
103 BS80.To_Bounded_Wide_String(Translate("el"));
104 Part4 : Wide_Character := Translate('s');
105 Part5 : BS80.Bounded_Wide_String :=
106 BS80.To_Bounded_Wide_String(Translate("tilt"));
107 Part6 : Wide_String(1..3) := Translate("ski");
108
109 Full_Catenate_String,
110 Full_Append_String,
111 Constructed_String,
112 Drop_String,
113 Replicated_String,
114 Token_String : BS80.Bounded_Wide_String;
115
116 CharA : Wide_Character := Translate('A');
117 CharB : Wide_Character := Translate('B');
118 CharC : Wide_Character := Translate('C');
119 CharD : Wide_Character := Translate('D');
120 CharE : Wide_Character := Translate('E');
121 CharF : Wide_Character := Translate('F');
122
123 ABStr : Wide_String(1..15) := Translate("AAAAABBBBBBBBBB");
124 StrB : Wide_String(1..2) := Translate("BB");
125 StrE : Wide_String(1..2) := Translate("EE");
126
127
128 begin
129
130 -- Evaluation of the overloaded forms of the "&" operator.
131
132 Full_Catenate_String :=
133 BS80."&"(Part2, -- WChar & Bnd WStr
134 BS80."&"(Part3, -- Bnd WStr & Bnd WStr
135 BS80."&"(Part4, -- WChar & Bnd WStr
136 BS80."&"(Part5, -- Bnd WStr & Bnd WStr
137 BS80.To_Bounded_Wide_String
138 (Part6)))));
139
140 Full_Catenate_String :=
141 BS80."&"(Part1, Full_Catenate_String); -- WStr & Bnd WStr
142 Full_Catenate_String :=
143 BS80."&"(Left => Full_Catenate_String,
144 Right => Translate('n')); -- Bnd WStr & WChar
145
146
147 -- Evaluation of the overloaded forms of function Append.
148
149 Full_Append_String :=
150 BS80.Append(Part2, -- WChar,Bnd WStr
151 BS80.Append(Part3, -- Bnd WStr, Bnd WStr
152 BS80.Append(Part4, -- WChar,Bnd WStr
153 BS80.Append(BS80.To_Wide_String(Part5), -- WStr,Bnd WStr
154 BS80.To_Bounded_Wide_String(Part6)))));
155
156 Full_Append_String :=
157 BS80.Append(BS80.To_Bounded_Wide_String(Part1), -- Bnd WStr, WStr
158 BS80.To_Wide_String(Full_Append_String));
159
160 Full_Append_String :=
161 BS80.Append(Left => Full_Append_String,
162 Right => Translate('n')); -- Bnd WStr, WChar
163
164
165 -- Validate the resulting bounded wide strings.
166
167 if BS80."<"(Full_Catenate_String, Full_Append_String) or
168 BS80.">"(Full_Catenate_String, Full_Append_String) or
169 not (Full_Catenate_String = Full_Append_String and
170 BS80."<="(Full_Catenate_String, Full_Append_String) and
171 BS80.">="(Full_Catenate_String, Full_Append_String))
172 then
173 Report.Failed
174 ("Incorrect results from bounded wide string catenation" &
175 " and comparison");
176 end if;
177
178
179 -- Evaluate the overloaded forms of the Constructor function "*" and
180 -- the Replicate function.
181
182 Constructed_String :=
183 BS80."*"(2,CharA) & -- "AA"
184 BS80."*"(2,StrB) & -- "AABBBB"
185 BS80."*"(3, BS80."*"(2, CharC)) & -- "AABBBBCCCCCC"
186 BS80.Replicate(3,
187 BS80.Replicate(2, CharD)) & -- "AABBBBCCCCCCDDDDDD"
188 BS80.Replicate(2, StrE) & -- "AABBBBCCCCCCDDDDDDEEEE"
189 BS80.Replicate(2, CharF); -- "AABBBBCCCCCCDDDDDDEEEEFF"
190
191
192 -- Use of Function Replicate that involves dropping wide characters.
193 -- The attempt to replicate the 15 character wide string six times will
194 -- exceed the 80 wide character bound of the wide string. Therefore,
195 -- the result should be the catenation of 5 copies of the 15 character
196 -- wide string, followed by 5 'A' wide characters (the first five wide
197 -- characters of the 6th replication) with the remaining wide
198 -- characters of the 6th replication dropped.
199
200 Drop_String :=
201 BS80.Replicate(Count => 6,
202 Item => ABStr, -- "AAAAABBBBBBBBBB"
203 Drop => Ada.Strings.Right);
204
205 if BS80.Element(Drop_String, 1) /= Translate('A') or
206 BS80.Element(Drop_String, 6) /= Translate('B') or
207 BS80.Element(Drop_String, 76) /= Translate('A') or
208 BS80.Element(Drop_String, 80) /= Translate('A')
209 then
210 Report.Failed("Incorrect result from Replicate with Drop");
211 end if;
212
213
214 -- Use function Index_Non_Blank in the evaluation of the
215 -- Constructed_String.
216
217 if BS80.Index_Non_Blank(Constructed_String, Ada.Strings.Forward) /=
218 BS80.To_Wide_String(Constructed_String)'First or
219 BS80.Index_Non_Blank(Constructed_String, Ada.Strings.Backward) /=
220 BS80.Length(Constructed_String)
221 then
222 Report.Failed("Incorrect results from constructor functions");
223 end if;
224
225
226
227 declare
228
229 -- Define wide character set objects for use with the Count function.
230 -- Constructed_String = "AABBBBCCCCCCDDDDDDEEEEFF" from above.
231
232 A_Set : Ada.Strings.Wide_Maps.Wide_Character_Set :=
233 Ada.Strings.Wide_Maps.To_Set(BS80.Element(Constructed_String,
234 1));
235 B_Set : Ada.Strings.Wide_Maps.Wide_Character_Set :=
236 Ada.Strings.Wide_Maps.To_Set(BS80.Element(Constructed_String,
237 3));
238 C_Set : Ada.Strings.Wide_Maps.Wide_Character_Set :=
239 Ada.Strings.Wide_Maps.To_Set(BS80.Element(Constructed_String,
240 7));
241 D_Set : Ada.Strings.Wide_Maps.Wide_Character_Set :=
242 Ada.Strings.Wide_Maps.To_Set(BS80.Element(Constructed_String,
243 13));
244 E_Set : Ada.Strings.Wide_Maps.Wide_Character_Set :=
245 Ada.Strings.Wide_Maps.To_Set(BS80.Element(Constructed_String,
246 19));
247 F_Set : Ada.Strings.Wide_Maps.Wide_Character_Set :=
248 Ada.Strings.Wide_Maps.To_Set(BS80.Element(Constructed_String,
249 23));
250 Start : Positive;
251 Stop : Natural := 0;
252
253 begin
254
255 -- Evaluate the results from function Count by comparing the number
256 -- of A's to the number of F's, B's to E's, and C's to D's in the
257 -- Constructed_String.
258 -- There should be an equal number of each of the wide characters that
259 -- are being compared (i.e., 2 A's and F's, 4 B's and E's, etc)
260
261 if BS80.Count(Constructed_String, A_Set) /=
262 BS80.Count(Constructed_String, F_Set) or
263 BS80.Count(Constructed_String, B_Set) /=
264 BS80.Count(Constructed_String, E_Set) or
265 not (BS80.Count(Constructed_String, C_Set) =
266 BS80.Count(Constructed_String, D_Set))
267 then
268 Report.Failed("Incorrect result from function Count");
269 end if;
270
271
272 -- Evaluate the functions Head, Tail, and Find_Token.
273 -- Create the Token_String from the Constructed_String above.
274
275 Token_String :=
276 BS80.Tail(BS80.Head(Constructed_String, 3), 2) & -- "AB" &
277 BS80.Head(BS80.Tail(Constructed_String, 13), 2) & -- "CD" &
278 BS80.Head(BS80.Tail(Constructed_String, 3), 2); -- "EF"
279
280 if Token_String /=
281 BS80.To_Bounded_Wide_String(Translate("ABCDEF")) then
282 Report.Failed("Incorrect result from Catenation of Token_String");
283 end if;
284
285
286 -- Find the starting/ending position of the first A in the
287 -- Token_String (both should be 1, only one A appears in string).
288 -- The Function Head uses the default pad character to return a
289 -- bounded wide string longer than its input parameter bounded
290 -- wide string.
291
292 BS80.Find_Token(BS80.Head(Token_String, 10), -- Default pad.
293 A_Set,
294 Ada.Strings.Inside,
295 Start,
296 Stop);
297
298 if Start /= 1 and Stop /= 1 then
299 Report.Failed("Incorrect result from Find_Token - 1");
300 end if;
301
302
303 -- Find the starting/ending position of the first non-AB slice in
304 -- the "head" five wide characters of Token_String (slice CDE at
305 -- positions 3-5)
306
307 BS80.Find_Token(BS80.Head(Token_String, 5), -- "ABCDE"
308 Ada.Strings.Wide_Maps."OR"(A_Set, B_Set), -- Set (AB)
309 Ada.Strings.Outside,
310 Start,
311 Stop);
312
313 if Start /= 3 and Stop /= 5 then
314 Report.Failed("Incorrect result from Find_Token - 2");
315 end if;
316
317
318 -- Find the starting/ending position of the first CD slice in
319 -- the "tail" eight wide characters (including two pad wide
320 -- characters) of Token_String (slice CD at positions 5-6 of
321 -- the tail portion specified)
322
323 BS80.Find_Token(BS80.Tail(Token_String, 8,
324 Ada.Strings.Wide_Space),
325 Ada.Strings.Wide_Maps."OR"(C_Set, D_Set),
326 Ada.Strings.Inside,
327 Start,
328 Stop);
329
330 if Start /= 5 and Stop /= 6 then
331 Report.Failed("Incorrect result from Find_Token - 3");
332 end if;
333
334
335 -- Evaluate the Replace_Element function.
336
337 -- Token_String = "ABCDEF"
338
339 BS80.Replace_Element(Token_String, 3, BS80.Element(Token_String,4));
340
341 -- Token_String = "ABDDEF"
342
343 BS80.Replace_Element(Source => Token_String,
344 Index => 2,
345 By => BS80.Element(Token_String, 5));
346
347 -- Token_String = "AEDDEF"
348
349 BS80.Replace_Element(Token_String,
350 1,
351 BS80.Element(BS80.Tail(Token_String, 2), 2));
352
353 -- Token_String = "FEDDEF"
354 -- Evaluate this result.
355
356 if BS80.Element(Token_String,
357 BS80.To_Wide_String(Token_String)'First) /=
358 BS80.Element(Token_String,
359 BS80.To_Wide_String(Token_String)'Last) or
360 BS80.Count(Token_String, D_Set) /=
361 BS80.Count(Token_String, E_Set) or
362 BS80.Index_Non_Blank(BS80.Head(Token_String,6)) /=
363 BS80.Index_Non_Blank(BS80.Tail(Token_String,6)) or
364 BS80.Head(Token_String, 1) /=
365 BS80.Tail(Token_String, 1)
366 then
367 Report.Failed("Incorrect result from operations in combination");
368 end if;
369
370 end;
371
372 exception
373 when others => Report.Failed ("Exception raised in Test_Block");
374 end Test_Block;
375
376
377 Report.Result;
378
379 end CXA4018;