|
111
|
1 -- CXB2001.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 subprograms Shift_Left, Shift_Right,
|
|
|
28 -- Shift_Right_Arithmetic, Rotate_Left, and Rotate_Right are available
|
|
|
29 -- and produce correct results for values of signed and modular
|
|
|
30 -- integer types of 8 bits.
|
|
|
31 --
|
|
|
32 -- TEST DESCRIPTION:
|
|
|
33 -- This test uses the shift and rotate functions of package Interfaces
|
|
|
34 -- with a modular type representative of 8 bits. The functions
|
|
|
35 -- are used as the right hand of assignment statements, as part of
|
|
|
36 -- conditional statements, and as arguments in other function calls.
|
|
|
37 --
|
|
|
38 -- A check is performed in the test to determine whether the bit
|
|
|
39 -- ordering method used by the machine/implementation is high-order
|
|
|
40 -- first ("Big Endian") or low-order first ("Little Endian"). The
|
|
|
41 -- specific subtests use this information to evaluate the results of
|
|
|
42 -- each of the functions under test.
|
|
|
43 --
|
|
|
44 -- Note: In the string associated with each Report.Failed statement, the
|
|
|
45 -- acronym BE refers to Big Endian, LE refers to Little Endian.
|
|
|
46 --
|
|
|
47 -- APPLICABILITY CRITERIA:
|
|
|
48 -- This test is applicable to all implementations that support signed
|
|
|
49 -- and modular integer types of 8 bits.
|
|
|
50 --
|
|
|
51 --
|
|
|
52 -- CHANGE HISTORY:
|
|
|
53 -- 21 Aug 95 SAIC Initial prerelease version.
|
|
|
54 -- 07 May 96 SAIC Incorporated reviewer comments for ACVC 2.1.
|
|
|
55 --
|
|
|
56 --!
|
|
|
57
|
|
|
58 with Report;
|
|
|
59 with Interfaces;
|
|
|
60 with Ada.Exceptions;
|
|
|
61
|
|
|
62 procedure CXB2001 is
|
|
|
63 begin
|
|
|
64
|
|
|
65 Report.Test ("CXB2001",
|
|
|
66 "Check that subprograms Shift_Left, Shift_Right, " &
|
|
|
67 "Shift_Right_Arithmetic, Rotate_Left, and Rotate_Right " &
|
|
|
68 "produce correct results for values of signed and " &
|
|
|
69 "modular integer types of 8 bits");
|
|
|
70
|
|
|
71 Test_Block:
|
|
|
72 declare
|
|
|
73
|
|
|
74 use Ada.Exceptions;
|
|
|
75 use Interfaces;
|
|
|
76
|
|
|
77 TC_Amount : Natural := Natural'First;
|
|
|
78 Big_Endian : Boolean := False;
|
|
|
79
|
|
|
80 -- Range of type Unsigned_8 is 0..255 (0..Modulus-1).
|
|
|
81 TC_Val_Unsigned_8,
|
|
|
82 TC_Result_Unsigned_8 : Unsigned_8 := Unsigned_8'First;
|
|
|
83
|
|
|
84 begin
|
|
|
85
|
|
|
86 -- Determine whether the machine uses high-order first or low-order
|
|
|
87 -- first bit ordering.
|
|
|
88 -- On a high-order first machine, bit zero of a storage element is
|
|
|
89 -- the most significant bit (interpreting the sequence of bits that
|
|
|
90 -- represent a component as an unsigned integer value).
|
|
|
91 -- On a low-order first machine, bit zero is the least significant.
|
|
|
92 -- In this check, a right shift of one place on a Big Endian machine
|
|
|
93 -- will yield a result of one, while on a Little Endian machine the
|
|
|
94 -- result would be four.
|
|
|
95
|
|
|
96 TC_Val_Unsigned_8 := 2;
|
|
|
97 Big_Endian := (Shift_Right(TC_Val_Unsigned_8, 1) = 1);
|
|
|
98
|
|
|
99
|
|
|
100 -- Note: The shifting and rotating subprograms operate on a bit-by-bit
|
|
|
101 -- basis, using the binary representation of the value of the
|
|
|
102 -- operands to yield a binary representation for the result.
|
|
|
103
|
|
|
104 -- Function Shift_Left.
|
|
|
105
|
|
|
106 if Big_Endian then -- High-order first bit ordering.
|
|
|
107
|
|
|
108 TC_Amount := 1;
|
|
|
109 TC_Val_Unsigned_8 := Unsigned_8'Last; -- 255.
|
|
|
110 TC_Result_Unsigned_8 := Shift_Left(Value => TC_Val_Unsigned_8,
|
|
|
111 Amount => TC_Amount);
|
|
|
112 if TC_Result_Unsigned_8 /= 254 then
|
|
|
113 Report.Failed("Incorrect result from BE Shift_Left - 1");
|
|
|
114 end if;
|
|
|
115
|
|
|
116 if Shift_Left(TC_Val_Unsigned_8, 2) /= 252 or
|
|
|
117 Shift_Left(TC_Val_Unsigned_8, 3) /= 248 or
|
|
|
118 Shift_Left(TC_Val_Unsigned_8, 5) /= 224 or
|
|
|
119 Shift_Left(TC_Val_Unsigned_8, 8) /= 0 or
|
|
|
120 Shift_Left(TC_Val_Unsigned_8, 9) /= 0 or
|
|
|
121 Shift_Left(TC_Val_Unsigned_8, 0) /= TC_Val_Unsigned_8
|
|
|
122 then
|
|
|
123 Report.Failed("Incorrect result from BE Shift_Left - 2");
|
|
|
124 end if;
|
|
|
125
|
|
|
126 TC_Val_Unsigned_8 := 1;
|
|
|
127 if Shift_Left(TC_Val_Unsigned_8, 1) /= 2 or
|
|
|
128 Shift_Left(TC_Val_Unsigned_8, Amount => 3) /= 8
|
|
|
129 then
|
|
|
130 Report.Failed("Incorrect result from BE Shift_Left - 3");
|
|
|
131 end if;
|
|
|
132
|
|
|
133 TC_Val_Unsigned_8 := 7;
|
|
|
134 if Shift_Left(TC_Val_Unsigned_8, Amount => 4) /= 112 or
|
|
|
135 Shift_Left(Shift_Left(TC_Val_Unsigned_8, 7), 1) /= 0
|
|
|
136 then
|
|
|
137 Report.Failed("Incorrect result from BE Shift_Left - 4");
|
|
|
138 end if;
|
|
|
139
|
|
|
140 else -- Low-order first bit ordering.
|
|
|
141
|
|
|
142 TC_Amount := 1;
|
|
|
143 TC_Val_Unsigned_8 := Unsigned_8'Last; -- 255.
|
|
|
144 TC_Result_Unsigned_8 := Shift_Left(TC_Val_Unsigned_8, TC_Amount);
|
|
|
145
|
|
|
146 if TC_Result_Unsigned_8 /= 127 then
|
|
|
147 Report.Failed("Incorrect result from LE Shift_Left - 1");
|
|
|
148 end if;
|
|
|
149
|
|
|
150 if Shift_Left(TC_Val_Unsigned_8, 2) /= 63 or
|
|
|
151 Shift_Left(TC_Val_Unsigned_8, 3) /= 31 or
|
|
|
152 Shift_Left(TC_Val_Unsigned_8, 5) /= 7 or
|
|
|
153 Shift_Left(TC_Val_Unsigned_8, 8) /= 0 or
|
|
|
154 Shift_Left(TC_Val_Unsigned_8, 0) /= TC_Val_Unsigned_8
|
|
|
155 then
|
|
|
156 Report.Failed("Incorrect result from LE Shift_Left - 2");
|
|
|
157 end if;
|
|
|
158
|
|
|
159 TC_Val_Unsigned_8 := 1;
|
|
|
160 if Shift_Left(TC_Val_Unsigned_8, 1) /= 0 or
|
|
|
161 Shift_Left(TC_Val_Unsigned_8, 7) /= 0
|
|
|
162 then
|
|
|
163 Report.Failed("Incorrect result from LE Shift_Left - 3");
|
|
|
164 end if;
|
|
|
165
|
|
|
166 TC_Val_Unsigned_8 := 129;
|
|
|
167 if Shift_Left(TC_Val_Unsigned_8, 4) /= 8 or
|
|
|
168 Shift_Left(Shift_Left(TC_Val_Unsigned_8, 7), 1) /= 0
|
|
|
169 then
|
|
|
170 Report.Failed("Incorrect result from LE Shift_Left - 4");
|
|
|
171 end if;
|
|
|
172
|
|
|
173 end if;
|
|
|
174
|
|
|
175
|
|
|
176
|
|
|
177 -- Function Shift_Right.
|
|
|
178
|
|
|
179 if Big_Endian then -- High-order first bit ordering.
|
|
|
180
|
|
|
181 TC_Amount := 1;
|
|
|
182 TC_Val_Unsigned_8 := Unsigned_8'Last; -- 255.
|
|
|
183 TC_Result_Unsigned_8 := Shift_Right(TC_Val_Unsigned_8, TC_Amount);
|
|
|
184
|
|
|
185 if TC_Result_Unsigned_8 /= 127 then
|
|
|
186 Report.Failed("Incorrect result from BE Shift_Right - 1");
|
|
|
187 end if;
|
|
|
188
|
|
|
189 if Shift_Right(TC_Val_Unsigned_8, 2) /= 63 or
|
|
|
190 Shift_Right(TC_Val_Unsigned_8, 3) /= 31 or
|
|
|
191 Shift_Right(TC_Val_Unsigned_8, 5) /= 7 or
|
|
|
192 Shift_Right(TC_Val_Unsigned_8, 8) /= 0 or
|
|
|
193 Shift_Right(TC_Val_Unsigned_8, 0) /= TC_Val_Unsigned_8
|
|
|
194 then
|
|
|
195 Report.Failed("Incorrect result from BE Shift_Right - 2");
|
|
|
196 end if;
|
|
|
197
|
|
|
198 TC_Val_Unsigned_8 := 1;
|
|
|
199 if Shift_Right(TC_Val_Unsigned_8, 1) /= 0 or
|
|
|
200 Shift_Right(TC_Val_Unsigned_8, 7) /= 0
|
|
|
201 then
|
|
|
202 Report.Failed("Incorrect result from BE Shift_Right - 3");
|
|
|
203 end if;
|
|
|
204
|
|
|
205 TC_Val_Unsigned_8 := 129;
|
|
|
206 if Shift_Right(TC_Val_Unsigned_8, 4) /= 8 or
|
|
|
207 Shift_Right(Shift_Right(TC_Val_Unsigned_8, 7), 1) /= 0
|
|
|
208 then
|
|
|
209 Report.Failed("Incorrect result from BE Shift_Right - 4");
|
|
|
210 end if;
|
|
|
211
|
|
|
212 else -- Low-order first bit ordering.
|
|
|
213
|
|
|
214 TC_Amount := 1;
|
|
|
215 TC_Val_Unsigned_8 := Unsigned_8'Last; -- 255.
|
|
|
216 TC_Result_Unsigned_8 := Shift_Right(Value => TC_Val_Unsigned_8,
|
|
|
217 Amount => TC_Amount);
|
|
|
218 if TC_Result_Unsigned_8 /= 254 then
|
|
|
219 Report.Failed("Incorrect result from LE Shift_Right - 1");
|
|
|
220 end if;
|
|
|
221
|
|
|
222 if Shift_Right(TC_Val_Unsigned_8, 2) /= 252 or
|
|
|
223 Shift_Right(TC_Val_Unsigned_8, 3) /= 248 or
|
|
|
224 Shift_Right(TC_Val_Unsigned_8, 5) /= 224 or
|
|
|
225 Shift_Right(TC_Val_Unsigned_8, 8) /= 0 or
|
|
|
226 Shift_Right(TC_Val_Unsigned_8, 9) /= 0 or
|
|
|
227 Shift_Right(TC_Val_Unsigned_8, 0) /= TC_Val_Unsigned_8
|
|
|
228 then
|
|
|
229 Report.Failed("Incorrect result from LE Shift_Right - 2");
|
|
|
230 end if;
|
|
|
231
|
|
|
232 TC_Val_Unsigned_8 := 1;
|
|
|
233 if Shift_Right(TC_Val_Unsigned_8, 1) /= 2 or
|
|
|
234 Shift_Right(TC_Val_Unsigned_8, Amount => 3) /= 8
|
|
|
235 then
|
|
|
236 Report.Failed("Incorrect result from LE Shift_Right - 3");
|
|
|
237 end if;
|
|
|
238
|
|
|
239 TC_Val_Unsigned_8 := 7;
|
|
|
240 if Shift_Right(TC_Val_Unsigned_8, Amount => 4) /= 112 or
|
|
|
241 Shift_Right(Shift_Right(TC_Val_Unsigned_8, 7), 1) /= 0
|
|
|
242 then
|
|
|
243 Report.Failed("Incorrect result from LE Shift_Right - 4");
|
|
|
244 end if;
|
|
|
245
|
|
|
246 end if;
|
|
|
247
|
|
|
248
|
|
|
249
|
|
|
250 -- Tests of Shift_Left and Shift_Right in combination.
|
|
|
251
|
|
|
252 if Big_Endian then -- High-order first bit ordering.
|
|
|
253
|
|
|
254 TC_Val_Unsigned_8 := 32;
|
|
|
255
|
|
|
256 if Shift_Left(Shift_Right(TC_Val_Unsigned_8, 2), 2) /=
|
|
|
257 TC_Val_Unsigned_8 or
|
|
|
258 Shift_Left(Shift_Right(TC_Val_Unsigned_8, 1), 3) /= 128 or
|
|
|
259 Shift_Right(Shift_Left(TC_Val_Unsigned_8, 2), 6) /= 2 or
|
|
|
260 Shift_Right(Shift_Left(TC_Val_Unsigned_8, 2), 8) /= 0
|
|
|
261 then
|
|
|
262 Report.Failed("Incorrect result from BE Shift_Left - " &
|
|
|
263 "Shift_Right functions used in combination");
|
|
|
264 end if;
|
|
|
265
|
|
|
266 else -- Low-order first bit ordering.
|
|
|
267
|
|
|
268 TC_Val_Unsigned_8 := 32;
|
|
|
269
|
|
|
270 if Shift_Left(Shift_Right(TC_Val_Unsigned_8, 2), 2) /=
|
|
|
271 TC_Val_Unsigned_8 or
|
|
|
272 Shift_Left(Shift_Right(TC_Val_Unsigned_8, 1), 3) /= 8 or
|
|
|
273 Shift_Right(Shift_Left(TC_Val_Unsigned_8, 2), 3) /= 64 or
|
|
|
274 Shift_Right(Shift_Left(TC_Val_Unsigned_8, 2), 4) /= 128
|
|
|
275 then
|
|
|
276 Report.Failed("Incorrect result from LE Shift_Left - " &
|
|
|
277 "Shift_Right functions used in combination");
|
|
|
278 end if;
|
|
|
279
|
|
|
280 end if;
|
|
|
281
|
|
|
282
|
|
|
283
|
|
|
284 -- Function Shift_Right_Arithmetic.
|
|
|
285
|
|
|
286 if Big_Endian then -- High-order first bit ordering.
|
|
|
287
|
|
|
288 -- Case where the parameter Value is less than
|
|
|
289 -- one half of the modulus. Zero bits will be shifted in.
|
|
|
290 -- Modulus of type Unsigned_8 is 256; half of the modulus is 128.
|
|
|
291
|
|
|
292 TC_Amount := 1;
|
|
|
293 TC_Val_Unsigned_8 := 127; -- Less than one half of modulus.
|
|
|
294 TC_Result_Unsigned_8 := Shift_Right_Arithmetic(TC_Val_Unsigned_8,
|
|
|
295 TC_Amount);
|
|
|
296 if TC_Result_Unsigned_8 /= 63 then
|
|
|
297 Report.Failed
|
|
|
298 ("Incorrect result from BE Shift_Right_Arithmetic - 1");
|
|
|
299 end if;
|
|
|
300
|
|
|
301 if Shift_Right_Arithmetic(TC_Val_Unsigned_8, 2) /= 31 or
|
|
|
302 Shift_Right_Arithmetic(TC_Val_Unsigned_8, 3) /= 15 or
|
|
|
303 Shift_Right_Arithmetic(TC_Val_Unsigned_8, 5) /= 3 or
|
|
|
304 Shift_Right_Arithmetic(TC_Val_Unsigned_8, 8) /= 0 or
|
|
|
305 Shift_Right_Arithmetic(TC_Val_Unsigned_8, 0) /= TC_Val_Unsigned_8
|
|
|
306 then
|
|
|
307 Report.Failed
|
|
|
308 ("Incorrect result from BE Shift_Right_Arithmetic - 2");
|
|
|
309 end if;
|
|
|
310
|
|
|
311 TC_Val_Unsigned_8 := 1;
|
|
|
312 if Shift_Right_Arithmetic(TC_Val_Unsigned_8, Amount => 1) /= 0 or
|
|
|
313 Shift_Right_Arithmetic(TC_Val_Unsigned_8, 3) /= 0
|
|
|
314 then
|
|
|
315 Report.Failed
|
|
|
316 ("Incorrect result from BE Shift_Right_Arithmetic - 3");
|
|
|
317 end if;
|
|
|
318
|
|
|
319 -- Case where the parameter Value is greater than or equal to
|
|
|
320 -- one half of the modulus. One bits will be shifted in.
|
|
|
321
|
|
|
322 TC_Amount := 1;
|
|
|
323 TC_Val_Unsigned_8 := 128; -- One half of modulus.
|
|
|
324 TC_Result_Unsigned_8 := Shift_Right_Arithmetic(TC_Val_Unsigned_8,
|
|
|
325 Amount => TC_Amount);
|
|
|
326 if TC_Result_Unsigned_8 /= 192 then
|
|
|
327 Report.Failed
|
|
|
328 ("Incorrect result from BE Shift_Right_Arithmetic - 4");
|
|
|
329 end if;
|
|
|
330
|
|
|
331 TC_Amount := 1;
|
|
|
332 TC_Val_Unsigned_8 := 129; -- Greater than one half of modulus.
|
|
|
333 TC_Result_Unsigned_8 := Shift_Right_Arithmetic(TC_Val_Unsigned_8,
|
|
|
334 Amount => TC_Amount);
|
|
|
335 if TC_Result_Unsigned_8 /= 192 then
|
|
|
336 Report.Failed
|
|
|
337 ("Incorrect result from BE Shift_Right_Arithmetic - 5");
|
|
|
338 end if;
|
|
|
339
|
|
|
340 if Shift_Right_Arithmetic(TC_Val_Unsigned_8, 2) /= 224 or
|
|
|
341 Shift_Right_Arithmetic(TC_Val_Unsigned_8, 3) /= 240 or
|
|
|
342 Shift_Right_Arithmetic(TC_Val_Unsigned_8, 5) /= 252 or
|
|
|
343 Shift_Right_Arithmetic(TC_Val_Unsigned_8, 7) /= Unsigned_8'Last or
|
|
|
344 Shift_Right_Arithmetic(TC_Val_Unsigned_8, 0) /= TC_Val_Unsigned_8
|
|
|
345 then
|
|
|
346 Report.Failed
|
|
|
347 ("Incorrect result from BE Shift_Right_Arithmetic - 6");
|
|
|
348 end if;
|
|
|
349
|
|
|
350 TC_Val_Unsigned_8 := Unsigned_8'Last;
|
|
|
351 if Shift_Right_Arithmetic(TC_Val_Unsigned_8, 1) /=
|
|
|
352 Unsigned_8'Last
|
|
|
353 then
|
|
|
354 Report.Failed
|
|
|
355 ("Incorrect result from BE Shift_Right_Arithmetic - 7");
|
|
|
356 end if;
|
|
|
357
|
|
|
358 else -- Low-order first bit ordering
|
|
|
359
|
|
|
360 -- Case where the parameter Value is less than
|
|
|
361 -- one half of the modulus. Zero bits will be shifted in.
|
|
|
362
|
|
|
363 TC_Amount := 1;
|
|
|
364 TC_Val_Unsigned_8 := 127; -- Less than one half of modulus.
|
|
|
365 TC_Result_Unsigned_8 := Shift_Right_Arithmetic(TC_Val_Unsigned_8,
|
|
|
366 TC_Amount);
|
|
|
367 if TC_Result_Unsigned_8 /= 254 then
|
|
|
368 Report.Failed
|
|
|
369 ("Incorrect result from LE Shift_Right_Arithmetic - 1");
|
|
|
370 end if;
|
|
|
371
|
|
|
372 TC_Val_Unsigned_8 := 2;
|
|
|
373 if Shift_Right_Arithmetic(TC_Val_Unsigned_8, 2) /= 8 or
|
|
|
374 Shift_Right_Arithmetic(TC_Val_Unsigned_8, 3) /= 16 or
|
|
|
375 Shift_Right_Arithmetic(TC_Val_Unsigned_8, 5) /= 64 or
|
|
|
376 Shift_Right_Arithmetic(TC_Val_Unsigned_8, 8) /= 0 or
|
|
|
377 Shift_Right_Arithmetic(TC_Val_Unsigned_8, 0) /= TC_Val_Unsigned_8
|
|
|
378 then
|
|
|
379 Report.Failed
|
|
|
380 ("Incorrect result from LE Shift_Right_Arithmetic - 2");
|
|
|
381 end if;
|
|
|
382
|
|
|
383 TC_Val_Unsigned_8 := 64;
|
|
|
384 if Shift_Right_Arithmetic(TC_Val_Unsigned_8, Amount => 1) /= 128 or
|
|
|
385 Shift_Right_Arithmetic(TC_Val_Unsigned_8, 3) /= 0
|
|
|
386 then
|
|
|
387 Report.Failed
|
|
|
388 ("Incorrect result from LE Shift_Right_Arithmetic - 3");
|
|
|
389 end if;
|
|
|
390
|
|
|
391 -- Case where the parameter Value is greater than or equal to
|
|
|
392 -- one half of the modulus. One bits will be shifted in.
|
|
|
393
|
|
|
394 TC_Amount := 1;
|
|
|
395 TC_Val_Unsigned_8 := 128; -- One half of modulus.
|
|
|
396 TC_Result_Unsigned_8 := Shift_Right_Arithmetic(TC_Val_Unsigned_8,
|
|
|
397 Amount => TC_Amount);
|
|
|
398
|
|
|
399 if TC_Result_Unsigned_8 /= 3 then
|
|
|
400 Report.Failed
|
|
|
401 ("Incorrect result from LE Shift_Right_Arithmetic - 4");
|
|
|
402 end if;
|
|
|
403
|
|
|
404 TC_Amount := 1;
|
|
|
405 TC_Val_Unsigned_8 := 129; -- Greater than one half of modulus.
|
|
|
406 TC_Result_Unsigned_8 := Shift_Right_Arithmetic(TC_Val_Unsigned_8,
|
|
|
407 Amount => TC_Amount);
|
|
|
408
|
|
|
409 if TC_Result_Unsigned_8 /= 3 then
|
|
|
410 Report.Failed
|
|
|
411 ("Incorrect result from LE Shift_Right_Arithmetic - 5");
|
|
|
412 end if;
|
|
|
413
|
|
|
414 TC_Val_Unsigned_8 := 135; -- Greater than one half of modulus.
|
|
|
415 if Shift_Right_Arithmetic(TC_Val_Unsigned_8, 2) /= 31 or
|
|
|
416 Shift_Right_Arithmetic(TC_Val_Unsigned_8, 3) /= 63 or
|
|
|
417 Shift_Right_Arithmetic(TC_Val_Unsigned_8, 5) /= Unsigned_8'Last or
|
|
|
418 Shift_Right_Arithmetic(TC_Val_Unsigned_8, 7) /= Unsigned_8'Last or
|
|
|
419 Shift_Right_Arithmetic(TC_Val_Unsigned_8, 0) /= TC_Val_Unsigned_8
|
|
|
420 then
|
|
|
421 Report.Failed
|
|
|
422 ("Incorrect result from LE Shift_Right_Arithmetic - 6");
|
|
|
423 end if;
|
|
|
424
|
|
|
425 TC_Val_Unsigned_8 := Unsigned_8'Last;
|
|
|
426 if Shift_Right_Arithmetic(TC_Val_Unsigned_8, 1) /=
|
|
|
427 Unsigned_8'Last
|
|
|
428 then
|
|
|
429 Report.Failed
|
|
|
430 ("Incorrect result from LE Shift_Right_Arithmetic - 7");
|
|
|
431 end if;
|
|
|
432
|
|
|
433 end if;
|
|
|
434
|
|
|
435
|
|
|
436
|
|
|
437 -- Function Rotate_Left.
|
|
|
438
|
|
|
439 if Big_Endian then -- High-order first bit ordering.
|
|
|
440
|
|
|
441 TC_Amount := 1;
|
|
|
442 TC_Val_Unsigned_8 := 129;
|
|
|
443 TC_Result_Unsigned_8 := Rotate_Left(Value => TC_Val_Unsigned_8,
|
|
|
444 Amount => TC_Amount);
|
|
|
445 if TC_Result_Unsigned_8 /= 3 then
|
|
|
446 Report.Failed("Incorrect result from BE Rotate_Left - 1");
|
|
|
447 end if;
|
|
|
448
|
|
|
449 if Rotate_Left(TC_Val_Unsigned_8, 2) /= 6 or
|
|
|
450 Rotate_Left(TC_Val_Unsigned_8, 3) /= 12 or
|
|
|
451 Rotate_Left(TC_Val_Unsigned_8, 5) /= 48 or
|
|
|
452 Rotate_Left(TC_Val_Unsigned_8, 8) /= 129 or
|
|
|
453 Rotate_Left(TC_Val_Unsigned_8, 0) /= TC_Val_Unsigned_8
|
|
|
454 then
|
|
|
455 Report.Failed("Incorrect result from BE Rotate_Left - 2");
|
|
|
456 end if;
|
|
|
457
|
|
|
458 TC_Val_Unsigned_8 := 1;
|
|
|
459 if Rotate_Left(Value => TC_Val_Unsigned_8, Amount => 1) /= 2 or
|
|
|
460 Rotate_Left(TC_Val_Unsigned_8, Amount => 3) /= 8
|
|
|
461 then
|
|
|
462 Report.Failed("Incorrect result from BE Rotate_Left - 3");
|
|
|
463 end if;
|
|
|
464
|
|
|
465 TC_Val_Unsigned_8 := 82;
|
|
|
466 if Rotate_Left(TC_Val_Unsigned_8, Amount => 4) /= 37 or
|
|
|
467 Rotate_Left(Rotate_Left(TC_Val_Unsigned_8, 7), 1) /= 82
|
|
|
468 then
|
|
|
469 Report.Failed("Incorrect result from BE Rotate_Left - 4");
|
|
|
470 end if;
|
|
|
471
|
|
|
472 else -- Low-order first bit ordering.
|
|
|
473
|
|
|
474 TC_Amount := 1;
|
|
|
475 TC_Val_Unsigned_8 := 1;
|
|
|
476 TC_Result_Unsigned_8 := Rotate_Left(TC_Val_Unsigned_8, TC_Amount);
|
|
|
477
|
|
|
478 if TC_Result_Unsigned_8 /= 128 then
|
|
|
479 Report.Failed("Incorrect result from LE Rotate_Left - 1");
|
|
|
480 end if;
|
|
|
481
|
|
|
482 TC_Val_Unsigned_8 := 15;
|
|
|
483 if Rotate_Left(TC_Val_Unsigned_8, 2) /= 195 or
|
|
|
484 Rotate_Left(TC_Val_Unsigned_8, 3) /= 225 or
|
|
|
485 Rotate_Left(TC_Val_Unsigned_8, 5) /= 120 or
|
|
|
486 Rotate_Left(TC_Val_Unsigned_8, 8) /= TC_Val_Unsigned_8 or
|
|
|
487 Rotate_Left(TC_Val_Unsigned_8, 0) /= TC_Val_Unsigned_8
|
|
|
488 then
|
|
|
489 Report.Failed("Incorrect result from LE Rotate_Left - 2");
|
|
|
490 end if;
|
|
|
491
|
|
|
492 TC_Val_Unsigned_8 := Unsigned_8'Last;
|
|
|
493 if Rotate_Left(TC_Val_Unsigned_8, 1) /= Unsigned_8'Last then
|
|
|
494 Report.Failed("Incorrect result from LE Rotate_Left - 3");
|
|
|
495 end if;
|
|
|
496
|
|
|
497 TC_Val_Unsigned_8 := 12;
|
|
|
498 if Rotate_Left(TC_Val_Unsigned_8, 1) /= 6 or
|
|
|
499 Rotate_Left(TC_Val_Unsigned_8, 3) /= 129
|
|
|
500 then
|
|
|
501 Report.Failed("Incorrect result from LE Rotate_Left - 4");
|
|
|
502 end if;
|
|
|
503
|
|
|
504 TC_Val_Unsigned_8 := 129;
|
|
|
505 if Rotate_Left(TC_Val_Unsigned_8, 4) /= 24 or
|
|
|
506 Rotate_Left(Rotate_Left(TC_Val_Unsigned_8, 7), 1) /= 129
|
|
|
507 then
|
|
|
508 Report.Failed("Incorrect result from LE Rotate_Left - 5");
|
|
|
509 end if;
|
|
|
510
|
|
|
511 end if;
|
|
|
512
|
|
|
513
|
|
|
514
|
|
|
515 -- Function Rotate_Right.
|
|
|
516
|
|
|
517 if Big_Endian then -- High-order first bit ordering.
|
|
|
518
|
|
|
519 TC_Amount := 1;
|
|
|
520 TC_Val_Unsigned_8 := 1;
|
|
|
521 TC_Result_Unsigned_8 := Rotate_Right(TC_Val_Unsigned_8, TC_Amount);
|
|
|
522
|
|
|
523 if TC_Result_Unsigned_8 /= 128 then
|
|
|
524 Report.Failed("Incorrect result from BE Rotate_Right - 1");
|
|
|
525 end if;
|
|
|
526
|
|
|
527 TC_Val_Unsigned_8 := 15;
|
|
|
528 if Rotate_Right(TC_Val_Unsigned_8, 2) /= 195 or
|
|
|
529 Rotate_Right(TC_Val_Unsigned_8, 3) /= 225 or
|
|
|
530 Rotate_Right(TC_Val_Unsigned_8, 5) /= 120 or
|
|
|
531 Rotate_Right(TC_Val_Unsigned_8, 8) /= TC_Val_Unsigned_8 or
|
|
|
532 Rotate_Right(TC_Val_Unsigned_8, 0) /= TC_Val_Unsigned_8
|
|
|
533 then
|
|
|
534 Report.Failed("Incorrect result from BE Rotate_Right - 2");
|
|
|
535 end if;
|
|
|
536
|
|
|
537 TC_Val_Unsigned_8 := Unsigned_8'Last;
|
|
|
538 if Rotate_Right(TC_Val_Unsigned_8, 1) /= Unsigned_8'Last then
|
|
|
539 Report.Failed("Incorrect result from BE Rotate_Right - 3");
|
|
|
540 end if;
|
|
|
541
|
|
|
542 TC_Val_Unsigned_8 := 12;
|
|
|
543 if Rotate_Right(TC_Val_Unsigned_8, 1) /= 6 or
|
|
|
544 Rotate_Right(TC_Val_Unsigned_8, 3) /= 129
|
|
|
545 then
|
|
|
546 Report.Failed("Incorrect result from BE Rotate_Right - 4");
|
|
|
547 end if;
|
|
|
548
|
|
|
549 TC_Val_Unsigned_8 := 129;
|
|
|
550 if Rotate_Right(TC_Val_Unsigned_8, 4) /= 24 or
|
|
|
551 Rotate_Right(Rotate_Right(TC_Val_Unsigned_8, 7), 1) /= 129
|
|
|
552 then
|
|
|
553 Report.Failed("Incorrect result from BE Rotate_Right - 5");
|
|
|
554 end if;
|
|
|
555
|
|
|
556 else -- Low-order first bit ordering.
|
|
|
557
|
|
|
558 TC_Amount := 1;
|
|
|
559 TC_Val_Unsigned_8 := 129;
|
|
|
560 TC_Result_Unsigned_8 := Rotate_Right(Value => TC_Val_Unsigned_8,
|
|
|
561 Amount => TC_Amount);
|
|
|
562 if TC_Result_Unsigned_8 /= 3 then
|
|
|
563 Report.Failed("Incorrect result from LE Rotate_Right - 1");
|
|
|
564 end if;
|
|
|
565
|
|
|
566 if Rotate_Right(TC_Val_Unsigned_8, 2) /= 6 or
|
|
|
567 Rotate_Right(TC_Val_Unsigned_8, 3) /= 12 or
|
|
|
568 Rotate_Right(TC_Val_Unsigned_8, 5) /= 48 or
|
|
|
569 Rotate_Right(TC_Val_Unsigned_8, 8) /= 129 or
|
|
|
570 Rotate_Right(TC_Val_Unsigned_8, 0) /= TC_Val_Unsigned_8
|
|
|
571 then
|
|
|
572 Report.Failed("Incorrect result from LE Rotate_Right - 2");
|
|
|
573 end if;
|
|
|
574
|
|
|
575 TC_Val_Unsigned_8 := 1;
|
|
|
576 if Rotate_Right(Value => TC_Val_Unsigned_8, Amount => 1) /= 2 or
|
|
|
577 Rotate_Right(TC_Val_Unsigned_8, Amount => 3) /= 8
|
|
|
578 then
|
|
|
579 Report.Failed("Incorrect result from LE Rotate_Right - 3");
|
|
|
580 end if;
|
|
|
581
|
|
|
582 TC_Val_Unsigned_8 := 82;
|
|
|
583 if Rotate_Right(TC_Val_Unsigned_8, Amount => 4) /= 37 or
|
|
|
584 Rotate_Right(Rotate_Right(TC_Val_Unsigned_8, 7), 1) /= 82
|
|
|
585 then
|
|
|
586 Report.Failed("Incorrect result from LE Rotate_Right - 4");
|
|
|
587 end if;
|
|
|
588
|
|
|
589 end if;
|
|
|
590
|
|
|
591
|
|
|
592
|
|
|
593 -- Tests of Rotate_Left and Rotate_Right in combination.
|
|
|
594
|
|
|
595 if Big_Endian then -- High-order first bit ordering.
|
|
|
596
|
|
|
597 TC_Val_Unsigned_8 := 17;
|
|
|
598
|
|
|
599 if Rotate_Left(Rotate_Right(TC_Val_Unsigned_8, 2), 2) /=
|
|
|
600 TC_Val_Unsigned_8 or
|
|
|
601 Rotate_Left(Rotate_Right(TC_Val_Unsigned_8, 1), 3) /= 68 or
|
|
|
602 Rotate_Right(Rotate_Left(TC_Val_Unsigned_8, 3), 7) /= 17 or
|
|
|
603 Rotate_Right(Rotate_Left(TC_Val_Unsigned_8, 2), 8) /= 68
|
|
|
604 then
|
|
|
605 Report.Failed("Incorrect result from BE Rotate_Left - " &
|
|
|
606 "Rotate_Right functions used in combination");
|
|
|
607 end if;
|
|
|
608
|
|
|
609 else -- Low-order first bit ordering.
|
|
|
610
|
|
|
611 TC_Val_Unsigned_8 := 4;
|
|
|
612
|
|
|
613 if Rotate_Left(Rotate_Right(TC_Val_Unsigned_8, 2), 2) /=
|
|
|
614 TC_Val_Unsigned_8 or
|
|
|
615 Rotate_Left(Rotate_Right(TC_Val_Unsigned_8, 1), 3) /= 1 or
|
|
|
616 Rotate_Right(Rotate_Left(TC_Val_Unsigned_8, 3), 7) /= 64 or
|
|
|
617 Rotate_Right(Rotate_Left(TC_Val_Unsigned_8, 2), 8) /= 1
|
|
|
618 then
|
|
|
619 Report.Failed("Incorrect result from LE Rotate_Left - " &
|
|
|
620 "Rotate_Right functions used in combination");
|
|
|
621 end if;
|
|
|
622
|
|
|
623 end if;
|
|
|
624
|
|
|
625 exception
|
|
|
626 when The_Error : others =>
|
|
|
627 Report.Failed ("The following exception was raised in the " &
|
|
|
628 "Test_Block: " & Exception_Name(The_Error));
|
|
|
629 end Test_Block;
|
|
|
630
|
|
|
631 Report.Result;
|
|
|
632
|
|
|
633 end CXB2001;
|
