TianoCore EDK2 master
Loading...
Searching...
No Matches
SafeIntLibUintnIntnUnitTests32.c
Go to the documentation of this file.
1
11#include "TestBaseSafeIntLib.h"
12
13UNIT_TEST_STATUS
14EFIAPI
15TestSafeInt32ToUintn (
16 IN UNIT_TEST_CONTEXT Context
17 )
18{
19 EFI_STATUS Status;
20 INT32 Operand;
21 UINTN Result;
22
23 //
24 // If Operand is non-negative, then it's a cast
25 //
26 Operand = 0x5bababab;
27 Result = 0;
28 Status = SafeInt32ToUintn (Operand, &Result);
29 UT_ASSERT_NOT_EFI_ERROR (Status);
30 UT_ASSERT_EQUAL (0x5bababab, Result);
31
32 //
33 // Otherwise should result in an error status
34 //
35 Operand = (-1537977259);
36 Status = SafeInt32ToUintn (Operand, &Result);
37 UT_ASSERT_EQUAL (RETURN_BUFFER_TOO_SMALL, Status);
38
39 return UNIT_TEST_PASSED;
40}
41
42UNIT_TEST_STATUS
43EFIAPI
44TestSafeUint32ToIntn (
45 IN UNIT_TEST_CONTEXT Context
46 )
47{
48 EFI_STATUS Status;
49 UINT32 Operand;
50 INTN Result;
51
52 //
53 // If Operand is <= MAX_INTN, then it's a cast
54 //
55 Operand = 0x5bababab;
56 Result = 0;
57 Status = SafeUint32ToIntn (Operand, &Result);
58 UT_ASSERT_NOT_EFI_ERROR (Status);
59 UT_ASSERT_EQUAL (0x5bababab, Result);
60
61 //
62 // Otherwise should result in an error status
63 //
64 Operand = (0xabababab);
65 Status = SafeUint32ToIntn (Operand, &Result);
66 UT_ASSERT_EQUAL (RETURN_BUFFER_TOO_SMALL, Status);
67
68 return UNIT_TEST_PASSED;
69}
70
71UNIT_TEST_STATUS
72EFIAPI
73TestSafeIntnToInt32 (
74 IN UNIT_TEST_CONTEXT Context
75 )
76{
77 EFI_STATUS Status;
78 INTN Operand;
79 INT32 Result;
80
81 //
82 // INTN is same as INT32 in IA32, so this is just a cast
83 //
84 Operand = 0x5bababab;
85 Result = 0;
86 Status = SafeIntnToInt32 (Operand, &Result);
87 UT_ASSERT_NOT_EFI_ERROR (Status);
88 UT_ASSERT_EQUAL (0x5bababab, Result);
89
90 return UNIT_TEST_PASSED;
91}
92
93UNIT_TEST_STATUS
94EFIAPI
95TestSafeIntnToUint32 (
96 IN UNIT_TEST_CONTEXT Context
97 )
98{
99 EFI_STATUS Status;
100 INTN Operand;
101 UINT32 Result;
102
103 //
104 // If Operand is non-negative, then it's a cast
105 //
106 Operand = 0x5bababab;
107 Result = 0;
108 Status = SafeIntnToUint32 (Operand, &Result);
109 UT_ASSERT_NOT_EFI_ERROR (Status);
110 UT_ASSERT_EQUAL (0x5bababab, Result);
111
112 //
113 // Otherwise should result in an error status
114 //
115 Operand = (-1537977259);
116 Status = SafeIntnToUint32 (Operand, &Result);
117 UT_ASSERT_EQUAL (RETURN_BUFFER_TOO_SMALL, Status);
118
119 return UNIT_TEST_PASSED;
120}
121
122UNIT_TEST_STATUS
123EFIAPI
124TestSafeUintnToUint32 (
125 IN UNIT_TEST_CONTEXT Context
126 )
127{
128 EFI_STATUS Status;
129 UINTN Operand;
130 UINT32 Result;
131
132 //
133 // UINTN is same as UINT32 in IA32, so this is just a cast
134 //
135 Operand = 0xabababab;
136 Result = 0;
137 Status = SafeUintnToUint32 (Operand, &Result);
138 UT_ASSERT_NOT_EFI_ERROR (Status);
139 UT_ASSERT_EQUAL (0xabababab, Result);
140
141 return UNIT_TEST_PASSED;
142}
143
144UNIT_TEST_STATUS
145EFIAPI
146TestSafeUintnToIntn (
147 IN UNIT_TEST_CONTEXT Context
148 )
149{
150 EFI_STATUS Status;
151 UINTN Operand;
152 INTN Result;
153
154 //
155 // If Operand is <= MAX_INTN, then it's a cast
156 //
157 Operand = 0x5bababab;
158 Result = 0;
159 Status = SafeUintnToIntn (Operand, &Result);
160 UT_ASSERT_NOT_EFI_ERROR (Status);
161 UT_ASSERT_EQUAL (0x5bababab, Result);
162
163 //
164 // Otherwise should result in an error status
165 //
166 Operand = (0xabababab);
167 Status = SafeUintnToIntn (Operand, &Result);
168 UT_ASSERT_EQUAL (RETURN_BUFFER_TOO_SMALL, Status);
169
170 return UNIT_TEST_PASSED;
171}
172
173UNIT_TEST_STATUS
174EFIAPI
175TestSafeUintnToInt64 (
176 IN UNIT_TEST_CONTEXT Context
177 )
178{
179 EFI_STATUS Status;
180 UINTN Operand;
181 INT64 Result;
182
183 //
184 // UINTN is same as UINT32 in IA32, and UINT32 is a subset of
185 // INT64, so this is just a cast
186 //
187 Operand = 0xabababab;
188 Result = 0;
189 Status = SafeUintnToInt64 (Operand, &Result);
190 UT_ASSERT_NOT_EFI_ERROR (Status);
191 UT_ASSERT_EQUAL (0xabababab, Result);
192
193 return UNIT_TEST_PASSED;
194}
195
196UNIT_TEST_STATUS
197EFIAPI
198TestSafeInt64ToIntn (
199 IN UNIT_TEST_CONTEXT Context
200 )
201{
202 EFI_STATUS Status;
203 INT64 Operand;
204 INTN Result;
205
206 //
207 // If Operand is between MIN_INTN and MAX_INTN2 inclusive, then it's a cast
208 //
209 Operand = 0x5bababab;
210 Result = 0;
211 Status = SafeInt64ToIntn (Operand, &Result);
212 UT_ASSERT_NOT_EFI_ERROR (Status);
213 UT_ASSERT_EQUAL (0x5bababab, Result);
214
215 Operand = (-1537977259);
216 Status = SafeInt64ToIntn (Operand, &Result);
217 UT_ASSERT_NOT_EFI_ERROR (Status);
218 UT_ASSERT_EQUAL ((-1537977259), Result);
219
220 //
221 // Otherwise should result in an error status
222 //
223 Operand = (0x5babababefefefef);
224 Status = SafeInt64ToIntn (Operand, &Result);
225 UT_ASSERT_EQUAL (RETURN_BUFFER_TOO_SMALL, Status);
226
227 Operand = (-6605562033422200815);
228 Status = SafeInt64ToIntn (Operand, &Result);
229 UT_ASSERT_EQUAL (RETURN_BUFFER_TOO_SMALL, Status);
230
231 return UNIT_TEST_PASSED;
232}
233
234UNIT_TEST_STATUS
235EFIAPI
236TestSafeInt64ToUintn (
237 IN UNIT_TEST_CONTEXT Context
238 )
239{
240 EFI_STATUS Status;
241 INT64 Operand;
242 UINTN Result;
243
244 //
245 // If Operand is between 0 and MAX_UINTN inclusive, then it's a cast
246 //
247 Operand = 0xabababab;
248 Result = 0;
249 Status = SafeInt64ToUintn (Operand, &Result);
250 UT_ASSERT_NOT_EFI_ERROR (Status);
251 UT_ASSERT_EQUAL (0xabababab, Result);
252
253 //
254 // Otherwise should result in an error status
255 //
256 Operand = (0x5babababefefefef);
257 Status = SafeInt64ToUintn (Operand, &Result);
258 UT_ASSERT_EQUAL (RETURN_BUFFER_TOO_SMALL, Status);
259
260 Operand = (-6605562033422200815);
261 Status = SafeInt64ToUintn (Operand, &Result);
262 UT_ASSERT_EQUAL (RETURN_BUFFER_TOO_SMALL, Status);
263
264 return UNIT_TEST_PASSED;
265}
266
267UNIT_TEST_STATUS
268EFIAPI
269TestSafeUint64ToIntn (
270 IN UNIT_TEST_CONTEXT Context
271 )
272{
273 EFI_STATUS Status;
274 UINT64 Operand;
275 INTN Result;
276
277 //
278 // If Operand is <= MAX_INTN, then it's a cast
279 //
280 Operand = 0x5bababab;
281 Result = 0;
282 Status = SafeUint64ToIntn (Operand, &Result);
283 UT_ASSERT_NOT_EFI_ERROR (Status);
284 UT_ASSERT_EQUAL (0x5bababab, Result);
285
286 //
287 // Otherwise should result in an error status
288 //
289 Operand = (0xababababefefefef);
290 Status = SafeUint64ToIntn (Operand, &Result);
291 UT_ASSERT_EQUAL (RETURN_BUFFER_TOO_SMALL, Status);
292
293 return UNIT_TEST_PASSED;
294}
295
296UNIT_TEST_STATUS
297EFIAPI
298TestSafeUint64ToUintn (
299 IN UNIT_TEST_CONTEXT Context
300 )
301{
302 EFI_STATUS Status;
303 UINT64 Operand;
304 UINTN Result;
305
306 //
307 // If Operand is <= MAX_UINTN, then it's a cast
308 //
309 Operand = 0xabababab;
310 Result = 0;
311 Status = SafeUint64ToUintn (Operand, &Result);
312 UT_ASSERT_NOT_EFI_ERROR (Status);
313 UT_ASSERT_EQUAL (0xabababab, Result);
314
315 //
316 // Otherwise should result in an error status
317 //
318 Operand = (0xababababefefefef);
319 Status = SafeUint64ToUintn (Operand, &Result);
320 UT_ASSERT_EQUAL (RETURN_BUFFER_TOO_SMALL, Status);
321
322 return UNIT_TEST_PASSED;
323}
324
325UNIT_TEST_STATUS
326EFIAPI
327TestSafeUintnAdd (
328 IN UNIT_TEST_CONTEXT Context
329 )
330{
331 EFI_STATUS Status;
332 UINTN Augend;
333 UINTN Addend;
334 UINTN Result;
335
336 //
337 // If the result of addition doesn't overflow MAX_UINTN, then it's addition
338 //
339 Augend = 0x3a3a3a3a;
340 Addend = 0x3a3a3a3a;
341 Result = 0;
342 Status = SafeUintnAdd (Augend, Addend, &Result);
343 UT_ASSERT_NOT_EFI_ERROR (Status);
344 UT_ASSERT_EQUAL (0x74747474, Result);
345
346 //
347 // Otherwise should result in an error status
348 //
349 Augend = 0xabababab;
350 Addend = 0xbcbcbcbc;
351 Status = SafeUintnAdd (Augend, Addend, &Result);
352 UT_ASSERT_EQUAL (RETURN_BUFFER_TOO_SMALL, Status);
353
354 return UNIT_TEST_PASSED;
355}
356
357UNIT_TEST_STATUS
358EFIAPI
359TestSafeIntnAdd (
360 IN UNIT_TEST_CONTEXT Context
361 )
362{
363 EFI_STATUS Status;
364 INTN Augend;
365 INTN Addend;
366 INTN Result;
367
368 //
369 // If the result of addition doesn't overflow MAX_INTN
370 // and doesn't underflow MIN_INTN, then it's addition
371 //
372 Augend = 0x3a3a3a3a;
373 Addend = 0x3a3a3a3a;
374 Result = 0;
375 Status = SafeIntnAdd (Augend, Addend, &Result);
376 UT_ASSERT_NOT_EFI_ERROR (Status);
377 UT_ASSERT_EQUAL (0x74747474, Result);
378
379 Augend = (-976894522);
380 Addend = (-976894522);
381 Status = SafeIntnAdd (Augend, Addend, &Result);
382 UT_ASSERT_NOT_EFI_ERROR (Status);
383 UT_ASSERT_EQUAL ((-1953789044), Result);
384
385 //
386 // Otherwise should result in an error status
387 //
388 Augend = 0x5a5a5a5a;
389 Addend = 0x5a5a5a5a;
390 Status = SafeIntnAdd (Augend, Addend, &Result);
391 UT_ASSERT_EQUAL (RETURN_BUFFER_TOO_SMALL, Status);
392
393 Augend = (-1515870810);
394 Addend = (-1515870810);
395 Status = SafeIntnAdd (Augend, Addend, &Result);
396 UT_ASSERT_EQUAL (RETURN_BUFFER_TOO_SMALL, Status);
397
398 return UNIT_TEST_PASSED;
399}
400
401UNIT_TEST_STATUS
402EFIAPI
403TestSafeUintnSub (
404 IN UNIT_TEST_CONTEXT Context
405 )
406{
407 EFI_STATUS Status;
408 UINTN Minuend;
409 UINTN Subtrahend;
410 UINTN Result;
411
412 //
413 // If Minuend >= Subtrahend, then it's subtraction
414 //
415 Minuend = 0x5a5a5a5a;
416 Subtrahend = 0x3b3b3b3b;
417 Result = 0;
418 Status = SafeUintnSub (Minuend, Subtrahend, &Result);
419 UT_ASSERT_NOT_EFI_ERROR (Status);
420 UT_ASSERT_EQUAL (0x1f1f1f1f, Result);
421
422 //
423 // Otherwise should result in an error status
424 //
425 Minuend = 0x5a5a5a5a;
426 Subtrahend = 0x6d6d6d6d;
427 Status = SafeUintnSub (Minuend, Subtrahend, &Result);
428 UT_ASSERT_EQUAL (RETURN_BUFFER_TOO_SMALL, Status);
429
430 return UNIT_TEST_PASSED;
431}
432
433UNIT_TEST_STATUS
434EFIAPI
435TestSafeIntnSub (
436 IN UNIT_TEST_CONTEXT Context
437 )
438{
439 EFI_STATUS Status;
440 INTN Minuend;
441 INTN Subtrahend;
442 INTN Result;
443
444 //
445 // If the result of subtractions doesn't overflow MAX_INTN or
446 // underflow MIN_INTN, then it's subtraction
447 //
448 Minuend = 0x5a5a5a5a;
449 Subtrahend = 0x3a3a3a3a;
450 Result = 0;
451 Status = SafeIntnSub (Minuend, Subtrahend, &Result);
452 UT_ASSERT_NOT_EFI_ERROR (Status);
453 UT_ASSERT_EQUAL (0x20202020, Result);
454
455 Minuend = 0x3a3a3a3a;
456 Subtrahend = 0x5a5a5a5a;
457 Status = SafeIntnSub (Minuend, Subtrahend, &Result);
458 UT_ASSERT_NOT_EFI_ERROR (Status);
459 UT_ASSERT_EQUAL ((-538976288), Result);
460
461 //
462 // Otherwise should result in an error status
463 //
464 Minuend = (-2054847098);
465 Subtrahend = 2054847098;
466 Status = SafeIntnSub (Minuend, Subtrahend, &Result);
467 UT_ASSERT_EQUAL (RETURN_BUFFER_TOO_SMALL, Status);
468
469 Minuend = (2054847098);
470 Subtrahend = (-2054847098);
471 Status = SafeIntnSub (Minuend, Subtrahend, &Result);
472 UT_ASSERT_EQUAL (RETURN_BUFFER_TOO_SMALL, Status);
473
474 return UNIT_TEST_PASSED;
475}
476
477UNIT_TEST_STATUS
478EFIAPI
479TestSafeUintnMult (
480 IN UNIT_TEST_CONTEXT Context
481 )
482{
483 EFI_STATUS Status;
484 UINTN Multiplicand;
485 UINTN Multiplier;
486 UINTN Result;
487
488 //
489 // If the result of multiplication doesn't overflow MAX_UINTN, it will succeed
490 //
491 Multiplicand = 0xa122a;
492 Multiplier = 0xd23;
493 Result = 0;
494 Status = SafeUintnMult (Multiplicand, Multiplier, &Result);
495 UT_ASSERT_NOT_EFI_ERROR (Status);
496 UT_ASSERT_EQUAL (0x844c9dbe, Result);
497
498 //
499 // Otherwise should result in an error status
500 //
501 Multiplicand = 0xa122a;
502 Multiplier = 0xed23;
503 Status = SafeUintnMult (Multiplicand, Multiplier, &Result);
504 UT_ASSERT_EQUAL (RETURN_BUFFER_TOO_SMALL, Status);
505
506 return UNIT_TEST_PASSED;
507}
508
509UNIT_TEST_STATUS
510EFIAPI
511TestSafeIntnMult (
512 IN UNIT_TEST_CONTEXT Context
513 )
514{
515 EFI_STATUS Status;
516 INTN Multiplicand;
517 INTN Multiplier;
518 INTN Result;
519
520 //
521 // If the result of multiplication doesn't overflow MAX_INTN and doesn't
522 // underflow MIN_UINTN, it will succeed
523 //
524 Multiplicand = 0x123456;
525 Multiplier = 0x678;
526 Result = 0;
527 Status = SafeIntnMult (Multiplicand, Multiplier, &Result);
528 UT_ASSERT_NOT_EFI_ERROR (Status);
529 UT_ASSERT_EQUAL (0x75c28c50, Result);
530
531 //
532 // Otherwise should result in an error status
533 //
534 Multiplicand = 0x123456;
535 Multiplier = 0xabc;
536 Status = SafeIntnMult (Multiplicand, Multiplier, &Result);
537 UT_ASSERT_EQUAL (RETURN_BUFFER_TOO_SMALL, Status);
538
539 return UNIT_TEST_PASSED;
540}
UINTN
UINT64 UINTN
Definition: ProcessorBind.h:112
INTN
INT64 INTN
Definition: ProcessorBind.h:118
RETURN_BUFFER_TOO_SMALL
#define RETURN_BUFFER_TOO_SMALL
Definition: Base.h:1093
IN
#define IN
Definition: Base.h:279
SafeInt64ToIntn
RETURN_STATUS EFIAPI SafeInt64ToIntn(IN INT64 Operand, OUT INTN *Result)
Definition: SafeIntLib32.c:247
SafeUint32ToIntn
RETURN_STATUS EFIAPI SafeUint32ToIntn(IN UINT32 Operand, OUT INTN *Result)
Definition: SafeIntLib32.c:68
SafeUintnAdd
RETURN_STATUS EFIAPI SafeUintnAdd(IN UINTN Augend, IN UINTN Addend, OUT UINTN *Result)
Definition: SafeIntLib32.c:338
SafeIntnToInt32
RETURN_STATUS EFIAPI SafeIntnToInt32(IN INTN Operand, OUT INT32 *Result)
Definition: SafeIntLib32.c:98
SafeUintnMult
RETURN_STATUS EFIAPI SafeUintnMult(IN UINTN Multiplicand, IN UINTN Multiplier, OUT UINTN *Result)
Definition: SafeIntLib32.c:430
SafeUintnToIntn
RETURN_STATUS EFIAPI SafeUintnToIntn(IN UINTN Operand, OUT INTN *Result)
Definition: SafeIntLib.c:2038
SafeIntnToUint32
RETURN_STATUS EFIAPI SafeIntnToUint32(IN INTN Operand, OUT UINT32 *Result)
Definition: SafeIntLib32.c:133
SafeUintnToUint32
RETURN_STATUS EFIAPI SafeUintnToUint32(IN UINTN Operand, OUT UINT32 *Result)
Definition: SafeIntLib32.c:177
SafeIntnMult
RETURN_STATUS EFIAPI SafeIntnMult(IN INTN Multiplicand, IN INTN Multiplier, OUT INTN *Result)
Definition: SafeIntLib32.c:530
SafeIntnSub
RETURN_STATUS EFIAPI SafeIntnSub(IN INTN Minuend, IN INTN Subtrahend, OUT INTN *Result)
Definition: SafeIntLib32.c:498
SafeUint64ToIntn
RETURN_STATUS EFIAPI SafeUint64ToIntn(IN UINT64 Operand, OUT INTN *Result)
Definition: SafeIntLib.c:2742
SafeUintnToInt64
RETURN_STATUS EFIAPI SafeUintnToInt64(IN UINTN Operand, OUT INT64 *Result)
Definition: SafeIntLib32.c:212
SafeInt32ToUintn
RETURN_STATUS EFIAPI SafeInt32ToUintn(IN INT32 Operand, OUT UINTN *Result)
Definition: SafeIntLib32.c:38
SafeIntnAdd
RETURN_STATUS EFIAPI SafeIntnAdd(IN INTN Augend, IN INTN Addend, OUT INTN *Result)
Definition: SafeIntLib32.c:466
SafeInt64ToUintn
RETURN_STATUS EFIAPI SafeInt64ToUintn(IN INT64 Operand, OUT UINTN *Result)
Definition: SafeIntLib32.c:277
SafeUint64ToUintn
RETURN_STATUS EFIAPI SafeUint64ToUintn(IN UINT64 Operand, OUT UINTN *Result)
Definition: SafeIntLib32.c:307
SafeUintnSub
RETURN_STATUS EFIAPI SafeUintnSub(IN UINTN Minuend, IN UINTN Subtrahend, OUT UINTN *Result)
Definition: SafeIntLib32.c:384
EFI_STATUS
RETURN_STATUS EFI_STATUS
Definition: UefiBaseType.h:29
UNIT_TEST_CONTEXT
VOID * UNIT_TEST_CONTEXT
Definition: UnitTestLib.h:54
UT_ASSERT_EQUAL
#define UT_ASSERT_EQUAL(ValueA, ValueB)
Definition: UnitTestLib.h:375
UNIT_TEST_STATUS
UINT32 UNIT_TEST_STATUS
Definition: UnitTestLib.h:16
UT_ASSERT_NOT_EFI_ERROR
#define UT_ASSERT_NOT_EFI_ERROR(Status)
Definition: UnitTestLib.h:414