MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntLib.c

   1 /** @file
   2   UEFI OS based application for unit testing the SafeIntLib.
   3
   4   Copyright (c) Microsoft Corporation.<BR>
   5   Copyright (c) 2018 - 2020, Intel Corporation. All rights reserved.<BR>
   6   SPDX-License-Identifier: BSD-2-Clause-Patent
   7
   8 **/
   9
  10 #include "TestBaseSafeIntLib.h"
  11
  12 #define UNIT_TEST_NAME        "Int Safe Lib Unit Test Application"
  13 #define UNIT_TEST_VERSION     "0.1"
  14
  15 //
  16 // Conversion function tests:
  17 //
  18 UNIT_TEST_STATUS
  19 EFIAPI
  20 TestSafeInt8ToUint8 (
  21   IN UNIT_TEST_CONTEXT           Context
  22   )
  23 {
  24   EFI_STATUS  Status;
  25   INT8        Operand;
  26   UINT8       Result;
  27
  28   //
  29   // Positive UINT8 should result in just a cast
  30   //
  31   Operand = 0x5b;
  32   Result = 0;
  33   Status = SafeInt8ToUint8(Operand, &Result);
  34   UT_ASSERT_NOT_EFI_ERROR(Status);
  35   UT_ASSERT_EQUAL(0x5b, Result);
  36
  37   //
  38   // Negative number should result in an error status
  39   //
  40   Operand = (-56);
  41   Status = SafeInt8ToUint8(Operand, &Result);
  42   UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
  43
  44   return UNIT_TEST_PASSED;
  45 }
  46
  47 UNIT_TEST_STATUS
  48 EFIAPI
  49 TestSafeInt8ToUint16 (
  50   IN UNIT_TEST_CONTEXT           Context
  51   )
  52 {
  53   EFI_STATUS  Status;
  54   INT8        Operand;
  55   UINT16      Result;
  56
  57   //
  58   // Positive UINT8 should result in just a cast
  59   //
  60   Operand = 0x5b;
  61   Result = 0;
  62   Status = SafeInt8ToUint16(Operand, &Result);
  63   UT_ASSERT_NOT_EFI_ERROR(Status);
  64   UT_ASSERT_EQUAL(0x5b, Result);
  65
  66   //
  67   // Negative number should result in an error status
  68   //
  69   Operand = (-56);
  70   Status = SafeInt8ToUint16(Operand, &Result);
  71   UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
  72
  73   return UNIT_TEST_PASSED;
  74 }
  75
  76 UNIT_TEST_STATUS
  77 EFIAPI
  78 TestSafeInt8ToUint32 (
  79   IN UNIT_TEST_CONTEXT           Context
  80   )
  81 {
  82   EFI_STATUS  Status;
  83   INT8        Operand;
  84   UINT32      Result;
  85
  86   //
  87   // Positive UINT8 should result in just a cast
  88   //
  89   Operand = 0x5b;
  90   Result = 0;
  91   Status = SafeInt8ToUint32(Operand, &Result);
  92   UT_ASSERT_NOT_EFI_ERROR(Status);
  93   UT_ASSERT_EQUAL(0x5b, Result);
  94
  95   //
  96   // Negative number should result in an error status
  97   //
  98   Operand = (-56);
  99   Status = SafeInt8ToUint32(Operand, &Result);
 100   UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
 101
 102   return UNIT_TEST_PASSED;
 103 }
 104
 105 UNIT_TEST_STATUS
 106 EFIAPI
 107 TestSafeInt8ToUintn (
 108   IN UNIT_TEST_CONTEXT           Context
 109   )
 110 {
 111   EFI_STATUS  Status;
 112   INT8        Operand;
 113   UINTN       Result;
 114
 115   //
 116   // Positive UINT8 should result in just a cast
 117   //
 118   Operand = 0x5b;
 119   Result = 0;
 120   Status = SafeInt8ToUintn(Operand, &Result);
 121   UT_ASSERT_NOT_EFI_ERROR(Status);
 122   UT_ASSERT_EQUAL(0x5b, Result);
 123
 124   //
 125   // Negative number should result in an error status
 126   //
 127   Operand = (-56);
 128   Status = SafeInt8ToUintn(Operand, &Result);
 129   UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
 130
 131   return UNIT_TEST_PASSED;
 132 }
 133
 134 UNIT_TEST_STATUS
 135 EFIAPI
 136 TestSafeInt8ToUint64 (
 137   IN UNIT_TEST_CONTEXT           Context
 138   )
 139 {
 140   EFI_STATUS  Status;
 141   INT8        Operand;
 142   UINT64      Result;
 143
 144   //
 145   // Positive UINT8 should result in just a cast
 146   //
 147   Operand = 0x5b;
 148   Result = 0;
 149   Status = SafeInt8ToUint64(Operand, &Result);
 150   UT_ASSERT_NOT_EFI_ERROR(Status);
 151   UT_ASSERT_EQUAL(0x5b, Result);
 152
 153   //
 154   // Negative number should result in an error status
 155   //
 156   Operand = (-56);
 157   Status = SafeInt8ToUint64(Operand, &Result);
 158   UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
 159
 160   return UNIT_TEST_PASSED;
 161 }
 162
 163 UNIT_TEST_STATUS
 164 EFIAPI
 165 TestSafeUint8ToInt8 (
 166   IN UNIT_TEST_CONTEXT           Context
 167   )
 168 {
 169   EFI_STATUS  Status;
 170   UINT8       Operand;
 171   INT8        Result;
 172
 173   //
 174   // Operand <= 0x7F (MAX_INT8) should result in a cast
 175   //
 176   Operand = 0x5b;
 177   Result = 0;
 178   Status = SafeUint8ToInt8(Operand, &Result);
 179   UT_ASSERT_NOT_EFI_ERROR(Status);
 180   UT_ASSERT_EQUAL(0x5b, Result);
 181
 182   //
 183   // Operand larger than 0x7f should result in an error status
 184   //
 185   Operand = 0xaf;
 186   Status = SafeUint8ToInt8(Operand, &Result);
 187   UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
 188
 189   return UNIT_TEST_PASSED;
 190 }
 191
 192 UNIT_TEST_STATUS
 193 EFIAPI
 194 TestSafeUint8ToChar8 (
 195   IN UNIT_TEST_CONTEXT           Context
 196   )
 197 {
 198   EFI_STATUS  Status;
 199   UINT8       Operand;
 200   CHAR8       Result;
 201
 202   //
 203   // CHAR8 is typedefed as char, which by default is signed, thus
 204   // CHAR8 is same as INT8, so same tests as above:
 205   //
 206
 207   //
 208   // Operand <= 0x7F (MAX_INT8) should result in a cast
 209   //
 210   Operand = 0x5b;
 211   Result = 0;
 212   Status = SafeUint8ToChar8(Operand, &Result);
 213   UT_ASSERT_NOT_EFI_ERROR(Status);
 214   UT_ASSERT_EQUAL(0x5b, Result);
 215
 216   //
 217   // Operand larger than 0x7f should result in an error status
 218   //
 219   Operand = 0xaf;
 220   Status = SafeUint8ToChar8(Operand, &Result);
 221   UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
 222
 223   return UNIT_TEST_PASSED;
 224 }
 225
 226 UNIT_TEST_STATUS
 227 EFIAPI
 228 TestSafeInt16ToInt8 (
 229   IN UNIT_TEST_CONTEXT           Context
 230   )
 231 {
 232   EFI_STATUS  Status;
 233   INT16       Operand;
 234   INT8        Result;
 235
 236   //
 237   // If Operand is between MIN_INT8 and MAX_INT8 inclusive, then it's a cast
 238   //
 239   Operand = 0x5b;
 240   Result = 0;
 241   Status = SafeInt16ToInt8(Operand, &Result);
 242   UT_ASSERT_NOT_EFI_ERROR(Status);
 243   UT_ASSERT_EQUAL(0x5b, Result);
 244
 245   Operand = (-35);
 246   Status = SafeInt16ToInt8(Operand, &Result);
 247   UT_ASSERT_NOT_EFI_ERROR(Status);
 248   UT_ASSERT_EQUAL((-35), Result);
 249
 250   //
 251   // Otherwise should result in an error status
 252   //
 253   Operand = 0x1234;
 254   Status = SafeInt16ToInt8(Operand, &Result);
 255   UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
 256
 257   Operand = (-17835);
 258   Status = SafeInt16ToInt8(Operand, &Result);
 259   UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
 260
 261   return UNIT_TEST_PASSED;
 262 }
 263
 264 UNIT_TEST_STATUS
 265 EFIAPI
 266 TestSafeInt16ToChar8 (
 267   IN UNIT_TEST_CONTEXT           Context
 268   )
 269 {
 270   EFI_STATUS  Status;
 271   INT16       Operand;
 272   CHAR8       Result;
 273
 274   //
 275   // CHAR8 is typedefed as char, which may be signed or unsigned based
 276   // on the compiler. Thus, for compatibility CHAR8 should be between 0 and MAX_INT8.
 277   //
 278
 279   //
 280   // If Operand is between 0 and MAX_INT8 inclusive, then it's a cast
 281   //
 282   Operand = 0x5b;
 283   Result = 0;
 284   Status = SafeInt16ToChar8(Operand, &Result);
 285   UT_ASSERT_NOT_EFI_ERROR(Status);
 286   UT_ASSERT_EQUAL(0x5b, Result);
 287
 288   Operand = 0;
 289   Result = 0;
 290   Status = SafeInt16ToChar8(Operand, &Result);
 291   UT_ASSERT_NOT_EFI_ERROR(Status);
 292   UT_ASSERT_EQUAL(0, Result);
 293
 294   Operand = MAX_INT8;
 295   Result = 0;
 296   Status = SafeInt16ToChar8(Operand, &Result);
 297   UT_ASSERT_NOT_EFI_ERROR(Status);
 298   UT_ASSERT_EQUAL(MAX_INT8, Result);
 299
 300   //
 301   // Otherwise should result in an error status
 302   //
 303   Operand = (-35);
 304   Status = SafeInt16ToChar8(Operand, &Result);
 305   UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
 306
 307   Operand = 0x1234;
 308   Status = SafeInt16ToChar8(Operand, &Result);
 309   UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
 310
 311   Operand = (-17835);
 312   Status = SafeInt16ToChar8(Operand, &Result);
 313   UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
 314
 315   return UNIT_TEST_PASSED;
 316 }
 317
 318 UNIT_TEST_STATUS
 319 EFIAPI
 320 TestSafeInt16ToUint8 (
 321   IN UNIT_TEST_CONTEXT           Context
 322   )
 323 {
 324   EFI_STATUS  Status;
 325   INT16       Operand;
 326   UINT8       Result;
 327
 328   //
 329   // If Operand is between 0 and MAX_INT8 inclusive, then it's a cast
 330   //
 331   Operand = 0x5b;
 332   Result = 0;
 333   Status = SafeInt16ToUint8(Operand, &Result);
 334   UT_ASSERT_NOT_EFI_ERROR(Status);
 335   UT_ASSERT_EQUAL(0x5b, Result);
 336
 337   //
 338   // Otherwise should result in an error status
 339   //
 340   Operand = 0x1234;
 341   Status = SafeInt16ToUint8(Operand, &Result);
 342   UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
 343
 344   Operand = (-17835);
 345   Status = SafeInt16ToUint8(Operand, &Result);
 346   UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
 347
 348   return UNIT_TEST_PASSED;
 349 }
 350
 351 UNIT_TEST_STATUS
 352 EFIAPI
 353 TestSafeInt16ToUint16 (
 354   IN UNIT_TEST_CONTEXT           Context
 355   )
 356 {
 357   EFI_STATUS  Status;
 358   INT16 Operand = 0x5b5b;
 359   UINT16 Result = 0;
 360
 361   //
 362   // If Operand is non-negative, then it's a cast
 363   //
 364   Status = SafeInt16ToUint16(Operand, &Result);
 365   UT_ASSERT_NOT_EFI_ERROR(Status);
 366   UT_ASSERT_EQUAL(0x5b5b, Result);
 367
 368   //
 369   // Otherwise should result in an error status
 370   //
 371   Operand = (-17835);
 372   Status = SafeInt16ToUint16(Operand, &Result);
 373   UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
 374
 375   return UNIT_TEST_PASSED;
 376 }
 377
 378 UNIT_TEST_STATUS
 379 EFIAPI
 380 TestSafeInt16ToUint32 (
 381   IN UNIT_TEST_CONTEXT           Context
 382   )
 383 {
 384   EFI_STATUS  Status;
 385   INT16       Operand;
 386   UINT32      Result;
 387
 388   //
 389   // If Operand is non-negative, then it's a cast
 390   //
 391   Operand = 0x5b5b;
 392   Result = 0;
 393   Status = SafeInt16ToUint32(Operand, &Result);
 394   UT_ASSERT_NOT_EFI_ERROR(Status);
 395   UT_ASSERT_EQUAL(0x5b5b, Result);
 396
 397   //
 398   // Otherwise should result in an error status
 399   //
 400   Operand = (-17835);
 401   Status = SafeInt16ToUint32(Operand, &Result);
 402   UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
 403
 404   return UNIT_TEST_PASSED;
 405 }
 406
 407 UNIT_TEST_STATUS
 408 EFIAPI
 409 TestSafeInt16ToUintn (
 410   IN UNIT_TEST_CONTEXT           Context
 411   )
 412 {
 413   EFI_STATUS  Status;
 414   INT16       Operand;
 415   UINTN       Result;
 416
 417   //
 418   // If Operand is non-negative, then it's a cast
 419   //
 420   Operand = 0x5b5b;
 421   Result = 0;
 422   Status = SafeInt16ToUintn(Operand, &Result);
 423   UT_ASSERT_NOT_EFI_ERROR(Status);
 424   UT_ASSERT_EQUAL(0x5b5b, Result);
 425
 426   //
 427   // Otherwise should result in an error status
 428   //
 429   Operand = (-17835);
 430   Status = SafeInt16ToUintn(Operand, &Result);
 431   UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
 432
 433   return UNIT_TEST_PASSED;
 434 }
 435
 436 UNIT_TEST_STATUS
 437 EFIAPI
 438 TestSafeInt16ToUint64 (
 439   IN UNIT_TEST_CONTEXT           Context
 440   )
 441 {
 442   EFI_STATUS  Status;
 443   INT16       Operand;
 444   UINT64      Result;
 445
 446   //
 447   // If Operand is non-negative, then it's a cast
 448   //
 449   Operand = 0x5b5b;
 450   Result = 0;
 451   Status = SafeInt16ToUint64(Operand, &Result);
 452   UT_ASSERT_NOT_EFI_ERROR(Status);
 453   UT_ASSERT_EQUAL(0x5b5b, Result);
 454
 455   //
 456   // Otherwise should result in an error status
 457   //
 458   Operand = (-17835);
 459   Status = SafeInt16ToUint64(Operand, &Result);
 460   UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
 461
 462   return UNIT_TEST_PASSED;
 463 }
 464
 465 UNIT_TEST_STATUS
 466 EFIAPI
 467 TestSafeUint16ToInt8 (
 468   IN UNIT_TEST_CONTEXT           Context
 469   )
 470 {
 471   EFI_STATUS  Status;
 472   UINT16      Operand;
 473   INT8        Result;
 474
 475   //
 476   // If Operand is <= MAX_INT8, it's a cast
 477   //
 478   Operand = 0x5b;
 479   Result = 0;
 480   Status = SafeUint16ToInt8(Operand, &Result);
 481   UT_ASSERT_NOT_EFI_ERROR(Status);
 482   UT_ASSERT_EQUAL(0x5b, Result);
 483
 484   //
 485   // Otherwise should result in an error status
 486   //
 487   Operand = (0x5b5b);
 488   Status = SafeUint16ToInt8(Operand, &Result);
 489   UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
 490
 491   return UNIT_TEST_PASSED;
 492 }
 493
 494 UNIT_TEST_STATUS
 495 EFIAPI
 496 TestSafeUint16ToChar8 (
 497   IN UNIT_TEST_CONTEXT           Context
 498   )
 499 {
 500   EFI_STATUS  Status;
 501   UINT16      Operand;
 502   CHAR8       Result;
 503
 504   // CHAR8 is typedefed as char, which by default is signed, thus
 505   // CHAR8 is same as INT8, so same tests as above:
 506
 507   //
 508   // If Operand is <= MAX_INT8, it's a cast
 509   //
 510   Operand = 0x5b;
 511   Result = 0;
 512   Status = SafeUint16ToChar8(Operand, &Result);
 513   UT_ASSERT_NOT_EFI_ERROR(Status);
 514   UT_ASSERT_EQUAL(0x5b, Result);
 515
 516   //
 517   // Otherwise should result in an error status
 518   //
 519   Operand = (0x5b5b);
 520   Status = SafeUint16ToChar8(Operand, &Result);
 521   UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
 522
 523   return UNIT_TEST_PASSED;
 524 }
 525
 526 UNIT_TEST_STATUS
 527 EFIAPI
 528 TestSafeUint16ToUint8 (
 529   IN UNIT_TEST_CONTEXT           Context
 530   )
 531 {
 532   EFI_STATUS  Status;
 533   UINT16      Operand;
 534   UINT8       Result;
 535
 536   //
 537   // If Operand is <= MAX_UINT8 (0xff), it's a cast
 538   //
 539   Operand = 0xab;
 540   Result = 0;
 541   Status = SafeUint16ToUint8(Operand, &Result);
 542   UT_ASSERT_NOT_EFI_ERROR(Status);
 543   UT_ASSERT_EQUAL(0xab, Result);
 544
 545   //
 546   // Otherwise should result in an error status
 547   //
 548   Operand = (0x5b5b);
 549   Status = SafeUint16ToUint8(Operand, &Result);
 550   UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
 551
 552   return UNIT_TEST_PASSED;
 553 }
 554
 555 UNIT_TEST_STATUS
 556 EFIAPI
 557 TestSafeUint16ToInt16 (
 558   IN UNIT_TEST_CONTEXT           Context
 559   )
 560 {
 561   EFI_STATUS  Status;
 562   UINT16      Operand;
 563   INT16       Result;
 564
 565   //
 566   // If Operand is <= MAX_INT16 (0x7fff), it's a cast
 567   //
 568   Operand = 0x5b5b;
 569   Result = 0;
 570   Status = SafeUint16ToInt16(Operand, &Result);
 571   UT_ASSERT_NOT_EFI_ERROR(Status);
 572   UT_ASSERT_EQUAL(0x5b5b, Result);
 573
 574   //
 575   // Otherwise should result in an error status
 576   //
 577   Operand = (0xabab);
 578   Status = SafeUint16ToInt16(Operand, &Result);
 579   UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
 580
 581   return UNIT_TEST_PASSED;
 582 }
 583
 584 UNIT_TEST_STATUS
 585 EFIAPI
 586 TestSafeInt32ToInt8 (
 587   IN UNIT_TEST_CONTEXT           Context
 588   )
 589 {
 590   EFI_STATUS  Status;
 591   INT32       Operand;
 592   INT8        Result;
 593
 594   //
 595   // If Operand is between MIN_INT8 and MAX_INT8 inclusive, then it's a cast
 596   //
 597   Operand = 0x5b;
 598   Result = 0;
 599   Status = SafeInt32ToInt8(Operand, &Result);
 600   UT_ASSERT_NOT_EFI_ERROR(Status);
 601   UT_ASSERT_EQUAL(0x5b, Result);
 602
 603   Operand = (-57);
 604   Status = SafeInt32ToInt8(Operand, &Result);
 605   UT_ASSERT_NOT_EFI_ERROR(Status);
 606   UT_ASSERT_EQUAL((-57), Result);
 607
 608   //
 609   // Otherwise should result in an error status
 610   //
 611   Operand = (0x5bababab);
 612   Status = SafeInt32ToInt8(Operand, &Result);
 613   UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
 614
 615   Operand = (-1537977259);
 616   Status = SafeInt32ToInt8(Operand, &Result);
 617   UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
 618
 619   return UNIT_TEST_PASSED;
 620 }
 621
 622 UNIT_TEST_STATUS
 623 EFIAPI
 624 TestSafeInt32ToChar8 (
 625   IN UNIT_TEST_CONTEXT           Context
 626   )
 627 {
 628   EFI_STATUS  Status;
 629   INT32       Operand;
 630   CHAR8       Result;
 631
 632   //
 633   // CHAR8 is typedefed as char, which may be signed or unsigned based
 634   // on the compiler. Thus, for compatibility CHAR8 should be between 0 and MAX_INT8.
 635   //
 636
 637   //
 638   // If Operand is between 0 and MAX_INT8 inclusive, then it's a cast
 639   //
 640   Operand = 0x5b;
 641   Result = 0;
 642   Status = SafeInt32ToChar8(Operand, &Result);
 643   UT_ASSERT_NOT_EFI_ERROR(Status);
 644   UT_ASSERT_EQUAL(0x5b, Result);
 645
 646   Operand = 0;
 647   Result = 0;
 648   Status = SafeInt32ToChar8(Operand, &Result);
 649   UT_ASSERT_NOT_EFI_ERROR(Status);
 650   UT_ASSERT_EQUAL(0, Result);
 651
 652   Operand = MAX_INT8;
 653   Result = 0;
 654   Status = SafeInt32ToChar8(Operand, &Result);
 655   UT_ASSERT_NOT_EFI_ERROR(Status);
 656   UT_ASSERT_EQUAL(MAX_INT8, Result);
 657
 658   //
 659   // Otherwise should result in an error status
 660   //
 661   Operand = (-57);
 662   Status = SafeInt32ToChar8(Operand, &Result);
 663   UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
 664
 665   Operand = (0x5bababab);
 666   Status = SafeInt32ToChar8(Operand, &Result);
 667   UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
 668
 669   Operand = (-1537977259);
 670   Status = SafeInt32ToChar8(Operand, &Result);
 671   UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
 672
 673   return UNIT_TEST_PASSED;
 674 }
 675
 676 UNIT_TEST_STATUS
 677 EFIAPI
 678 TestSafeInt32ToUint8 (
 679   IN UNIT_TEST_CONTEXT           Context
 680   )
 681 {
 682   EFI_STATUS  Status;
 683   INT32       Operand;
 684   UINT8       Result;
 685
 686   //
 687   // If Operand is between 0 and MAX_INT8 inclusive, then it's a cast
 688   //
 689   Operand = 0x5b;
 690   Result = 0;
 691   Status = SafeInt32ToUint8(Operand, &Result);
 692   UT_ASSERT_NOT_EFI_ERROR(Status);
 693   UT_ASSERT_EQUAL(0x5b, Result);
 694
 695   //
 696   // Otherwise should result in an error status
 697   //
 698   Operand = (-57);
 699   Status = SafeInt32ToUint8(Operand, &Result);
 700   UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
 701
 702   Operand = (0x5bababab);
 703   Status = SafeInt32ToUint8(Operand, &Result);
 704   UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
 705
 706   Operand = (-1537977259);
 707   Status = SafeInt32ToUint8(Operand, &Result);
 708   UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
 709
 710   return UNIT_TEST_PASSED;
 711 }
 712
 713 UNIT_TEST_STATUS
 714 EFIAPI
 715 TestSafeInt32ToInt16 (
 716   IN UNIT_TEST_CONTEXT           Context
 717   )
 718 {
 719   EFI_STATUS  Status;
 720   INT32       Operand;
 721   INT16       Result;
 722
 723   //
 724   // If Operand is between MIN_INT16 and MAX_INT16 inclusive, then it's a cast
 725   //
 726   Operand = 0x5b5b;
 727   Result = 0;
 728   Status = SafeInt32ToInt16(Operand, &Result);
 729   UT_ASSERT_NOT_EFI_ERROR(Status);
 730   UT_ASSERT_EQUAL(0x5b5b, Result);
 731
 732   Operand = (-17857);
 733   Status = SafeInt32ToInt16(Operand, &Result);
 734   UT_ASSERT_NOT_EFI_ERROR(Status);
 735   UT_ASSERT_EQUAL((-17857), Result);
 736
 737   //
 738   // Otherwise should result in an error status
 739   //
 740   Operand = (0x5bababab);
 741   Status = SafeInt32ToInt16(Operand, &Result);
 742   UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
 743
 744   Operand = (-1537977259);
 745   Status = SafeInt32ToInt16(Operand, &Result);
 746   UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
 747
 748   return UNIT_TEST_PASSED;
 749 }
 750
 751 UNIT_TEST_STATUS
 752 EFIAPI
 753 TestSafeInt32ToUint16 (
 754   IN UNIT_TEST_CONTEXT           Context
 755   )
 756 {
 757   EFI_STATUS  Status;
 758   INT32       Operand;
 759   UINT16      Result;
 760
 761   //
 762   // If Operand is between 0 and MAX_UINT16 inclusive, then it's a cast
 763   //
 764   Operand = 0xabab;
 765   Result = 0;
 766   Status = SafeInt32ToUint16(Operand, &Result);
 767   UT_ASSERT_NOT_EFI_ERROR(Status);
 768   UT_ASSERT_EQUAL(0xabab, Result);
 769
 770   //
 771   // Otherwise should result in an error status
 772   //
 773   Operand = (-17857);
 774   Status = SafeInt32ToUint16(Operand, &Result);
 775   UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
 776
 777   Operand = (0x5bababab);
 778   Status = SafeInt32ToUint16(Operand, &Result);
 779   UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
 780
 781   Operand = (-1537977259);
 782   Status = SafeInt32ToUint16(Operand, &Result);
 783   UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
 784
 785   return UNIT_TEST_PASSED;
 786 }
 787
 788 UNIT_TEST_STATUS
 789 EFIAPI
 790 TestSafeInt32ToUint32 (
 791   IN UNIT_TEST_CONTEXT           Context
 792   )
 793 {
 794   EFI_STATUS  Status;
 795   INT32       Operand;
 796   UINT32      Result;
 797
 798   //
 799   // If Operand is non-negative, then it's a cast
 800   //
 801   Operand = 0x5bababab;
 802   Result = 0;
 803   Status = SafeInt32ToUint32(Operand, &Result);
 804   UT_ASSERT_NOT_EFI_ERROR(Status);
 805   UT_ASSERT_EQUAL(0x5bababab, Result);
 806
 807   //
 808   // Otherwise should result in an error status
 809   //
 810   Operand = (-1537977259);
 811   Status = SafeInt32ToUint32(Operand, &Result);
 812   UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
 813
 814   return UNIT_TEST_PASSED;
 815 }
 816
 817 UNIT_TEST_STATUS
 818 EFIAPI
 819 TestSafeInt32ToUint64 (
 820   IN UNIT_TEST_CONTEXT           Context
 821   )
 822 {
 823   EFI_STATUS  Status;
 824   INT32       Operand;
 825   UINT64      Result;
 826
 827   //
 828   // If Operand is non-negative, then it's a cast
 829   //
 830   Operand = 0x5bababab;
 831   Result = 0;
 832   Status = SafeInt32ToUint64(Operand, &Result);
 833   UT_ASSERT_NOT_EFI_ERROR(Status);
 834   UT_ASSERT_EQUAL(0x5bababab, Result);
 835
 836   //
 837   // Otherwise should result in an error status
 838   //
 839   Operand = (-1537977259);
 840   Status = SafeInt32ToUint64(Operand, &Result);
 841   UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
 842
 843   return UNIT_TEST_PASSED;
 844 }
 845
 846 UNIT_TEST_STATUS
 847 EFIAPI
 848 TestSafeUint32ToInt8 (
 849   IN UNIT_TEST_CONTEXT           Context
 850   )
 851 {
 852   EFI_STATUS  Status;
 853   UINT32      Operand;
 854   INT8        Result;
 855
 856   //
 857   // If Operand is <= MAX_INT8, then it's a cast
 858   //
 859   Operand = 0x5b;
 860   Result = 0;
 861   Status = SafeUint32ToInt8(Operand, &Result);
 862   UT_ASSERT_NOT_EFI_ERROR(Status);
 863   UT_ASSERT_EQUAL(0x5b, Result);
 864
 865   //
 866   // Otherwise should result in an error status
 867   //
 868   Operand = (0x5bababab);
 869   Status = SafeUint32ToInt8(Operand, &Result);
 870   UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
 871
 872   return UNIT_TEST_PASSED;
 873 }
 874
 875 UNIT_TEST_STATUS
 876 EFIAPI
 877 TestSafeUint32ToChar8 (
 878   IN UNIT_TEST_CONTEXT           Context
 879   )
 880 {
 881   EFI_STATUS  Status;
 882   UINT32      Operand;
 883   CHAR8       Result;
 884
 885   // CHAR8 is typedefed as char, which by default is signed, thus
 886   // CHAR8 is same as INT8, so same tests as above:
 887
 888   //
 889   // If Operand is <= MAX_INT8, then it's a cast
 890   //
 891   Operand = 0x5b;
 892   Result = 0;
 893   Status = SafeUint32ToChar8(Operand, &Result);
 894   UT_ASSERT_NOT_EFI_ERROR(Status);
 895   UT_ASSERT_EQUAL(0x5b, Result);
 896
 897   //
 898   // Otherwise should result in an error status
 899   //
 900   Operand = (0x5bababab);
 901   Status = SafeUint32ToChar8(Operand, &Result);
 902   UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
 903
 904   return UNIT_TEST_PASSED;
 905 }
 906
 907 UNIT_TEST_STATUS
 908 EFIAPI
 909 TestSafeUint32ToUint8 (
 910   IN UNIT_TEST_CONTEXT           Context
 911   )
 912 {
 913   EFI_STATUS  Status;
 914   UINT32      Operand;
 915   UINT8       Result;
 916
 917   //
 918   // If Operand is <= MAX_UINT8, then it's a cast
 919   //
 920   Operand = 0xab;
 921   Result = 0;
 922   Status = SafeUint32ToUint8(Operand, &Result);
 923   UT_ASSERT_NOT_EFI_ERROR(Status);
 924   UT_ASSERT_EQUAL(0xab, Result);
 925
 926   //
 927   // Otherwise should result in an error status
 928   //
 929   Operand = (0xabababab);
 930   Status = SafeUint32ToUint8(Operand, &Result);
 931   UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
 932
 933   return UNIT_TEST_PASSED;
 934 }
 935
 936 UNIT_TEST_STATUS
 937 EFIAPI
 938 TestSafeUint32ToInt16 (
 939   IN UNIT_TEST_CONTEXT           Context
 940   )
 941 {
 942   EFI_STATUS  Status;
 943   UINT32      Operand;
 944   INT16       Result;
 945
 946   //
 947   // If Operand is <= MAX_INT16, then it's a cast
 948   //
 949   Operand = 0x5bab;
 950   Result = 0;
 951   Status = SafeUint32ToInt16(Operand, &Result);
 952   UT_ASSERT_NOT_EFI_ERROR(Status);
 953   UT_ASSERT_EQUAL(0x5bab, Result);
 954
 955   //
 956   // Otherwise should result in an error status
 957   //
 958   Operand = (0xabababab);
 959   Status = SafeUint32ToInt16(Operand, &Result);
 960   UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
 961
 962   return UNIT_TEST_PASSED;
 963 }
 964
 965 UNIT_TEST_STATUS
 966 EFIAPI
 967 TestSafeUint32ToUint16 (
 968   IN UNIT_TEST_CONTEXT           Context
 969   )
 970 {
 971   EFI_STATUS  Status;
 972   UINT32      Operand;
 973   UINT16      Result;
 974
 975   //
 976   // If Operand is <= MAX_UINT16, then it's a cast
 977   //
 978   Operand = 0xabab;
 979   Result = 0;
 980   Status = SafeUint32ToUint16(Operand, &Result);
 981   UT_ASSERT_NOT_EFI_ERROR(Status);
 982   UT_ASSERT_EQUAL(0xabab, Result);
 983
 984   //
 985   // Otherwise should result in an error status
 986   //
 987   Operand = (0xabababab);
 988   Status = SafeUint32ToUint16(Operand, &Result);
 989   UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
 990
 991   return UNIT_TEST_PASSED;
 992 }
 993
 994 UNIT_TEST_STATUS
 995 EFIAPI
 996 TestSafeUint32ToInt32 (
 997   IN UNIT_TEST_CONTEXT           Context
 998   )
 999 {
1000   EFI_STATUS  Status;
1001   UINT32      Operand;
1002   INT32       Result;
1003
1004   //
1005   // If Operand is <= MAX_INT32, then it's a cast
1006   //
1007   Operand = 0x5bababab;
1008   Result = 0;
1009   Status = SafeUint32ToInt32(Operand, &Result);
1010   UT_ASSERT_NOT_EFI_ERROR(Status);
1011   UT_ASSERT_EQUAL(0x5bababab, Result);
1012
1013   //
1014   // Otherwise should result in an error status
1015   //
1016   Operand = (0xabababab);
1017   Status = SafeUint32ToInt32(Operand, &Result);
1018   UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
1019
1020   return UNIT_TEST_PASSED;
1021 }
1022
1023 UNIT_TEST_STATUS
1024 EFIAPI
1025 TestSafeIntnToInt8 (
1026   IN UNIT_TEST_CONTEXT           Context
1027   )
1028 {
1029   EFI_STATUS  Status;
1030   INTN        Operand;
1031   INT8        Result;
1032
1033   //
1034   // If Operand is between MIN_INT8 and MAX_INT8 inclusive, then it's a cast
1035   //
1036   Operand = 0x5b;
1037   Result = 0;
1038   Status = SafeIntnToInt8(Operand, &Result);
1039   UT_ASSERT_NOT_EFI_ERROR(Status);
1040   UT_ASSERT_EQUAL(0x5b, Result);
1041
1042   Operand = (-53);
1043   Status = SafeIntnToInt8(Operand, &Result);
1044   UT_ASSERT_NOT_EFI_ERROR(Status);
1045   UT_ASSERT_EQUAL((-53), Result);
1046
1047   //
1048   // Otherwise should result in an error status
1049   //
1050   Operand = (0x5bababab);
1051   Status = SafeIntnToInt8(Operand, &Result);
1052   UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
1053
1054   Operand = (-1537977259);
1055   Status = SafeIntnToInt8(Operand, &Result);
1056   UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
1057
1058   return UNIT_TEST_PASSED;
1059 }
1060
1061 UNIT_TEST_STATUS
1062 EFIAPI
1063 TestSafeIntnToChar8 (
1064   IN UNIT_TEST_CONTEXT           Context
1065   )
1066 {
1067   EFI_STATUS  Status;
1068   INTN        Operand;
1069   CHAR8       Result;
1070
1071   //
1072   // CHAR8 is typedefed as char, which may be signed or unsigned based
1073   // on the compiler. Thus, for compatibility CHAR8 should be between 0 and MAX_INT8.
1074   //
1075
1076   //
1077   // If Operand is between MIN_INT8 and MAX_INT8 inclusive, then it's a cast
1078   //
1079   Operand = 0x5b;
1080   Result = 0;
1081   Status = SafeIntnToChar8(Operand, &Result);
1082   UT_ASSERT_NOT_EFI_ERROR(Status);
1083   UT_ASSERT_EQUAL(0x5b, Result);
1084
1085   Operand = 0;
1086   Result = 0;
1087   Status = SafeIntnToChar8(Operand, &Result);
1088   UT_ASSERT_NOT_EFI_ERROR(Status);
1089   UT_ASSERT_EQUAL(0, Result);
1090
1091   Operand = MAX_INT8;
1092   Result = 0;
1093   Status = SafeIntnToChar8(Operand, &Result);
1094   UT_ASSERT_NOT_EFI_ERROR(Status);
1095   UT_ASSERT_EQUAL(MAX_INT8, Result);
1096
1097   //
1098   // Otherwise should result in an error status
1099   //
1100   Operand = (-53);
1101   Status = SafeIntnToChar8(Operand, &Result);
1102   UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
1103
1104   Operand = (0x5bababab);
1105   Status = SafeIntnToChar8(Operand, &Result);
1106   UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
1107
1108   Operand = (-1537977259);
1109   Status = SafeIntnToChar8(Operand, &Result);
1110   UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
1111
1112   return UNIT_TEST_PASSED;
1113 }
1114
1115 UNIT_TEST_STATUS
1116 EFIAPI
1117 TestSafeIntnToUint8 (
1118   IN UNIT_TEST_CONTEXT           Context
1119   )
1120 {
1121   EFI_STATUS  Status;
1122   INTN        Operand;
1123   UINT8       Result;
1124
1125   //
1126   // If Operand is between 0 and MAX_UINT8 inclusive, then it's a cast
1127   //
1128   Operand = 0xab;
1129   Result = 0;
1130   Status = SafeIntnToUint8(Operand, &Result);
1131   UT_ASSERT_NOT_EFI_ERROR(Status);
1132   UT_ASSERT_EQUAL(0xab, Result);
1133
1134   //
1135   // Otherwise should result in an error status
1136   //
1137   Operand = (0x5bababab);
1138   Status = SafeIntnToUint8(Operand, &Result);
1139   UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
1140
1141   Operand = (-1537977259);
1142   Status = SafeIntnToUint8(Operand, &Result);
1143   UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
1144
1145   return UNIT_TEST_PASSED;
1146 }
1147
1148 UNIT_TEST_STATUS
1149 EFIAPI
1150 TestSafeIntnToInt16 (
1151   IN UNIT_TEST_CONTEXT           Context
1152   )
1153 {
1154   EFI_STATUS  Status;
1155   INTN        Operand;
1156   INT16       Result;
1157
1158   //
1159   // If Operand is between MIN_INT16 and MAX_INT16 inclusive, then it's a cast
1160   //
1161   Operand = 0x5bab;
1162   Result = 0;
1163   Status = SafeIntnToInt16(Operand, &Result);
1164   UT_ASSERT_NOT_EFI_ERROR(Status);
1165   UT_ASSERT_EQUAL(0x5bab, Result);
1166
1167   Operand = (-23467);
1168   Status = SafeIntnToInt16(Operand, &Result);
1169   UT_ASSERT_NOT_EFI_ERROR(Status);
1170   UT_ASSERT_EQUAL((-23467), Result);
1171
1172   //
1173   // Otherwise should result in an error status
1174   //
1175   Operand = (0x5bababab);
1176   Status = SafeIntnToInt16(Operand, &Result);
1177   UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
1178
1179   Operand = (-1537977259);
1180   Status = SafeIntnToInt16(Operand, &Result);
1181   UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
1182
1183   return UNIT_TEST_PASSED;
1184 }
1185
1186 UNIT_TEST_STATUS
1187 EFIAPI
1188 TestSafeIntnToUint16 (
1189   IN UNIT_TEST_CONTEXT           Context
1190   )
1191 {
1192   EFI_STATUS  Status;
1193   INTN        Operand;
1194   UINT16      Result;
1195
1196   //
1197   // If Operand is between 0 and MAX_UINT16 inclusive, then it's a cast
1198   //
1199   Operand = 0xabab;
1200   Result = 0;
1201   Status = SafeIntnToUint16(Operand, &Result);
1202   UT_ASSERT_NOT_EFI_ERROR(Status);
1203   UT_ASSERT_EQUAL(0xabab, Result);
1204
1205   //
1206   // Otherwise should result in an error status
1207   //
1208   Operand = (0x5bababab);
1209   Status = SafeIntnToUint16(Operand, &Result);
1210   UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
1211
1212   Operand = (-1537977259);
1213   Status = SafeIntnToUint16(Operand, &Result);
1214   UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
1215
1216   return UNIT_TEST_PASSED;
1217 }
1218
1219 UNIT_TEST_STATUS
1220 EFIAPI
1221 TestSafeIntnToUintn (
1222   IN UNIT_TEST_CONTEXT           Context
1223   )
1224 {
1225   EFI_STATUS  Status;
1226   INTN        Operand;
1227   UINTN       Result;
1228
1229   //
1230   // If Operand is non-negative, then it's a cast
1231   //
1232   Operand = 0x5bababab;
1233   Result = 0;
1234   Status = SafeIntnToUintn(Operand, &Result);
1235   UT_ASSERT_NOT_EFI_ERROR(Status);
1236   UT_ASSERT_EQUAL(0x5bababab, Result);
1237
1238   //
1239   // Otherwise should result in an error status
1240   //
1241   Operand = (-1537977259);
1242   Status = SafeIntnToUintn(Operand, &Result);
1243   UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
1244
1245   return UNIT_TEST_PASSED;
1246 }
1247
1248 UNIT_TEST_STATUS
1249 EFIAPI
1250 TestSafeIntnToUint64 (
1251   IN UNIT_TEST_CONTEXT           Context
1252   )
1253 {
1254   EFI_STATUS  Status;
1255   INTN        Operand;
1256   UINT64      Result;
1257
1258   //
1259   // If Operand is non-negative, then it's a cast
1260   //
1261   Operand = 0x5bababab;
1262   Result = 0;
1263   Status = SafeIntnToUint64(Operand, &Result);
1264   UT_ASSERT_NOT_EFI_ERROR(Status);
1265   UT_ASSERT_EQUAL(0x5bababab, Result);
1266
1267   //
1268   // Otherwise should result in an error status
1269   //
1270   Operand = (-1537977259);
1271   Status = SafeIntnToUint64(Operand, &Result);
1272   UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
1273
1274   return UNIT_TEST_PASSED;
1275 }
1276
1277 UNIT_TEST_STATUS
1278 EFIAPI
1279 TestSafeUintnToInt8 (
1280   IN UNIT_TEST_CONTEXT           Context
1281   )
1282 {
1283   EFI_STATUS  Status;
1284   UINTN       Operand;
1285   INT8        Result;
1286
1287   //
1288   // If Operand is <= MAX_INT8, then it's a cast
1289   //
1290   Operand = 0x5b;
1291   Result = 0;
1292   Status = SafeUintnToInt8(Operand, &Result);
1293   UT_ASSERT_NOT_EFI_ERROR(Status);
1294   UT_ASSERT_EQUAL(0x5b, Result);
1295
1296   //
1297   // Otherwise should result in an error status
1298   //
1299   Operand = (0xabab);
1300   Status = SafeUintnToInt8(Operand, &Result);
1301   UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
1302
1303   return UNIT_TEST_PASSED;
1304 }
1305
1306 UNIT_TEST_STATUS
1307 EFIAPI
1308 TestSafeUintnToChar8 (
1309   IN UNIT_TEST_CONTEXT           Context
1310   )
1311 {
1312   EFI_STATUS  Status;
1313   UINTN       Operand;
1314   CHAR8       Result;
1315
1316   // CHAR8 is typedefed as char, which by default is signed, thus
1317   // CHAR8 is same as INT8, so same tests as above:
1318
1319   //
1320   // If Operand is <= MAX_INT8, then it's a cast
1321   //
1322   Operand = 0x5b;
1323   Result = 0;
1324   Status = SafeUintnToChar8(Operand, &Result);
1325   UT_ASSERT_NOT_EFI_ERROR(Status);
1326   UT_ASSERT_EQUAL(0x5b, Result);
1327
1328   //
1329   // Otherwise should result in an error status
1330   //
1331   Operand = (0xabab);
1332   Status = SafeUintnToChar8(Operand, &Result);
1333   UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
1334
1335   return UNIT_TEST_PASSED;
1336 }
1337
1338 UNIT_TEST_STATUS
1339 EFIAPI
1340 TestSafeUintnToUint8 (
1341   IN UNIT_TEST_CONTEXT           Context
1342   )
1343 {
1344   EFI_STATUS  Status;
1345   UINTN       Operand;
1346   UINT8       Result;
1347
1348   //
1349   // If Operand is <= MAX_UINT8, then it's a cast
1350   //
1351   Operand = 0xab;
1352   Result = 0;
1353   Status = SafeUintnToUint8(Operand, &Result);
1354   UT_ASSERT_NOT_EFI_ERROR(Status);
1355   UT_ASSERT_EQUAL(0xab, Result);
1356
1357   //
1358   // Otherwise should result in an error status
1359   //
1360   Operand = (0xabab);
1361   Status = SafeUintnToUint8(Operand, &Result);
1362   UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
1363
1364   return UNIT_TEST_PASSED;
1365 }
1366
1367 UNIT_TEST_STATUS
1368 EFIAPI
1369 TestSafeUintnToInt16 (
1370   IN UNIT_TEST_CONTEXT           Context
1371   )
1372 {
1373   EFI_STATUS  Status;
1374   UINTN       Operand;
1375   INT16       Result;
1376
1377   //
1378   // If Operand is <= MAX_INT16, then it's a cast
1379   //
1380   Operand = 0x5bab;
1381   Result = 0;
1382   Status = SafeUintnToInt16(Operand, &Result);
1383   UT_ASSERT_NOT_EFI_ERROR(Status);
1384   UT_ASSERT_EQUAL(0x5bab, Result);
1385
1386   //
1387   // Otherwise should result in an error status
1388   //
1389   Operand = (0xabab);
1390   Status = SafeUintnToInt16(Operand, &Result);
1391   UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
1392
1393   return UNIT_TEST_PASSED;
1394 }
1395
1396 UNIT_TEST_STATUS
1397 EFIAPI
1398 TestSafeUintnToUint16 (
1399   IN UNIT_TEST_CONTEXT           Context
1400   )
1401 {
1402   EFI_STATUS  Status;
1403   UINTN       Operand;
1404   UINT16      Result;
1405
1406   //
1407   // If Operand is <= MAX_UINT16, then it's a cast
1408   //
1409   Operand = 0xabab;
1410   Result = 0;
1411   Status = SafeUintnToUint16(Operand, &Result);
1412   UT_ASSERT_NOT_EFI_ERROR(Status);
1413   UT_ASSERT_EQUAL(0xabab, Result);
1414
1415   //
1416   // Otherwise should result in an error status
1417   //
1418   Operand = (0xabababab);
1419   Status = SafeUintnToUint16(Operand, &Result);
1420   UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
1421
1422   return UNIT_TEST_PASSED;
1423 }
1424
1425 UNIT_TEST_STATUS
1426 EFIAPI
1427 TestSafeUintnToInt32 (
1428   IN UNIT_TEST_CONTEXT           Context
1429   )
1430 {
1431   EFI_STATUS  Status;
1432   UINTN       Operand;
1433   INT32       Result;
1434
1435   //
1436   // If Operand is <= MAX_INT32, then it's a cast
1437   //
1438   Operand = 0x5bababab;
1439   Result = 0;
1440   Status = SafeUintnToInt32(Operand, &Result);
1441   UT_ASSERT_NOT_EFI_ERROR(Status);
1442   UT_ASSERT_EQUAL(0x5bababab, Result);
1443
1444   //
1445   // Otherwise should result in an error status
1446   //
1447   Operand = (0xabababab);
1448   Status = SafeUintnToInt32(Operand, &Result);
1449   UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
1450
1451   return UNIT_TEST_PASSED;
1452 }
1453
1454 UNIT_TEST_STATUS
1455 EFIAPI
1456 TestSafeInt64ToInt8 (
1457   IN UNIT_TEST_CONTEXT           Context
1458   )
1459 {
1460   EFI_STATUS  Status;
1461   INT64       Operand;
1462   INT8        Result;
1463
1464   //
1465   // If Operand is between MIN_INT8 and  MAX_INT8 inclusive, then it's a cast
1466   //
1467   Operand = 0x5b;
1468   Result = 0;
1469   Status = SafeInt64ToInt8(Operand, &Result);
1470   UT_ASSERT_NOT_EFI_ERROR(Status);
1471   UT_ASSERT_EQUAL(0x5b, Result);
1472
1473   Operand = (-37);
1474   Status = SafeInt64ToInt8(Operand, &Result);
1475   UT_ASSERT_NOT_EFI_ERROR(Status);
1476   UT_ASSERT_EQUAL((-37), Result);
1477
1478   //
1479   // Otherwise should result in an error status
1480   //
1481   Operand = (0x5babababefefefef);
1482   Status = SafeInt64ToInt8(Operand, &Result);
1483   UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
1484
1485   Operand =  (-6605562033422200815);
1486   Status = SafeInt64ToInt8(Operand, &Result);
1487   UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
1488
1489   return UNIT_TEST_PASSED;
1490 }
1491
1492 UNIT_TEST_STATUS
1493 EFIAPI
1494 TestSafeInt64ToChar8 (
1495   IN UNIT_TEST_CONTEXT           Context
1496   )
1497 {
1498   EFI_STATUS  Status;
1499   INT64       Operand;
1500   CHAR8       Result;
1501
1502   //
1503   // CHAR8 is typedefed as char, which may be signed or unsigned based
1504   // on the compiler. Thus, for compatibility CHAR8 should be between 0 and MAX_INT8.
1505   //
1506
1507   //
1508   // If Operand is between MIN_INT8 and  MAX_INT8 inclusive, then it's a cast
1509   //
1510   Operand = 0x5b;
1511   Result = 0;
1512   Status = SafeInt64ToChar8(Operand, &Result);
1513   UT_ASSERT_NOT_EFI_ERROR(Status);
1514   UT_ASSERT_EQUAL(0x5b, Result);
1515
1516   Operand = 0;
1517   Result = 0;
1518   Status = SafeInt64ToChar8(Operand, &Result);
1519   UT_ASSERT_NOT_EFI_ERROR(Status);
1520   UT_ASSERT_EQUAL(0, Result);
1521
1522   Operand = MAX_INT8;
1523   Result = 0;
1524   Status = SafeInt64ToChar8(Operand, &Result);
1525   UT_ASSERT_NOT_EFI_ERROR(Status);
1526   UT_ASSERT_EQUAL(MAX_INT8, Result);
1527
1528   //
1529   // Otherwise should result in an error status
1530   //
1531   Operand = (-37);
1532   Status = SafeInt64ToChar8(Operand, &Result);
1533   UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
1534
1535   Operand = (0x5babababefefefef);
1536   Status = SafeInt64ToChar8(Operand, &Result);
1537   UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
1538
1539   Operand =  (-6605562033422200815);
1540   Status = SafeInt64ToChar8(Operand, &Result);
1541   UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
1542
1543   return UNIT_TEST_PASSED;
1544 }
1545
1546 UNIT_TEST_STATUS
1547 EFIAPI
1548 TestSafeInt64ToUint8 (
1549   IN UNIT_TEST_CONTEXT           Context
1550   )
1551 {
1552   EFI_STATUS  Status;
1553   INT64       Operand;
1554   UINT8       Result;
1555
1556   //
1557   // If Operand is between 0 and  MAX_UINT8 inclusive, then it's a cast
1558   //
1559   Operand = 0xab;
1560   Result = 0;
1561   Status = SafeInt64ToUint8(Operand, &Result);
1562   UT_ASSERT_NOT_EFI_ERROR(Status);
1563   UT_ASSERT_EQUAL(0xab, Result);
1564
1565   //
1566   // Otherwise should result in an error status
1567   //
1568   Operand = (0x5babababefefefef);
1569   Status = SafeInt64ToUint8(Operand, &Result);
1570   UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
1571
1572   Operand =  (-6605562033422200815);
1573   Status = SafeInt64ToUint8(Operand, &Result);
1574   UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
1575
1576   return UNIT_TEST_PASSED;
1577 }
1578
1579 UNIT_TEST_STATUS
1580 EFIAPI
1581 TestSafeInt64ToInt16 (
1582   IN UNIT_TEST_CONTEXT           Context
1583   )
1584 {
1585   EFI_STATUS  Status;
1586   INT64       Operand;
1587   INT16       Result;
1588
1589   //
1590   // If Operand is between MIN_INT16 and  MAX_INT16 inclusive, then it's a cast
1591   //
1592   Operand = 0x5bab;
1593   Result = 0;
1594   Status = SafeInt64ToInt16(Operand, &Result);
1595   UT_ASSERT_NOT_EFI_ERROR(Status);
1596   UT_ASSERT_EQUAL(0x5bab, Result);
1597
1598   Operand = (-23467);
1599   Status = SafeInt64ToInt16(Operand, &Result);
1600   UT_ASSERT_NOT_EFI_ERROR(Status);
1601   UT_ASSERT_EQUAL((-23467), Result);
1602
1603   //
1604   // Otherwise should result in an error status
1605   //
1606   Operand = (0x5babababefefefef);
1607   Status = SafeInt64ToInt16(Operand, &Result);
1608   UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
1609
1610   Operand =  (-6605562033422200815);
1611   Status = SafeInt64ToInt16(Operand, &Result);
1612   UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
1613
1614   return UNIT_TEST_PASSED;
1615 }
1616
1617 UNIT_TEST_STATUS
1618 EFIAPI
1619 TestSafeInt64ToUint16 (
1620   IN UNIT_TEST_CONTEXT           Context
1621   )
1622 {
1623   EFI_STATUS  Status;
1624   INT64       Operand;
1625   UINT16      Result;
1626
1627   //
1628   // If Operand is between 0 and  MAX_UINT16 inclusive, then it's a cast
1629   //
1630   Operand = 0xabab;
1631   Result = 0;
1632   Status = SafeInt64ToUint16(Operand, &Result);
1633   UT_ASSERT_NOT_EFI_ERROR(Status);
1634   UT_ASSERT_EQUAL(0xabab, Result);
1635
1636   //
1637   // Otherwise should result in an error status
1638   //
1639   Operand = (0x5babababefefefef);
1640   Status = SafeInt64ToUint16(Operand, &Result);
1641   UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
1642
1643   Operand =  (-6605562033422200815);
1644   Status = SafeInt64ToUint16(Operand, &Result);
1645   UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
1646
1647   return UNIT_TEST_PASSED;
1648 }
1649
1650 UNIT_TEST_STATUS
1651 EFIAPI
1652 TestSafeInt64ToInt32 (
1653   IN UNIT_TEST_CONTEXT           Context
1654   )
1655 {
1656   EFI_STATUS  Status;
1657   INT64       Operand;
1658   INT32       Result;
1659
1660   //
1661   // If Operand is between MIN_INT32 and  MAX_INT32 inclusive, then it's a cast
1662   //
1663   Operand = 0x5bababab;
1664   Result = 0;
1665   Status = SafeInt64ToInt32(Operand, &Result);
1666   UT_ASSERT_NOT_EFI_ERROR(Status);
1667   UT_ASSERT_EQUAL(0x5bababab, Result);
1668
1669   Operand = (-1537977259);
1670   Status = SafeInt64ToInt32(Operand, &Result);
1671   UT_ASSERT_NOT_EFI_ERROR(Status);
1672   UT_ASSERT_EQUAL((-1537977259), Result);
1673
1674   //
1675   // Otherwise should result in an error status
1676   //
1677   Operand = (0x5babababefefefef);
1678   Status = SafeInt64ToInt32(Operand, &Result);
1679   UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
1680
1681   Operand =  (-6605562033422200815);
1682   Status = SafeInt64ToInt32(Operand, &Result);
1683   UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
1684
1685   return UNIT_TEST_PASSED;
1686 }
1687
1688 UNIT_TEST_STATUS
1689 EFIAPI
1690 TestSafeInt64ToUint32 (
1691   IN UNIT_TEST_CONTEXT           Context
1692   )
1693 {
1694   EFI_STATUS  Status;
1695   INT64       Operand;
1696   UINT32      Result;
1697
1698   //
1699   // If Operand is between 0 and  MAX_UINT32 inclusive, then it's a cast
1700   //
1701   Operand = 0xabababab;
1702   Result = 0;
1703   Status = SafeInt64ToUint32(Operand, &Result);
1704   UT_ASSERT_NOT_EFI_ERROR(Status);
1705   UT_ASSERT_EQUAL(0xabababab, Result);
1706
1707   //
1708   // Otherwise should result in an error status
1709   //
1710   Operand = (0x5babababefefefef);
1711   Status = SafeInt64ToUint32(Operand, &Result);
1712   UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
1713
1714   Operand =  (-6605562033422200815);
1715   Status = SafeInt64ToUint32(Operand, &Result);
1716   UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
1717
1718   return UNIT_TEST_PASSED;
1719 }
1720
1721 UNIT_TEST_STATUS
1722 EFIAPI
1723 TestSafeInt64ToUint64 (
1724   IN UNIT_TEST_CONTEXT           Context
1725   )
1726 {
1727   EFI_STATUS  Status;
1728   INT64       Operand;
1729   UINT64      Result;
1730
1731   //
1732   // If Operand is non-negative, then it's a cast
1733   //
1734   Operand = 0x5babababefefefef;
1735   Result = 0;
1736   Status = SafeInt64ToUint64(Operand, &Result);
1737   UT_ASSERT_NOT_EFI_ERROR(Status);
1738   UT_ASSERT_EQUAL(0x5babababefefefef, Result);
1739
1740   //
1741   // Otherwise should result in an error status
1742   //
1743   Operand =  (-6605562033422200815);
1744   Status = SafeInt64ToUint64(Operand, &Result);
1745   UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
1746
1747   return UNIT_TEST_PASSED;
1748 }
1749
1750 UNIT_TEST_STATUS
1751 EFIAPI
1752 TestSafeUint64ToInt8 (
1753   IN UNIT_TEST_CONTEXT           Context
1754   )
1755 {
1756   EFI_STATUS  Status;
1757   UINT64      Operand;
1758   INT8        Result;
1759
1760   //
1761   // If Operand is <= MAX_INT8, then it's a cast
1762   //
1763   Operand = 0x5b;
1764   Result = 0;
1765   Status = SafeUint64ToInt8(Operand, &Result);
1766   UT_ASSERT_NOT_EFI_ERROR(Status);
1767   UT_ASSERT_EQUAL(0x5b, Result);
1768
1769   //
1770   // Otherwise should result in an error status
1771   //
1772   Operand = (0xababababefefefef);
1773   Status = SafeUint64ToInt8(Operand, &Result);
1774   UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
1775
1776   return UNIT_TEST_PASSED;
1777 }
1778
1779 UNIT_TEST_STATUS
1780 EFIAPI
1781 TestSafeUint64ToChar8 (
1782   IN UNIT_TEST_CONTEXT           Context
1783   )
1784 {
1785   EFI_STATUS  Status;
1786   UINT64      Operand;
1787   CHAR8       Result;
1788
1789   // CHAR8 is typedefed as char, which by default is signed, thus
1790   // CHAR8 is same as INT8, so same tests as above:
1791
1792   //
1793   // If Operand is <= MAX_INT8, then it's a cast
1794   //
1795   Operand = 0x5b;
1796   Result = 0;
1797   Status = SafeUint64ToChar8(Operand, &Result);
1798   UT_ASSERT_NOT_EFI_ERROR(Status);
1799   UT_ASSERT_EQUAL(0x5b, Result);
1800
1801   //
1802   // Otherwise should result in an error status
1803   //
1804   Operand = (0xababababefefefef);
1805   Status = SafeUint64ToChar8(Operand, &Result);
1806   UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
1807
1808   return UNIT_TEST_PASSED;
1809 }
1810
1811 UNIT_TEST_STATUS
1812 EFIAPI
1813 TestSafeUint64ToUint8 (
1814   IN UNIT_TEST_CONTEXT           Context
1815   )
1816 {
1817   EFI_STATUS  Status;
1818   UINT64      Operand;
1819   UINT8       Result;
1820
1821   //
1822   // If Operand is <= MAX_UINT8, then it's a cast
1823   //
1824   Operand = 0xab;
1825   Result = 0;
1826   Status = SafeUint64ToUint8(Operand, &Result);
1827   UT_ASSERT_NOT_EFI_ERROR(Status);
1828   UT_ASSERT_EQUAL(0xab, Result);
1829
1830   //
1831   // Otherwise should result in an error status
1832   //
1833   Operand = (0xababababefefefef);
1834   Status = SafeUint64ToUint8(Operand, &Result);
1835   UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
1836
1837   return UNIT_TEST_PASSED;
1838 }
1839
1840 UNIT_TEST_STATUS
1841 EFIAPI
1842 TestSafeUint64ToInt16 (
1843   IN UNIT_TEST_CONTEXT           Context
1844   )
1845 {
1846   EFI_STATUS  Status;
1847   UINT64      Operand;
1848   INT16       Result;
1849
1850   //
1851   // If Operand is <= MAX_INT16, then it's a cast
1852   //
1853   Operand = 0x5bab;
1854   Result = 0;
1855   Status = SafeUint64ToInt16(Operand, &Result);
1856   UT_ASSERT_NOT_EFI_ERROR(Status);
1857   UT_ASSERT_EQUAL(0x5bab, Result);
1858
1859   //
1860   // Otherwise should result in an error status
1861   //
1862   Operand = (0xababababefefefef);
1863   Status = SafeUint64ToInt16(Operand, &Result);
1864   UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
1865
1866   return UNIT_TEST_PASSED;
1867 }
1868
1869 UNIT_TEST_STATUS
1870 EFIAPI
1871 TestSafeUint64ToUint16 (
1872   IN UNIT_TEST_CONTEXT           Context
1873   )
1874 {
1875   EFI_STATUS  Status;
1876   UINT64      Operand;
1877   UINT16      Result;
1878
1879   //
1880   // If Operand is <= MAX_UINT16, then it's a cast
1881   //
1882   Operand = 0xabab;
1883   Result = 0;
1884   Status = SafeUint64ToUint16(Operand, &Result);
1885   UT_ASSERT_NOT_EFI_ERROR(Status);
1886   UT_ASSERT_EQUAL(0xabab, Result);
1887
1888   //
1889   // Otherwise should result in an error status
1890   //
1891   Operand = (0xababababefefefef);
1892   Status = SafeUint64ToUint16(Operand, &Result);
1893   UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
1894
1895   return UNIT_TEST_PASSED;
1896 }
1897
1898 UNIT_TEST_STATUS
1899 EFIAPI
1900 TestSafeUint64ToInt32 (
1901   IN UNIT_TEST_CONTEXT           Context
1902   )
1903 {
1904   EFI_STATUS  Status;
1905   UINT64      Operand;
1906   INT32       Result;
1907
1908   //
1909   // If Operand is <= MAX_INT32, then it's a cast
1910   //
1911   Operand = 0x5bababab;
1912   Result = 0;
1913   Status = SafeUint64ToInt32(Operand, &Result);
1914   UT_ASSERT_NOT_EFI_ERROR(Status);
1915   UT_ASSERT_EQUAL(0x5bababab, Result);
1916
1917   //
1918   // Otherwise should result in an error status
1919   //
1920   Operand = (0xababababefefefef);
1921   Status = SafeUint64ToInt32(Operand, &Result);
1922   UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
1923
1924   return UNIT_TEST_PASSED;
1925 }
1926
1927 UNIT_TEST_STATUS
1928 EFIAPI
1929 TestSafeUint64ToUint32 (
1930   IN UNIT_TEST_CONTEXT           Context
1931   )
1932 {
1933   EFI_STATUS  Status;
1934   UINT64      Operand;
1935   UINT32      Result;
1936
1937   //
1938   // If Operand is <= MAX_UINT32, then it's a cast
1939   //
1940   Operand = 0xabababab;
1941   Result = 0;
1942   Status = SafeUint64ToUint32(Operand, &Result);
1943   UT_ASSERT_NOT_EFI_ERROR(Status);
1944   UT_ASSERT_EQUAL(0xabababab, Result);
1945
1946   //
1947   // Otherwise should result in an error status
1948   //
1949   Operand = (0xababababefefefef);
1950   Status = SafeUint64ToUint32(Operand, &Result);
1951   UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
1952
1953   return UNIT_TEST_PASSED;
1954 }
1955
1956 UNIT_TEST_STATUS
1957 EFIAPI
1958 TestSafeUint64ToInt64 (
1959   IN UNIT_TEST_CONTEXT           Context
1960   )
1961 {
1962   EFI_STATUS  Status;
1963   UINT64      Operand;
1964   INT64       Result;
1965
1966   //
1967   // If Operand is <= MAX_INT64, then it's a cast
1968   //
1969   Operand = 0x5babababefefefef;
1970   Result = 0;
1971   Status = SafeUint64ToInt64(Operand, &Result);
1972   UT_ASSERT_NOT_EFI_ERROR(Status);
1973   UT_ASSERT_EQUAL(0x5babababefefefef, Result);
1974
1975   //
1976   // Otherwise should result in an error status
1977   //
1978   Operand = (0xababababefefefef);
1979   Status = SafeUint64ToInt64(Operand, &Result);
1980   UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
1981
1982   return UNIT_TEST_PASSED;
1983 }
1984
1985 //
1986 // Addition function tests:
1987 //
1988 UNIT_TEST_STATUS
1989 EFIAPI
1990 TestSafeUint8Add (
1991   IN UNIT_TEST_CONTEXT           Context
1992   )
1993 {
1994   EFI_STATUS  Status;
1995   UINT8       Augend;
1996   UINT8       Addend;
1997   UINT8       Result;
1998
1999   //
2000   // If the result of addition doesn't overflow MAX_UINT8, then it's addition
2001   //
2002   Augend = 0x3a;
2003   Addend = 0x3a;
2004   Result = 0;
2005   Status = SafeUint8Add(Augend, Addend, &Result);
2006   UT_ASSERT_NOT_EFI_ERROR(Status);
2007   UT_ASSERT_EQUAL(0x74, Result);
2008
2009   //
2010   // Otherwise should result in an error status
2011   //
2012   Augend = 0xab;
2013   Addend = 0xbc;
2014   Status = SafeUint8Add(Augend, Addend, &Result);
2015   UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
2016
2017   return UNIT_TEST_PASSED;
2018 }
2019
2020 UNIT_TEST_STATUS
2021 EFIAPI
2022 TestSafeUint16Add (
2023   IN UNIT_TEST_CONTEXT           Context
2024   )
2025 {
2026   EFI_STATUS  Status;
2027   UINT16 Augend = 0x3a3a;
2028   UINT16 Addend = 0x3a3a;
2029   UINT16 Result = 0;
2030
2031   //
2032   // If the result of addition doesn't overflow MAX_UINT16, then it's addition
2033   //
2034   Status = SafeUint16Add(Augend, Addend, &Result);
2035   UT_ASSERT_NOT_EFI_ERROR(Status);
2036   UT_ASSERT_EQUAL(0x7474, Result);
2037
2038   //
2039   // Otherwise should result in an error status
2040   //
2041   Augend = 0xabab;
2042   Addend = 0xbcbc;
2043   Status = SafeUint16Add(Augend, Addend, &Result);
2044   UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
2045
2046   return UNIT_TEST_PASSED;
2047 }
2048
2049 UNIT_TEST_STATUS
2050 EFIAPI
2051 TestSafeUint32Add (
2052   IN UNIT_TEST_CONTEXT           Context
2053   )
2054 {
2055   EFI_STATUS  Status;
2056   UINT32      Augend;
2057   UINT32      Addend;
2058   UINT32      Result;
2059
2060   //
2061   // If the result of addition doesn't overflow MAX_UINT32, then it's addition
2062   //
2063   Augend = 0x3a3a3a3a;
2064   Addend = 0x3a3a3a3a;
2065   Result = 0;
2066   Status = SafeUint32Add(Augend, Addend, &Result);
2067   UT_ASSERT_NOT_EFI_ERROR(Status);
2068   UT_ASSERT_EQUAL(0x74747474, Result);
2069
2070   //
2071   // Otherwise should result in an error status
2072   //
2073   Augend = 0xabababab;
2074   Addend = 0xbcbcbcbc;
2075   Status = SafeUint32Add(Augend, Addend, &Result);
2076   UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
2077
2078   return UNIT_TEST_PASSED;
2079 }
2080
2081 UNIT_TEST_STATUS
2082 EFIAPI
2083 TestSafeUint64Add (
2084   IN UNIT_TEST_CONTEXT           Context
2085   )
2086 {
2087   EFI_STATUS  Status;
2088   UINT64      Augend;
2089   UINT64      Addend;
2090   UINT64      Result;
2091
2092   //
2093   // If the result of addition doesn't overflow MAX_UINT64, then it's addition
2094   //
2095   Augend = 0x3a3a3a3a12121212;
2096   Addend = 0x3a3a3a3a12121212;
2097   Result = 0;
2098   Status = SafeUint64Add(Augend, Addend, &Result);
2099   UT_ASSERT_NOT_EFI_ERROR(Status);
2100   UT_ASSERT_EQUAL(0x7474747424242424, Result);
2101
2102   //
2103   // Otherwise should result in an error status
2104   //
2105   Augend = 0xababababefefefef;
2106   Addend = 0xbcbcbcbcdededede;
2107   Status = SafeUint64Add(Augend, Addend, &Result);
2108   UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
2109
2110   return UNIT_TEST_PASSED;
2111 }
2112
2113 UNIT_TEST_STATUS
2114 EFIAPI
2115 TestSafeInt8Add (
2116   IN UNIT_TEST_CONTEXT           Context
2117   )
2118 {
2119   EFI_STATUS  Status;
2120   INT8        Augend;
2121   INT8        Addend;
2122   INT8        Result;
2123
2124   //
2125   // If the result of addition doesn't overflow MAX_INT8
2126   // and doesn't underflow MIN_INT8, then it's addition
2127   //
2128   Augend = 0x3a;
2129   Addend = 0x3a;
2130   Result = 0;
2131   Status = SafeInt8Add(Augend, Addend, &Result);
2132   UT_ASSERT_NOT_EFI_ERROR(Status);
2133   UT_ASSERT_EQUAL(0x74, Result);
2134
2135   Augend = (-58);
2136   Addend = (-58);
2137   Status = SafeInt8Add(Augend, Addend, &Result);
2138   UT_ASSERT_NOT_EFI_ERROR(Status);
2139   UT_ASSERT_EQUAL((-116), Result);
2140
2141   //
2142   // Otherwise should result in an error status
2143   //
2144   Augend = 0x5a;
2145   Addend = 0x5a;
2146   Status = SafeInt8Add(Augend, Addend, &Result);
2147   UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
2148
2149   Augend = (-90);
2150   Addend = (-90);
2151   Status = SafeInt8Add(Augend, Addend, &Result);
2152   UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
2153
2154   return UNIT_TEST_PASSED;
2155
2156 }
2157
2158 UNIT_TEST_STATUS
2159 EFIAPI
2160 TestSafeInt16Add (
2161   IN UNIT_TEST_CONTEXT           Context
2162   )
2163 {
2164   EFI_STATUS  Status;
2165   INT16       Augend;
2166   INT16       Addend;
2167   INT16       Result;
2168
2169   //
2170   // If the result of addition doesn't overflow MAX_INT16
2171   // and doesn't underflow MIN_INT16, then it's addition
2172   //
2173   Augend = 0x3a3a;
2174   Addend = 0x3a3a;
2175   Result = 0;
2176   Status = SafeInt16Add(Augend, Addend, &Result);
2177   UT_ASSERT_NOT_EFI_ERROR(Status);
2178   UT_ASSERT_EQUAL(0x7474, Result);
2179
2180   Augend = (-14906);
2181   Addend = (-14906);
2182   Status = SafeInt16Add(Augend, Addend, &Result);
2183   UT_ASSERT_NOT_EFI_ERROR(Status);
2184   UT_ASSERT_EQUAL((-29812), Result);
2185
2186   //
2187   // Otherwise should result in an error status
2188   //
2189   Augend = 0x5a5a;
2190   Addend = 0x5a5a;
2191   Status = SafeInt16Add(Augend, Addend, &Result);
2192   UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
2193
2194   Augend = (-23130);
2195   Addend = (-23130);
2196   Status = SafeInt16Add(Augend, Addend, &Result);
2197   UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
2198
2199   return UNIT_TEST_PASSED;
2200 }
2201
2202 UNIT_TEST_STATUS
2203 EFIAPI
2204 TestSafeInt32Add (
2205   IN UNIT_TEST_CONTEXT           Context
2206   )
2207 {
2208   EFI_STATUS  Status;
2209   INT32       Augend;
2210   INT32       Addend;
2211   INT32       Result;
2212
2213   //
2214   // If the result of addition doesn't overflow MAX_INT32
2215   // and doesn't underflow MIN_INT32, then it's addition
2216   //
2217   Augend = 0x3a3a3a3a;
2218   Addend = 0x3a3a3a3a;
2219   Result = 0;
2220   Status = SafeInt32Add(Augend, Addend, &Result);
2221   UT_ASSERT_NOT_EFI_ERROR(Status);
2222   UT_ASSERT_EQUAL(0x74747474, Result);
2223
2224   Augend = (-976894522);
2225   Addend = (-976894522);
2226   Status = SafeInt32Add(Augend, Addend, &Result);
2227   UT_ASSERT_NOT_EFI_ERROR(Status);
2228   UT_ASSERT_EQUAL((-1953789044), Result);
2229
2230   //
2231   // Otherwise should result in an error status
2232   //
2233   Augend = 0x5a5a5a5a;
2234   Addend = 0x5a5a5a5a;
2235   Status = SafeInt32Add(Augend, Addend, &Result);
2236   UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
2237
2238   Augend = (-1515870810);
2239   Addend = (-1515870810);
2240   Status = SafeInt32Add(Augend, Addend, &Result);
2241   UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
2242
2243   return UNIT_TEST_PASSED;
2244 }
2245
2246 UNIT_TEST_STATUS
2247 EFIAPI
2248 TestSafeInt64Add (
2249   IN UNIT_TEST_CONTEXT           Context
2250   )
2251 {
2252   EFI_STATUS  Status;
2253   INT64       Augend;
2254   INT64       Addend;
2255   INT64       Result;
2256
2257   //
2258   // If the result of addition doesn't overflow MAX_INT64
2259   // and doesn't underflow MIN_INT64, then it's addition
2260   //
2261   Augend = 0x3a3a3a3a3a3a3a3a;
2262   Addend = 0x3a3a3a3a3a3a3a3a;
2263   Result = 0;
2264   Status = SafeInt64Add(Augend, Addend, &Result);
2265   UT_ASSERT_NOT_EFI_ERROR(Status);
2266   UT_ASSERT_EQUAL(0x7474747474747474, Result);
2267
2268   Augend = (-4195730024608447034);
2269   Addend = (-4195730024608447034);
2270   Status = SafeInt64Add(Augend, Addend, &Result);
2271   UT_ASSERT_NOT_EFI_ERROR(Status);
2272   UT_ASSERT_EQUAL((-8391460049216894068), Result);
2273
2274   //
2275   // Otherwise should result in an error status
2276   //
2277   Augend = 0x5a5a5a5a5a5a5a5a;
2278   Addend = 0x5a5a5a5a5a5a5a5a;
2279   Status = SafeInt64Add(Augend, Addend, &Result);
2280   UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
2281
2282   Augend = (-6510615555426900570);
2283   Addend = (-6510615555426900570);
2284   Status = SafeInt64Add(Augend, Addend, &Result);
2285   UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
2286
2287   return UNIT_TEST_PASSED;
2288 }
2289
2290 //
2291 // Subtraction function tests:
2292 //
2293 UNIT_TEST_STATUS
2294 EFIAPI
2295 TestSafeUint8Sub (
2296   IN UNIT_TEST_CONTEXT           Context
2297   )
2298 {
2299   EFI_STATUS  Status;
2300   UINT8       Minuend;
2301   UINT8       Subtrahend;
2302   UINT8       Result;
2303
2304   //
2305   // If Minuend >= Subtrahend, then it's subtraction
2306   //
2307   Minuend = 0x5a;
2308   Subtrahend = 0x3b;
2309   Result = 0;
2310   Status = SafeUint8Sub(Minuend, Subtrahend, &Result);
2311   UT_ASSERT_NOT_EFI_ERROR(Status);
2312   UT_ASSERT_EQUAL(0x1f, Result);
2313
2314   //
2315   // Otherwise should result in an error status
2316   //
2317   Minuend = 0x5a;
2318   Subtrahend = 0x6d;
2319   Status = SafeUint8Sub(Minuend, Subtrahend, &Result);
2320   UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
2321
2322   return UNIT_TEST_PASSED;
2323 }
2324
2325 UNIT_TEST_STATUS
2326 EFIAPI
2327 TestSafeUint16Sub (
2328   IN UNIT_TEST_CONTEXT           Context
2329   )
2330 {
2331   EFI_STATUS  Status;
2332   UINT16      Minuend;
2333   UINT16      Subtrahend;
2334   UINT16      Result;
2335
2336   //
2337   // If Minuend >= Subtrahend, then it's subtraction
2338   //
2339   Minuend = 0x5a5a;
2340   Subtrahend = 0x3b3b;
2341   Result = 0;
2342   Status = SafeUint16Sub(Minuend, Subtrahend, &Result);
2343   UT_ASSERT_NOT_EFI_ERROR(Status);
2344   UT_ASSERT_EQUAL(0x1f1f, Result);
2345
2346   //
2347   // Otherwise should result in an error status
2348   //
2349   Minuend = 0x5a5a;
2350   Subtrahend = 0x6d6d;
2351   Status = SafeUint16Sub(Minuend, Subtrahend, &Result);
2352   UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
2353
2354   return UNIT_TEST_PASSED;
2355 }
2356
2357 UNIT_TEST_STATUS
2358 EFIAPI
2359 TestSafeUint32Sub (
2360   IN UNIT_TEST_CONTEXT           Context
2361   )
2362 {
2363   EFI_STATUS  Status;
2364   UINT32      Minuend;
2365   UINT32      Subtrahend;
2366   UINT32      Result;
2367
2368   //
2369   // If Minuend >= Subtrahend, then it's subtraction
2370   //
2371   Minuend = 0x5a5a5a5a;
2372   Subtrahend = 0x3b3b3b3b;
2373   Result = 0;
2374   Status = SafeUint32Sub(Minuend, Subtrahend, &Result);
2375   UT_ASSERT_NOT_EFI_ERROR(Status);
2376   UT_ASSERT_EQUAL(0x1f1f1f1f, Result);
2377
2378   //
2379   // Otherwise should result in an error status
2380   //
2381   Minuend = 0x5a5a5a5a;
2382   Subtrahend = 0x6d6d6d6d;
2383   Status = SafeUint32Sub(Minuend, Subtrahend, &Result);
2384   UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
2385
2386   return UNIT_TEST_PASSED;
2387 }
2388
2389 UNIT_TEST_STATUS
2390 EFIAPI
2391 TestSafeUint64Sub (
2392   IN UNIT_TEST_CONTEXT           Context
2393   )
2394 {
2395   EFI_STATUS  Status;
2396   UINT64      Minuend;
2397   UINT64      Subtrahend;
2398   UINT64      Result;
2399
2400   //
2401   // If Minuend >= Subtrahend, then it's subtraction
2402   //
2403   Minuend = 0x5a5a5a5a5a5a5a5a;
2404   Subtrahend = 0x3b3b3b3b3b3b3b3b;
2405   Result = 0;
2406   Status = SafeUint64Sub(Minuend, Subtrahend, &Result);
2407   UT_ASSERT_NOT_EFI_ERROR(Status);
2408   UT_ASSERT_EQUAL(0x1f1f1f1f1f1f1f1f, Result);
2409
2410   //
2411   // Otherwise should result in an error status
2412   //
2413   Minuend = 0x5a5a5a5a5a5a5a5a;
2414   Subtrahend = 0x6d6d6d6d6d6d6d6d;
2415   Status = SafeUint64Sub(Minuend, Subtrahend, &Result);
2416   UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
2417
2418   return UNIT_TEST_PASSED;
2419 }
2420
2421 UNIT_TEST_STATUS
2422 EFIAPI
2423 TestSafeInt8Sub (
2424   IN UNIT_TEST_CONTEXT           Context
2425   )
2426 {
2427   EFI_STATUS  Status;
2428   INT8        Minuend;
2429   INT8        Subtrahend;
2430   INT8        Result;
2431
2432   //
2433   // If the result of subtractions doesn't overflow MAX_INT8 or
2434   // underflow MIN_INT8, then it's subtraction
2435   //
2436   Minuend = 0x5a;
2437   Subtrahend = 0x3a;
2438   Result = 0;
2439   Status = SafeInt8Sub(Minuend, Subtrahend, &Result);
2440   UT_ASSERT_NOT_EFI_ERROR(Status);
2441   UT_ASSERT_EQUAL(0x20, Result);
2442
2443   Minuend = 58;
2444   Subtrahend = 78;
2445   Status = SafeInt8Sub(Minuend, Subtrahend, &Result);
2446   UT_ASSERT_NOT_EFI_ERROR(Status);
2447   UT_ASSERT_EQUAL((-20), Result);
2448
2449   //
2450   // Otherwise should result in an error status
2451   //
2452   Minuend = (-80);
2453   Subtrahend = 80;
2454   Status = SafeInt8Sub(Minuend, Subtrahend, &Result);
2455   UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
2456
2457   Minuend = (80);
2458   Subtrahend = (-80);
2459   Status = SafeInt8Sub(Minuend, Subtrahend, &Result);
2460   UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
2461
2462   return UNIT_TEST_PASSED;
2463 }
2464
2465 UNIT_TEST_STATUS
2466 EFIAPI
2467 TestSafeInt16Sub (
2468   IN UNIT_TEST_CONTEXT           Context
2469   )
2470 {
2471   EFI_STATUS  Status;
2472   INT16       Minuend;
2473   INT16       Subtrahend;
2474   INT16       Result;
2475
2476   //
2477   // If the result of subtractions doesn't overflow MAX_INT16 or
2478   // underflow MIN_INT16, then it's subtraction
2479   //
2480   Minuend = 0x5a5a;
2481   Subtrahend = 0x3a3a;
2482   Result = 0;
2483   Status = SafeInt16Sub(Minuend, Subtrahend, &Result);
2484   UT_ASSERT_NOT_EFI_ERROR(Status);
2485   UT_ASSERT_EQUAL(0x2020, Result);
2486
2487   Minuend = 0x3a3a;
2488   Subtrahend = 0x5a5a;
2489   Status = SafeInt16Sub(Minuend, Subtrahend, &Result);
2490   UT_ASSERT_NOT_EFI_ERROR(Status);
2491   UT_ASSERT_EQUAL((-8224), Result);
2492
2493   //
2494   // Otherwise should result in an error status
2495   //
2496   Minuend = (-31354);
2497   Subtrahend = 31354;
2498   Status = SafeInt16Sub(Minuend, Subtrahend, &Result);
2499   UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
2500
2501   Minuend = (31354);
2502   Subtrahend = (-31354);
2503   Status = SafeInt16Sub(Minuend, Subtrahend, &Result);
2504   UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
2505
2506   return UNIT_TEST_PASSED;
2507 }
2508
2509 UNIT_TEST_STATUS
2510 EFIAPI
2511 TestSafeInt32Sub (
2512   IN UNIT_TEST_CONTEXT           Context
2513   )
2514 {
2515   EFI_STATUS  Status;
2516   INT32       Minuend;
2517   INT32       Subtrahend;
2518   INT32       Result;
2519
2520   //
2521   // If the result of subtractions doesn't overflow MAX_INT32 or
2522   // underflow MIN_INT32, then it's subtraction
2523   //
2524   Minuend = 0x5a5a5a5a;
2525   Subtrahend = 0x3a3a3a3a;
2526   Result = 0;
2527   Status = SafeInt32Sub(Minuend, Subtrahend, &Result);
2528   UT_ASSERT_NOT_EFI_ERROR(Status);
2529   UT_ASSERT_EQUAL(0x20202020, Result);
2530
2531   Minuend = 0x3a3a3a3a;
2532   Subtrahend = 0x5a5a5a5a;
2533   Status = SafeInt32Sub(Minuend, Subtrahend, &Result);
2534   UT_ASSERT_NOT_EFI_ERROR(Status);
2535   UT_ASSERT_EQUAL((-538976288), Result);
2536
2537   //
2538   // Otherwise should result in an error status
2539   //
2540   Minuend = (-2054847098);
2541   Subtrahend = 2054847098;
2542   Status = SafeInt32Sub(Minuend, Subtrahend, &Result);
2543   UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
2544
2545   Minuend = (2054847098);
2546   Subtrahend = (-2054847098);
2547   Status = SafeInt32Sub(Minuend, Subtrahend, &Result);
2548   UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
2549
2550   return UNIT_TEST_PASSED;
2551 }
2552
2553 UNIT_TEST_STATUS
2554 EFIAPI
2555 TestSafeInt64Sub (
2556   IN UNIT_TEST_CONTEXT           Context
2557   )
2558 {
2559   EFI_STATUS  Status;
2560   INT64       Minuend;
2561   INT64       Subtrahend;
2562   INT64       Result;
2563
2564   //
2565   // If the result of subtractions doesn't overflow MAX_INT64 or
2566   // underflow MIN_INT64, then it's subtraction
2567   //
2568   Minuend = 0x5a5a5a5a5a5a5a5a;
2569   Subtrahend = 0x3a3a3a3a3a3a3a3a;
2570   Result = 0;
2571   Status = SafeInt64Sub(Minuend, Subtrahend, &Result);
2572   UT_ASSERT_NOT_EFI_ERROR(Status);
2573   UT_ASSERT_EQUAL(0x2020202020202020, Result);
2574
2575   Minuend = 0x3a3a3a3a3a3a3a3a;
2576   Subtrahend = 0x5a5a5a5a5a5a5a5a;
2577   Status = SafeInt64Sub(Minuend, Subtrahend, &Result);
2578   UT_ASSERT_NOT_EFI_ERROR(Status);
2579   UT_ASSERT_EQUAL((-2314885530818453536), Result);
2580
2581   //
2582   // Otherwise should result in an error status
2583   //
2584   Minuend = (-8825501086245354106);
2585   Subtrahend = 8825501086245354106;
2586   Status = SafeInt64Sub(Minuend, Subtrahend, &Result);
2587   UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
2588
2589   Minuend = (8825501086245354106);
2590   Subtrahend = (-8825501086245354106);
2591   Status = SafeInt64Sub(Minuend, Subtrahend, &Result);
2592   UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
2593
2594   return UNIT_TEST_PASSED;
2595 }
2596
2597 //
2598 // Multiplication function tests:
2599 //
2600 UNIT_TEST_STATUS
2601 EFIAPI
2602 TestSafeUint8Mult (
2603   IN UNIT_TEST_CONTEXT           Context
2604   )
2605 {
2606   EFI_STATUS  Status;
2607   UINT8       Multiplicand;
2608   UINT8       Multiplier;
2609   UINT8       Result;
2610
2611   //
2612   // If the result of multiplication doesn't overflow MAX_UINT8, it will succeed
2613   //
2614   Multiplicand = 0x12;
2615   Multiplier = 0xa;
2616   Result = 0;
2617   Status = SafeUint8Mult(Multiplicand, Multiplier, &Result);
2618   UT_ASSERT_NOT_EFI_ERROR(Status);
2619   UT_ASSERT_EQUAL(0xb4, Result);
2620
2621   //
2622   // Otherwise should result in an error status
2623   //
2624   Multiplicand = 0x12;
2625   Multiplier = 0x23;
2626   Status = SafeUint8Mult(Multiplicand, Multiplier, &Result);
2627   UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
2628
2629   return UNIT_TEST_PASSED;
2630 }
2631
2632 UNIT_TEST_STATUS
2633 EFIAPI
2634 TestSafeUint16Mult (
2635   IN UNIT_TEST_CONTEXT           Context
2636   )
2637 {
2638   EFI_STATUS  Status;
2639   UINT16      Multiplicand;
2640   UINT16      Multiplier;
2641   UINT16      Result;
2642
2643   //
2644   // If the result of multiplication doesn't overflow MAX_UINT16, it will succeed
2645   //
2646   Multiplicand = 0x212;
2647   Multiplier = 0x7a;
2648   Result = 0;
2649   Status = SafeUint16Mult(Multiplicand, Multiplier, &Result);
2650   UT_ASSERT_NOT_EFI_ERROR(Status);
2651   UT_ASSERT_EQUAL(0xfc94, Result);
2652
2653   //
2654   // Otherwise should result in an error status
2655   //
2656   Multiplicand = 0x1234;
2657   Multiplier = 0x213;
2658   Status = SafeUint16Mult(Multiplicand, Multiplier, &Result);
2659   UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
2660
2661   return UNIT_TEST_PASSED;
2662 }
2663
2664 UNIT_TEST_STATUS
2665 EFIAPI
2666 TestSafeUint32Mult (
2667   IN UNIT_TEST_CONTEXT           Context
2668   )
2669 {
2670   EFI_STATUS  Status;
2671   UINT32      Multiplicand;
2672   UINT32      Multiplier;
2673   UINT32      Result;
2674
2675   //
2676   // If the result of multiplication doesn't overflow MAX_UINT32, it will succeed
2677   //
2678   Multiplicand = 0xa122a;
2679   Multiplier = 0xd23;
2680   Result = 0;
2681   Status = SafeUint32Mult(Multiplicand, Multiplier, &Result);
2682   UT_ASSERT_NOT_EFI_ERROR(Status);
2683   UT_ASSERT_EQUAL(0x844c9dbe, Result);
2684
2685   //
2686   // Otherwise should result in an error status
2687   //
2688   Multiplicand = 0xa122a;
2689   Multiplier = 0xed23;
2690   Status = SafeUint32Mult(Multiplicand, Multiplier, &Result);
2691   UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
2692
2693   return UNIT_TEST_PASSED;
2694 }
2695
2696 UNIT_TEST_STATUS
2697 EFIAPI
2698 TestSafeUint64Mult (
2699   IN UNIT_TEST_CONTEXT           Context
2700   )
2701 {
2702   EFI_STATUS  Status;
2703   UINT64      Multiplicand;
2704   UINT64      Multiplier;
2705   UINT64      Result;
2706
2707   //
2708   // If the result of multiplication doesn't overflow MAX_UINT64, it will succeed
2709   //
2710   Multiplicand = 0x123456789a;
2711   Multiplier = 0x1234567;
2712   Result = 0;
2713   Status = SafeUint64Mult(Multiplicand, Multiplier, &Result);
2714   UT_ASSERT_NOT_EFI_ERROR(Status);
2715   UT_ASSERT_EQUAL(0x14b66db9745a07f6, Result);
2716
2717   //
2718   // Otherwise should result in an error status
2719   //
2720   Multiplicand = 0x123456789a;
2721   Multiplier = 0x12345678;
2722   Status = SafeUint64Mult(Multiplicand, Multiplier, &Result);
2723   UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
2724
2725   return UNIT_TEST_PASSED;
2726 }
2727
2728 UNIT_TEST_STATUS
2729 EFIAPI
2730 TestSafeInt8Mult (
2731   IN UNIT_TEST_CONTEXT           Context
2732   )
2733 {
2734   EFI_STATUS  Status;
2735   INT8        Multiplicand;
2736   INT8        Multiplier;
2737   INT8        Result;
2738
2739   //
2740   // If the result of multiplication doesn't overflow MAX_INT8 and doesn't
2741   // underflow MIN_UINT8, it will succeed
2742   //
2743   Multiplicand = 0x12;
2744   Multiplier = 0x7;
2745   Result = 0;
2746   Status = SafeInt8Mult(Multiplicand, Multiplier, &Result);
2747   UT_ASSERT_NOT_EFI_ERROR(Status);
2748   UT_ASSERT_EQUAL(0x7e, Result);
2749
2750   //
2751   // Otherwise should result in an error status
2752   //
2753   Multiplicand = 0x12;
2754   Multiplier = 0xa;
2755   Status = SafeInt8Mult(Multiplicand, Multiplier, &Result);
2756   UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
2757
2758   return UNIT_TEST_PASSED;
2759 }
2760
2761 UNIT_TEST_STATUS
2762 EFIAPI
2763 TestSafeInt16Mult (
2764   IN UNIT_TEST_CONTEXT           Context
2765   )
2766 {
2767   EFI_STATUS  Status;
2768   INT16       Multiplicand;
2769   INT16       Multiplier;
2770   INT16       Result;
2771
2772   //
2773   // If the result of multiplication doesn't overflow MAX_INT16 and doesn't
2774   // underflow MIN_UINT16, it will succeed
2775   //
2776   Multiplicand = 0x123;
2777   Multiplier = 0x67;
2778   Result = 0;
2779   Status = SafeInt16Mult(Multiplicand, Multiplier, &Result);
2780   UT_ASSERT_NOT_EFI_ERROR(Status);
2781   UT_ASSERT_EQUAL(0x7515, Result);
2782
2783   //
2784   // Otherwise should result in an error status
2785   //
2786   Multiplicand = 0x123;
2787   Multiplier = 0xab;
2788   Status = SafeInt16Mult(Multiplicand, Multiplier, &Result);
2789   UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
2790
2791   return UNIT_TEST_PASSED;
2792 }
2793
2794 UNIT_TEST_STATUS
2795 EFIAPI
2796 TestSafeInt32Mult (
2797   IN UNIT_TEST_CONTEXT           Context
2798   )
2799 {
2800   EFI_STATUS  Status;
2801   INT32       Multiplicand;
2802   INT32       Multiplier;
2803   INT32       Result;
2804
2805   //
2806   // If the result of multiplication doesn't overflow MAX_INT32 and doesn't
2807   // underflow MIN_UINT32, it will succeed
2808   //
2809   Multiplicand = 0x123456;
2810   Multiplier = 0x678;
2811   Result = 0;
2812   Status = SafeInt32Mult(Multiplicand, Multiplier, &Result);
2813   UT_ASSERT_NOT_EFI_ERROR(Status);
2814   UT_ASSERT_EQUAL(0x75c28c50, Result);
2815
2816   //
2817   // Otherwise should result in an error status
2818   //
2819   Multiplicand = 0x123456;
2820   Multiplier = 0xabc;
2821   Status = SafeInt32Mult(Multiplicand, Multiplier, &Result);
2822   UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
2823
2824   return UNIT_TEST_PASSED;
2825 }
2826
2827 UNIT_TEST_STATUS
2828 EFIAPI
2829 TestSafeInt64Mult (
2830   IN UNIT_TEST_CONTEXT           Context
2831   )
2832 {
2833   EFI_STATUS  Status;
2834   INT64       Multiplicand;
2835   INT64       Multiplier;
2836   INT64       Result;
2837
2838   //
2839   // If the result of multiplication doesn't overflow MAX_INT64 and doesn't
2840   // underflow MIN_UINT64, it will succeed
2841   //
2842   Multiplicand = 0x123456789;
2843   Multiplier = 0x6789abcd;
2844   Result = 0;
2845   Status = SafeInt64Mult(Multiplicand, Multiplier, &Result);
2846   UT_ASSERT_NOT_EFI_ERROR(Status);
2847   UT_ASSERT_EQUAL(0x75cd9045220d6bb5, Result);
2848
2849   //
2850   // Otherwise should result in an error status
2851   //
2852   Multiplicand = 0x123456789;
2853   Multiplier = 0xa789abcd;
2854   Status = SafeInt64Mult(Multiplicand, Multiplier, &Result);
2855   UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
2856
2857   return UNIT_TEST_PASSED;
2858 }
2859
2860 /**
2861
2862   Main fuction sets up the unit test environment
2863
2864 **/
2865 EFI_STATUS
2866 EFIAPI
2867 UefiTestMain (
2868   VOID
2869   )
2870 {
2871   EFI_STATUS                  Status;
2872   UNIT_TEST_FRAMEWORK_HANDLE  Framework;
2873   UNIT_TEST_SUITE_HANDLE      ConversionTestSuite;
2874   UNIT_TEST_SUITE_HANDLE      AdditionSubtractionTestSuite;
2875   UNIT_TEST_SUITE_HANDLE      MultiplicationTestSuite;
2876
2877   Framework = NULL;
2878   ConversionTestSuite = NULL;
2879   AdditionSubtractionTestSuite = NULL;
2880   MultiplicationTestSuite = NULL;
2881
2882   DEBUG((DEBUG_INFO, "%a v%a\n", UNIT_TEST_NAME, UNIT_TEST_VERSION));
2883
2884   //
2885   // Start setting up the test framework for running the tests.
2886   //
2887   Status = InitUnitTestFramework (&Framework, UNIT_TEST_NAME, gEfiCallerBaseName, UNIT_TEST_VERSION);
2888   if (EFI_ERROR(Status)) {
2889     DEBUG((DEBUG_ERROR, "Failed in InitUnitTestFramework. Status = %r\n", Status));
2890     goto EXIT;
2891   }
2892
2893   ///
2894   // Test the conversion functions
2895   //
2896   Status = CreateUnitTestSuite (&ConversionTestSuite, Framework, "Int Safe Conversions Test Suite", "Common.SafeInt.Convert", NULL, NULL);
2897   if (EFI_ERROR(Status)) {
2898     DEBUG((DEBUG_ERROR, "Failed in CreateUnitTestSuite for Conversions Test Suite\n"));
2899     Status = EFI_OUT_OF_RESOURCES;
2900     goto EXIT;
2901   }
2902   AddTestCase(ConversionTestSuite, "Test SafeInt8ToUint8",    "TestSafeInt8ToUint8",    TestSafeInt8ToUint8,    NULL, NULL, NULL);
2903   AddTestCase(ConversionTestSuite, "Test SafeInt8ToUint16",   "TestSafeInt8ToUint16",   TestSafeInt8ToUint16,   NULL, NULL, NULL);
2904   AddTestCase(ConversionTestSuite, "Test SafeInt8ToUint32",   "TestSafeInt8ToUint32",   TestSafeInt8ToUint32,   NULL, NULL, NULL);
2905   AddTestCase(ConversionTestSuite, "Test SafeInt8ToUintn",    "TestSafeInt8ToUintn",    TestSafeInt8ToUintn,    NULL, NULL, NULL);
2906   AddTestCase(ConversionTestSuite, "Test SafeInt8ToUint64",   "TestSafeInt8ToUint64",   TestSafeInt8ToUint64,   NULL, NULL, NULL);
2907   AddTestCase(ConversionTestSuite, "Test SafeUint8ToInt8",    "TestSafeUint8ToInt8",    TestSafeUint8ToInt8,    NULL, NULL, NULL);
2908   AddTestCase(ConversionTestSuite, "Test SafeUint8ToChar8",   "TestSafeUint8ToChar8",   TestSafeUint8ToChar8,   NULL, NULL, NULL);
2909   AddTestCase(ConversionTestSuite, "Test SafeInt16ToInt8",    "TestSafeInt16ToInt8",    TestSafeInt16ToInt8,    NULL, NULL, NULL);
2910   AddTestCase(ConversionTestSuite, "Test SafeInt16ToChar8",   "TestSafeInt16ToChar8",   TestSafeInt16ToChar8,   NULL, NULL, NULL);
2911   AddTestCase(ConversionTestSuite, "Test SafeInt16ToUint8",   "TestSafeInt16ToUint8",   TestSafeInt16ToUint8,   NULL, NULL, NULL);
2912   AddTestCase(ConversionTestSuite, "Test SafeInt16ToUint16",  "TestSafeInt16ToUint16",  TestSafeInt16ToUint16,  NULL, NULL, NULL);
2913   AddTestCase(ConversionTestSuite, "Test SafeInt16ToUint32",  "TestSafeInt16ToUint32",  TestSafeInt16ToUint32,  NULL, NULL, NULL);
2914   AddTestCase(ConversionTestSuite, "Test SafeInt16ToUintn",   "TestSafeInt16ToUintn",   TestSafeInt16ToUintn,   NULL, NULL, NULL);
2915   AddTestCase(ConversionTestSuite, "Test SafeInt16ToUint64",  "TestSafeInt16ToUint64",  TestSafeInt16ToUint64,  NULL, NULL, NULL);
2916   AddTestCase(ConversionTestSuite, "Test SafeUint16ToInt8",   "TestSafeUint16ToInt8",   TestSafeUint16ToInt8,   NULL, NULL, NULL);
2917   AddTestCase(ConversionTestSuite, "Test SafeUint16ToChar8",  "TestSafeUint16ToChar8",  TestSafeUint16ToChar8,  NULL, NULL, NULL);
2918   AddTestCase(ConversionTestSuite, "Test SafeUint16ToUint8",  "TestSafeUint16ToUint8",  TestSafeUint16ToUint8,  NULL, NULL, NULL);
2919   AddTestCase(ConversionTestSuite, "Test SafeUint16ToInt16",  "TestSafeUint16ToInt16",  TestSafeUint16ToInt16,  NULL, NULL, NULL);
2920   AddTestCase(ConversionTestSuite, "Test SafeInt32ToInt8",    "TestSafeInt32ToInt8",    TestSafeInt32ToInt8,    NULL, NULL, NULL);
2921   AddTestCase(ConversionTestSuite, "Test SafeInt32ToChar8",   "TestSafeInt32ToChar8",   TestSafeInt32ToChar8,   NULL, NULL, NULL);
2922   AddTestCase(ConversionTestSuite, "Test SafeInt32ToUint8",   "TestSafeInt32ToUint8",   TestSafeInt32ToUint8,   NULL, NULL, NULL);
2923   AddTestCase(ConversionTestSuite, "Test SafeInt32ToInt16",   "TestSafeInt32ToInt16",   TestSafeInt32ToInt16,   NULL, NULL, NULL);
2924   AddTestCase(ConversionTestSuite, "Test SafeInt32ToUint16",  "TestSafeInt32ToUint16",  TestSafeInt32ToUint16,  NULL, NULL, NULL);
2925   AddTestCase(ConversionTestSuite, "Test SafeInt32ToUint32",  "TestSafeInt32ToUint32",  TestSafeInt32ToUint32,  NULL, NULL, NULL);
2926   AddTestCase(ConversionTestSuite, "Test SafeInt32ToUintn",   "TestSafeInt32ToUintn",   TestSafeInt32ToUintn,   NULL, NULL, NULL);
2927   AddTestCase(ConversionTestSuite, "Test SafeInt32ToUint64",  "TestSafeInt32ToUint64",  TestSafeInt32ToUint64,  NULL, NULL, NULL);
2928   AddTestCase(ConversionTestSuite, "Test SafeUint32ToInt8",   "TestSafeUint32ToInt8",   TestSafeUint32ToInt8,   NULL, NULL, NULL);
2929   AddTestCase(ConversionTestSuite, "Test SafeUint32ToChar8",  "TestSafeUint32ToChar8",  TestSafeUint32ToChar8,  NULL, NULL, NULL);
2930   AddTestCase(ConversionTestSuite, "Test SafeUint32ToUint8",  "TestSafeUint32ToUint8",  TestSafeUint32ToUint8,  NULL, NULL, NULL);
2931   AddTestCase(ConversionTestSuite, "Test SafeUint32ToInt16",  "TestSafeUint32ToInt16",  TestSafeUint32ToInt16,  NULL, NULL, NULL);
2932   AddTestCase(ConversionTestSuite, "Test SafeUint32ToUint16", "TestSafeUint32ToUint16", TestSafeUint32ToUint16, NULL, NULL, NULL);
2933   AddTestCase(ConversionTestSuite, "Test SafeUint32ToInt32",  "TestSafeUint32ToInt32",  TestSafeUint32ToInt32,  NULL, NULL, NULL);
2934   AddTestCase(ConversionTestSuite, "Test SafeUint32ToIntn",   "TestSafeUint32ToIntn",   TestSafeUint32ToIntn,   NULL, NULL, NULL);
2935   AddTestCase(ConversionTestSuite, "Test SafeIntnToInt8",     "TestSafeIntnToInt8",     TestSafeIntnToInt8,     NULL, NULL, NULL);
2936   AddTestCase(ConversionTestSuite, "Test SafeIntnToChar8",    "TestSafeIntnToChar8",    TestSafeIntnToChar8,    NULL, NULL, NULL);
2937   AddTestCase(ConversionTestSuite, "Test SafeIntnToUint8",    "TestSafeIntnToUint8",    TestSafeIntnToUint8,    NULL, NULL, NULL);
2938   AddTestCase(ConversionTestSuite, "Test SafeIntnToInt16",    "TestSafeIntnToInt16",    TestSafeIntnToInt16,    NULL, NULL, NULL);
2939   AddTestCase(ConversionTestSuite, "Test SafeIntnToUint16",   "TestSafeIntnToUint16",   TestSafeIntnToUint16,   NULL, NULL, NULL);
2940   AddTestCase(ConversionTestSuite, "Test SafeIntnToInt32",    "TestSafeIntnToInt32",    TestSafeIntnToInt32,    NULL, NULL, NULL);
2941   AddTestCase(ConversionTestSuite, "Test SafeIntnToUint32",   "TestSafeIntnToUint32",   TestSafeIntnToUint32,   NULL, NULL, NULL);
2942   AddTestCase(ConversionTestSuite, "Test SafeIntnToUintn",    "TestSafeIntnToUintn",    TestSafeIntnToUintn,    NULL, NULL, NULL);
2943   AddTestCase(ConversionTestSuite, "Test SafeIntnToUint64",   "TestSafeIntnToUint64",   TestSafeIntnToUint64,   NULL, NULL, NULL);
2944   AddTestCase(ConversionTestSuite, "Test SafeUintnToInt8",    "TestSafeUintnToInt8",    TestSafeUintnToInt8,    NULL, NULL, NULL);
2945   AddTestCase(ConversionTestSuite, "Test SafeUintnToChar8",   "TestSafeUintnToChar8",   TestSafeUintnToChar8,   NULL, NULL, NULL);
2946   AddTestCase(ConversionTestSuite, "Test SafeUintnToUint8",   "TestSafeUintnToUint8",   TestSafeUintnToUint8,   NULL, NULL, NULL);
2947   AddTestCase(ConversionTestSuite, "Test SafeUintnToInt16",   "TestSafeUintnToInt16",   TestSafeUintnToInt16,   NULL, NULL, NULL);
2948   AddTestCase(ConversionTestSuite, "Test SafeUintnToUint16",  "TestSafeUintnToUint16",  TestSafeUintnToUint16,  NULL, NULL, NULL);
2949   AddTestCase(ConversionTestSuite, "Test SafeUintnToInt32",   "TestSafeUintnToInt32",   TestSafeUintnToInt32,   NULL, NULL, NULL);
2950   AddTestCase(ConversionTestSuite, "Test SafeUintnToUint32",  "TestSafeUintnToUint32",  TestSafeUintnToUint32,  NULL, NULL, NULL);
2951   AddTestCase(ConversionTestSuite, "Test SafeUintnToIntn",    "TestSafeUintnToIntn",    TestSafeUintnToIntn,    NULL, NULL, NULL);
2952   AddTestCase(ConversionTestSuite, "Test SafeUintnToInt64",   "TestSafeUintnToInt64",   TestSafeUintnToInt64,   NULL, NULL, NULL);
2953   AddTestCase(ConversionTestSuite, "Test SafeInt64ToInt8",    "TestSafeInt64ToInt8",    TestSafeInt64ToInt8,    NULL, NULL, NULL);
2954   AddTestCase(ConversionTestSuite, "Test SafeInt64ToChar8",   "TestSafeInt64ToChar8",   TestSafeInt64ToChar8,   NULL, NULL, NULL);
2955   AddTestCase(ConversionTestSuite, "Test SafeInt64ToUint8",   "TestSafeInt64ToUint8",   TestSafeInt64ToUint8,   NULL, NULL, NULL);
2956   AddTestCase(ConversionTestSuite, "Test SafeInt64ToInt16",   "TestSafeInt64ToInt16",   TestSafeInt64ToInt16,   NULL, NULL, NULL);
2957   AddTestCase(ConversionTestSuite, "Test SafeInt64ToUint16",  "TestSafeInt64ToUint16",  TestSafeInt64ToUint16,  NULL, NULL, NULL);
2958   AddTestCase(ConversionTestSuite, "Test SafeInt64ToInt32",   "TestSafeInt64ToInt32",   TestSafeInt64ToInt32,   NULL, NULL, NULL);
2959   AddTestCase(ConversionTestSuite, "Test SafeInt64ToUint32",  "TestSafeInt64ToUint32",  TestSafeInt64ToUint32,  NULL, NULL, NULL);
2960   AddTestCase(ConversionTestSuite, "Test SafeInt64ToIntn",    "TestSafeInt64ToIntn",    TestSafeInt64ToIntn,    NULL, NULL, NULL);
2961   AddTestCase(ConversionTestSuite, "Test SafeInt64ToUintn",   "TestSafeInt64ToUintn",   TestSafeInt64ToUintn,   NULL, NULL, NULL);
2962   AddTestCase(ConversionTestSuite, "Test SafeInt64ToUint64",  "TestSafeInt64ToUint64",  TestSafeInt64ToUint64,  NULL, NULL, NULL);
2963   AddTestCase(ConversionTestSuite, "Test SafeUint64ToInt8",   "TestSafeUint64ToInt8",   TestSafeUint64ToInt8,   NULL, NULL, NULL);
2964   AddTestCase(ConversionTestSuite, "Test SafeUint64ToChar8",  "TestSafeUint64ToChar8",  TestSafeUint64ToChar8,  NULL, NULL, NULL);
2965   AddTestCase(ConversionTestSuite, "Test SafeUint64ToUint8",  "TestSafeUint64ToUint8",  TestSafeUint64ToUint8,  NULL, NULL, NULL);
2966   AddTestCase(ConversionTestSuite, "Test SafeUint64ToInt16",  "TestSafeUint64ToInt16",  TestSafeUint64ToInt16,  NULL, NULL, NULL);
2967   AddTestCase(ConversionTestSuite, "Test SafeUint64ToUint16", "TestSafeUint64ToUint16", TestSafeUint64ToUint16, NULL, NULL, NULL);
2968   AddTestCase(ConversionTestSuite, "Test SafeUint64ToInt32",  "TestSafeUint64ToInt32",  TestSafeUint64ToInt32,  NULL, NULL, NULL);
2969   AddTestCase(ConversionTestSuite, "Test SafeUint64ToUint32", "TestSafeUint64ToUint32", TestSafeUint64ToUint32, NULL, NULL, NULL);
2970   AddTestCase(ConversionTestSuite, "Test SafeUint64ToIntn",   "TestSafeUint64ToIntn",   TestSafeUint64ToIntn,   NULL, NULL, NULL);
2971   AddTestCase(ConversionTestSuite, "Test SafeUint64ToUintn",  "TestSafeUint64ToUintn",  TestSafeUint64ToUintn,  NULL, NULL, NULL);
2972   AddTestCase(ConversionTestSuite, "Test SafeUint64ToInt64",  "TestSafeUint64ToInt64",  TestSafeUint64ToInt64,  NULL, NULL, NULL);
2973
2974   //
2975   // Test the addition and subtraction functions
2976   //
2977   Status = CreateUnitTestSuite(&AdditionSubtractionTestSuite, Framework, "Int Safe Add/Subtract Test Suite", "Common.SafeInt.AddSubtract", NULL, NULL);
2978   if (EFI_ERROR(Status)) {
2979     DEBUG((DEBUG_ERROR, "Failed in CreateUnitTestSuite for Int Safe Add/Subtract Test Suite\n"));
2980     Status = EFI_OUT_OF_RESOURCES;
2981     goto EXIT;
2982   }
2983   AddTestCase(AdditionSubtractionTestSuite, "Test SafeUint8Add",  "TestSafeUint8Add",  TestSafeUint8Add,  NULL, NULL, NULL);
2984   AddTestCase(AdditionSubtractionTestSuite, "Test SafeUint16Add", "TestSafeUint16Add", TestSafeUint16Add, NULL, NULL, NULL);
2985   AddTestCase(AdditionSubtractionTestSuite, "Test SafeUint32Add", "TestSafeUint32Add", TestSafeUint32Add, NULL, NULL, NULL);
2986   AddTestCase(AdditionSubtractionTestSuite, "Test SafeUintnAdd",  "TestSafeUintnAdd",  TestSafeUintnAdd,  NULL, NULL, NULL);
2987   AddTestCase(AdditionSubtractionTestSuite, "Test SafeUint64Add", "TestSafeUint64Add", TestSafeUint64Add, NULL, NULL, NULL);
2988   AddTestCase(AdditionSubtractionTestSuite, "Test SafeInt8Add",   "TestSafeInt8Add",   TestSafeInt8Add,   NULL, NULL, NULL);
2989   AddTestCase(AdditionSubtractionTestSuite, "Test SafeInt16Add",  "TestSafeInt16Add",  TestSafeInt16Add,  NULL, NULL, NULL);
2990   AddTestCase(AdditionSubtractionTestSuite, "Test SafeInt32Add",  "TestSafeInt32Add",  TestSafeInt32Add,  NULL, NULL, NULL);
2991   AddTestCase(AdditionSubtractionTestSuite, "Test SafeIntnAdd",   "TestSafeIntnAdd",   TestSafeIntnAdd,   NULL, NULL, NULL);
2992   AddTestCase(AdditionSubtractionTestSuite, "Test SafeInt64Add",  "TestSafeInt64Add",  TestSafeInt64Add,  NULL, NULL, NULL);
2993   AddTestCase(AdditionSubtractionTestSuite, "Test SafeUint8Sub",  "TestSafeUint8Sub",  TestSafeUint8Sub,  NULL, NULL, NULL);
2994   AddTestCase(AdditionSubtractionTestSuite, "Test SafeUint16Sub", "TestSafeUint16Sub", TestSafeUint16Sub, NULL, NULL, NULL);
2995   AddTestCase(AdditionSubtractionTestSuite, "Test SafeUint32Sub", "TestSafeUint32Sub", TestSafeUint32Sub, NULL, NULL, NULL);
2996   AddTestCase(AdditionSubtractionTestSuite, "Test SafeUintnSub",  "TestSafeUintnSub",  TestSafeUintnSub,  NULL, NULL, NULL);
2997   AddTestCase(AdditionSubtractionTestSuite, "Test SafeUint64Sub", "TestSafeUint64Sub", TestSafeUint64Sub, NULL, NULL, NULL);
2998   AddTestCase(AdditionSubtractionTestSuite, "Test SafeInt8Sub",   "TestSafeInt8Sub",   TestSafeInt8Sub,   NULL, NULL, NULL);
2999   AddTestCase(AdditionSubtractionTestSuite, "Test SafeInt16Sub",  "TestSafeInt16Sub",  TestSafeInt16Sub,  NULL, NULL, NULL);
3000   AddTestCase(AdditionSubtractionTestSuite, "Test SafeInt32Sub",  "TestSafeInt32Sub",  TestSafeInt32Sub,  NULL, NULL, NULL);
3001   AddTestCase(AdditionSubtractionTestSuite, "Test SafeIntnSub",   "TestSafeIntnSub",   TestSafeIntnSub,   NULL, NULL, NULL);
3002   AddTestCase(AdditionSubtractionTestSuite, "Test SafeInt64Sub",  "TestSafeInt64Sub",  TestSafeInt64Sub,  NULL, NULL, NULL);
3003
3004   //
3005   // Test the multiplication functions
3006   //
3007   Status = CreateUnitTestSuite(&MultiplicationTestSuite, Framework, "Int Safe Multiply Test Suite", "Common.SafeInt.Multiply", NULL, NULL);
3008   if (EFI_ERROR(Status)) {
3009     DEBUG((DEBUG_ERROR, "Failed in CreateUnitTestSuite for Int Safe Multiply Test Suite\n"));
3010     Status = EFI_OUT_OF_RESOURCES;
3011     goto EXIT;
3012   }
3013   AddTestCase(MultiplicationTestSuite, "Test SafeUint8Mult",  "TestSafeUint8Mult",  TestSafeUint8Mult,  NULL, NULL, NULL);
3014   AddTestCase(MultiplicationTestSuite, "Test SafeUint16Mult", "TestSafeUint16Mult", TestSafeUint16Mult, NULL, NULL, NULL);
3015   AddTestCase(MultiplicationTestSuite, "Test SafeUint32Mult", "TestSafeUint32Mult", TestSafeUint32Mult, NULL, NULL, NULL);
3016   AddTestCase(MultiplicationTestSuite, "Test SafeUintnMult",  "TestSafeUintnMult",  TestSafeUintnMult,  NULL, NULL, NULL);
3017   AddTestCase(MultiplicationTestSuite, "Test SafeUint64Mult", "TestSafeUint64Mult", TestSafeUint64Mult, NULL, NULL, NULL);
3018   AddTestCase(MultiplicationTestSuite, "Test SafeInt8Mult",   "TestSafeInt8Mult",   TestSafeInt8Mult,   NULL, NULL, NULL);
3019   AddTestCase(MultiplicationTestSuite, "Test SafeInt16Mult",  "TestSafeInt16Mult",  TestSafeInt16Mult,  NULL, NULL, NULL);
3020   AddTestCase(MultiplicationTestSuite, "Test SafeInt32Mult",  "TestSafeInt32Mult",  TestSafeInt32Mult,  NULL, NULL, NULL);
3021   AddTestCase(MultiplicationTestSuite, "Test SafeIntnMult",   "TestSafeIntnMult",   TestSafeIntnMult,   NULL, NULL, NULL);
3022   AddTestCase(MultiplicationTestSuite, "Test SafeInt64Mult",  "TestSafeInt64Mult",  TestSafeInt64Mult,  NULL, NULL, NULL);
3023
3024   //
3025   // Execute the tests.
3026   //
3027   Status = RunAllTestSuites(Framework);
3028
3029 EXIT:
3030   if (Framework != NULL) {
3031     FreeUnitTestFramework(Framework);
3032   }
3033
3034   return Status;
3035 }
3036
3037 EFI_STATUS
3038 EFIAPI
3039 PeiEntryPoint (
3040   IN EFI_PEI_FILE_HANDLE       FileHandle,
3041   IN CONST EFI_PEI_SERVICES    **PeiServices
3042   )
3043 {
3044   return UefiTestMain ();
3045 }
3046
3047 EFI_STATUS
3048 EFIAPI
3049 DxeEntryPoint (
3050   IN EFI_HANDLE        ImageHandle,
3051   IN EFI_SYSTEM_TABLE  *SystemTable
3052   )
3053 {
3054   return UefiTestMain ();
3055 }
3056
3057 int
3058 main (
3059   int argc,
3060   char *argv[]
3061   )
3062 {
3063   return UefiTestMain ();
3064 }