public inbox for devel@edk2.groups.io
 help / color / mirror / Atom feed
From: "Liming Gao" <liming.gao@intel.com>
To: "Kinney, Michael D" <michael.d.kinney@intel.com>,
	"devel@edk2.groups.io" <devel@edk2.groups.io>
Cc: Sean Brogan <sean.brogan@microsoft.com>,
	Bret Barkelew <Bret.Barkelew@microsoft.com>
Subject: Re: [Patch 08/11] MdePkg/Test: Add SafeIntLib and BaseLib Base64 unit tests
Date: Fri, 7 Feb 2020 07:56:35 +0000	[thread overview]
Message-ID: <03ad7e4568304fde814f966e109372b6@intel.com> (raw)
In-Reply-To: <20200124021032.13808-9-michael.d.kinney@intel.com>

Mike:
  Is there the ready UEFI shell environment to run target based tests? Is Emulator used?

Thanks
Liming
> -----Original Message-----
> From: Kinney, Michael D <michael.d.kinney@intel.com>
> Sent: Friday, January 24, 2020 10:10 AM
> To: devel@edk2.groups.io
> Cc: Sean Brogan <sean.brogan@microsoft.com>; Bret Barkelew <Bret.Barkelew@microsoft.com>; Gao, Liming <liming.gao@intel.com>
> Subject: [Patch 08/11] MdePkg/Test: Add SafeIntLib and BaseLib Base64 unit tests
> 
> * Add unit tests for SafeIntLib class
> * Add unit tests for BaseLib Base64 conversion APIs.
> * Add Test/MdePkgHostTest.dsc -to build host based unit
>   tests
> * Update MdePkg.dsc to build target based tests for
>   SafeIntLib and BaseLib
> * Update MdePkg.ci.yaml to build and run host based
>   tests for SafeIntLib and BaseLib
> 
> Cc: Sean Brogan <sean.brogan@microsoft.com>
> Cc: Bret Barkelew <Bret.Barkelew@microsoft.com>
> Cc: Liming Gao <liming.gao@intel.com>
> Signed-off-by: Michael D Kinney <michael.d.kinney@intel.com>
> ---
>  MdePkg/MdePkg.ci.yaml                         |   19 +-
>  MdePkg/MdePkg.dsc                             |   18 +
>  MdePkg/Test/MdePkgHostTest.dsc                |   30 +
>  .../UnitTest/Library/BaseLib/Base64UnitTest.c |  404 +++
>  .../Library/BaseLib/BaseLibUnitTestsHost.inf  |   32 +
>  .../Library/BaseLib/BaseLibUnitTestsUefi.inf  |   33 +
>  .../SafeIntLibUintnIntnUnitTests32.c          |  540 +++
>  .../SafeIntLibUintnIntnUnitTests64.c          |  544 +++
>  .../BaseSafeIntLib/TestBaseSafeIntLib.c       | 3064 +++++++++++++++++
>  .../BaseSafeIntLib/TestBaseSafeIntLib.h       |  123 +
>  .../BaseSafeIntLib/TestBaseSafeIntLib.uni     |   13 +
>  .../BaseSafeIntLib/TestBaseSafeIntLibDxe.inf  |   45 +
>  .../BaseSafeIntLib/TestBaseSafeIntLibHost.inf |   40 +
>  .../BaseSafeIntLib/TestBaseSafeIntLibPei.inf  |   45 +
>  .../BaseSafeIntLib/TestBaseSafeIntLibSmm.inf  |   45 +
>  .../TestBaseSafeIntLibUefiShell.inf           |   42 +
>  16 files changed, 5034 insertions(+), 3 deletions(-)
>  create mode 100644 MdePkg/Test/MdePkgHostTest.dsc
>  create mode 100644 MdePkg/Test/UnitTest/Library/BaseLib/Base64UnitTest.c
>  create mode 100644 MdePkg/Test/UnitTest/Library/BaseLib/BaseLibUnitTestsHost.inf
>  create mode 100644 MdePkg/Test/UnitTest/Library/BaseLib/BaseLibUnitTestsUefi.inf
>  create mode 100644 MdePkg/Test/UnitTest/Library/BaseSafeIntLib/SafeIntLibUintnIntnUnitTests32.c
>  create mode 100644 MdePkg/Test/UnitTest/Library/BaseSafeIntLib/SafeIntLibUintnIntnUnitTests64.c
>  create mode 100644 MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntLib.c
>  create mode 100644 MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntLib.h
>  create mode 100644 MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntLib.uni
>  create mode 100644 MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntLibDxe.inf
>  create mode 100644 MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntLibHost.inf
>  create mode 100644 MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntLibPei.inf
>  create mode 100644 MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntLibSmm.inf
>  create mode 100644 MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntLibUefiShell.inf
> 
> diff --git a/MdePkg/MdePkg.ci.yaml b/MdePkg/MdePkg.ci.yaml
> index 65c4ec3bec..88e490fcb6 100644
> --- a/MdePkg/MdePkg.ci.yaml
> +++ b/MdePkg/MdePkg.ci.yaml
> @@ -10,8 +10,13 @@
>          "DscPath": "MdePkg.dsc"
>      },
> 
> +    ## options defined ci/Plugin/HostUnitTestCompilerPlugin
> +    "HostUnitTestCompilerPlugin": {
> +        "DscPath": "Test/MdePkgHostTest.dsc"
> +    },
> +
>      ## options defined ci/Plugin/CharEncodingCheck
> -"CharEncodingCheck": {
> +    "CharEncodingCheck": {
>          "IgnoreFiles": []
>      },
> 
> @@ -21,7 +26,9 @@
>              "MdePkg/MdePkg.dec"
>          ],
>          # For host based unit tests
> -        "AcceptableDependencies-HOST_APPLICATION":[],
> +        "AcceptableDependencies-HOST_APPLICATION":[
> +            "UnitTestFrameworkPkg/UnitTestFrameworkPkg.dec"
> +        ],
>          # For UEFI shell based apps
>          "AcceptableDependencies-UEFI_APPLICATION":[],
>          "IgnoreInf": []
> @@ -29,10 +36,16 @@
> 
>      ## options defined ci/Plugin/DscCompleteCheck
>      "DscCompleteCheck": {
> -        "IgnoreInf": [],
> +        "IgnoreInf": [""],
>          "DscPath": "MdePkg.dsc"
>      },
> 
> +    ## options defined ci/Plugin/HostUnitTestDscCompleteCheck
> +    "HostUnitTestDscCompleteCheck": {
> +        "IgnoreInf": [""],
> +        "DscPath": "Test/MdePkgHostTest.dsc"
> +    },
> +
>      ## options defined ci/Plugin/GuidCheck
>      "GuidCheck": {
>          "IgnoreGuidName": [
> diff --git a/MdePkg/MdePkg.dsc b/MdePkg/MdePkg.dsc
> index 0aeafaaacc..87af740853 100644
> --- a/MdePkg/MdePkg.dsc
> +++ b/MdePkg/MdePkg.dsc
> @@ -18,6 +18,8 @@ [Defines]
>    BUILD_TARGETS                  = DEBUG|RELEASE|NOOPT
>    SKUID_IDENTIFIER               = DEFAULT
> 
> +!include UnitTestFrameworkPkg/UnitTestFrameworkPkgTarget.dsc.inc
> +
>  [PcdsFeatureFlag]
>    gEfiMdePkgTokenSpaceGuid.PcdUgaConsumeSupport|TRUE
> 
> @@ -26,6 +28,9 @@ [PcdsFixedAtBuild]
>    gEfiMdePkgTokenSpaceGuid.PcdDebugPrintErrorLevel|0x80000000
>    gEfiMdePkgTokenSpaceGuid.PcdPciExpressBaseAddress|0xE0000000
> 
> +[LibraryClasses]
> +  SafeIntLib|MdePkg/Library/BaseSafeIntLib/BaseSafeIntLib.inf
> +
>  [Components]
>    MdePkg/Library/UefiFileHandleLib/UefiFileHandleLib.inf
>    MdePkg/Library/BaseCacheMaintenanceLib/BaseCacheMaintenanceLib.inf
> @@ -115,6 +120,19 @@ [Components]
>    MdePkg/Library/StandaloneMmDriverEntryPoint/StandaloneMmDriverEntryPoint.inf
>    MdePkg/Library/StandaloneMmServicesTableLib/StandaloneMmServicesTableLib.inf
> 
> +  #
> +  # Add UEFI Target Based Unit Tests
> +  #
> +  MdePkg/Test/UnitTest/Library/BaseLib/BaseLibUnitTestsUefi.inf
> +
> +  #
> +  # Build PEIM, DXE_DRIVER, SMM_DRIVER, UEFI Shell components that test SafeIntLib
> +  #
> +  MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntLibPei.inf
> +  MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntLibDxe.inf
> +  MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntLibSmm.inf
> +  MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntLibUefiShell.inf
> +
>  [Components.IA32, Components.X64]
>    MdePkg/Library/BaseIoLibIntrinsic/BaseIoLibIntrinsic.inf
>    MdePkg/Library/BaseIoLibIntrinsic/BaseIoLibIntrinsicSev.inf
> diff --git a/MdePkg/Test/MdePkgHostTest.dsc b/MdePkg/Test/MdePkgHostTest.dsc
> new file mode 100644
> index 0000000000..3d677ee75c
> --- /dev/null
> +++ b/MdePkg/Test/MdePkgHostTest.dsc
> @@ -0,0 +1,30 @@
> +## @file
> +# MdePkg DSC file used to build host-based unit tests.
> +#
> +# Copyright (c) 2019 - 2020, Intel Corporation. All rights reserved.<BR>
> +# Copyright (C) Microsoft Corporation.
> +# SPDX-License-Identifier: BSD-2-Clause-Patent
> +#
> +##
> +
> +[Defines]
> +  PLATFORM_NAME           = MdePkgHostTest
> +  PLATFORM_GUID           = 50652B4C-88CB-4481-96E8-37F2D0034440
> +  PLATFORM_VERSION        = 0.1
> +  DSC_SPECIFICATION       = 0x00010005
> +  OUTPUT_DIRECTORY        = Build/MdePkg/HostTest
> +  SUPPORTED_ARCHITECTURES = IA32|X64
> +  BUILD_TARGETS           = NOOPT
> +  SKUID_IDENTIFIER        = DEFAULT
> +
> +!include UnitTestFrameworkPkg/UnitTestFrameworkPkgHost.dsc.inc
> +
> +[LibraryClasses]
> +  SafeIntLib|MdePkg/Library/BaseSafeIntLib/BaseSafeIntLib.inf
> +
> +[Components]
> +  #
> +  # Build HOST_APPLICATION that tests the SafeIntLib
> +  #
> +  MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntLibHost.inf
> +  MdePkg/Test/UnitTest/Library/BaseLib/BaseLibUnitTestsHost.inf
> diff --git a/MdePkg/Test/UnitTest/Library/BaseLib/Base64UnitTest.c b/MdePkg/Test/UnitTest/Library/BaseLib/Base64UnitTest.c
> new file mode 100644
> index 0000000000..0ad078155c
> --- /dev/null
> +++ b/MdePkg/Test/UnitTest/Library/BaseLib/Base64UnitTest.c
> @@ -0,0 +1,404 @@
> +/** @file
> +  Unit tests of Base64 conversion APIs in BaseLib.
> +
> +  Copyright (C) Microsoft Corporation.
> +  SPDX-License-Identifier: BSD-2-Clause-Patent
> +
> +**/
> +
> +#include <Uefi.h>
> +#include <Library/BaseLib.h>
> +#include <Library/BaseMemoryLib.h>
> +#include <Library/DebugLib.h>
> +#include <Library/MemoryAllocationLib.h>
> +#include <Library/UnitTestLib.h>
> +
> +#define UNIT_TEST_APP_NAME     "BaseLib Unit Test Application"
> +#define UNIT_TEST_APP_VERSION  "1.0"
> +
> +/**
> +  RFC 4648  https://tools.ietf.org/html/rfc4648 test vectors
> +
> +  BASE64("") = ""
> +  BASE64("f") = "Zg=="
> +  BASE64("fo") = "Zm8="
> +  BASE64("foo") = "Zm9v"
> +  BASE64("foob") = "Zm9vYg=="
> +  BASE64("fooba") = "Zm9vYmE="
> +  BASE64("foobar") = "Zm9vYmFy"
> +
> +  The test vectors are using ascii strings for the binary data
> + */
> +
> +typedef struct {
> +    CHAR8      *TestInput;
> +    CHAR8      *TestOutput;
> +    EFI_STATUS  ExpectedStatus;
> +    VOID       *BufferToFree;
> +    UINTN       ExpectedSize;
> +} BASIC_TEST_CONTEXT;
> +
> +#define B64_TEST_1     ""
> +#define BIN_TEST_1     ""
> +
> +#define B64_TEST_2     "Zg=="
> +#define BIN_TEST_2     "f"
> +
> +#define B64_TEST_3     "Zm8="
> +#define BIN_TEST_3     "fo"
> +
> +#define B64_TEST_4     "Zm9v"
> +#define BIN_TEST_4     "foo"
> +
> +#define B64_TEST_5     "Zm9vYg=="
> +#define BIN_TEST_5     "foob"
> +
> +#define B64_TEST_6     "Zm9vYmE="
> +#define BIN_TEST_6     "fooba"
> +
> +#define B64_TEST_7     "Zm9vYmFy"
> +#define BIN_TEST_7     "foobar"
> +
> +// Adds all white space - also ends the last quantum with only spaces afterwards
> +#define B64_TEST_8_IN   " \t\v  Zm9\r\nvYmFy \f  "
> +#define BIN_TEST_8      "foobar"
> +
> +// Not a quantum multiple of 4
> +#define B64_ERROR_1  "Zm9vymFy="
> +
> +// Invalid characters in the string
> +#define B64_ERROR_2  "Zm$vymFy"
> +
> +// Too many '=' characters
> +#define B64_ERROR_3 "Z==="
> +
> +// Poorly placed '='
> +#define B64_ERROR_4 "Zm=vYmFy"
> +
> +#define MAX_TEST_STRING_SIZE (200)
> +
> +// ------------------------------------------------ Input----------Output-----------Result-------Free--Expected Output Size
> +static BASIC_TEST_CONTEXT    mBasicEncodeTest1  = {BIN_TEST_1,     B64_TEST_1,      EFI_SUCCESS, NULL, sizeof(B64_TEST_1)};
> +static BASIC_TEST_CONTEXT    mBasicEncodeTest2  = {BIN_TEST_2,     B64_TEST_2,      EFI_SUCCESS, NULL, sizeof(B64_TEST_2)};
> +static BASIC_TEST_CONTEXT    mBasicEncodeTest3  = {BIN_TEST_3,     B64_TEST_3,      EFI_SUCCESS, NULL, sizeof(B64_TEST_3)};
> +static BASIC_TEST_CONTEXT    mBasicEncodeTest4  = {BIN_TEST_4,     B64_TEST_4,      EFI_SUCCESS, NULL, sizeof(B64_TEST_4)};
> +static BASIC_TEST_CONTEXT    mBasicEncodeTest5  = {BIN_TEST_5,     B64_TEST_5,      EFI_SUCCESS, NULL, sizeof(B64_TEST_5)};
> +static BASIC_TEST_CONTEXT    mBasicEncodeTest6  = {BIN_TEST_6,     B64_TEST_6,      EFI_SUCCESS, NULL, sizeof(B64_TEST_6)};
> +static BASIC_TEST_CONTEXT    mBasicEncodeTest7  = {BIN_TEST_7,     B64_TEST_7,      EFI_SUCCESS, NULL, sizeof(B64_TEST_7)};
> +static BASIC_TEST_CONTEXT    mBasicEncodeError1 = {BIN_TEST_7,     B64_TEST_1,      EFI_BUFFER_TOO_SMALL, NULL,
> sizeof(B64_TEST_7)};
> +
> +static BASIC_TEST_CONTEXT    mBasicDecodeTest1  = {B64_TEST_1,     BIN_TEST_1,      EFI_SUCCESS, NULL, sizeof(BIN_TEST_1)-1};
> +static BASIC_TEST_CONTEXT    mBasicDecodeTest2  = {B64_TEST_2,     BIN_TEST_2,      EFI_SUCCESS, NULL, sizeof(BIN_TEST_2)-1};
> +static BASIC_TEST_CONTEXT    mBasicDecodeTest3  = {B64_TEST_3,     BIN_TEST_3,      EFI_SUCCESS, NULL, sizeof(BIN_TEST_3)-1};
> +static BASIC_TEST_CONTEXT    mBasicDecodeTest4  = {B64_TEST_4,     BIN_TEST_4,      EFI_SUCCESS, NULL, sizeof(BIN_TEST_4)-1};
> +static BASIC_TEST_CONTEXT    mBasicDecodeTest5  = {B64_TEST_5,     BIN_TEST_5,      EFI_SUCCESS, NULL, sizeof(BIN_TEST_5)-1};
> +static BASIC_TEST_CONTEXT    mBasicDecodeTest6  = {B64_TEST_6,     BIN_TEST_6,      EFI_SUCCESS, NULL, sizeof(BIN_TEST_6)-1};
> +static BASIC_TEST_CONTEXT    mBasicDecodeTest7  = {B64_TEST_7,     BIN_TEST_7,      EFI_SUCCESS, NULL, sizeof(BIN_TEST_7)-1};
> +static BASIC_TEST_CONTEXT    mBasicDecodeTest8  = {B64_TEST_8_IN,  BIN_TEST_8,      EFI_SUCCESS, NULL, sizeof(BIN_TEST_8)-1};
> +
> +static BASIC_TEST_CONTEXT    mBasicDecodeError1 = {B64_ERROR_1,    B64_ERROR_1,     EFI_INVALID_PARAMETER, NULL, 0};
> +static BASIC_TEST_CONTEXT    mBasicDecodeError2 = {B64_ERROR_2,    B64_ERROR_2,     EFI_INVALID_PARAMETER, NULL, 0};
> +static BASIC_TEST_CONTEXT    mBasicDecodeError3 = {B64_ERROR_3,    B64_ERROR_3,     EFI_INVALID_PARAMETER, NULL, 0};
> +static BASIC_TEST_CONTEXT    mBasicDecodeError4 = {B64_ERROR_4,    B64_ERROR_4,     EFI_INVALID_PARAMETER, NULL, 0};
> +static BASIC_TEST_CONTEXT    mBasicDecodeError5 = {B64_TEST_7,     BIN_TEST_1,      EFI_BUFFER_TOO_SMALL,  NULL,
> sizeof(BIN_TEST_7)-1};
> +
> +/**
> +  Simple clean up method to make sure tests clean up even if interrupted and fail
> +  in the middle.
> +**/
> +STATIC
> +VOID
> +EFIAPI
> +CleanUpB64TestContext (
> +  IN UNIT_TEST_CONTEXT  Context
> +  )
> +{
> +  BASIC_TEST_CONTEXT  *Btc;
> +
> +  Btc = (BASIC_TEST_CONTEXT *)Context;
> +  if (Btc != NULL) {
> +    //free string if set
> +    if (Btc->BufferToFree != NULL) {
> +      FreePool (Btc->BufferToFree);
> +      Btc->BufferToFree = NULL;
> +    }
> +  }
> +}
> +
> +/**
> +  Unit test for Base64 encode APIs of BaseLib.
> +
> +  @param[in]  Context    [Optional] An optional paramter that enables:
> +                         1) test-case reuse with varied parameters and
> +                         2) test-case re-entry for Target tests that need a
> +                         reboot.  This parameter is a VOID* and it is the
> +                         responsibility of the test author to ensure that the
> +                         contents are well understood by all test cases that may
> +                         consume it.
> +
> +  @retval  UNIT_TEST_PASSED             The Unit test has completed and the test
> +                                        case was successful.
> +  @retval  UNIT_TEST_ERROR_TEST_FAILED  A test case assertion has failed.
> +**/
> +STATIC
> +UNIT_TEST_STATUS
> +EFIAPI
> +RfcEncodeTest (
> +  IN UNIT_TEST_CONTEXT  Context
> +  )
> +{
> +  BASIC_TEST_CONTEXT  *Btc;
> +  CHAR8               *b64String;
> +  CHAR8               *binString;
> +  UINTN               b64StringSize;
> +  EFI_STATUS          Status;
> +  UINT8               *BinData;
> +  UINTN               BinSize;
> +  CHAR8               *b64WorkString;
> +  UINTN               ReturnSize;
> +  INTN                CompareStatus;
> +  UINTN               indx;
> +
> +  Btc = (BASIC_TEST_CONTEXT *) Context;
> +  binString = Btc->TestInput;
> +  b64String = Btc->TestOutput;
> +
> +  //
> +  // Only testing the the translate functionality, so preallocate the proper
> +  // string buffer.
> +  //
> +
> +  b64StringSize = AsciiStrnSizeS(b64String, MAX_TEST_STRING_SIZE);
> +  BinSize = AsciiStrnLenS(binString, MAX_TEST_STRING_SIZE);
> +  BinData = (UINT8 *)  binString;
> +
> +  b64WorkString = (CHAR8 *) AllocatePool(b64StringSize);
> +  UT_ASSERT_NOT_NULL(b64WorkString);
> +
> +  Btc->BufferToFree = b64WorkString;
> +  ReturnSize = b64StringSize;
> +
> +  Status = Base64Encode(BinData, BinSize, b64WorkString, &ReturnSize);
> +
> +  UT_ASSERT_STATUS_EQUAL(Status, Btc->ExpectedStatus);
> +
> +  UT_ASSERT_EQUAL(ReturnSize, Btc->ExpectedSize);
> +
> +  if (!EFI_ERROR (Btc->ExpectedStatus)) {
> +    if (ReturnSize != 0) {
> +      CompareStatus = AsciiStrnCmp (b64String, b64WorkString, ReturnSize);
> +      if (CompareStatus != 0) {
> +        UT_LOG_ERROR ("b64 string compare error - size=%d\n", ReturnSize);
> +        for (indx = 0; indx < ReturnSize; indx++) {
> +          UT_LOG_ERROR (" %2.2x", 0xff & b64String[indx]);
> +        }
> +        UT_LOG_ERROR ("\n b64 work string:\n");
> +        for (indx = 0; indx < ReturnSize; indx++) {
> +          UT_LOG_ERROR (" %2.2x", 0xff & b64WorkString[indx]);
> +        }
> +        UT_LOG_ERROR ("\n");
> +      }
> +      UT_ASSERT_EQUAL (CompareStatus, 0);
> +    }
> +  }
> +
> +  Btc->BufferToFree = NULL;
> +  FreePool (b64WorkString);
> +  return UNIT_TEST_PASSED;
> +}
> +
> +/**
> +  Unit test for Base64 decode APIs of BaseLib.
> +
> +  @param[in]  Context    [Optional] An optional paramter that enables:
> +                         1) test-case reuse with varied parameters and
> +                         2) test-case re-entry for Target tests that need a
> +                         reboot.  This parameter is a VOID* and it is the
> +                         responsibility of the test author to ensure that the
> +                         contents are well understood by all test cases that may
> +                         consume it.
> +
> +  @retval  UNIT_TEST_PASSED             The Unit test has completed and the test
> +                                        case was successful.
> +  @retval  UNIT_TEST_ERROR_TEST_FAILED  A test case assertion has failed.
> +**/
> +STATIC
> +UNIT_TEST_STATUS
> +EFIAPI
> +RfcDecodeTest(
> +  IN UNIT_TEST_CONTEXT  Context
> +  )
> +{
> +  BASIC_TEST_CONTEXT *Btc;
> +  CHAR8              *b64String;
> +  CHAR8              *binString;
> +  EFI_STATUS          Status;
> +  UINTN               b64StringLen;
> +  UINTN               ReturnSize;
> +  UINT8              *BinData;
> +  UINTN               BinSize;
> +  INTN                CompareStatus;
> +  UINTN               indx;
> +
> +  Btc = (BASIC_TEST_CONTEXT *)Context;
> +  b64String = Btc->TestInput;
> +  binString = Btc->TestOutput;
> +
> +  //
> +  //  Only testing the the translate functionality
> +  //
> +
> +  b64StringLen = AsciiStrnLenS (b64String, MAX_TEST_STRING_SIZE);
> +  BinSize = AsciiStrnLenS (binString, MAX_TEST_STRING_SIZE);
> +
> +  BinData = AllocatePool (BinSize);
> +  Btc->BufferToFree = BinData;
> +
> +  ReturnSize = BinSize;
> +  Status = Base64Decode (b64String, b64StringLen, BinData, &ReturnSize);
> +
> +  UT_ASSERT_STATUS_EQUAL (Status, Btc->ExpectedStatus);
> +
> +  // If an error is not expected, check the results
> +  if (EFI_ERROR (Btc->ExpectedStatus)) {
> +    if (Btc->ExpectedStatus == EFI_BUFFER_TOO_SMALL) {
> +      UT_ASSERT_EQUAL (ReturnSize, Btc->ExpectedSize);
> +    }
> +  } else {
> +    UT_ASSERT_EQUAL (ReturnSize, Btc->ExpectedSize);
> +    if (ReturnSize != 0) {
> +      CompareStatus = CompareMem (binString, BinData, ReturnSize);
> +      if (CompareStatus != 0) {
> +        UT_LOG_ERROR ("bin string compare error - size=%d\n", ReturnSize);
> +        for (indx = 0; indx < ReturnSize; indx++) {
> +          UT_LOG_ERROR (" %2.2x", 0xff & binString[indx]);
> +        }
> +        UT_LOG_ERROR ("\nBinData:\n");
> +        for (indx = 0; indx < ReturnSize; indx++) {
> +          UT_LOG_ERROR (" %2.2x", 0xff & BinData[indx]);
> +        }
> +        UT_LOG_ERROR ("\n");
> +      }
> +      UT_ASSERT_EQUAL (CompareStatus, 0);
> +    }
> +  }
> +
> +  Btc->BufferToFree = NULL;
> +  FreePool (BinData);
> +  return UNIT_TEST_PASSED;
> +}
> +
> +/**
> +  Initialze the unit test framework, suite, and unit tests for the
> +  Base64 conversion APIs of BaseLib and run the unit tests.
> +
> +  @retval  EFI_SUCCESS           All test cases were dispached.
> +  @retval  EFI_OUT_OF_RESOURCES  There are not enough resources available to
> +                                 initialize the unit tests.
> +**/
> +STATIC
> +EFI_STATUS
> +EFIAPI
> +UnitTestingEntry (
> +  VOID
> +  )
> +{
> +  EFI_STATUS                  Status;
> +  UNIT_TEST_FRAMEWORK_HANDLE  Fw;
> +  UNIT_TEST_SUITE_HANDLE      b64EncodeTests;
> +  UNIT_TEST_SUITE_HANDLE      b64DecodeTests;
> +
> +  Fw = NULL;
> +
> +  DEBUG ((DEBUG_INFO, "%a v%a\n", UNIT_TEST_APP_NAME, UNIT_TEST_APP_VERSION));
> +
> +  //
> +  // Start setting up the test framework for running the tests.
> +  //
> +  Status = InitUnitTestFramework (&Fw, UNIT_TEST_APP_NAME, gEfiCallerBaseName, UNIT_TEST_APP_VERSION);
> +  if (EFI_ERROR (Status)) {
> +      DEBUG ((DEBUG_ERROR, "Failed in InitUnitTestFramework. Status = %r\n", Status));
> +      goto EXIT;
> +  }
> +
> +  //
> +  // Populate the B64 Encode Unit Test Suite.
> +  //
> +  Status = CreateUnitTestSuite (&b64EncodeTests, Fw, "b64 Encode binary to Ascii string", "BaseLib.b64Encode", NULL, NULL);
> +  if (EFI_ERROR (Status)) {
> +    DEBUG ((DEBUG_ERROR, "Failed in CreateUnitTestSuite for b64EncodeTests\n"));
> +    Status = EFI_OUT_OF_RESOURCES;
> +    goto EXIT;
> +  }
> +
> +  // --------------Suite-----------Description--------------Class Name----------Function--------Pre---Post-------------------Context-----------
> +  AddTestCase (b64EncodeTests, "RFC 4686 Test Vector - Empty", "Test1", RfcEncodeTest, NULL, CleanUpB64TestContext,
> &mBasicEncodeTest1);
> +  AddTestCase (b64EncodeTests, "RFC 4686 Test Vector - f", "Test2", RfcEncodeTest, NULL, CleanUpB64TestContext,
> &mBasicEncodeTest2);
> +  AddTestCase (b64EncodeTests, "RFC 4686 Test Vector - fo", "Test3", RfcEncodeTest, NULL, CleanUpB64TestContext,
> &mBasicEncodeTest3);
> +  AddTestCase (b64EncodeTests, "RFC 4686 Test Vector - foo", "Test4", RfcEncodeTest, NULL, CleanUpB64TestContext,
> &mBasicEncodeTest4);
> +  AddTestCase (b64EncodeTests, "RFC 4686 Test Vector - foob", "Test5", RfcEncodeTest, NULL, CleanUpB64TestContext,
> &mBasicEncodeTest5);
> +  AddTestCase (b64EncodeTests, "RFC 4686 Test Vector - fooba", "Test6", RfcEncodeTest, NULL, CleanUpB64TestContext,
> &mBasicEncodeTest6);
> +  AddTestCase (b64EncodeTests, "RFC 4686 Test Vector - foobar", "Test7", RfcEncodeTest, NULL, CleanUpB64TestContext,
> &mBasicEncodeTest7);
> +  AddTestCase (b64EncodeTests, "Too small of output buffer", "Error1", RfcEncodeTest, NULL, CleanUpB64TestContext,
> &mBasicEncodeError1);
> +  //
> +  // Populate the B64 Decode Unit Test Suite.
> +  //
> +  Status = CreateUnitTestSuite (&b64DecodeTests, Fw, "b64 Decode Ascii string to binary", "BaseLib.b64Decode", NULL, NULL);
> +  if (EFI_ERROR (Status)) {
> +      DEBUG ((DEBUG_ERROR, "Failed in CreateUnitTestSuite for b64Decode Tests\n"));
> +      Status = EFI_OUT_OF_RESOURCES;
> +      goto EXIT;
> +  }
> +
> +  AddTestCase (b64DecodeTests, "RFC 4686 Test Vector - Empty", "Test1",  RfcDecodeTest, NULL, CleanUpB64TestContext,
> &mBasicDecodeTest1);
> +  AddTestCase (b64DecodeTests, "RFC 4686 Test Vector - f", "Test2",  RfcDecodeTest, NULL, CleanUpB64TestContext,
> &mBasicDecodeTest2);
> +  AddTestCase (b64DecodeTests, "RFC 4686 Test Vector - fo", "Test3",  RfcDecodeTest, NULL, CleanUpB64TestContext,
> &mBasicDecodeTest3);
> +  AddTestCase (b64DecodeTests, "RFC 4686 Test Vector - foo", "Test4",  RfcDecodeTest, NULL, CleanUpB64TestContext,
> &mBasicDecodeTest4);
> +  AddTestCase (b64DecodeTests, "RFC 4686 Test Vector - foob", "Test5",  RfcDecodeTest, NULL, CleanUpB64TestContext,
> &mBasicDecodeTest5);
> +  AddTestCase (b64DecodeTests, "RFC 4686 Test Vector - fooba", "Test6",  RfcDecodeTest, NULL, CleanUpB64TestContext,
> &mBasicDecodeTest6);
> +  AddTestCase (b64DecodeTests, "RFC 4686 Test Vector - foobar", "Test7",  RfcDecodeTest, NULL, CleanUpB64TestContext,
> &mBasicDecodeTest7);
> +  AddTestCase (b64DecodeTests, "Ignore Whitespace test", "Test8",  RfcDecodeTest, NULL, CleanUpB64TestContext,
> &mBasicDecodeTest8);
> +
> +  AddTestCase (b64DecodeTests, "Not a quantum multiple of 4", "Error1", RfcDecodeTest, NULL, CleanUpB64TestContext,
> &mBasicDecodeError1);
> +  AddTestCase (b64DecodeTests, "Invalid characters in the string", "Error2", RfcDecodeTest, NULL, CleanUpB64TestContext,
> &mBasicDecodeError2);
> +  AddTestCase (b64DecodeTests, "Too many padding characters", "Error3", RfcDecodeTest, NULL, CleanUpB64TestContext,
> &mBasicDecodeError3);
> +  AddTestCase (b64DecodeTests, "Incorrectly placed padding character", "Error4", RfcDecodeTest, NULL, CleanUpB64TestContext,
> &mBasicDecodeError4);
> +  AddTestCase (b64DecodeTests, "Too small of output buffer", "Error5", RfcDecodeTest, NULL, CleanUpB64TestContext,
> &mBasicDecodeError5);
> +
> +  //
> +  // Execute the tests.
> +  //
> +  Status = RunAllTestSuites (Fw);
> +
> +EXIT:
> +  if (Fw) {
> +    FreeUnitTestFramework (Fw);
> +  }
> +
> +  return Status;
> +}
> +
> +/**
> +  Standard UEFI entry point for target based unit test execution from UEFI Shell.
> +**/
> +EFI_STATUS
> +EFIAPI
> +BaseLibUnitTestAppEntry (
> +  IN EFI_HANDLE        ImageHandle,
> +  IN EFI_SYSTEM_TABLE  *SystemTable
> +  )
> +{
> +  return UnitTestingEntry ();
> +}
> +
> +/**
> +  Standard POSIX C entry point for host based unit test execution.
> +**/
> +int
> +main (
> +  int argc,
> +  char *argv[]
> +  )
> +{
> +  return UnitTestingEntry ();
> +}
> diff --git a/MdePkg/Test/UnitTest/Library/BaseLib/BaseLibUnitTestsHost.inf
> b/MdePkg/Test/UnitTest/Library/BaseLib/BaseLibUnitTestsHost.inf
> new file mode 100644
> index 0000000000..b31afae633
> --- /dev/null
> +++ b/MdePkg/Test/UnitTest/Library/BaseLib/BaseLibUnitTestsHost.inf
> @@ -0,0 +1,32 @@
> +## @file
> +# Unit tests of Base64 conversion APIs in BaseLib that are run from host
> +# environment.
> +#
> +# Copyright (C) Microsoft Corporation.
> +# SPDX-License-Identifier: BSD-2-Clause-Patent
> +##
> +
> +[Defines]
> +  INF_VERSION                    = 0x00010006
> +  BASE_NAME                      = BaseLibUnitTestsHost
> +  FILE_GUID                      = 1d005f4c-4dfa-41b5-ab0c-be91fe121459
> +  MODULE_TYPE                    = HOST_APPLICATION
> +  VERSION_STRING                 = 1.0
> +
> +#
> +# The following information is for reference only and not required by the build tools.
> +#
> +#  VALID_ARCHITECTURES           = IA32 X64
> +#
> +
> +[Sources]
> +  Base64UnitTest.c
> +
> +[Packages]
> +  MdePkg/MdePkg.dec
> +
> +[LibraryClasses]
> +  BaseLib
> +  BaseMemoryLib
> +  DebugLib
> +  UnitTestLib
> diff --git a/MdePkg/Test/UnitTest/Library/BaseLib/BaseLibUnitTestsUefi.inf
> b/MdePkg/Test/UnitTest/Library/BaseLib/BaseLibUnitTestsUefi.inf
> new file mode 100644
> index 0000000000..907503898a
> --- /dev/null
> +++ b/MdePkg/Test/UnitTest/Library/BaseLib/BaseLibUnitTestsUefi.inf
> @@ -0,0 +1,33 @@
> +## @file
> +# Unit tests of Base64 conversion APIs in BaseLib that are run from UEFI Shell.
> +#
> +# Copyright (C) Microsoft Corporation.
> +# SPDX-License-Identifier: BSD-2-Clause-Patent
> +##
> +
> +[Defines]
> +  INF_VERSION                    = 0x00010006
> +  BASE_NAME                      = BaseLibUnitTestsUefi
> +  FILE_GUID                      = df5a6fed-8786-4a9d-9d02-eab39497b4a1
> +  MODULE_TYPE                    = UEFI_APPLICATION
> +  VERSION_STRING                 = 1.0
> +  ENTRY_POINT                    = BaseLibUnitTestAppEntry
> +
> +#
> +# The following information is for reference only and not required by the build tools.
> +#
> +#  VALID_ARCHITECTURES           = IA32 X64
> +#
> +
> +[Sources]
> +  Base64UnitTest.c
> +
> +[Packages]
> +  MdePkg/MdePkg.dec
> +
> +[LibraryClasses]
> +  BaseLib
> +  BaseMemoryLib
> +  UefiApplicationEntryPoint
> +  DebugLib
> +  UnitTestLib
> diff --git a/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/SafeIntLibUintnIntnUnitTests32.c
> b/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/SafeIntLibUintnIntnUnitTests32.c
> new file mode 100644
> index 0000000000..be5c0e15d3
> --- /dev/null
> +++ b/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/SafeIntLibUintnIntnUnitTests32.c
> @@ -0,0 +1,540 @@
> +/** @file
> +  IA32-specific functions for unit-testing INTN and UINTN functions in
> +  SafeIntLib.
> +
> +  Copyright (c) Microsoft Corporation.<BR>
> +  Copyright (c) 2019 - 2020, Intel Corporation. All rights reserved.<BR>
> +  SPDX-License-Identifier: BSD-2-Clause-Patent
> +
> +**/
> +
> +#include "TestBaseSafeIntLib.h"
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeInt32ToUintn (
> +  IN UNIT_TEST_CONTEXT           Context
> +  )
> +{
> +  EFI_STATUS  Status;
> +  INT32       Operand;
> +  UINTN       Result;
> +
> +  //
> +  // If Operand is non-negative, then it's a cast
> +  //
> +  Operand = 0x5bababab;
> +  Result = 0;
> +  Status = SafeInt32ToUintn(Operand, &Result);
> +  UT_ASSERT_NOT_EFI_ERROR(Status);
> +  UT_ASSERT_EQUAL(0x5bababab, Result);
> +
> +  //
> +  // Otherwise should result in an error status
> +  //
> +  Operand = (-1537977259);
> +  Status = SafeInt32ToUintn(Operand, &Result);
> +  UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> +  return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUint32ToIntn (
> +  IN UNIT_TEST_CONTEXT           Context
> +  )
> +{
> +  EFI_STATUS  Status;
> +  UINT32      Operand;
> +  INTN        Result;
> +
> +  //
> +  // If Operand is <= MAX_INTN, then it's a cast
> +  //
> +  Operand = 0x5bababab;
> +  Result = 0;
> +  Status = SafeUint32ToIntn(Operand, &Result);
> +  UT_ASSERT_NOT_EFI_ERROR(Status);
> +  UT_ASSERT_EQUAL(0x5bababab, Result);
> +
> +  //
> +  // Otherwise should result in an error status
> +  //
> +  Operand = (0xabababab);
> +  Status = SafeUint32ToIntn(Operand, &Result);
> +  UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> +  return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeIntnToInt32 (
> +  IN UNIT_TEST_CONTEXT           Context
> +  )
> +{
> +  EFI_STATUS  Status;
> +  INTN        Operand;
> +  INT32       Result;
> +
> +  //
> +  // INTN is same as INT32 in IA32, so this is just a cast
> +  //
> +  Operand = 0x5bababab;
> +  Result = 0;
> +  Status = SafeIntnToInt32(Operand, &Result);
> +  UT_ASSERT_NOT_EFI_ERROR(Status);
> +  UT_ASSERT_EQUAL(0x5bababab, Result);
> +
> +  return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeIntnToUint32 (
> +  IN UNIT_TEST_CONTEXT           Context
> +  )
> +{
> +  EFI_STATUS  Status;
> +  INTN        Operand;
> +  UINT32      Result;
> +
> +  //
> +  // If Operand is non-negative, then it's a cast
> +  //
> +  Operand = 0x5bababab;
> +  Result = 0;
> +  Status = SafeIntnToUint32(Operand, &Result);
> +  UT_ASSERT_NOT_EFI_ERROR(Status);
> +  UT_ASSERT_EQUAL(0x5bababab, Result);
> +
> +  //
> +  // Otherwise should result in an error status
> +  //
> +  Operand = (-1537977259);
> +  Status = SafeIntnToUint32(Operand, &Result);
> +  UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> +  return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUintnToUint32 (
> +  IN UNIT_TEST_CONTEXT           Context
> +  )
> +{
> +  EFI_STATUS  Status;
> +  UINTN       Operand;
> +  UINT32      Result;
> +
> +  //
> +  // UINTN is same as UINT32 in IA32, so this is just a cast
> +  //
> +  Operand = 0xabababab;
> +  Result = 0;
> +  Status = SafeUintnToUint32(Operand, &Result);
> +  UT_ASSERT_NOT_EFI_ERROR(Status);
> +  UT_ASSERT_EQUAL(0xabababab, Result);
> +
> +  return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUintnToIntn (
> +  IN UNIT_TEST_CONTEXT           Context
> +  )
> +{
> +  EFI_STATUS  Status;
> +  UINTN       Operand;
> +  INTN        Result;
> +
> +  //
> +  // If Operand is <= MAX_INTN, then it's a cast
> +  //
> +  Operand = 0x5bababab;
> +  Result = 0;
> +  Status = SafeUintnToIntn(Operand, &Result);
> +  UT_ASSERT_NOT_EFI_ERROR(Status);
> +  UT_ASSERT_EQUAL(0x5bababab, Result);
> +
> +  //
> +  // Otherwise should result in an error status
> +  //
> +  Operand = (0xabababab);
> +  Status = SafeUintnToIntn(Operand, &Result);
> +  UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> +  return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUintnToInt64 (
> +  IN UNIT_TEST_CONTEXT           Context
> +  )
> +{
> +  EFI_STATUS  Status;
> +  UINTN       Operand;
> +  INT64       Result;
> +
> +  //
> +  // UINTN is same as UINT32 in IA32, and UINT32 is a subset of
> +  // INT64, so this is just a cast
> +  //
> +  Operand = 0xabababab;
> +  Result = 0;
> +  Status = SafeUintnToInt64(Operand, &Result);
> +  UT_ASSERT_NOT_EFI_ERROR(Status);
> +  UT_ASSERT_EQUAL(0xabababab, Result);
> +
> +  return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeInt64ToIntn (
> +  IN UNIT_TEST_CONTEXT           Context
> +  )
> +{
> +  EFI_STATUS  Status;
> +  INT64       Operand;
> +  INTN        Result;
> +
> +  //
> +  // If Operand is between MIN_INTN and  MAX_INTN2 inclusive, then it's a cast
> +  //
> +  Operand = 0x5bababab;
> +  Result = 0;
> +  Status = SafeInt64ToIntn(Operand, &Result);
> +  UT_ASSERT_NOT_EFI_ERROR(Status);
> +  UT_ASSERT_EQUAL(0x5bababab, Result);
> +
> +  Operand = (-1537977259);
> +  Status = SafeInt64ToIntn(Operand, &Result);
> +  UT_ASSERT_NOT_EFI_ERROR(Status);
> +  UT_ASSERT_EQUAL((-1537977259), Result);
> +
> +  //
> +  // Otherwise should result in an error status
> +  //
> +  Operand = (0x5babababefefefef);
> +  Status = SafeInt64ToIntn(Operand, &Result);
> +  UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> +  Operand =  (-6605562033422200815);
> +  Status = SafeInt64ToIntn(Operand, &Result);
> +  UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> +  return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeInt64ToUintn (
> +  IN UNIT_TEST_CONTEXT           Context
> +  )
> +{
> +  EFI_STATUS  Status;
> +  INT64       Operand;
> +  UINTN       Result;
> +
> +  //
> +  // If Operand is between 0 and  MAX_UINTN inclusive, then it's a cast
> +  //
> +  Operand = 0xabababab;
> +  Result = 0;
> +  Status = SafeInt64ToUintn(Operand, &Result);
> +  UT_ASSERT_NOT_EFI_ERROR(Status);
> +  UT_ASSERT_EQUAL(0xabababab, Result);
> +
> +  //
> +  // Otherwise should result in an error status
> +  //
> +  Operand = (0x5babababefefefef);
> +  Status = SafeInt64ToUintn(Operand, &Result);
> +  UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> +  Operand =  (-6605562033422200815);
> +  Status = SafeInt64ToUintn(Operand, &Result);
> +  UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> +  return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUint64ToIntn (
> +  IN UNIT_TEST_CONTEXT           Context
> +  )
> +{
> +  EFI_STATUS  Status;
> +  UINT64      Operand;
> +  INTN        Result;
> +
> +  //
> +  // If Operand is <= MAX_INTN, then it's a cast
> +  //
> +  Operand = 0x5bababab;
> +  Result = 0;
> +  Status = SafeUint64ToIntn(Operand, &Result);
> +  UT_ASSERT_NOT_EFI_ERROR(Status);
> +  UT_ASSERT_EQUAL(0x5bababab, Result);
> +
> +  //
> +  // Otherwise should result in an error status
> +  //
> +  Operand = (0xababababefefefef);
> +  Status = SafeUint64ToIntn(Operand, &Result);
> +  UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> +  return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUint64ToUintn (
> +  IN UNIT_TEST_CONTEXT           Context
> +  )
> +{
> +  EFI_STATUS  Status;
> +  UINT64      Operand;
> +  UINTN       Result;
> +
> +  //
> +  // If Operand is <= MAX_UINTN, then it's a cast
> +  //
> +  Operand = 0xabababab;
> +  Result = 0;
> +  Status = SafeUint64ToUintn(Operand, &Result);
> +  UT_ASSERT_NOT_EFI_ERROR(Status);
> +  UT_ASSERT_EQUAL(0xabababab, Result);
> +
> +  //
> +  // Otherwise should result in an error status
> +  //
> +  Operand = (0xababababefefefef);
> +  Status = SafeUint64ToUintn(Operand, &Result);
> +  UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> +  return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUintnAdd (
> +  IN UNIT_TEST_CONTEXT           Context
> +  )
> +{
> +  EFI_STATUS  Status;
> +  UINTN       Augend;
> +  UINTN       Addend;
> +  UINTN       Result;
> +
> +  //
> +  // If the result of addition doesn't overflow MAX_UINTN, then it's addition
> +  //
> +  Augend = 0x3a3a3a3a;
> +  Addend = 0x3a3a3a3a;
> +  Result = 0;
> +  Status = SafeUintnAdd(Augend, Addend, &Result);
> +  UT_ASSERT_NOT_EFI_ERROR(Status);
> +  UT_ASSERT_EQUAL(0x74747474, Result);
> +
> +  //
> +  // Otherwise should result in an error status
> +  //
> +  Augend = 0xabababab;
> +  Addend = 0xbcbcbcbc;
> +  Status = SafeUintnAdd(Augend, Addend, &Result);
> +  UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> +  return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeIntnAdd (
> +  IN UNIT_TEST_CONTEXT           Context
> +  )
> +{
> +  EFI_STATUS  Status;
> +  INTN        Augend;
> +  INTN        Addend;
> +  INTN        Result;
> +
> +  //
> +  // If the result of addition doesn't overflow MAX_INTN
> +  // and doesn't underflow MIN_INTN, then it's addition
> +  //
> +  Augend = 0x3a3a3a3a;
> +  Addend = 0x3a3a3a3a;
> +  Result = 0;
> +  Status = SafeIntnAdd(Augend, Addend, &Result);
> +  UT_ASSERT_NOT_EFI_ERROR(Status);
> +  UT_ASSERT_EQUAL(0x74747474, Result);
> +
> +  Augend = (-976894522);
> +  Addend = (-976894522);
> +  Status = SafeIntnAdd(Augend, Addend, &Result);
> +  UT_ASSERT_NOT_EFI_ERROR(Status);
> +  UT_ASSERT_EQUAL((-1953789044), Result);
> +
> +  //
> +  // Otherwise should result in an error status
> +  //
> +  Augend = 0x5a5a5a5a;
> +  Addend = 0x5a5a5a5a;
> +  Status = SafeIntnAdd(Augend, Addend, &Result);
> +  UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> +  Augend = (-1515870810);
> +  Addend = (-1515870810);
> +  Status = SafeIntnAdd(Augend, Addend, &Result);
> +  UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> +  return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUintnSub (
> +  IN UNIT_TEST_CONTEXT           Context
> +  )
> +{
> +  EFI_STATUS  Status;
> +  UINTN       Minuend;
> +  UINTN       Subtrahend;
> +  UINTN       Result;
> +
> +  //
> +  // If Minuend >= Subtrahend, then it's subtraction
> +  //
> +  Minuend = 0x5a5a5a5a;
> +  Subtrahend = 0x3b3b3b3b;
> +  Result = 0;
> +  Status = SafeUintnSub(Minuend, Subtrahend, &Result);
> +  UT_ASSERT_NOT_EFI_ERROR(Status);
> +  UT_ASSERT_EQUAL(0x1f1f1f1f, Result);
> +
> +  //
> +  // Otherwise should result in an error status
> +  //
> +  Minuend = 0x5a5a5a5a;
> +  Subtrahend = 0x6d6d6d6d;
> +  Status = SafeUintnSub(Minuend, Subtrahend, &Result);
> +  UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> +  return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeIntnSub (
> +  IN UNIT_TEST_CONTEXT           Context
> +  )
> +{
> +  EFI_STATUS  Status;
> +  INTN        Minuend;
> +  INTN        Subtrahend;
> +  INTN        Result;
> +
> +  //
> +  // If the result of subtractions doesn't overflow MAX_INTN or
> +  // underflow MIN_INTN, then it's subtraction
> +  //
> +  Minuend = 0x5a5a5a5a;
> +  Subtrahend = 0x3a3a3a3a;
> +  Result = 0;
> +  Status = SafeIntnSub(Minuend, Subtrahend, &Result);
> +  UT_ASSERT_NOT_EFI_ERROR(Status);
> +  UT_ASSERT_EQUAL(0x20202020, Result);
> +
> +  Minuend = 0x3a3a3a3a;
> +  Subtrahend = 0x5a5a5a5a;
> +  Status = SafeIntnSub(Minuend, Subtrahend, &Result);
> +  UT_ASSERT_NOT_EFI_ERROR(Status);
> +  UT_ASSERT_EQUAL((-538976288), Result);
> +
> +  //
> +  // Otherwise should result in an error status
> +  //
> +  Minuend = (-2054847098);
> +  Subtrahend = 2054847098;
> +  Status = SafeIntnSub(Minuend, Subtrahend, &Result);
> +  UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> +  Minuend = (2054847098);
> +  Subtrahend = (-2054847098);
> +  Status = SafeIntnSub(Minuend, Subtrahend, &Result);
> +  UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> +  return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUintnMult (
> +  IN UNIT_TEST_CONTEXT           Context
> +  )
> +{
> +  EFI_STATUS  Status;
> +  UINTN       Multiplicand;
> +  UINTN       Multiplier;
> +  UINTN       Result;
> +
> +  //
> +  // If the result of multiplication doesn't overflow MAX_UINTN, it will succeed
> +  //
> +  Multiplicand = 0xa122a;
> +  Multiplier = 0xd23;
> +  Result = 0;
> +  Status = SafeUintnMult(Multiplicand, Multiplier, &Result);
> +  UT_ASSERT_NOT_EFI_ERROR(Status);
> +  UT_ASSERT_EQUAL(0x844c9dbe, Result);
> +
> +  //
> +  // Otherwise should result in an error status
> +  //
> +  Multiplicand = 0xa122a;
> +  Multiplier = 0xed23;
> +  Status = SafeUintnMult(Multiplicand, Multiplier, &Result);
> +  UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> +  return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeIntnMult (
> +  IN UNIT_TEST_CONTEXT           Context
> +  )
> +{
> +  EFI_STATUS  Status;
> +  INTN        Multiplicand;
> +  INTN        Multiplier;
> +  INTN        Result;
> +
> +  //
> +  // If the result of multiplication doesn't overflow MAX_INTN and doesn't
> +  // underflow MIN_UINTN, it will succeed
> +  //
> +  Multiplicand = 0x123456;
> +  Multiplier = 0x678;
> +  Result = 0;
> +  Status = SafeIntnMult(Multiplicand, Multiplier, &Result);
> +  UT_ASSERT_NOT_EFI_ERROR(Status);
> +  UT_ASSERT_EQUAL(0x75c28c50, Result);
> +
> +  //
> +  // Otherwise should result in an error status
> +  //
> +  Multiplicand = 0x123456;
> +  Multiplier = 0xabc;
> +  Status = SafeIntnMult(Multiplicand, Multiplier, &Result);
> +  UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> +  return UNIT_TEST_PASSED;
> +}
> diff --git a/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/SafeIntLibUintnIntnUnitTests64.c
> b/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/SafeIntLibUintnIntnUnitTests64.c
> new file mode 100644
> index 0000000000..0fee298172
> --- /dev/null
> +++ b/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/SafeIntLibUintnIntnUnitTests64.c
> @@ -0,0 +1,544 @@
> +/** @file
> +  x64-specific functions for unit-testing INTN and UINTN functions in
> +  SafeIntLib.
> +
> +  Copyright (c) Microsoft Corporation.<BR>
> +  Copyright (c) 2019 - 2020, Intel Corporation. All rights reserved.<BR>
> +  SPDX-License-Identifier: BSD-2-Clause-Patent
> +
> +**/
> +
> +#include "TestBaseSafeIntLib.h"
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeInt32ToUintn (
> +  IN UNIT_TEST_CONTEXT           Context
> +  )
> +{
> +  EFI_STATUS  Status;
> +  INT32       Operand;
> +  UINTN       Result;
> +
> +  //
> +  // If Operand is non-negative, then it's a cast
> +  //
> +  Operand = 0x5bababab;
> +  Result = 0;
> +  Status = SafeInt32ToUintn(Operand, &Result);
> +  UT_ASSERT_NOT_EFI_ERROR(Status);
> +  UT_ASSERT_EQUAL(0x5bababab, Result);
> +
> +  //
> +  // Otherwise should result in an error status
> +  //
> +  Operand = (-1537977259);
> +  Status = SafeInt32ToUintn(Operand, &Result);
> +  UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> +  return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUint32ToIntn (
> +  IN UNIT_TEST_CONTEXT           Context
> +  )
> +{
> +  EFI_STATUS  Status;
> +  UINT32      Operand;
> +  INTN        Result;
> +
> +  //
> +  // For x64, INTN is same as INT64 which is a superset of INT32
> +  // This is just a cast then, and it'll never fail
> +  //
> +
> +  //
> +  // If Operand is non-negative, then it's a cast
> +  //
> +  Operand = 0xabababab;
> +  Result = 0;
> +  Status = SafeUint32ToIntn(Operand, &Result);
> +  UT_ASSERT_NOT_EFI_ERROR(Status);
> +  UT_ASSERT_EQUAL(0xabababab, Result);
> +
> +  return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeIntnToInt32 (
> +  IN UNIT_TEST_CONTEXT           Context
> +  )
> +{
> +  EFI_STATUS  Status;
> +  INTN        Operand;
> +  INT32       Result;
> +
> +  //
> +  // If Operand is between MIN_INT32 and  MAX_INT32 inclusive, then it's a cast
> +  //
> +  Operand = 0x5bababab;
> +  Result = 0;
> +  Status = SafeIntnToInt32(Operand, &Result);
> +  UT_ASSERT_NOT_EFI_ERROR(Status);
> +  UT_ASSERT_EQUAL(0x5bababab, Result);
> +
> +  Operand = (-1537977259);
> +  Status = SafeIntnToInt32(Operand, &Result);
> +  UT_ASSERT_NOT_EFI_ERROR(Status);
> +  UT_ASSERT_EQUAL((-1537977259), Result);
> +
> +  //
> +  // Otherwise should result in an error status
> +  //
> +  Operand = (0x5babababefefefef);
> +  Status = SafeIntnToInt32(Operand, &Result);
> +  UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> +  Operand =  (-6605562033422200815);
> +  Status = SafeIntnToInt32(Operand, &Result);
> +  UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> +  return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeIntnToUint32 (
> +  IN UNIT_TEST_CONTEXT           Context
> +  )
> +{
> +  EFI_STATUS  Status;
> +  INTN        Operand;
> +  UINT32      Result;
> +
> +  //
> +  // If Operand is between 0 and  MAX_UINT32 inclusive, then it's a cast
> +  //
> +  Operand = 0xabababab;
> +  Result = 0;
> +  Status = SafeIntnToUint32(Operand, &Result);
> +  UT_ASSERT_NOT_EFI_ERROR(Status);
> +  UT_ASSERT_EQUAL(0xabababab, Result);
> +
> +  //
> +  // Otherwise should result in an error status
> +  //
> +  Operand = (0x5babababefefefef);
> +  Status = SafeIntnToUint32(Operand, &Result);
> +  UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> +  Operand =  (-6605562033422200815);
> +  Status = SafeIntnToUint32(Operand, &Result);
> +  UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> +  return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUintnToUint32 (
> +  IN UNIT_TEST_CONTEXT           Context
> +  )
> +{
> +  EFI_STATUS  Status;
> +  UINTN       Operand;
> +  UINT32      Result;
> +
> +  //
> +  // If Operand is <= MAX_UINT32, then it's a cast
> +  //
> +  Operand = 0xabababab;
> +  Result = 0;
> +  Status = SafeUintnToUint32(Operand, &Result);
> +  UT_ASSERT_NOT_EFI_ERROR(Status);
> +  UT_ASSERT_EQUAL(0xabababab, Result);
> +
> +  //
> +  // Otherwise should result in an error status
> +  //
> +  Operand = (0xababababefefefef);
> +  Status = SafeUintnToUint32(Operand, &Result);
> +  UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> +  return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUintnToIntn (
> +  IN UNIT_TEST_CONTEXT           Context
> +  )
> +{
> +  EFI_STATUS  Status;
> +  UINTN       Operand;
> +  INTN        Result;
> +
> +  //
> +  // If Operand is <= MAX_INTN (0x7fff_ffff_ffff_ffff), then it's a cast
> +  //
> +  Operand = 0x5babababefefefef;
> +  Result = 0;
> +  Status = SafeUintnToIntn(Operand, &Result);
> +  UT_ASSERT_NOT_EFI_ERROR(Status);
> +  UT_ASSERT_EQUAL(0x5babababefefefef, Result);
> +
> +  //
> +  // Otherwise should result in an error status
> +  //
> +  Operand = (0xababababefefefef);
> +  Status = SafeUintnToIntn(Operand, &Result);
> +  UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> +  return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUintnToInt64 (
> +  IN UNIT_TEST_CONTEXT           Context
> +  )
> +{
> +  EFI_STATUS  Status;
> +  UINTN       Operand;
> +  INT64       Result;
> +
> +  //
> +  // If Operand is <= MAX_INT64, then it's a cast
> +  //
> +  Operand = 0x5babababefefefef;
> +  Result = 0;
> +  Status = SafeUintnToInt64(Operand, &Result);
> +  UT_ASSERT_NOT_EFI_ERROR(Status);
> +  UT_ASSERT_EQUAL(0x5babababefefefef, Result);
> +
> +  //
> +  // Otherwise should result in an error status
> +  //
> +  Operand = (0xababababefefefef);
> +  Status = SafeUintnToInt64(Operand, &Result);
> +  UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> +  return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeInt64ToIntn (
> +  IN UNIT_TEST_CONTEXT           Context
> +  )
> +{
> +  EFI_STATUS  Status;
> +  INT64       Operand;
> +  INTN        Result;
> +
> +  //
> +  // INTN is same as INT64 in x64, so this is just a cast
> +  //
> +  Operand = 0x5babababefefefef;
> +  Result = 0;
> +  Status = SafeInt64ToIntn(Operand, &Result);
> +  UT_ASSERT_NOT_EFI_ERROR(Status);
> +  UT_ASSERT_EQUAL(0x5babababefefefef, Result);
> +
> +  return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeInt64ToUintn (
> +  IN UNIT_TEST_CONTEXT           Context
> +  )
> +{
> +  EFI_STATUS  Status;
> +  INT64       Operand;
> +  UINTN       Result;
> +
> +  //
> +  // If Operand is non-negative, then it's a cast
> +  //
> +  Operand = 0x5babababefefefef;
> +  Result = 0;
> +  Status = SafeInt64ToUintn(Operand, &Result);
> +  UT_ASSERT_NOT_EFI_ERROR(Status);
> +  UT_ASSERT_EQUAL(0x5babababefefefef, Result);
> +
> +  //
> +  // Otherwise should result in an error status
> +  //
> +  Operand =  (-6605562033422200815);
> +  Status = SafeInt64ToUintn(Operand, &Result);
> +  UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> +  return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUint64ToIntn (
> +  IN UNIT_TEST_CONTEXT           Context
> +  )
> +{
> +  EFI_STATUS  Status;
> +  UINT64      Operand;
> +  INTN        Result;
> +
> +  //
> +  // If Operand is <= MAX_INTN (0x7fff_ffff_ffff_ffff), then it's a cast
> +  //
> +  Operand = 0x5babababefefefef;
> +  Result = 0;
> +  Status = SafeUint64ToIntn(Operand, &Result);
> +  UT_ASSERT_NOT_EFI_ERROR(Status);
> +  UT_ASSERT_EQUAL(0x5babababefefefef, Result);
> +
> +  //
> +  // Otherwise should result in an error status
> +  //
> +  Operand = (0xababababefefefef);
> +  Status = SafeUint64ToIntn(Operand, &Result);
> +  UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> +  return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUint64ToUintn (
> +  IN UNIT_TEST_CONTEXT           Context
> +  )
> +{
> +  EFI_STATUS  Status;
> +  UINT64      Operand;
> +  UINTN       Result;
> +
> +  //
> +  // UINTN is same as UINT64 in x64, so this is just a cast
> +  //
> +  Operand = 0xababababefefefef;
> +  Result = 0;
> +  Status = SafeUint64ToUintn(Operand, &Result);
> +  UT_ASSERT_NOT_EFI_ERROR(Status);
> +  UT_ASSERT_EQUAL(0xababababefefefef, Result);
> +
> +  return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUintnAdd (
> +  IN UNIT_TEST_CONTEXT           Context
> +  )
> +{
> +  EFI_STATUS  Status;
> +  UINTN       Augend;
> +  UINTN       Addend;
> +  UINTN       Result;
> +
> +  //
> +  // If the result of addition doesn't overflow MAX_UINTN, then it's addition
> +  //
> +  Augend = 0x3a3a3a3a12121212;
> +  Addend = 0x3a3a3a3a12121212;
> +  Result = 0;
> +  Status = SafeUintnAdd(Augend, Addend, &Result);
> +  UT_ASSERT_NOT_EFI_ERROR(Status);
> +  UT_ASSERT_EQUAL(0x7474747424242424, Result);
> +
> +  //
> +  // Otherwise should result in an error status
> +  //
> +  Augend = 0xababababefefefef;
> +  Addend = 0xbcbcbcbcdededede;
> +  Status = SafeUintnAdd(Augend, Addend, &Result);
> +  UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> +  return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeIntnAdd (
> +  IN UNIT_TEST_CONTEXT           Context
> +  )
> +{
> +  EFI_STATUS  Status;
> +  INTN        Augend;
> +  INTN        Addend;
> +  INTN        Result;
> +
> +  //
> +  // If the result of addition doesn't overflow MAX_INTN
> +  // and doesn't underflow MIN_INTN, then it's addition
> +  //
> +  Augend = 0x3a3a3a3a3a3a3a3a;
> +  Addend = 0x3a3a3a3a3a3a3a3a;
> +  Result = 0;
> +  Status = SafeIntnAdd(Augend, Addend, &Result);
> +  UT_ASSERT_NOT_EFI_ERROR(Status);
> +  UT_ASSERT_EQUAL(0x7474747474747474, Result);
> +
> +  Augend = (-4195730024608447034);
> +  Addend = (-4195730024608447034);
> +  Status = SafeIntnAdd(Augend, Addend, &Result);
> +  UT_ASSERT_NOT_EFI_ERROR(Status);
> +  UT_ASSERT_EQUAL((-8391460049216894068), Result);
> +
> +  //
> +  // Otherwise should result in an error status
> +  //
> +  Augend = 0x5a5a5a5a5a5a5a5a;
> +  Addend = 0x5a5a5a5a5a5a5a5a;
> +  Status = SafeIntnAdd(Augend, Addend, &Result);
> +  UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> +  Augend = (-6510615555426900570);
> +  Addend = (-6510615555426900570);
> +  Status = SafeIntnAdd(Augend, Addend, &Result);
> +  UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> +  return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUintnSub (
> +  IN UNIT_TEST_CONTEXT           Context
> +  )
> +{
> +  EFI_STATUS  Status;
> +  UINTN       Minuend;
> +  UINTN       Subtrahend;
> +  UINTN       Result;
> +
> +  //
> +  // If Minuend >= Subtrahend, then it's subtraction
> +  //
> +  Minuend = 0x5a5a5a5a5a5a5a5a;
> +  Subtrahend = 0x3b3b3b3b3b3b3b3b;
> +  Result = 0;
> +  Status = SafeUintnSub(Minuend, Subtrahend, &Result);
> +  UT_ASSERT_NOT_EFI_ERROR(Status);
> +  UT_ASSERT_EQUAL(0x1f1f1f1f1f1f1f1f, Result);
> +
> +  //
> +  // Otherwise should result in an error status
> +  //
> +  Minuend = 0x5a5a5a5a5a5a5a5a;
> +  Subtrahend = 0x6d6d6d6d6d6d6d6d;
> +  Status = SafeUintnSub(Minuend, Subtrahend, &Result);
> +  UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> +  return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeIntnSub (
> +  IN UNIT_TEST_CONTEXT           Context
> +  )
> +{
> +  EFI_STATUS  Status;
> +  INTN        Minuend;
> +  INTN        Subtrahend;
> +  INTN        Result;
> +
> +  //
> +  // If the result of subtractions doesn't overflow MAX_INTN or
> +  // underflow MIN_INTN, then it's subtraction
> +  //
> +  Minuend = 0x5a5a5a5a5a5a5a5a;
> +  Subtrahend = 0x3a3a3a3a3a3a3a3a;
> +  Result = 0;
> +  Status = SafeIntnSub(Minuend, Subtrahend, &Result);
> +  UT_ASSERT_NOT_EFI_ERROR(Status);
> +  UT_ASSERT_EQUAL(0x2020202020202020, Result);
> +
> +  Minuend = 0x3a3a3a3a3a3a3a3a;
> +  Subtrahend = 0x5a5a5a5a5a5a5a5a;
> +  Status = SafeIntnSub(Minuend, Subtrahend, &Result);
> +  UT_ASSERT_NOT_EFI_ERROR(Status);
> +  UT_ASSERT_EQUAL((-2314885530818453536), Result);
> +
> +  //
> +  // Otherwise should result in an error status
> +  //
> +  Minuend = (-8825501086245354106);
> +  Subtrahend = 8825501086245354106;
> +  Status = SafeIntnSub(Minuend, Subtrahend, &Result);
> +  UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> +  Minuend = (8825501086245354106);
> +  Subtrahend = (-8825501086245354106);
> +  Status = SafeIntnSub(Minuend, Subtrahend, &Result);
> +  UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> +  return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUintnMult (
> +  IN UNIT_TEST_CONTEXT           Context
> +  )
> +{
> +  EFI_STATUS  Status;
> +  UINTN       Multiplicand;
> +  UINTN       Multiplier;
> +  UINTN       Result;
> +
> +  //
> +  // If the result of multiplication doesn't overflow MAX_UINTN, it will succeed
> +  //
> +  Multiplicand = 0x123456789a;
> +  Multiplier = 0x1234567;
> +  Result = 0;
> +  Status = SafeUintnMult(Multiplicand, Multiplier, &Result);
> +  UT_ASSERT_NOT_EFI_ERROR(Status);
> +  UT_ASSERT_EQUAL(0x14b66db9745a07f6, Result);
> +
> +  //
> +  // Otherwise should result in an error status
> +  //
> +  Multiplicand = 0x123456789a;
> +  Multiplier = 0x12345678;
> +  Status = SafeUintnMult(Multiplicand, Multiplier, &Result);
> +  UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> +  return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeIntnMult (
> +  IN UNIT_TEST_CONTEXT           Context
> +  )
> +{
> +  EFI_STATUS  Status;
> +  INTN        Multiplicand;
> +  INTN        Multiplier;
> +  INTN        Result;
> +
> +  //
> +  // If the result of multiplication doesn't overflow MAX_INTN and doesn't
> +  // underflow MIN_UINTN, it will succeed
> +  //
> +  Multiplicand = 0x123456789;
> +  Multiplier = 0x6789abcd;
> +  Result = 0;
> +  Status = SafeIntnMult(Multiplicand, Multiplier, &Result);
> +  UT_ASSERT_NOT_EFI_ERROR(Status);
> +  UT_ASSERT_EQUAL(0x75cd9045220d6bb5, Result);
> +
> +  //
> +  // Otherwise should result in an error status
> +  //
> +  Multiplicand = 0x123456789;
> +  Multiplier = 0xa789abcd;
> +  Status = SafeIntnMult(Multiplicand, Multiplier, &Result);
> +  UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> +  return UNIT_TEST_PASSED;
> +}
> diff --git a/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntLib.c
> b/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntLib.c
> new file mode 100644
> index 0000000000..2b1a2223a0
> --- /dev/null
> +++ b/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntLib.c
> @@ -0,0 +1,3064 @@
> +/** @file
> +  UEFI OS based application for unit testing the SafeIntLib.
> +
> +  Copyright (c) Microsoft Corporation.<BR>
> +  Copyright (c) 2018 - 2020, Intel Corporation. All rights reserved.<BR>
> +  SPDX-License-Identifier: BSD-2-Clause-Patent
> +
> +**/
> +
> +#include "TestBaseSafeIntLib.h"
> +
> +#define UNIT_TEST_NAME        "Int Safe Lib Unit Test Application"
> +#define UNIT_TEST_VERSION     "0.1"
> +
> +//
> +// Conversion function tests:
> +//
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeInt8ToUint8 (
> +  IN UNIT_TEST_CONTEXT           Context
> +  )
> +{
> +  EFI_STATUS  Status;
> +  INT8        Operand;
> +  UINT8       Result;
> +
> +  //
> +  // Positive UINT8 should result in just a cast
> +  //
> +  Operand = 0x5b;
> +  Result = 0;
> +  Status = SafeInt8ToUint8(Operand, &Result);
> +  UT_ASSERT_NOT_EFI_ERROR(Status);
> +  UT_ASSERT_EQUAL(0x5b, Result);
> +
> +  //
> +  // Negative number should result in an error status
> +  //
> +  Operand = (-56);
> +  Status = SafeInt8ToUint8(Operand, &Result);
> +  UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> +  return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeInt8ToUint16 (
> +  IN UNIT_TEST_CONTEXT           Context
> +  )
> +{
> +  EFI_STATUS  Status;
> +  INT8        Operand;
> +  UINT16      Result;
> +
> +  //
> +  // Positive UINT8 should result in just a cast
> +  //
> +  Operand = 0x5b;
> +  Result = 0;
> +  Status = SafeInt8ToUint16(Operand, &Result);
> +  UT_ASSERT_NOT_EFI_ERROR(Status);
> +  UT_ASSERT_EQUAL(0x5b, Result);
> +
> +  //
> +  // Negative number should result in an error status
> +  //
> +  Operand = (-56);
> +  Status = SafeInt8ToUint16(Operand, &Result);
> +  UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> +  return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeInt8ToUint32 (
> +  IN UNIT_TEST_CONTEXT           Context
> +  )
> +{
> +  EFI_STATUS  Status;
> +  INT8        Operand;
> +  UINT32      Result;
> +
> +  //
> +  // Positive UINT8 should result in just a cast
> +  //
> +  Operand = 0x5b;
> +  Result = 0;
> +  Status = SafeInt8ToUint32(Operand, &Result);
> +  UT_ASSERT_NOT_EFI_ERROR(Status);
> +  UT_ASSERT_EQUAL(0x5b, Result);
> +
> +  //
> +  // Negative number should result in an error status
> +  //
> +  Operand = (-56);
> +  Status = SafeInt8ToUint32(Operand, &Result);
> +  UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> +  return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeInt8ToUintn (
> +  IN UNIT_TEST_CONTEXT           Context
> +  )
> +{
> +  EFI_STATUS  Status;
> +  INT8        Operand;
> +  UINTN       Result;
> +
> +  //
> +  // Positive UINT8 should result in just a cast
> +  //
> +  Operand = 0x5b;
> +  Result = 0;
> +  Status = SafeInt8ToUintn(Operand, &Result);
> +  UT_ASSERT_NOT_EFI_ERROR(Status);
> +  UT_ASSERT_EQUAL(0x5b, Result);
> +
> +  //
> +  // Negative number should result in an error status
> +  //
> +  Operand = (-56);
> +  Status = SafeInt8ToUintn(Operand, &Result);
> +  UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> +  return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeInt8ToUint64 (
> +  IN UNIT_TEST_CONTEXT           Context
> +  )
> +{
> +  EFI_STATUS  Status;
> +  INT8        Operand;
> +  UINT64      Result;
> +
> +  //
> +  // Positive UINT8 should result in just a cast
> +  //
> +  Operand = 0x5b;
> +  Result = 0;
> +  Status = SafeInt8ToUint64(Operand, &Result);
> +  UT_ASSERT_NOT_EFI_ERROR(Status);
> +  UT_ASSERT_EQUAL(0x5b, Result);
> +
> +  //
> +  // Negative number should result in an error status
> +  //
> +  Operand = (-56);
> +  Status = SafeInt8ToUint64(Operand, &Result);
> +  UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> +  return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUint8ToInt8 (
> +  IN UNIT_TEST_CONTEXT           Context
> +  )
> +{
> +  EFI_STATUS  Status;
> +  UINT8       Operand;
> +  INT8        Result;
> +
> +  //
> +  // Operand <= 0x7F (MAX_INT8) should result in a cast
> +  //
> +  Operand = 0x5b;
> +  Result = 0;
> +  Status = SafeUint8ToInt8(Operand, &Result);
> +  UT_ASSERT_NOT_EFI_ERROR(Status);
> +  UT_ASSERT_EQUAL(0x5b, Result);
> +
> +  //
> +  // Operand larger than 0x7f should result in an error status
> +  //
> +  Operand = 0xaf;
> +  Status = SafeUint8ToInt8(Operand, &Result);
> +  UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> +  return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUint8ToChar8 (
> +  IN UNIT_TEST_CONTEXT           Context
> +  )
> +{
> +  EFI_STATUS  Status;
> +  UINT8       Operand;
> +  CHAR8       Result;
> +
> +  //
> +  // CHAR8 is typedefed as char, which by default is signed, thus
> +  // CHAR8 is same as INT8, so same tests as above:
> +  //
> +
> +  //
> +  // Operand <= 0x7F (MAX_INT8) should result in a cast
> +  //
> +  Operand = 0x5b;
> +  Result = 0;
> +  Status = SafeUint8ToChar8(Operand, &Result);
> +  UT_ASSERT_NOT_EFI_ERROR(Status);
> +  UT_ASSERT_EQUAL(0x5b, Result);
> +
> +  //
> +  // Operand larger than 0x7f should result in an error status
> +  //
> +  Operand = 0xaf;
> +  Status = SafeUint8ToChar8(Operand, &Result);
> +  UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> +  return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeInt16ToInt8 (
> +  IN UNIT_TEST_CONTEXT           Context
> +  )
> +{
> +  EFI_STATUS  Status;
> +  INT16       Operand;
> +  INT8        Result;
> +
> +  //
> +  // If Operand is between MIN_INT8 and MAX_INT8 inclusive, then it's a cast
> +  //
> +  Operand = 0x5b;
> +  Result = 0;
> +  Status = SafeInt16ToInt8(Operand, &Result);
> +  UT_ASSERT_NOT_EFI_ERROR(Status);
> +  UT_ASSERT_EQUAL(0x5b, Result);
> +
> +  Operand = (-35);
> +  Status = SafeInt16ToInt8(Operand, &Result);
> +  UT_ASSERT_NOT_EFI_ERROR(Status);
> +  UT_ASSERT_EQUAL((-35), Result);
> +
> +  //
> +  // Otherwise should result in an error status
> +  //
> +  Operand = 0x1234;
> +  Status = SafeInt16ToInt8(Operand, &Result);
> +  UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> +  Operand = (-17835);
> +  Status = SafeInt16ToInt8(Operand, &Result);
> +  UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> +  return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeInt16ToChar8 (
> +  IN UNIT_TEST_CONTEXT           Context
> +  )
> +{
> +  EFI_STATUS  Status;
> +  INT16       Operand;
> +  CHAR8       Result;
> +
> +  //
> +  // CHAR8 is typedefed as char, which may be signed or unsigned based
> +  // on the compiler. Thus, for compatibility CHAR8 should be between 0 and MAX_INT8.
> +  //
> +
> +  //
> +  // If Operand is between 0 and MAX_INT8 inclusive, then it's a cast
> +  //
> +  Operand = 0x5b;
> +  Result = 0;
> +  Status = SafeInt16ToChar8(Operand, &Result);
> +  UT_ASSERT_NOT_EFI_ERROR(Status);
> +  UT_ASSERT_EQUAL(0x5b, Result);
> +
> +  Operand = 0;
> +  Result = 0;
> +  Status = SafeInt16ToChar8(Operand, &Result);
> +  UT_ASSERT_NOT_EFI_ERROR(Status);
> +  UT_ASSERT_EQUAL(0, Result);
> +
> +  Operand = MAX_INT8;
> +  Result = 0;
> +  Status = SafeInt16ToChar8(Operand, &Result);
> +  UT_ASSERT_NOT_EFI_ERROR(Status);
> +  UT_ASSERT_EQUAL(MAX_INT8, Result);
> +
> +  //
> +  // Otherwise should result in an error status
> +  //
> +  Operand = (-35);
> +  Status = SafeInt16ToChar8(Operand, &Result);
> +  UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> +  Operand = 0x1234;
> +  Status = SafeInt16ToChar8(Operand, &Result);
> +  UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> +  Operand = (-17835);
> +  Status = SafeInt16ToChar8(Operand, &Result);
> +  UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> +  return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeInt16ToUint8 (
> +  IN UNIT_TEST_CONTEXT           Context
> +  )
> +{
> +  EFI_STATUS  Status;
> +  INT16       Operand;
> +  UINT8       Result;
> +
> +  //
> +  // If Operand is between 0 and MAX_INT8 inclusive, then it's a cast
> +  //
> +  Operand = 0x5b;
> +  Result = 0;
> +  Status = SafeInt16ToUint8(Operand, &Result);
> +  UT_ASSERT_NOT_EFI_ERROR(Status);
> +  UT_ASSERT_EQUAL(0x5b, Result);
> +
> +  //
> +  // Otherwise should result in an error status
> +  //
> +  Operand = 0x1234;
> +  Status = SafeInt16ToUint8(Operand, &Result);
> +  UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> +  Operand = (-17835);
> +  Status = SafeInt16ToUint8(Operand, &Result);
> +  UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> +  return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeInt16ToUint16 (
> +  IN UNIT_TEST_CONTEXT           Context
> +  )
> +{
> +  EFI_STATUS  Status;
> +  INT16 Operand = 0x5b5b;
> +  UINT16 Result = 0;
> +
> +  //
> +  // If Operand is non-negative, then it's a cast
> +  //
> +  Status = SafeInt16ToUint16(Operand, &Result);
> +  UT_ASSERT_NOT_EFI_ERROR(Status);
> +  UT_ASSERT_EQUAL(0x5b5b, Result);
> +
> +  //
> +  // Otherwise should result in an error status
> +  //
> +  Operand = (-17835);
> +  Status = SafeInt16ToUint16(Operand, &Result);
> +  UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> +  return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeInt16ToUint32 (
> +  IN UNIT_TEST_CONTEXT           Context
> +  )
> +{
> +  EFI_STATUS  Status;
> +  INT16       Operand;
> +  UINT32      Result;
> +
> +  //
> +  // If Operand is non-negative, then it's a cast
> +  //
> +  Operand = 0x5b5b;
> +  Result = 0;
> +  Status = SafeInt16ToUint32(Operand, &Result);
> +  UT_ASSERT_NOT_EFI_ERROR(Status);
> +  UT_ASSERT_EQUAL(0x5b5b, Result);
> +
> +  //
> +  // Otherwise should result in an error status
> +  //
> +  Operand = (-17835);
> +  Status = SafeInt16ToUint32(Operand, &Result);
> +  UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> +  return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeInt16ToUintn (
> +  IN UNIT_TEST_CONTEXT           Context
> +  )
> +{
> +  EFI_STATUS  Status;
> +  INT16       Operand;
> +  UINTN       Result;
> +
> +  //
> +  // If Operand is non-negative, then it's a cast
> +  //
> +  Operand = 0x5b5b;
> +  Result = 0;
> +  Status = SafeInt16ToUintn(Operand, &Result);
> +  UT_ASSERT_NOT_EFI_ERROR(Status);
> +  UT_ASSERT_EQUAL(0x5b5b, Result);
> +
> +  //
> +  // Otherwise should result in an error status
> +  //
> +  Operand = (-17835);
> +  Status = SafeInt16ToUintn(Operand, &Result);
> +  UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> +  return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeInt16ToUint64 (
> +  IN UNIT_TEST_CONTEXT           Context
> +  )
> +{
> +  EFI_STATUS  Status;
> +  INT16       Operand;
> +  UINT64      Result;
> +
> +  //
> +  // If Operand is non-negative, then it's a cast
> +  //
> +  Operand = 0x5b5b;
> +  Result = 0;
> +  Status = SafeInt16ToUint64(Operand, &Result);
> +  UT_ASSERT_NOT_EFI_ERROR(Status);
> +  UT_ASSERT_EQUAL(0x5b5b, Result);
> +
> +  //
> +  // Otherwise should result in an error status
> +  //
> +  Operand = (-17835);
> +  Status = SafeInt16ToUint64(Operand, &Result);
> +  UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> +  return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUint16ToInt8 (
> +  IN UNIT_TEST_CONTEXT           Context
> +  )
> +{
> +  EFI_STATUS  Status;
> +  UINT16      Operand;
> +  INT8        Result;
> +
> +  //
> +  // If Operand is <= MAX_INT8, it's a cast
> +  //
> +  Operand = 0x5b;
> +  Result = 0;
> +  Status = SafeUint16ToInt8(Operand, &Result);
> +  UT_ASSERT_NOT_EFI_ERROR(Status);
> +  UT_ASSERT_EQUAL(0x5b, Result);
> +
> +  //
> +  // Otherwise should result in an error status
> +  //
> +  Operand = (0x5b5b);
> +  Status = SafeUint16ToInt8(Operand, &Result);
> +  UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> +  return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUint16ToChar8 (
> +  IN UNIT_TEST_CONTEXT           Context
> +  )
> +{
> +  EFI_STATUS  Status;
> +  UINT16      Operand;
> +  CHAR8       Result;
> +
> +  // CHAR8 is typedefed as char, which by default is signed, thus
> +  // CHAR8 is same as INT8, so same tests as above:
> +
> +  //
> +  // If Operand is <= MAX_INT8, it's a cast
> +  //
> +  Operand = 0x5b;
> +  Result = 0;
> +  Status = SafeUint16ToChar8(Operand, &Result);
> +  UT_ASSERT_NOT_EFI_ERROR(Status);
> +  UT_ASSERT_EQUAL(0x5b, Result);
> +
> +  //
> +  // Otherwise should result in an error status
> +  //
> +  Operand = (0x5b5b);
> +  Status = SafeUint16ToChar8(Operand, &Result);
> +  UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> +  return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUint16ToUint8 (
> +  IN UNIT_TEST_CONTEXT           Context
> +  )
> +{
> +  EFI_STATUS  Status;
> +  UINT16      Operand;
> +  UINT8       Result;
> +
> +  //
> +  // If Operand is <= MAX_UINT8 (0xff), it's a cast
> +  //
> +  Operand = 0xab;
> +  Result = 0;
> +  Status = SafeUint16ToUint8(Operand, &Result);
> +  UT_ASSERT_NOT_EFI_ERROR(Status);
> +  UT_ASSERT_EQUAL(0xab, Result);
> +
> +  //
> +  // Otherwise should result in an error status
> +  //
> +  Operand = (0x5b5b);
> +  Status = SafeUint16ToUint8(Operand, &Result);
> +  UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> +  return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUint16ToInt16 (
> +  IN UNIT_TEST_CONTEXT           Context
> +  )
> +{
> +  EFI_STATUS  Status;
> +  UINT16      Operand;
> +  INT16       Result;
> +
> +  //
> +  // If Operand is <= MAX_INT16 (0x7fff), it's a cast
> +  //
> +  Operand = 0x5b5b;
> +  Result = 0;
> +  Status = SafeUint16ToInt16(Operand, &Result);
> +  UT_ASSERT_NOT_EFI_ERROR(Status);
> +  UT_ASSERT_EQUAL(0x5b5b, Result);
> +
> +  //
> +  // Otherwise should result in an error status
> +  //
> +  Operand = (0xabab);
> +  Status = SafeUint16ToInt16(Operand, &Result);
> +  UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> +  return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeInt32ToInt8 (
> +  IN UNIT_TEST_CONTEXT           Context
> +  )
> +{
> +  EFI_STATUS  Status;
> +  INT32       Operand;
> +  INT8        Result;
> +
> +  //
> +  // If Operand is between MIN_INT8 and MAX_INT8 inclusive, then it's a cast
> +  //
> +  Operand = 0x5b;
> +  Result = 0;
> +  Status = SafeInt32ToInt8(Operand, &Result);
> +  UT_ASSERT_NOT_EFI_ERROR(Status);
> +  UT_ASSERT_EQUAL(0x5b, Result);
> +
> +  Operand = (-57);
> +  Status = SafeInt32ToInt8(Operand, &Result);
> +  UT_ASSERT_NOT_EFI_ERROR(Status);
> +  UT_ASSERT_EQUAL((-57), Result);
> +
> +  //
> +  // Otherwise should result in an error status
> +  //
> +  Operand = (0x5bababab);
> +  Status = SafeInt32ToInt8(Operand, &Result);
> +  UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> +  Operand = (-1537977259);
> +  Status = SafeInt32ToInt8(Operand, &Result);
> +  UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> +  return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeInt32ToChar8 (
> +  IN UNIT_TEST_CONTEXT           Context
> +  )
> +{
> +  EFI_STATUS  Status;
> +  INT32       Operand;
> +  CHAR8       Result;
> +
> +  //
> +  // CHAR8 is typedefed as char, which may be signed or unsigned based
> +  // on the compiler. Thus, for compatibility CHAR8 should be between 0 and MAX_INT8.
> +  //
> +
> +  //
> +  // If Operand is between 0 and MAX_INT8 inclusive, then it's a cast
> +  //
> +  Operand = 0x5b;
> +  Result = 0;
> +  Status = SafeInt32ToChar8(Operand, &Result);
> +  UT_ASSERT_NOT_EFI_ERROR(Status);
> +  UT_ASSERT_EQUAL(0x5b, Result);
> +
> +  Operand = 0;
> +  Result = 0;
> +  Status = SafeInt32ToChar8(Operand, &Result);
> +  UT_ASSERT_NOT_EFI_ERROR(Status);
> +  UT_ASSERT_EQUAL(0, Result);
> +
> +  Operand = MAX_INT8;
> +  Result = 0;
> +  Status = SafeInt32ToChar8(Operand, &Result);
> +  UT_ASSERT_NOT_EFI_ERROR(Status);
> +  UT_ASSERT_EQUAL(MAX_INT8, Result);
> +
> +  //
> +  // Otherwise should result in an error status
> +  //
> +  Operand = (-57);
> +  Status = SafeInt32ToChar8(Operand, &Result);
> +  UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> +  Operand = (0x5bababab);
> +  Status = SafeInt32ToChar8(Operand, &Result);
> +  UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> +  Operand = (-1537977259);
> +  Status = SafeInt32ToChar8(Operand, &Result);
> +  UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> +  return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeInt32ToUint8 (
> +  IN UNIT_TEST_CONTEXT           Context
> +  )
> +{
> +  EFI_STATUS  Status;
> +  INT32       Operand;
> +  UINT8       Result;
> +
> +  //
> +  // If Operand is between 0 and MAX_INT8 inclusive, then it's a cast
> +  //
> +  Operand = 0x5b;
> +  Result = 0;
> +  Status = SafeInt32ToUint8(Operand, &Result);
> +  UT_ASSERT_NOT_EFI_ERROR(Status);
> +  UT_ASSERT_EQUAL(0x5b, Result);
> +
> +  //
> +  // Otherwise should result in an error status
> +  //
> +  Operand = (-57);
> +  Status = SafeInt32ToUint8(Operand, &Result);
> +  UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> +  Operand = (0x5bababab);
> +  Status = SafeInt32ToUint8(Operand, &Result);
> +  UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> +  Operand = (-1537977259);
> +  Status = SafeInt32ToUint8(Operand, &Result);
> +  UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> +  return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeInt32ToInt16 (
> +  IN UNIT_TEST_CONTEXT           Context
> +  )
> +{
> +  EFI_STATUS  Status;
> +  INT32       Operand;
> +  INT16       Result;
> +
> +  //
> +  // If Operand is between MIN_INT16 and MAX_INT16 inclusive, then it's a cast
> +  //
> +  Operand = 0x5b5b;
> +  Result = 0;
> +  Status = SafeInt32ToInt16(Operand, &Result);
> +  UT_ASSERT_NOT_EFI_ERROR(Status);
> +  UT_ASSERT_EQUAL(0x5b5b, Result);
> +
> +  Operand = (-17857);
> +  Status = SafeInt32ToInt16(Operand, &Result);
> +  UT_ASSERT_NOT_EFI_ERROR(Status);
> +  UT_ASSERT_EQUAL((-17857), Result);
> +
> +  //
> +  // Otherwise should result in an error status
> +  //
> +  Operand = (0x5bababab);
> +  Status = SafeInt32ToInt16(Operand, &Result);
> +  UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> +  Operand = (-1537977259);
> +  Status = SafeInt32ToInt16(Operand, &Result);
> +  UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> +  return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeInt32ToUint16 (
> +  IN UNIT_TEST_CONTEXT           Context
> +  )
> +{
> +  EFI_STATUS  Status;
> +  INT32       Operand;
> +  UINT16      Result;
> +
> +  //
> +  // If Operand is between 0 and MAX_UINT16 inclusive, then it's a cast
> +  //
> +  Operand = 0xabab;
> +  Result = 0;
> +  Status = SafeInt32ToUint16(Operand, &Result);
> +  UT_ASSERT_NOT_EFI_ERROR(Status);
> +  UT_ASSERT_EQUAL(0xabab, Result);
> +
> +  //
> +  // Otherwise should result in an error status
> +  //
> +  Operand = (-17857);
> +  Status = SafeInt32ToUint16(Operand, &Result);
> +  UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> +  Operand = (0x5bababab);
> +  Status = SafeInt32ToUint16(Operand, &Result);
> +  UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> +  Operand = (-1537977259);
> +  Status = SafeInt32ToUint16(Operand, &Result);
> +  UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> +  return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeInt32ToUint32 (
> +  IN UNIT_TEST_CONTEXT           Context
> +  )
> +{
> +  EFI_STATUS  Status;
> +  INT32       Operand;
> +  UINT32      Result;
> +
> +  //
> +  // If Operand is non-negative, then it's a cast
> +  //
> +  Operand = 0x5bababab;
> +  Result = 0;
> +  Status = SafeInt32ToUint32(Operand, &Result);
> +  UT_ASSERT_NOT_EFI_ERROR(Status);
> +  UT_ASSERT_EQUAL(0x5bababab, Result);
> +
> +  //
> +  // Otherwise should result in an error status
> +  //
> +  Operand = (-1537977259);
> +  Status = SafeInt32ToUint32(Operand, &Result);
> +  UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> +  return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeInt32ToUint64 (
> +  IN UNIT_TEST_CONTEXT           Context
> +  )
> +{
> +  EFI_STATUS  Status;
> +  INT32       Operand;
> +  UINT64      Result;
> +
> +  //
> +  // If Operand is non-negative, then it's a cast
> +  //
> +  Operand = 0x5bababab;
> +  Result = 0;
> +  Status = SafeInt32ToUint64(Operand, &Result);
> +  UT_ASSERT_NOT_EFI_ERROR(Status);
> +  UT_ASSERT_EQUAL(0x5bababab, Result);
> +
> +  //
> +  // Otherwise should result in an error status
> +  //
> +  Operand = (-1537977259);
> +  Status = SafeInt32ToUint64(Operand, &Result);
> +  UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> +  return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUint32ToInt8 (
> +  IN UNIT_TEST_CONTEXT           Context
> +  )
> +{
> +  EFI_STATUS  Status;
> +  UINT32      Operand;
> +  INT8        Result;
> +
> +  //
> +  // If Operand is <= MAX_INT8, then it's a cast
> +  //
> +  Operand = 0x5b;
> +  Result = 0;
> +  Status = SafeUint32ToInt8(Operand, &Result);
> +  UT_ASSERT_NOT_EFI_ERROR(Status);
> +  UT_ASSERT_EQUAL(0x5b, Result);
> +
> +  //
> +  // Otherwise should result in an error status
> +  //
> +  Operand = (0x5bababab);
> +  Status = SafeUint32ToInt8(Operand, &Result);
> +  UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> +  return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUint32ToChar8 (
> +  IN UNIT_TEST_CONTEXT           Context
> +  )
> +{
> +  EFI_STATUS  Status;
> +  UINT32      Operand;
> +  CHAR8       Result;
> +
> +  // CHAR8 is typedefed as char, which by default is signed, thus
> +  // CHAR8 is same as INT8, so same tests as above:
> +
> +  //
> +  // If Operand is <= MAX_INT8, then it's a cast
> +  //
> +  Operand = 0x5b;
> +  Result = 0;
> +  Status = SafeUint32ToChar8(Operand, &Result);
> +  UT_ASSERT_NOT_EFI_ERROR(Status);
> +  UT_ASSERT_EQUAL(0x5b, Result);
> +
> +  //
> +  // Otherwise should result in an error status
> +  //
> +  Operand = (0x5bababab);
> +  Status = SafeUint32ToChar8(Operand, &Result);
> +  UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> +  return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUint32ToUint8 (
> +  IN UNIT_TEST_CONTEXT           Context
> +  )
> +{
> +  EFI_STATUS  Status;
> +  UINT32      Operand;
> +  UINT8       Result;
> +
> +  //
> +  // If Operand is <= MAX_UINT8, then it's a cast
> +  //
> +  Operand = 0xab;
> +  Result = 0;
> +  Status = SafeUint32ToUint8(Operand, &Result);
> +  UT_ASSERT_NOT_EFI_ERROR(Status);
> +  UT_ASSERT_EQUAL(0xab, Result);
> +
> +  //
> +  // Otherwise should result in an error status
> +  //
> +  Operand = (0xabababab);
> +  Status = SafeUint32ToUint8(Operand, &Result);
> +  UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> +  return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUint32ToInt16 (
> +  IN UNIT_TEST_CONTEXT           Context
> +  )
> +{
> +  EFI_STATUS  Status;
> +  UINT32      Operand;
> +  INT16       Result;
> +
> +  //
> +  // If Operand is <= MAX_INT16, then it's a cast
> +  //
> +  Operand = 0x5bab;
> +  Result = 0;
> +  Status = SafeUint32ToInt16(Operand, &Result);
> +  UT_ASSERT_NOT_EFI_ERROR(Status);
> +  UT_ASSERT_EQUAL(0x5bab, Result);
> +
> +  //
> +  // Otherwise should result in an error status
> +  //
> +  Operand = (0xabababab);
> +  Status = SafeUint32ToInt16(Operand, &Result);
> +  UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> +  return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUint32ToUint16 (
> +  IN UNIT_TEST_CONTEXT           Context
> +  )
> +{
> +  EFI_STATUS  Status;
> +  UINT32      Operand;
> +  UINT16      Result;
> +
> +  //
> +  // If Operand is <= MAX_UINT16, then it's a cast
> +  //
> +  Operand = 0xabab;
> +  Result = 0;
> +  Status = SafeUint32ToUint16(Operand, &Result);
> +  UT_ASSERT_NOT_EFI_ERROR(Status);
> +  UT_ASSERT_EQUAL(0xabab, Result);
> +
> +  //
> +  // Otherwise should result in an error status
> +  //
> +  Operand = (0xabababab);
> +  Status = SafeUint32ToUint16(Operand, &Result);
> +  UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> +  return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUint32ToInt32 (
> +  IN UNIT_TEST_CONTEXT           Context
> +  )
> +{
> +  EFI_STATUS  Status;
> +  UINT32      Operand;
> +  INT32       Result;
> +
> +  //
> +  // If Operand is <= MAX_INT32, then it's a cast
> +  //
> +  Operand = 0x5bababab;
> +  Result = 0;
> +  Status = SafeUint32ToInt32(Operand, &Result);
> +  UT_ASSERT_NOT_EFI_ERROR(Status);
> +  UT_ASSERT_EQUAL(0x5bababab, Result);
> +
> +  //
> +  // Otherwise should result in an error status
> +  //
> +  Operand = (0xabababab);
> +  Status = SafeUint32ToInt32(Operand, &Result);
> +  UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> +  return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeIntnToInt8 (
> +  IN UNIT_TEST_CONTEXT           Context
> +  )
> +{
> +  EFI_STATUS  Status;
> +  INTN        Operand;
> +  INT8        Result;
> +
> +  //
> +  // If Operand is between MIN_INT8 and MAX_INT8 inclusive, then it's a cast
> +  //
> +  Operand = 0x5b;
> +  Result = 0;
> +  Status = SafeIntnToInt8(Operand, &Result);
> +  UT_ASSERT_NOT_EFI_ERROR(Status);
> +  UT_ASSERT_EQUAL(0x5b, Result);
> +
> +  Operand = (-53);
> +  Status = SafeIntnToInt8(Operand, &Result);
> +  UT_ASSERT_NOT_EFI_ERROR(Status);
> +  UT_ASSERT_EQUAL((-53), Result);
> +
> +  //
> +  // Otherwise should result in an error status
> +  //
> +  Operand = (0x5bababab);
> +  Status = SafeIntnToInt8(Operand, &Result);
> +  UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> +  Operand = (-1537977259);
> +  Status = SafeIntnToInt8(Operand, &Result);
> +  UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> +  return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeIntnToChar8 (
> +  IN UNIT_TEST_CONTEXT           Context
> +  )
> +{
> +  EFI_STATUS  Status;
> +  INTN        Operand;
> +  CHAR8       Result;
> +
> +  //
> +  // CHAR8 is typedefed as char, which may be signed or unsigned based
> +  // on the compiler. Thus, for compatibility CHAR8 should be between 0 and MAX_INT8.
> +  //
> +
> +  //
> +  // If Operand is between MIN_INT8 and MAX_INT8 inclusive, then it's a cast
> +  //
> +  Operand = 0x5b;
> +  Result = 0;
> +  Status = SafeIntnToChar8(Operand, &Result);
> +  UT_ASSERT_NOT_EFI_ERROR(Status);
> +  UT_ASSERT_EQUAL(0x5b, Result);
> +
> +  Operand = 0;
> +  Result = 0;
> +  Status = SafeIntnToChar8(Operand, &Result);
> +  UT_ASSERT_NOT_EFI_ERROR(Status);
> +  UT_ASSERT_EQUAL(0, Result);
> +
> +  Operand = MAX_INT8;
> +  Result = 0;
> +  Status = SafeIntnToChar8(Operand, &Result);
> +  UT_ASSERT_NOT_EFI_ERROR(Status);
> +  UT_ASSERT_EQUAL(MAX_INT8, Result);
> +
> +  //
> +  // Otherwise should result in an error status
> +  //
> +  Operand = (-53);
> +  Status = SafeIntnToChar8(Operand, &Result);
> +  UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> +  Operand = (0x5bababab);
> +  Status = SafeIntnToChar8(Operand, &Result);
> +  UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> +  Operand = (-1537977259);
> +  Status = SafeIntnToChar8(Operand, &Result);
> +  UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> +  return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeIntnToUint8 (
> +  IN UNIT_TEST_CONTEXT           Context
> +  )
> +{
> +  EFI_STATUS  Status;
> +  INTN        Operand;
> +  UINT8       Result;
> +
> +  //
> +  // If Operand is between 0 and MAX_UINT8 inclusive, then it's a cast
> +  //
> +  Operand = 0xab;
> +  Result = 0;
> +  Status = SafeIntnToUint8(Operand, &Result);
> +  UT_ASSERT_NOT_EFI_ERROR(Status);
> +  UT_ASSERT_EQUAL(0xab, Result);
> +
> +  //
> +  // Otherwise should result in an error status
> +  //
> +  Operand = (0x5bababab);
> +  Status = SafeIntnToUint8(Operand, &Result);
> +  UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> +  Operand = (-1537977259);
> +  Status = SafeIntnToUint8(Operand, &Result);
> +  UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> +  return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeIntnToInt16 (
> +  IN UNIT_TEST_CONTEXT           Context
> +  )
> +{
> +  EFI_STATUS  Status;
> +  INTN        Operand;
> +  INT16       Result;
> +
> +  //
> +  // If Operand is between MIN_INT16 and MAX_INT16 inclusive, then it's a cast
> +  //
> +  Operand = 0x5bab;
> +  Result = 0;
> +  Status = SafeIntnToInt16(Operand, &Result);
> +  UT_ASSERT_NOT_EFI_ERROR(Status);
> +  UT_ASSERT_EQUAL(0x5bab, Result);
> +
> +  Operand = (-23467);
> +  Status = SafeIntnToInt16(Operand, &Result);
> +  UT_ASSERT_NOT_EFI_ERROR(Status);
> +  UT_ASSERT_EQUAL((-23467), Result);
> +
> +  //
> +  // Otherwise should result in an error status
> +  //
> +  Operand = (0x5bababab);
> +  Status = SafeIntnToInt16(Operand, &Result);
> +  UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> +  Operand = (-1537977259);
> +  Status = SafeIntnToInt16(Operand, &Result);
> +  UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> +  return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeIntnToUint16 (
> +  IN UNIT_TEST_CONTEXT           Context
> +  )
> +{
> +  EFI_STATUS  Status;
> +  INTN        Operand;
> +  UINT16      Result;
> +
> +  //
> +  // If Operand is between 0 and MAX_UINT16 inclusive, then it's a cast
> +  //
> +  Operand = 0xabab;
> +  Result = 0;
> +  Status = SafeIntnToUint16(Operand, &Result);
> +  UT_ASSERT_NOT_EFI_ERROR(Status);
> +  UT_ASSERT_EQUAL(0xabab, Result);
> +
> +  //
> +  // Otherwise should result in an error status
> +  //
> +  Operand = (0x5bababab);
> +  Status = SafeIntnToUint16(Operand, &Result);
> +  UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> +  Operand = (-1537977259);
> +  Status = SafeIntnToUint16(Operand, &Result);
> +  UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> +  return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeIntnToUintn (
> +  IN UNIT_TEST_CONTEXT           Context
> +  )
> +{
> +  EFI_STATUS  Status;
> +  INTN        Operand;
> +  UINTN       Result;
> +
> +  //
> +  // If Operand is non-negative, then it's a cast
> +  //
> +  Operand = 0x5bababab;
> +  Result = 0;
> +  Status = SafeIntnToUintn(Operand, &Result);
> +  UT_ASSERT_NOT_EFI_ERROR(Status);
> +  UT_ASSERT_EQUAL(0x5bababab, Result);
> +
> +  //
> +  // Otherwise should result in an error status
> +  //
> +  Operand = (-1537977259);
> +  Status = SafeIntnToUintn(Operand, &Result);
> +  UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> +  return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeIntnToUint64 (
> +  IN UNIT_TEST_CONTEXT           Context
> +  )
> +{
> +  EFI_STATUS  Status;
> +  INTN        Operand;
> +  UINT64      Result;
> +
> +  //
> +  // If Operand is non-negative, then it's a cast
> +  //
> +  Operand = 0x5bababab;
> +  Result = 0;
> +  Status = SafeIntnToUint64(Operand, &Result);
> +  UT_ASSERT_NOT_EFI_ERROR(Status);
> +  UT_ASSERT_EQUAL(0x5bababab, Result);
> +
> +  //
> +  // Otherwise should result in an error status
> +  //
> +  Operand = (-1537977259);
> +  Status = SafeIntnToUint64(Operand, &Result);
> +  UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> +  return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUintnToInt8 (
> +  IN UNIT_TEST_CONTEXT           Context
> +  )
> +{
> +  EFI_STATUS  Status;
> +  UINTN       Operand;
> +  INT8        Result;
> +
> +  //
> +  // If Operand is <= MAX_INT8, then it's a cast
> +  //
> +  Operand = 0x5b;
> +  Result = 0;
> +  Status = SafeUintnToInt8(Operand, &Result);
> +  UT_ASSERT_NOT_EFI_ERROR(Status);
> +  UT_ASSERT_EQUAL(0x5b, Result);
> +
> +  //
> +  // Otherwise should result in an error status
> +  //
> +  Operand = (0xabab);
> +  Status = SafeUintnToInt8(Operand, &Result);
> +  UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> +  return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUintnToChar8 (
> +  IN UNIT_TEST_CONTEXT           Context
> +  )
> +{
> +  EFI_STATUS  Status;
> +  UINTN       Operand;
> +  CHAR8       Result;
> +
> +  // CHAR8 is typedefed as char, which by default is signed, thus
> +  // CHAR8 is same as INT8, so same tests as above:
> +
> +  //
> +  // If Operand is <= MAX_INT8, then it's a cast
> +  //
> +  Operand = 0x5b;
> +  Result = 0;
> +  Status = SafeUintnToChar8(Operand, &Result);
> +  UT_ASSERT_NOT_EFI_ERROR(Status);
> +  UT_ASSERT_EQUAL(0x5b, Result);
> +
> +  //
> +  // Otherwise should result in an error status
> +  //
> +  Operand = (0xabab);
> +  Status = SafeUintnToChar8(Operand, &Result);
> +  UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> +  return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUintnToUint8 (
> +  IN UNIT_TEST_CONTEXT           Context
> +  )
> +{
> +  EFI_STATUS  Status;
> +  UINTN       Operand;
> +  UINT8       Result;
> +
> +  //
> +  // If Operand is <= MAX_UINT8, then it's a cast
> +  //
> +  Operand = 0xab;
> +  Result = 0;
> +  Status = SafeUintnToUint8(Operand, &Result);
> +  UT_ASSERT_NOT_EFI_ERROR(Status);
> +  UT_ASSERT_EQUAL(0xab, Result);
> +
> +  //
> +  // Otherwise should result in an error status
> +  //
> +  Operand = (0xabab);
> +  Status = SafeUintnToUint8(Operand, &Result);
> +  UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> +  return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUintnToInt16 (
> +  IN UNIT_TEST_CONTEXT           Context
> +  )
> +{
> +  EFI_STATUS  Status;
> +  UINTN       Operand;
> +  INT16       Result;
> +
> +  //
> +  // If Operand is <= MAX_INT16, then it's a cast
> +  //
> +  Operand = 0x5bab;
> +  Result = 0;
> +  Status = SafeUintnToInt16(Operand, &Result);
> +  UT_ASSERT_NOT_EFI_ERROR(Status);
> +  UT_ASSERT_EQUAL(0x5bab, Result);
> +
> +  //
> +  // Otherwise should result in an error status
> +  //
> +  Operand = (0xabab);
> +  Status = SafeUintnToInt16(Operand, &Result);
> +  UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> +  return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUintnToUint16 (
> +  IN UNIT_TEST_CONTEXT           Context
> +  )
> +{
> +  EFI_STATUS  Status;
> +  UINTN       Operand;
> +  UINT16      Result;
> +
> +  //
> +  // If Operand is <= MAX_UINT16, then it's a cast
> +  //
> +  Operand = 0xabab;
> +  Result = 0;
> +  Status = SafeUintnToUint16(Operand, &Result);
> +  UT_ASSERT_NOT_EFI_ERROR(Status);
> +  UT_ASSERT_EQUAL(0xabab, Result);
> +
> +  //
> +  // Otherwise should result in an error status
> +  //
> +  Operand = (0xabababab);
> +  Status = SafeUintnToUint16(Operand, &Result);
> +  UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> +  return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUintnToInt32 (
> +  IN UNIT_TEST_CONTEXT           Context
> +  )
> +{
> +  EFI_STATUS  Status;
> +  UINTN       Operand;
> +  INT32       Result;
> +
> +  //
> +  // If Operand is <= MAX_INT32, then it's a cast
> +  //
> +  Operand = 0x5bababab;
> +  Result = 0;
> +  Status = SafeUintnToInt32(Operand, &Result);
> +  UT_ASSERT_NOT_EFI_ERROR(Status);
> +  UT_ASSERT_EQUAL(0x5bababab, Result);
> +
> +  //
> +  // Otherwise should result in an error status
> +  //
> +  Operand = (0xabababab);
> +  Status = SafeUintnToInt32(Operand, &Result);
> +  UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> +  return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeInt64ToInt8 (
> +  IN UNIT_TEST_CONTEXT           Context
> +  )
> +{
> +  EFI_STATUS  Status;
> +  INT64       Operand;
> +  INT8        Result;
> +
> +  //
> +  // If Operand is between MIN_INT8 and  MAX_INT8 inclusive, then it's a cast
> +  //
> +  Operand = 0x5b;
> +  Result = 0;
> +  Status = SafeInt64ToInt8(Operand, &Result);
> +  UT_ASSERT_NOT_EFI_ERROR(Status);
> +  UT_ASSERT_EQUAL(0x5b, Result);
> +
> +  Operand = (-37);
> +  Status = SafeInt64ToInt8(Operand, &Result);
> +  UT_ASSERT_NOT_EFI_ERROR(Status);
> +  UT_ASSERT_EQUAL((-37), Result);
> +
> +  //
> +  // Otherwise should result in an error status
> +  //
> +  Operand = (0x5babababefefefef);
> +  Status = SafeInt64ToInt8(Operand, &Result);
> +  UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> +  Operand =  (-6605562033422200815);
> +  Status = SafeInt64ToInt8(Operand, &Result);
> +  UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> +  return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeInt64ToChar8 (
> +  IN UNIT_TEST_CONTEXT           Context
> +  )
> +{
> +  EFI_STATUS  Status;
> +  INT64       Operand;
> +  CHAR8       Result;
> +
> +  //
> +  // CHAR8 is typedefed as char, which may be signed or unsigned based
> +  // on the compiler. Thus, for compatibility CHAR8 should be between 0 and MAX_INT8.
> +  //
> +
> +  //
> +  // If Operand is between MIN_INT8 and  MAX_INT8 inclusive, then it's a cast
> +  //
> +  Operand = 0x5b;
> +  Result = 0;
> +  Status = SafeInt64ToChar8(Operand, &Result);
> +  UT_ASSERT_NOT_EFI_ERROR(Status);
> +  UT_ASSERT_EQUAL(0x5b, Result);
> +
> +  Operand = 0;
> +  Result = 0;
> +  Status = SafeInt64ToChar8(Operand, &Result);
> +  UT_ASSERT_NOT_EFI_ERROR(Status);
> +  UT_ASSERT_EQUAL(0, Result);
> +
> +  Operand = MAX_INT8;
> +  Result = 0;
> +  Status = SafeInt64ToChar8(Operand, &Result);
> +  UT_ASSERT_NOT_EFI_ERROR(Status);
> +  UT_ASSERT_EQUAL(MAX_INT8, Result);
> +
> +  //
> +  // Otherwise should result in an error status
> +  //
> +  Operand = (-37);
> +  Status = SafeInt64ToChar8(Operand, &Result);
> +  UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> +  Operand = (0x5babababefefefef);
> +  Status = SafeInt64ToChar8(Operand, &Result);
> +  UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> +  Operand =  (-6605562033422200815);
> +  Status = SafeInt64ToChar8(Operand, &Result);
> +  UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> +  return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeInt64ToUint8 (
> +  IN UNIT_TEST_CONTEXT           Context
> +  )
> +{
> +  EFI_STATUS  Status;
> +  INT64       Operand;
> +  UINT8       Result;
> +
> +  //
> +  // If Operand is between 0 and  MAX_UINT8 inclusive, then it's a cast
> +  //
> +  Operand = 0xab;
> +  Result = 0;
> +  Status = SafeInt64ToUint8(Operand, &Result);
> +  UT_ASSERT_NOT_EFI_ERROR(Status);
> +  UT_ASSERT_EQUAL(0xab, Result);
> +
> +  //
> +  // Otherwise should result in an error status
> +  //
> +  Operand = (0x5babababefefefef);
> +  Status = SafeInt64ToUint8(Operand, &Result);
> +  UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> +  Operand =  (-6605562033422200815);
> +  Status = SafeInt64ToUint8(Operand, &Result);
> +  UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> +  return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeInt64ToInt16 (
> +  IN UNIT_TEST_CONTEXT           Context
> +  )
> +{
> +  EFI_STATUS  Status;
> +  INT64       Operand;
> +  INT16       Result;
> +
> +  //
> +  // If Operand is between MIN_INT16 and  MAX_INT16 inclusive, then it's a cast
> +  //
> +  Operand = 0x5bab;
> +  Result = 0;
> +  Status = SafeInt64ToInt16(Operand, &Result);
> +  UT_ASSERT_NOT_EFI_ERROR(Status);
> +  UT_ASSERT_EQUAL(0x5bab, Result);
> +
> +  Operand = (-23467);
> +  Status = SafeInt64ToInt16(Operand, &Result);
> +  UT_ASSERT_NOT_EFI_ERROR(Status);
> +  UT_ASSERT_EQUAL((-23467), Result);
> +
> +  //
> +  // Otherwise should result in an error status
> +  //
> +  Operand = (0x5babababefefefef);
> +  Status = SafeInt64ToInt16(Operand, &Result);
> +  UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> +  Operand =  (-6605562033422200815);
> +  Status = SafeInt64ToInt16(Operand, &Result);
> +  UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> +  return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeInt64ToUint16 (
> +  IN UNIT_TEST_CONTEXT           Context
> +  )
> +{
> +  EFI_STATUS  Status;
> +  INT64       Operand;
> +  UINT16      Result;
> +
> +  //
> +  // If Operand is between 0 and  MAX_UINT16 inclusive, then it's a cast
> +  //
> +  Operand = 0xabab;
> +  Result = 0;
> +  Status = SafeInt64ToUint16(Operand, &Result);
> +  UT_ASSERT_NOT_EFI_ERROR(Status);
> +  UT_ASSERT_EQUAL(0xabab, Result);
> +
> +  //
> +  // Otherwise should result in an error status
> +  //
> +  Operand = (0x5babababefefefef);
> +  Status = SafeInt64ToUint16(Operand, &Result);
> +  UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> +  Operand =  (-6605562033422200815);
> +  Status = SafeInt64ToUint16(Operand, &Result);
> +  UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> +  return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeInt64ToInt32 (
> +  IN UNIT_TEST_CONTEXT           Context
> +  )
> +{
> +  EFI_STATUS  Status;
> +  INT64       Operand;
> +  INT32       Result;
> +
> +  //
> +  // If Operand is between MIN_INT32 and  MAX_INT32 inclusive, then it's a cast
> +  //
> +  Operand = 0x5bababab;
> +  Result = 0;
> +  Status = SafeInt64ToInt32(Operand, &Result);
> +  UT_ASSERT_NOT_EFI_ERROR(Status);
> +  UT_ASSERT_EQUAL(0x5bababab, Result);
> +
> +  Operand = (-1537977259);
> +  Status = SafeInt64ToInt32(Operand, &Result);
> +  UT_ASSERT_NOT_EFI_ERROR(Status);
> +  UT_ASSERT_EQUAL((-1537977259), Result);
> +
> +  //
> +  // Otherwise should result in an error status
> +  //
> +  Operand = (0x5babababefefefef);
> +  Status = SafeInt64ToInt32(Operand, &Result);
> +  UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> +  Operand =  (-6605562033422200815);
> +  Status = SafeInt64ToInt32(Operand, &Result);
> +  UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> +  return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeInt64ToUint32 (
> +  IN UNIT_TEST_CONTEXT           Context
> +  )
> +{
> +  EFI_STATUS  Status;
> +  INT64       Operand;
> +  UINT32      Result;
> +
> +  //
> +  // If Operand is between 0 and  MAX_UINT32 inclusive, then it's a cast
> +  //
> +  Operand = 0xabababab;
> +  Result = 0;
> +  Status = SafeInt64ToUint32(Operand, &Result);
> +  UT_ASSERT_NOT_EFI_ERROR(Status);
> +  UT_ASSERT_EQUAL(0xabababab, Result);
> +
> +  //
> +  // Otherwise should result in an error status
> +  //
> +  Operand = (0x5babababefefefef);
> +  Status = SafeInt64ToUint32(Operand, &Result);
> +  UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> +  Operand =  (-6605562033422200815);
> +  Status = SafeInt64ToUint32(Operand, &Result);
> +  UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> +  return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeInt64ToUint64 (
> +  IN UNIT_TEST_CONTEXT           Context
> +  )
> +{
> +  EFI_STATUS  Status;
> +  INT64       Operand;
> +  UINT64      Result;
> +
> +  //
> +  // If Operand is non-negative, then it's a cast
> +  //
> +  Operand = 0x5babababefefefef;
> +  Result = 0;
> +  Status = SafeInt64ToUint64(Operand, &Result);
> +  UT_ASSERT_NOT_EFI_ERROR(Status);
> +  UT_ASSERT_EQUAL(0x5babababefefefef, Result);
> +
> +  //
> +  // Otherwise should result in an error status
> +  //
> +  Operand =  (-6605562033422200815);
> +  Status = SafeInt64ToUint64(Operand, &Result);
> +  UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> +  return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUint64ToInt8 (
> +  IN UNIT_TEST_CONTEXT           Context
> +  )
> +{
> +  EFI_STATUS  Status;
> +  UINT64      Operand;
> +  INT8        Result;
> +
> +  //
> +  // If Operand is <= MAX_INT8, then it's a cast
> +  //
> +  Operand = 0x5b;
> +  Result = 0;
> +  Status = SafeUint64ToInt8(Operand, &Result);
> +  UT_ASSERT_NOT_EFI_ERROR(Status);
> +  UT_ASSERT_EQUAL(0x5b, Result);
> +
> +  //
> +  // Otherwise should result in an error status
> +  //
> +  Operand = (0xababababefefefef);
> +  Status = SafeUint64ToInt8(Operand, &Result);
> +  UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> +  return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUint64ToChar8 (
> +  IN UNIT_TEST_CONTEXT           Context
> +  )
> +{
> +  EFI_STATUS  Status;
> +  UINT64      Operand;
> +  CHAR8       Result;
> +
> +  // CHAR8 is typedefed as char, which by default is signed, thus
> +  // CHAR8 is same as INT8, so same tests as above:
> +
> +  //
> +  // If Operand is <= MAX_INT8, then it's a cast
> +  //
> +  Operand = 0x5b;
> +  Result = 0;
> +  Status = SafeUint64ToChar8(Operand, &Result);
> +  UT_ASSERT_NOT_EFI_ERROR(Status);
> +  UT_ASSERT_EQUAL(0x5b, Result);
> +
> +  //
> +  // Otherwise should result in an error status
> +  //
> +  Operand = (0xababababefefefef);
> +  Status = SafeUint64ToChar8(Operand, &Result);
> +  UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> +  return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUint64ToUint8 (
> +  IN UNIT_TEST_CONTEXT           Context
> +  )
> +{
> +  EFI_STATUS  Status;
> +  UINT64      Operand;
> +  UINT8       Result;
> +
> +  //
> +  // If Operand is <= MAX_UINT8, then it's a cast
> +  //
> +  Operand = 0xab;
> +  Result = 0;
> +  Status = SafeUint64ToUint8(Operand, &Result);
> +  UT_ASSERT_NOT_EFI_ERROR(Status);
> +  UT_ASSERT_EQUAL(0xab, Result);
> +
> +  //
> +  // Otherwise should result in an error status
> +  //
> +  Operand = (0xababababefefefef);
> +  Status = SafeUint64ToUint8(Operand, &Result);
> +  UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> +  return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUint64ToInt16 (
> +  IN UNIT_TEST_CONTEXT           Context
> +  )
> +{
> +  EFI_STATUS  Status;
> +  UINT64      Operand;
> +  INT16       Result;
> +
> +  //
> +  // If Operand is <= MAX_INT16, then it's a cast
> +  //
> +  Operand = 0x5bab;
> +  Result = 0;
> +  Status = SafeUint64ToInt16(Operand, &Result);
> +  UT_ASSERT_NOT_EFI_ERROR(Status);
> +  UT_ASSERT_EQUAL(0x5bab, Result);
> +
> +  //
> +  // Otherwise should result in an error status
> +  //
> +  Operand = (0xababababefefefef);
> +  Status = SafeUint64ToInt16(Operand, &Result);
> +  UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> +  return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUint64ToUint16 (
> +  IN UNIT_TEST_CONTEXT           Context
> +  )
> +{
> +  EFI_STATUS  Status;
> +  UINT64      Operand;
> +  UINT16      Result;
> +
> +  //
> +  // If Operand is <= MAX_UINT16, then it's a cast
> +  //
> +  Operand = 0xabab;
> +  Result = 0;
> +  Status = SafeUint64ToUint16(Operand, &Result);
> +  UT_ASSERT_NOT_EFI_ERROR(Status);
> +  UT_ASSERT_EQUAL(0xabab, Result);
> +
> +  //
> +  // Otherwise should result in an error status
> +  //
> +  Operand = (0xababababefefefef);
> +  Status = SafeUint64ToUint16(Operand, &Result);
> +  UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> +  return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUint64ToInt32 (
> +  IN UNIT_TEST_CONTEXT           Context
> +  )
> +{
> +  EFI_STATUS  Status;
> +  UINT64      Operand;
> +  INT32       Result;
> +
> +  //
> +  // If Operand is <= MAX_INT32, then it's a cast
> +  //
> +  Operand = 0x5bababab;
> +  Result = 0;
> +  Status = SafeUint64ToInt32(Operand, &Result);
> +  UT_ASSERT_NOT_EFI_ERROR(Status);
> +  UT_ASSERT_EQUAL(0x5bababab, Result);
> +
> +  //
> +  // Otherwise should result in an error status
> +  //
> +  Operand = (0xababababefefefef);
> +  Status = SafeUint64ToInt32(Operand, &Result);
> +  UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> +  return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUint64ToUint32 (
> +  IN UNIT_TEST_CONTEXT           Context
> +  )
> +{
> +  EFI_STATUS  Status;
> +  UINT64      Operand;
> +  UINT32      Result;
> +
> +  //
> +  // If Operand is <= MAX_UINT32, then it's a cast
> +  //
> +  Operand = 0xabababab;
> +  Result = 0;
> +  Status = SafeUint64ToUint32(Operand, &Result);
> +  UT_ASSERT_NOT_EFI_ERROR(Status);
> +  UT_ASSERT_EQUAL(0xabababab, Result);
> +
> +  //
> +  // Otherwise should result in an error status
> +  //
> +  Operand = (0xababababefefefef);
> +  Status = SafeUint64ToUint32(Operand, &Result);
> +  UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> +  return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUint64ToInt64 (
> +  IN UNIT_TEST_CONTEXT           Context
> +  )
> +{
> +  EFI_STATUS  Status;
> +  UINT64      Operand;
> +  INT64       Result;
> +
> +  //
> +  // If Operand is <= MAX_INT64, then it's a cast
> +  //
> +  Operand = 0x5babababefefefef;
> +  Result = 0;
> +  Status = SafeUint64ToInt64(Operand, &Result);
> +  UT_ASSERT_NOT_EFI_ERROR(Status);
> +  UT_ASSERT_EQUAL(0x5babababefefefef, Result);
> +
> +  //
> +  // Otherwise should result in an error status
> +  //
> +  Operand = (0xababababefefefef);
> +  Status = SafeUint64ToInt64(Operand, &Result);
> +  UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> +  return UNIT_TEST_PASSED;
> +}
> +
> +//
> +// Addition function tests:
> +//
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUint8Add (
> +  IN UNIT_TEST_CONTEXT           Context
> +  )
> +{
> +  EFI_STATUS  Status;
> +  UINT8       Augend;
> +  UINT8       Addend;
> +  UINT8       Result;
> +
> +  //
> +  // If the result of addition doesn't overflow MAX_UINT8, then it's addition
> +  //
> +  Augend = 0x3a;
> +  Addend = 0x3a;
> +  Result = 0;
> +  Status = SafeUint8Add(Augend, Addend, &Result);
> +  UT_ASSERT_NOT_EFI_ERROR(Status);
> +  UT_ASSERT_EQUAL(0x74, Result);
> +
> +  //
> +  // Otherwise should result in an error status
> +  //
> +  Augend = 0xab;
> +  Addend = 0xbc;
> +  Status = SafeUint8Add(Augend, Addend, &Result);
> +  UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> +  return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUint16Add (
> +  IN UNIT_TEST_CONTEXT           Context
> +  )
> +{
> +  EFI_STATUS  Status;
> +  UINT16 Augend = 0x3a3a;
> +  UINT16 Addend = 0x3a3a;
> +  UINT16 Result = 0;
> +
> +  //
> +  // If the result of addition doesn't overflow MAX_UINT16, then it's addition
> +  //
> +  Status = SafeUint16Add(Augend, Addend, &Result);
> +  UT_ASSERT_NOT_EFI_ERROR(Status);
> +  UT_ASSERT_EQUAL(0x7474, Result);
> +
> +  //
> +  // Otherwise should result in an error status
> +  //
> +  Augend = 0xabab;
> +  Addend = 0xbcbc;
> +  Status = SafeUint16Add(Augend, Addend, &Result);
> +  UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> +  return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUint32Add (
> +  IN UNIT_TEST_CONTEXT           Context
> +  )
> +{
> +  EFI_STATUS  Status;
> +  UINT32      Augend;
> +  UINT32      Addend;
> +  UINT32      Result;
> +
> +  //
> +  // If the result of addition doesn't overflow MAX_UINT32, then it's addition
> +  //
> +  Augend = 0x3a3a3a3a;
> +  Addend = 0x3a3a3a3a;
> +  Result = 0;
> +  Status = SafeUint32Add(Augend, Addend, &Result);
> +  UT_ASSERT_NOT_EFI_ERROR(Status);
> +  UT_ASSERT_EQUAL(0x74747474, Result);
> +
> +  //
> +  // Otherwise should result in an error status
> +  //
> +  Augend = 0xabababab;
> +  Addend = 0xbcbcbcbc;
> +  Status = SafeUint32Add(Augend, Addend, &Result);
> +  UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> +  return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUint64Add (
> +  IN UNIT_TEST_CONTEXT           Context
> +  )
> +{
> +  EFI_STATUS  Status;
> +  UINT64      Augend;
> +  UINT64      Addend;
> +  UINT64      Result;
> +
> +  //
> +  // If the result of addition doesn't overflow MAX_UINT64, then it's addition
> +  //
> +  Augend = 0x3a3a3a3a12121212;
> +  Addend = 0x3a3a3a3a12121212;
> +  Result = 0;
> +  Status = SafeUint64Add(Augend, Addend, &Result);
> +  UT_ASSERT_NOT_EFI_ERROR(Status);
> +  UT_ASSERT_EQUAL(0x7474747424242424, Result);
> +
> +  //
> +  // Otherwise should result in an error status
> +  //
> +  Augend = 0xababababefefefef;
> +  Addend = 0xbcbcbcbcdededede;
> +  Status = SafeUint64Add(Augend, Addend, &Result);
> +  UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> +  return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeInt8Add (
> +  IN UNIT_TEST_CONTEXT           Context
> +  )
> +{
> +  EFI_STATUS  Status;
> +  INT8        Augend;
> +  INT8        Addend;
> +  INT8        Result;
> +
> +  //
> +  // If the result of addition doesn't overflow MAX_INT8
> +  // and doesn't underflow MIN_INT8, then it's addition
> +  //
> +  Augend = 0x3a;
> +  Addend = 0x3a;
> +  Result = 0;
> +  Status = SafeInt8Add(Augend, Addend, &Result);
> +  UT_ASSERT_NOT_EFI_ERROR(Status);
> +  UT_ASSERT_EQUAL(0x74, Result);
> +
> +  Augend = (-58);
> +  Addend = (-58);
> +  Status = SafeInt8Add(Augend, Addend, &Result);
> +  UT_ASSERT_NOT_EFI_ERROR(Status);
> +  UT_ASSERT_EQUAL((-116), Result);
> +
> +  //
> +  // Otherwise should result in an error status
> +  //
> +  Augend = 0x5a;
> +  Addend = 0x5a;
> +  Status = SafeInt8Add(Augend, Addend, &Result);
> +  UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> +  Augend = (-90);
> +  Addend = (-90);
> +  Status = SafeInt8Add(Augend, Addend, &Result);
> +  UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> +  return UNIT_TEST_PASSED;
> +
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeInt16Add (
> +  IN UNIT_TEST_CONTEXT           Context
> +  )
> +{
> +  EFI_STATUS  Status;
> +  INT16       Augend;
> +  INT16       Addend;
> +  INT16       Result;
> +
> +  //
> +  // If the result of addition doesn't overflow MAX_INT16
> +  // and doesn't underflow MIN_INT16, then it's addition
> +  //
> +  Augend = 0x3a3a;
> +  Addend = 0x3a3a;
> +  Result = 0;
> +  Status = SafeInt16Add(Augend, Addend, &Result);
> +  UT_ASSERT_NOT_EFI_ERROR(Status);
> +  UT_ASSERT_EQUAL(0x7474, Result);
> +
> +  Augend = (-14906);
> +  Addend = (-14906);
> +  Status = SafeInt16Add(Augend, Addend, &Result);
> +  UT_ASSERT_NOT_EFI_ERROR(Status);
> +  UT_ASSERT_EQUAL((-29812), Result);
> +
> +  //
> +  // Otherwise should result in an error status
> +  //
> +  Augend = 0x5a5a;
> +  Addend = 0x5a5a;
> +  Status = SafeInt16Add(Augend, Addend, &Result);
> +  UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> +  Augend = (-23130);
> +  Addend = (-23130);
> +  Status = SafeInt16Add(Augend, Addend, &Result);
> +  UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> +  return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeInt32Add (
> +  IN UNIT_TEST_CONTEXT           Context
> +  )
> +{
> +  EFI_STATUS  Status;
> +  INT32       Augend;
> +  INT32       Addend;
> +  INT32       Result;
> +
> +  //
> +  // If the result of addition doesn't overflow MAX_INT32
> +  // and doesn't underflow MIN_INT32, then it's addition
> +  //
> +  Augend = 0x3a3a3a3a;
> +  Addend = 0x3a3a3a3a;
> +  Result = 0;
> +  Status = SafeInt32Add(Augend, Addend, &Result);
> +  UT_ASSERT_NOT_EFI_ERROR(Status);
> +  UT_ASSERT_EQUAL(0x74747474, Result);
> +
> +  Augend = (-976894522);
> +  Addend = (-976894522);
> +  Status = SafeInt32Add(Augend, Addend, &Result);
> +  UT_ASSERT_NOT_EFI_ERROR(Status);
> +  UT_ASSERT_EQUAL((-1953789044), Result);
> +
> +  //
> +  // Otherwise should result in an error status
> +  //
> +  Augend = 0x5a5a5a5a;
> +  Addend = 0x5a5a5a5a;
> +  Status = SafeInt32Add(Augend, Addend, &Result);
> +  UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> +  Augend = (-1515870810);
> +  Addend = (-1515870810);
> +  Status = SafeInt32Add(Augend, Addend, &Result);
> +  UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> +  return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeInt64Add (
> +  IN UNIT_TEST_CONTEXT           Context
> +  )
> +{
> +  EFI_STATUS  Status;
> +  INT64       Augend;
> +  INT64       Addend;
> +  INT64       Result;
> +
> +  //
> +  // If the result of addition doesn't overflow MAX_INT64
> +  // and doesn't underflow MIN_INT64, then it's addition
> +  //
> +  Augend = 0x3a3a3a3a3a3a3a3a;
> +  Addend = 0x3a3a3a3a3a3a3a3a;
> +  Result = 0;
> +  Status = SafeInt64Add(Augend, Addend, &Result);
> +  UT_ASSERT_NOT_EFI_ERROR(Status);
> +  UT_ASSERT_EQUAL(0x7474747474747474, Result);
> +
> +  Augend = (-4195730024608447034);
> +  Addend = (-4195730024608447034);
> +  Status = SafeInt64Add(Augend, Addend, &Result);
> +  UT_ASSERT_NOT_EFI_ERROR(Status);
> +  UT_ASSERT_EQUAL((-8391460049216894068), Result);
> +
> +  //
> +  // Otherwise should result in an error status
> +  //
> +  Augend = 0x5a5a5a5a5a5a5a5a;
> +  Addend = 0x5a5a5a5a5a5a5a5a;
> +  Status = SafeInt64Add(Augend, Addend, &Result);
> +  UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> +  Augend = (-6510615555426900570);
> +  Addend = (-6510615555426900570);
> +  Status = SafeInt64Add(Augend, Addend, &Result);
> +  UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> +  return UNIT_TEST_PASSED;
> +}
> +
> +//
> +// Subtraction function tests:
> +//
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUint8Sub (
> +  IN UNIT_TEST_CONTEXT           Context
> +  )
> +{
> +  EFI_STATUS  Status;
> +  UINT8       Minuend;
> +  UINT8       Subtrahend;
> +  UINT8       Result;
> +
> +  //
> +  // If Minuend >= Subtrahend, then it's subtraction
> +  //
> +  Minuend = 0x5a;
> +  Subtrahend = 0x3b;
> +  Result = 0;
> +  Status = SafeUint8Sub(Minuend, Subtrahend, &Result);
> +  UT_ASSERT_NOT_EFI_ERROR(Status);
> +  UT_ASSERT_EQUAL(0x1f, Result);
> +
> +  //
> +  // Otherwise should result in an error status
> +  //
> +  Minuend = 0x5a;
> +  Subtrahend = 0x6d;
> +  Status = SafeUint8Sub(Minuend, Subtrahend, &Result);
> +  UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> +  return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUint16Sub (
> +  IN UNIT_TEST_CONTEXT           Context
> +  )
> +{
> +  EFI_STATUS  Status;
> +  UINT16      Minuend;
> +  UINT16      Subtrahend;
> +  UINT16      Result;
> +
> +  //
> +  // If Minuend >= Subtrahend, then it's subtraction
> +  //
> +  Minuend = 0x5a5a;
> +  Subtrahend = 0x3b3b;
> +  Result = 0;
> +  Status = SafeUint16Sub(Minuend, Subtrahend, &Result);
> +  UT_ASSERT_NOT_EFI_ERROR(Status);
> +  UT_ASSERT_EQUAL(0x1f1f, Result);
> +
> +  //
> +  // Otherwise should result in an error status
> +  //
> +  Minuend = 0x5a5a;
> +  Subtrahend = 0x6d6d;
> +  Status = SafeUint16Sub(Minuend, Subtrahend, &Result);
> +  UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> +  return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUint32Sub (
> +  IN UNIT_TEST_CONTEXT           Context
> +  )
> +{
> +  EFI_STATUS  Status;
> +  UINT32      Minuend;
> +  UINT32      Subtrahend;
> +  UINT32      Result;
> +
> +  //
> +  // If Minuend >= Subtrahend, then it's subtraction
> +  //
> +  Minuend = 0x5a5a5a5a;
> +  Subtrahend = 0x3b3b3b3b;
> +  Result = 0;
> +  Status = SafeUint32Sub(Minuend, Subtrahend, &Result);
> +  UT_ASSERT_NOT_EFI_ERROR(Status);
> +  UT_ASSERT_EQUAL(0x1f1f1f1f, Result);
> +
> +  //
> +  // Otherwise should result in an error status
> +  //
> +  Minuend = 0x5a5a5a5a;
> +  Subtrahend = 0x6d6d6d6d;
> +  Status = SafeUint32Sub(Minuend, Subtrahend, &Result);
> +  UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> +  return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUint64Sub (
> +  IN UNIT_TEST_CONTEXT           Context
> +  )
> +{
> +  EFI_STATUS  Status;
> +  UINT64      Minuend;
> +  UINT64      Subtrahend;
> +  UINT64      Result;
> +
> +  //
> +  // If Minuend >= Subtrahend, then it's subtraction
> +  //
> +  Minuend = 0x5a5a5a5a5a5a5a5a;
> +  Subtrahend = 0x3b3b3b3b3b3b3b3b;
> +  Result = 0;
> +  Status = SafeUint64Sub(Minuend, Subtrahend, &Result);
> +  UT_ASSERT_NOT_EFI_ERROR(Status);
> +  UT_ASSERT_EQUAL(0x1f1f1f1f1f1f1f1f, Result);
> +
> +  //
> +  // Otherwise should result in an error status
> +  //
> +  Minuend = 0x5a5a5a5a5a5a5a5a;
> +  Subtrahend = 0x6d6d6d6d6d6d6d6d;
> +  Status = SafeUint64Sub(Minuend, Subtrahend, &Result);
> +  UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> +  return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeInt8Sub (
> +  IN UNIT_TEST_CONTEXT           Context
> +  )
> +{
> +  EFI_STATUS  Status;
> +  INT8        Minuend;
> +  INT8        Subtrahend;
> +  INT8        Result;
> +
> +  //
> +  // If the result of subtractions doesn't overflow MAX_INT8 or
> +  // underflow MIN_INT8, then it's subtraction
> +  //
> +  Minuend = 0x5a;
> +  Subtrahend = 0x3a;
> +  Result = 0;
> +  Status = SafeInt8Sub(Minuend, Subtrahend, &Result);
> +  UT_ASSERT_NOT_EFI_ERROR(Status);
> +  UT_ASSERT_EQUAL(0x20, Result);
> +
> +  Minuend = 58;
> +  Subtrahend = 78;
> +  Status = SafeInt8Sub(Minuend, Subtrahend, &Result);
> +  UT_ASSERT_NOT_EFI_ERROR(Status);
> +  UT_ASSERT_EQUAL((-20), Result);
> +
> +  //
> +  // Otherwise should result in an error status
> +  //
> +  Minuend = (-80);
> +  Subtrahend = 80;
> +  Status = SafeInt8Sub(Minuend, Subtrahend, &Result);
> +  UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> +  Minuend = (80);
> +  Subtrahend = (-80);
> +  Status = SafeInt8Sub(Minuend, Subtrahend, &Result);
> +  UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> +  return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeInt16Sub (
> +  IN UNIT_TEST_CONTEXT           Context
> +  )
> +{
> +  EFI_STATUS  Status;
> +  INT16       Minuend;
> +  INT16       Subtrahend;
> +  INT16       Result;
> +
> +  //
> +  // If the result of subtractions doesn't overflow MAX_INT16 or
> +  // underflow MIN_INT16, then it's subtraction
> +  //
> +  Minuend = 0x5a5a;
> +  Subtrahend = 0x3a3a;
> +  Result = 0;
> +  Status = SafeInt16Sub(Minuend, Subtrahend, &Result);
> +  UT_ASSERT_NOT_EFI_ERROR(Status);
> +  UT_ASSERT_EQUAL(0x2020, Result);
> +
> +  Minuend = 0x3a3a;
> +  Subtrahend = 0x5a5a;
> +  Status = SafeInt16Sub(Minuend, Subtrahend, &Result);
> +  UT_ASSERT_NOT_EFI_ERROR(Status);
> +  UT_ASSERT_EQUAL((-8224), Result);
> +
> +  //
> +  // Otherwise should result in an error status
> +  //
> +  Minuend = (-31354);
> +  Subtrahend = 31354;
> +  Status = SafeInt16Sub(Minuend, Subtrahend, &Result);
> +  UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> +  Minuend = (31354);
> +  Subtrahend = (-31354);
> +  Status = SafeInt16Sub(Minuend, Subtrahend, &Result);
> +  UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> +  return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeInt32Sub (
> +  IN UNIT_TEST_CONTEXT           Context
> +  )
> +{
> +  EFI_STATUS  Status;
> +  INT32       Minuend;
> +  INT32       Subtrahend;
> +  INT32       Result;
> +
> +  //
> +  // If the result of subtractions doesn't overflow MAX_INT32 or
> +  // underflow MIN_INT32, then it's subtraction
> +  //
> +  Minuend = 0x5a5a5a5a;
> +  Subtrahend = 0x3a3a3a3a;
> +  Result = 0;
> +  Status = SafeInt32Sub(Minuend, Subtrahend, &Result);
> +  UT_ASSERT_NOT_EFI_ERROR(Status);
> +  UT_ASSERT_EQUAL(0x20202020, Result);
> +
> +  Minuend = 0x3a3a3a3a;
> +  Subtrahend = 0x5a5a5a5a;
> +  Status = SafeInt32Sub(Minuend, Subtrahend, &Result);
> +  UT_ASSERT_NOT_EFI_ERROR(Status);
> +  UT_ASSERT_EQUAL((-538976288), Result);
> +
> +  //
> +  // Otherwise should result in an error status
> +  //
> +  Minuend = (-2054847098);
> +  Subtrahend = 2054847098;
> +  Status = SafeInt32Sub(Minuend, Subtrahend, &Result);
> +  UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> +  Minuend = (2054847098);
> +  Subtrahend = (-2054847098);
> +  Status = SafeInt32Sub(Minuend, Subtrahend, &Result);
> +  UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> +  return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeInt64Sub (
> +  IN UNIT_TEST_CONTEXT           Context
> +  )
> +{
> +  EFI_STATUS  Status;
> +  INT64       Minuend;
> +  INT64       Subtrahend;
> +  INT64       Result;
> +
> +  //
> +  // If the result of subtractions doesn't overflow MAX_INT64 or
> +  // underflow MIN_INT64, then it's subtraction
> +  //
> +  Minuend = 0x5a5a5a5a5a5a5a5a;
> +  Subtrahend = 0x3a3a3a3a3a3a3a3a;
> +  Result = 0;
> +  Status = SafeInt64Sub(Minuend, Subtrahend, &Result);
> +  UT_ASSERT_NOT_EFI_ERROR(Status);
> +  UT_ASSERT_EQUAL(0x2020202020202020, Result);
> +
> +  Minuend = 0x3a3a3a3a3a3a3a3a;
> +  Subtrahend = 0x5a5a5a5a5a5a5a5a;
> +  Status = SafeInt64Sub(Minuend, Subtrahend, &Result);
> +  UT_ASSERT_NOT_EFI_ERROR(Status);
> +  UT_ASSERT_EQUAL((-2314885530818453536), Result);
> +
> +  //
> +  // Otherwise should result in an error status
> +  //
> +  Minuend = (-8825501086245354106);
> +  Subtrahend = 8825501086245354106;
> +  Status = SafeInt64Sub(Minuend, Subtrahend, &Result);
> +  UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> +  Minuend = (8825501086245354106);
> +  Subtrahend = (-8825501086245354106);
> +  Status = SafeInt64Sub(Minuend, Subtrahend, &Result);
> +  UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> +  return UNIT_TEST_PASSED;
> +}
> +
> +//
> +// Multiplication function tests:
> +//
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUint8Mult (
> +  IN UNIT_TEST_CONTEXT           Context
> +  )
> +{
> +  EFI_STATUS  Status;
> +  UINT8       Multiplicand;
> +  UINT8       Multiplier;
> +  UINT8       Result;
> +
> +  //
> +  // If the result of multiplication doesn't overflow MAX_UINT8, it will succeed
> +  //
> +  Multiplicand = 0x12;
> +  Multiplier = 0xa;
> +  Result = 0;
> +  Status = SafeUint8Mult(Multiplicand, Multiplier, &Result);
> +  UT_ASSERT_NOT_EFI_ERROR(Status);
> +  UT_ASSERT_EQUAL(0xb4, Result);
> +
> +  //
> +  // Otherwise should result in an error status
> +  //
> +  Multiplicand = 0x12;
> +  Multiplier = 0x23;
> +  Status = SafeUint8Mult(Multiplicand, Multiplier, &Result);
> +  UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> +  return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUint16Mult (
> +  IN UNIT_TEST_CONTEXT           Context
> +  )
> +{
> +  EFI_STATUS  Status;
> +  UINT16      Multiplicand;
> +  UINT16      Multiplier;
> +  UINT16      Result;
> +
> +  //
> +  // If the result of multiplication doesn't overflow MAX_UINT16, it will succeed
> +  //
> +  Multiplicand = 0x212;
> +  Multiplier = 0x7a;
> +  Result = 0;
> +  Status = SafeUint16Mult(Multiplicand, Multiplier, &Result);
> +  UT_ASSERT_NOT_EFI_ERROR(Status);
> +  UT_ASSERT_EQUAL(0xfc94, Result);
> +
> +  //
> +  // Otherwise should result in an error status
> +  //
> +  Multiplicand = 0x1234;
> +  Multiplier = 0x213;
> +  Status = SafeUint16Mult(Multiplicand, Multiplier, &Result);
> +  UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> +  return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUint32Mult (
> +  IN UNIT_TEST_CONTEXT           Context
> +  )
> +{
> +  EFI_STATUS  Status;
> +  UINT32      Multiplicand;
> +  UINT32      Multiplier;
> +  UINT32      Result;
> +
> +  //
> +  // If the result of multiplication doesn't overflow MAX_UINT32, it will succeed
> +  //
> +  Multiplicand = 0xa122a;
> +  Multiplier = 0xd23;
> +  Result = 0;
> +  Status = SafeUint32Mult(Multiplicand, Multiplier, &Result);
> +  UT_ASSERT_NOT_EFI_ERROR(Status);
> +  UT_ASSERT_EQUAL(0x844c9dbe, Result);
> +
> +  //
> +  // Otherwise should result in an error status
> +  //
> +  Multiplicand = 0xa122a;
> +  Multiplier = 0xed23;
> +  Status = SafeUint32Mult(Multiplicand, Multiplier, &Result);
> +  UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> +  return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUint64Mult (
> +  IN UNIT_TEST_CONTEXT           Context
> +  )
> +{
> +  EFI_STATUS  Status;
> +  UINT64      Multiplicand;
> +  UINT64      Multiplier;
> +  UINT64      Result;
> +
> +  //
> +  // If the result of multiplication doesn't overflow MAX_UINT64, it will succeed
> +  //
> +  Multiplicand = 0x123456789a;
> +  Multiplier = 0x1234567;
> +  Result = 0;
> +  Status = SafeUint64Mult(Multiplicand, Multiplier, &Result);
> +  UT_ASSERT_NOT_EFI_ERROR(Status);
> +  UT_ASSERT_EQUAL(0x14b66db9745a07f6, Result);
> +
> +  //
> +  // Otherwise should result in an error status
> +  //
> +  Multiplicand = 0x123456789a;
> +  Multiplier = 0x12345678;
> +  Status = SafeUint64Mult(Multiplicand, Multiplier, &Result);
> +  UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> +  return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeInt8Mult (
> +  IN UNIT_TEST_CONTEXT           Context
> +  )
> +{
> +  EFI_STATUS  Status;
> +  INT8        Multiplicand;
> +  INT8        Multiplier;
> +  INT8        Result;
> +
> +  //
> +  // If the result of multiplication doesn't overflow MAX_INT8 and doesn't
> +  // underflow MIN_UINT8, it will succeed
> +  //
> +  Multiplicand = 0x12;
> +  Multiplier = 0x7;
> +  Result = 0;
> +  Status = SafeInt8Mult(Multiplicand, Multiplier, &Result);
> +  UT_ASSERT_NOT_EFI_ERROR(Status);
> +  UT_ASSERT_EQUAL(0x7e, Result);
> +
> +  //
> +  // Otherwise should result in an error status
> +  //
> +  Multiplicand = 0x12;
> +  Multiplier = 0xa;
> +  Status = SafeInt8Mult(Multiplicand, Multiplier, &Result);
> +  UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> +  return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeInt16Mult (
> +  IN UNIT_TEST_CONTEXT           Context
> +  )
> +{
> +  EFI_STATUS  Status;
> +  INT16       Multiplicand;
> +  INT16       Multiplier;
> +  INT16       Result;
> +
> +  //
> +  // If the result of multiplication doesn't overflow MAX_INT16 and doesn't
> +  // underflow MIN_UINT16, it will succeed
> +  //
> +  Multiplicand = 0x123;
> +  Multiplier = 0x67;
> +  Result = 0;
> +  Status = SafeInt16Mult(Multiplicand, Multiplier, &Result);
> +  UT_ASSERT_NOT_EFI_ERROR(Status);
> +  UT_ASSERT_EQUAL(0x7515, Result);
> +
> +  //
> +  // Otherwise should result in an error status
> +  //
> +  Multiplicand = 0x123;
> +  Multiplier = 0xab;
> +  Status = SafeInt16Mult(Multiplicand, Multiplier, &Result);
> +  UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> +  return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeInt32Mult (
> +  IN UNIT_TEST_CONTEXT           Context
> +  )
> +{
> +  EFI_STATUS  Status;
> +  INT32       Multiplicand;
> +  INT32       Multiplier;
> +  INT32       Result;
> +
> +  //
> +  // If the result of multiplication doesn't overflow MAX_INT32 and doesn't
> +  // underflow MIN_UINT32, it will succeed
> +  //
> +  Multiplicand = 0x123456;
> +  Multiplier = 0x678;
> +  Result = 0;
> +  Status = SafeInt32Mult(Multiplicand, Multiplier, &Result);
> +  UT_ASSERT_NOT_EFI_ERROR(Status);
> +  UT_ASSERT_EQUAL(0x75c28c50, Result);
> +
> +  //
> +  // Otherwise should result in an error status
> +  //
> +  Multiplicand = 0x123456;
> +  Multiplier = 0xabc;
> +  Status = SafeInt32Mult(Multiplicand, Multiplier, &Result);
> +  UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> +  return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeInt64Mult (
> +  IN UNIT_TEST_CONTEXT           Context
> +  )
> +{
> +  EFI_STATUS  Status;
> +  INT64       Multiplicand;
> +  INT64       Multiplier;
> +  INT64       Result;
> +
> +  //
> +  // If the result of multiplication doesn't overflow MAX_INT64 and doesn't
> +  // underflow MIN_UINT64, it will succeed
> +  //
> +  Multiplicand = 0x123456789;
> +  Multiplier = 0x6789abcd;
> +  Result = 0;
> +  Status = SafeInt64Mult(Multiplicand, Multiplier, &Result);
> +  UT_ASSERT_NOT_EFI_ERROR(Status);
> +  UT_ASSERT_EQUAL(0x75cd9045220d6bb5, Result);
> +
> +  //
> +  // Otherwise should result in an error status
> +  //
> +  Multiplicand = 0x123456789;
> +  Multiplier = 0xa789abcd;
> +  Status = SafeInt64Mult(Multiplicand, Multiplier, &Result);
> +  UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> +  return UNIT_TEST_PASSED;
> +}
> +
> +/**
> +
> +  Main fuction sets up the unit test environment
> +
> +**/
> +EFI_STATUS
> +EFIAPI
> +UefiTestMain (
> +  VOID
> +  )
> +{
> +  EFI_STATUS                  Status;
> +  UNIT_TEST_FRAMEWORK_HANDLE  Framework;
> +  UNIT_TEST_SUITE_HANDLE      ConversionTestSuite;
> +  UNIT_TEST_SUITE_HANDLE      AdditionSubtractionTestSuite;
> +  UNIT_TEST_SUITE_HANDLE      MultiplicationTestSuite;
> +
> +  Framework = NULL;
> +  ConversionTestSuite = NULL;
> +  AdditionSubtractionTestSuite = NULL;
> +  MultiplicationTestSuite = NULL;
> +
> +  DEBUG((DEBUG_INFO, "%a v%a\n", UNIT_TEST_NAME, UNIT_TEST_VERSION));
> +
> +  //
> +  // Start setting up the test framework for running the tests.
> +  //
> +  Status = InitUnitTestFramework (&Framework, UNIT_TEST_NAME, gEfiCallerBaseName, UNIT_TEST_VERSION);
> +  if (EFI_ERROR(Status)) {
> +    DEBUG((DEBUG_ERROR, "Failed in InitUnitTestFramework. Status = %r\n", Status));
> +    goto EXIT;
> +  }
> +
> +  ///
> +  // Test the conversion functions
> +  //
> +  Status = CreateUnitTestSuite (&ConversionTestSuite, Framework, "Int Safe Conversions Test Suite", "Common.SafeInt.Convert", NULL,
> NULL);
> +  if (EFI_ERROR(Status)) {
> +    DEBUG((DEBUG_ERROR, "Failed in CreateUnitTestSuite for Conversions Test Suite\n"));
> +    Status = EFI_OUT_OF_RESOURCES;
> +    goto EXIT;
> +  }
> +  AddTestCase(ConversionTestSuite, "Test SafeInt8ToUint8",    "TestSafeInt8ToUint8",    TestSafeInt8ToUint8,    NULL, NULL, NULL);
> +  AddTestCase(ConversionTestSuite, "Test SafeInt8ToUint16",   "TestSafeInt8ToUint16",   TestSafeInt8ToUint16,   NULL, NULL, NULL);
> +  AddTestCase(ConversionTestSuite, "Test SafeInt8ToUint32",   "TestSafeInt8ToUint32",   TestSafeInt8ToUint32,   NULL, NULL, NULL);
> +  AddTestCase(ConversionTestSuite, "Test SafeInt8ToUintn",    "TestSafeInt8ToUintn",    TestSafeInt8ToUintn,    NULL, NULL, NULL);
> +  AddTestCase(ConversionTestSuite, "Test SafeInt8ToUint64",   "TestSafeInt8ToUint64",   TestSafeInt8ToUint64,   NULL, NULL, NULL);
> +  AddTestCase(ConversionTestSuite, "Test SafeUint8ToInt8",    "TestSafeUint8ToInt8",    TestSafeUint8ToInt8,    NULL, NULL, NULL);
> +  AddTestCase(ConversionTestSuite, "Test SafeUint8ToChar8",   "TestSafeUint8ToChar8",   TestSafeUint8ToChar8,   NULL, NULL, NULL);
> +  AddTestCase(ConversionTestSuite, "Test SafeInt16ToInt8",    "TestSafeInt16ToInt8",    TestSafeInt16ToInt8,    NULL, NULL, NULL);
> +  AddTestCase(ConversionTestSuite, "Test SafeInt16ToChar8",   "TestSafeInt16ToChar8",   TestSafeInt16ToChar8,   NULL, NULL, NULL);
> +  AddTestCase(ConversionTestSuite, "Test SafeInt16ToUint8",   "TestSafeInt16ToUint8",   TestSafeInt16ToUint8,   NULL, NULL, NULL);
> +  AddTestCase(ConversionTestSuite, "Test SafeInt16ToUint16",  "TestSafeInt16ToUint16",  TestSafeInt16ToUint16,  NULL, NULL, NULL);
> +  AddTestCase(ConversionTestSuite, "Test SafeInt16ToUint32",  "TestSafeInt16ToUint32",  TestSafeInt16ToUint32,  NULL, NULL, NULL);
> +  AddTestCase(ConversionTestSuite, "Test SafeInt16ToUintn",   "TestSafeInt16ToUintn",   TestSafeInt16ToUintn,   NULL, NULL, NULL);
> +  AddTestCase(ConversionTestSuite, "Test SafeInt16ToUint64",  "TestSafeInt16ToUint64",  TestSafeInt16ToUint64,  NULL, NULL, NULL);
> +  AddTestCase(ConversionTestSuite, "Test SafeUint16ToInt8",   "TestSafeUint16ToInt8",   TestSafeUint16ToInt8,   NULL, NULL, NULL);
> +  AddTestCase(ConversionTestSuite, "Test SafeUint16ToChar8",  "TestSafeUint16ToChar8",  TestSafeUint16ToChar8,  NULL, NULL, NULL);
> +  AddTestCase(ConversionTestSuite, "Test SafeUint16ToUint8",  "TestSafeUint16ToUint8",  TestSafeUint16ToUint8,  NULL, NULL, NULL);
> +  AddTestCase(ConversionTestSuite, "Test SafeUint16ToInt16",  "TestSafeUint16ToInt16",  TestSafeUint16ToInt16,  NULL, NULL, NULL);
> +  AddTestCase(ConversionTestSuite, "Test SafeInt32ToInt8",    "TestSafeInt32ToInt8",    TestSafeInt32ToInt8,    NULL, NULL, NULL);
> +  AddTestCase(ConversionTestSuite, "Test SafeInt32ToChar8",   "TestSafeInt32ToChar8",   TestSafeInt32ToChar8,   NULL, NULL, NULL);
> +  AddTestCase(ConversionTestSuite, "Test SafeInt32ToUint8",   "TestSafeInt32ToUint8",   TestSafeInt32ToUint8,   NULL, NULL, NULL);
> +  AddTestCase(ConversionTestSuite, "Test SafeInt32ToInt16",   "TestSafeInt32ToInt16",   TestSafeInt32ToInt16,   NULL, NULL, NULL);
> +  AddTestCase(ConversionTestSuite, "Test SafeInt32ToUint16",  "TestSafeInt32ToUint16",  TestSafeInt32ToUint16,  NULL, NULL, NULL);
> +  AddTestCase(ConversionTestSuite, "Test SafeInt32ToUint32",  "TestSafeInt32ToUint32",  TestSafeInt32ToUint32,  NULL, NULL, NULL);
> +  AddTestCase(ConversionTestSuite, "Test SafeInt32ToUintn",   "TestSafeInt32ToUintn",   TestSafeInt32ToUintn,   NULL, NULL, NULL);
> +  AddTestCase(ConversionTestSuite, "Test SafeInt32ToUint64",  "TestSafeInt32ToUint64",  TestSafeInt32ToUint64,  NULL, NULL, NULL);
> +  AddTestCase(ConversionTestSuite, "Test SafeUint32ToInt8",   "TestSafeUint32ToInt8",   TestSafeUint32ToInt8,   NULL, NULL, NULL);
> +  AddTestCase(ConversionTestSuite, "Test SafeUint32ToChar8",  "TestSafeUint32ToChar8",  TestSafeUint32ToChar8,  NULL, NULL, NULL);
> +  AddTestCase(ConversionTestSuite, "Test SafeUint32ToUint8",  "TestSafeUint32ToUint8",  TestSafeUint32ToUint8,  NULL, NULL, NULL);
> +  AddTestCase(ConversionTestSuite, "Test SafeUint32ToInt16",  "TestSafeUint32ToInt16",  TestSafeUint32ToInt16,  NULL, NULL, NULL);
> +  AddTestCase(ConversionTestSuite, "Test SafeUint32ToUint16", "TestSafeUint32ToUint16", TestSafeUint32ToUint16, NULL, NULL,
> NULL);
> +  AddTestCase(ConversionTestSuite, "Test SafeUint32ToInt32",  "TestSafeUint32ToInt32",  TestSafeUint32ToInt32,  NULL, NULL, NULL);
> +  AddTestCase(ConversionTestSuite, "Test SafeUint32ToIntn",   "TestSafeUint32ToIntn",   TestSafeUint32ToIntn,   NULL, NULL, NULL);
> +  AddTestCase(ConversionTestSuite, "Test SafeIntnToInt8",     "TestSafeIntnToInt8",     TestSafeIntnToInt8,     NULL, NULL, NULL);
> +  AddTestCase(ConversionTestSuite, "Test SafeIntnToChar8",    "TestSafeIntnToChar8",    TestSafeIntnToChar8,    NULL, NULL, NULL);
> +  AddTestCase(ConversionTestSuite, "Test SafeIntnToUint8",    "TestSafeIntnToUint8",    TestSafeIntnToUint8,    NULL, NULL, NULL);
> +  AddTestCase(ConversionTestSuite, "Test SafeIntnToInt16",    "TestSafeIntnToInt16",    TestSafeIntnToInt16,    NULL, NULL, NULL);
> +  AddTestCase(ConversionTestSuite, "Test SafeIntnToUint16",   "TestSafeIntnToUint16",   TestSafeIntnToUint16,   NULL, NULL, NULL);
> +  AddTestCase(ConversionTestSuite, "Test SafeIntnToInt32",    "TestSafeIntnToInt32",    TestSafeIntnToInt32,    NULL, NULL, NULL);
> +  AddTestCase(ConversionTestSuite, "Test SafeIntnToUint32",   "TestSafeIntnToUint32",   TestSafeIntnToUint32,   NULL, NULL, NULL);
> +  AddTestCase(ConversionTestSuite, "Test SafeIntnToUintn",    "TestSafeIntnToUintn",    TestSafeIntnToUintn,    NULL, NULL, NULL);
> +  AddTestCase(ConversionTestSuite, "Test SafeIntnToUint64",   "TestSafeIntnToUint64",   TestSafeIntnToUint64,   NULL, NULL, NULL);
> +  AddTestCase(ConversionTestSuite, "Test SafeUintnToInt8",    "TestSafeUintnToInt8",    TestSafeUintnToInt8,    NULL, NULL, NULL);
> +  AddTestCase(ConversionTestSuite, "Test SafeUintnToChar8",   "TestSafeUintnToChar8",   TestSafeUintnToChar8,   NULL, NULL, NULL);
> +  AddTestCase(ConversionTestSuite, "Test SafeUintnToUint8",   "TestSafeUintnToUint8",   TestSafeUintnToUint8,   NULL, NULL, NULL);
> +  AddTestCase(ConversionTestSuite, "Test SafeUintnToInt16",   "TestSafeUintnToInt16",   TestSafeUintnToInt16,   NULL, NULL, NULL);
> +  AddTestCase(ConversionTestSuite, "Test SafeUintnToUint16",  "TestSafeUintnToUint16",  TestSafeUintnToUint16,  NULL, NULL, NULL);
> +  AddTestCase(ConversionTestSuite, "Test SafeUintnToInt32",   "TestSafeUintnToInt32",   TestSafeUintnToInt32,   NULL, NULL, NULL);
> +  AddTestCase(ConversionTestSuite, "Test SafeUintnToUint32",  "TestSafeUintnToUint32",  TestSafeUintnToUint32,  NULL, NULL, NULL);
> +  AddTestCase(ConversionTestSuite, "Test SafeUintnToIntn",    "TestSafeUintnToIntn",    TestSafeUintnToIntn,    NULL, NULL, NULL);
> +  AddTestCase(ConversionTestSuite, "Test SafeUintnToInt64",   "TestSafeUintnToInt64",   TestSafeUintnToInt64,   NULL, NULL, NULL);
> +  AddTestCase(ConversionTestSuite, "Test SafeInt64ToInt8",    "TestSafeInt64ToInt8",    TestSafeInt64ToInt8,    NULL, NULL, NULL);
> +  AddTestCase(ConversionTestSuite, "Test SafeInt64ToChar8",   "TestSafeInt64ToChar8",   TestSafeInt64ToChar8,   NULL, NULL, NULL);
> +  AddTestCase(ConversionTestSuite, "Test SafeInt64ToUint8",   "TestSafeInt64ToUint8",   TestSafeInt64ToUint8,   NULL, NULL, NULL);
> +  AddTestCase(ConversionTestSuite, "Test SafeInt64ToInt16",   "TestSafeInt64ToInt16",   TestSafeInt64ToInt16,   NULL, NULL, NULL);
> +  AddTestCase(ConversionTestSuite, "Test SafeInt64ToUint16",  "TestSafeInt64ToUint16",  TestSafeInt64ToUint16,  NULL, NULL, NULL);
> +  AddTestCase(ConversionTestSuite, "Test SafeInt64ToInt32",   "TestSafeInt64ToInt32",   TestSafeInt64ToInt32,   NULL, NULL, NULL);
> +  AddTestCase(ConversionTestSuite, "Test SafeInt64ToUint32",  "TestSafeInt64ToUint32",  TestSafeInt64ToUint32,  NULL, NULL, NULL);
> +  AddTestCase(ConversionTestSuite, "Test SafeInt64ToIntn",    "TestSafeInt64ToIntn",    TestSafeInt64ToIntn,    NULL, NULL, NULL);
> +  AddTestCase(ConversionTestSuite, "Test SafeInt64ToUintn",   "TestSafeInt64ToUintn",   TestSafeInt64ToUintn,   NULL, NULL, NULL);
> +  AddTestCase(ConversionTestSuite, "Test SafeInt64ToUint64",  "TestSafeInt64ToUint64",  TestSafeInt64ToUint64,  NULL, NULL, NULL);
> +  AddTestCase(ConversionTestSuite, "Test SafeUint64ToInt8",   "TestSafeUint64ToInt8",   TestSafeUint64ToInt8,   NULL, NULL, NULL);
> +  AddTestCase(ConversionTestSuite, "Test SafeUint64ToChar8",  "TestSafeUint64ToChar8",  TestSafeUint64ToChar8,  NULL, NULL, NULL);
> +  AddTestCase(ConversionTestSuite, "Test SafeUint64ToUint8",  "TestSafeUint64ToUint8",  TestSafeUint64ToUint8,  NULL, NULL, NULL);
> +  AddTestCase(ConversionTestSuite, "Test SafeUint64ToInt16",  "TestSafeUint64ToInt16",  TestSafeUint64ToInt16,  NULL, NULL, NULL);
> +  AddTestCase(ConversionTestSuite, "Test SafeUint64ToUint16", "TestSafeUint64ToUint16", TestSafeUint64ToUint16, NULL, NULL,
> NULL);
> +  AddTestCase(ConversionTestSuite, "Test SafeUint64ToInt32",  "TestSafeUint64ToInt32",  TestSafeUint64ToInt32,  NULL, NULL, NULL);
> +  AddTestCase(ConversionTestSuite, "Test SafeUint64ToUint32", "TestSafeUint64ToUint32", TestSafeUint64ToUint32, NULL, NULL,
> NULL);
> +  AddTestCase(ConversionTestSuite, "Test SafeUint64ToIntn",   "TestSafeUint64ToIntn",   TestSafeUint64ToIntn,   NULL, NULL, NULL);
> +  AddTestCase(ConversionTestSuite, "Test SafeUint64ToUintn",  "TestSafeUint64ToUintn",  TestSafeUint64ToUintn,  NULL, NULL, NULL);
> +  AddTestCase(ConversionTestSuite, "Test SafeUint64ToInt64",  "TestSafeUint64ToInt64",  TestSafeUint64ToInt64,  NULL, NULL, NULL);
> +
> +  //
> +  // Test the addition and subtraction functions
> +  //
> +  Status = CreateUnitTestSuite(&AdditionSubtractionTestSuite, Framework, "Int Safe Add/Subtract Test Suite",
> "Common.SafeInt.AddSubtract", NULL, NULL);
> +  if (EFI_ERROR(Status)) {
> +    DEBUG((DEBUG_ERROR, "Failed in CreateUnitTestSuite for Int Safe Add/Subtract Test Suite\n"));
> +    Status = EFI_OUT_OF_RESOURCES;
> +    goto EXIT;
> +  }
> +  AddTestCase(AdditionSubtractionTestSuite, "Test SafeUint8Add",  "TestSafeUint8Add",  TestSafeUint8Add,  NULL, NULL, NULL);
> +  AddTestCase(AdditionSubtractionTestSuite, "Test SafeUint16Add", "TestSafeUint16Add", TestSafeUint16Add, NULL, NULL, NULL);
> +  AddTestCase(AdditionSubtractionTestSuite, "Test SafeUint32Add", "TestSafeUint32Add", TestSafeUint32Add, NULL, NULL, NULL);
> +  AddTestCase(AdditionSubtractionTestSuite, "Test SafeUintnAdd",  "TestSafeUintnAdd",  TestSafeUintnAdd,  NULL, NULL, NULL);
> +  AddTestCase(AdditionSubtractionTestSuite, "Test SafeUint64Add", "TestSafeUint64Add", TestSafeUint64Add, NULL, NULL, NULL);
> +  AddTestCase(AdditionSubtractionTestSuite, "Test SafeInt8Add",   "TestSafeInt8Add",   TestSafeInt8Add,   NULL, NULL, NULL);
> +  AddTestCase(AdditionSubtractionTestSuite, "Test SafeInt16Add",  "TestSafeInt16Add",  TestSafeInt16Add,  NULL, NULL, NULL);
> +  AddTestCase(AdditionSubtractionTestSuite, "Test SafeInt32Add",  "TestSafeInt32Add",  TestSafeInt32Add,  NULL, NULL, NULL);
> +  AddTestCase(AdditionSubtractionTestSuite, "Test SafeIntnAdd",   "TestSafeIntnAdd",   TestSafeIntnAdd,   NULL, NULL, NULL);
> +  AddTestCase(AdditionSubtractionTestSuite, "Test SafeInt64Add",  "TestSafeInt64Add",  TestSafeInt64Add,  NULL, NULL, NULL);
> +  AddTestCase(AdditionSubtractionTestSuite, "Test SafeUint8Sub",  "TestSafeUint8Sub",  TestSafeUint8Sub,  NULL, NULL, NULL);
> +  AddTestCase(AdditionSubtractionTestSuite, "Test SafeUint16Sub", "TestSafeUint16Sub", TestSafeUint16Sub, NULL, NULL, NULL);
> +  AddTestCase(AdditionSubtractionTestSuite, "Test SafeUint32Sub", "TestSafeUint32Sub", TestSafeUint32Sub, NULL, NULL, NULL);
> +  AddTestCase(AdditionSubtractionTestSuite, "Test SafeUintnSub",  "TestSafeUintnSub",  TestSafeUintnSub,  NULL, NULL, NULL);
> +  AddTestCase(AdditionSubtractionTestSuite, "Test SafeUint64Sub", "TestSafeUint64Sub", TestSafeUint64Sub, NULL, NULL, NULL);
> +  AddTestCase(AdditionSubtractionTestSuite, "Test SafeInt8Sub",   "TestSafeInt8Sub",   TestSafeInt8Sub,   NULL, NULL, NULL);
> +  AddTestCase(AdditionSubtractionTestSuite, "Test SafeInt16Sub",  "TestSafeInt16Sub",  TestSafeInt16Sub,  NULL, NULL, NULL);
> +  AddTestCase(AdditionSubtractionTestSuite, "Test SafeInt32Sub",  "TestSafeInt32Sub",  TestSafeInt32Sub,  NULL, NULL, NULL);
> +  AddTestCase(AdditionSubtractionTestSuite, "Test SafeIntnSub",   "TestSafeIntnSub",   TestSafeIntnSub,   NULL, NULL, NULL);
> +  AddTestCase(AdditionSubtractionTestSuite, "Test SafeInt64Sub",  "TestSafeInt64Sub",  TestSafeInt64Sub,  NULL, NULL, NULL);
> +
> +  //
> +  // Test the multiplication functions
> +  //
> +  Status = CreateUnitTestSuite(&MultiplicationTestSuite, Framework, "Int Safe Multiply Test Suite", "Common.SafeInt.Multiply", NULL,
> NULL);
> +  if (EFI_ERROR(Status)) {
> +    DEBUG((DEBUG_ERROR, "Failed in CreateUnitTestSuite for Int Safe Multiply Test Suite\n"));
> +    Status = EFI_OUT_OF_RESOURCES;
> +    goto EXIT;
> +  }
> +  AddTestCase(MultiplicationTestSuite, "Test SafeUint8Mult",  "TestSafeUint8Mult",  TestSafeUint8Mult,  NULL, NULL, NULL);
> +  AddTestCase(MultiplicationTestSuite, "Test SafeUint16Mult", "TestSafeUint16Mult", TestSafeUint16Mult, NULL, NULL, NULL);
> +  AddTestCase(MultiplicationTestSuite, "Test SafeUint32Mult", "TestSafeUint32Mult", TestSafeUint32Mult, NULL, NULL, NULL);
> +  AddTestCase(MultiplicationTestSuite, "Test SafeUintnMult",  "TestSafeUintnMult",  TestSafeUintnMult,  NULL, NULL, NULL);
> +  AddTestCase(MultiplicationTestSuite, "Test SafeUint64Mult", "TestSafeUint64Mult", TestSafeUint64Mult, NULL, NULL, NULL);
> +  AddTestCase(MultiplicationTestSuite, "Test SafeInt8Mult",   "TestSafeInt8Mult",   TestSafeInt8Mult,   NULL, NULL, NULL);
> +  AddTestCase(MultiplicationTestSuite, "Test SafeInt16Mult",  "TestSafeInt16Mult",  TestSafeInt16Mult,  NULL, NULL, NULL);
> +  AddTestCase(MultiplicationTestSuite, "Test SafeInt32Mult",  "TestSafeInt32Mult",  TestSafeInt32Mult,  NULL, NULL, NULL);
> +  AddTestCase(MultiplicationTestSuite, "Test SafeIntnMult",   "TestSafeIntnMult",   TestSafeIntnMult,   NULL, NULL, NULL);
> +  AddTestCase(MultiplicationTestSuite, "Test SafeInt64Mult",  "TestSafeInt64Mult",  TestSafeInt64Mult,  NULL, NULL, NULL);
> +
> +  //
> +  // Execute the tests.
> +  //
> +  Status = RunAllTestSuites(Framework);
> +
> +EXIT:
> +  if (Framework != NULL) {
> +    FreeUnitTestFramework(Framework);
> +  }
> +
> +  return Status;
> +}
> +
> +EFI_STATUS
> +EFIAPI
> +PeiEntryPoint (
> +  IN EFI_PEI_FILE_HANDLE       FileHandle,
> +  IN CONST EFI_PEI_SERVICES    **PeiServices
> +  )
> +{
> +  return UefiTestMain ();
> +}
> +
> +EFI_STATUS
> +EFIAPI
> +DxeEntryPoint (
> +  IN EFI_HANDLE        ImageHandle,
> +  IN EFI_SYSTEM_TABLE  *SystemTable
> +  )
> +{
> +  return UefiTestMain ();
> +}
> +
> +int
> +main (
> +  int argc,
> +  char *argv[]
> +  )
> +{
> +  return UefiTestMain ();
> +}
> diff --git a/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntLib.h
> b/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntLib.h
> new file mode 100644
> index 0000000000..7957c99a85
> --- /dev/null
> +++ b/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntLib.h
> @@ -0,0 +1,123 @@
> +/** @file
> +  UEFI OS based application for unit testing the SafeIntLib.
> +
> +  Copyright (c) Microsoft Corporation.<BR>
> +  Copyright (c) 2018 - 2020, Intel Corporation. All rights reserved.<BR>
> +  SPDX-License-Identifier: BSD-2-Clause-Patent
> +
> +**/
> +
> +#ifndef _TEST_BASE_SAFE_INT_LIB_H_
> +#define _TEST_BASE_SAFE_INT_LIB_H_
> +
> +#include <PiPei.h>
> +#include <Uefi.h>
> +#include <Library/UefiLib.h>
> +#include <Library/DebugLib.h>
> +#include <Library/MemoryAllocationLib.h>
> +#include <Library/UnitTestLib.h>
> +#include <Library/SafeIntLib.h>
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeInt32ToUintn(
> +  IN UNIT_TEST_CONTEXT           Context
> +  );
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUint32ToIntn(
> +  IN UNIT_TEST_CONTEXT           Context
> +  );
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeIntnToInt32(
> +  IN UNIT_TEST_CONTEXT           Context
> +  );
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeIntnToUint32(
> +  IN UNIT_TEST_CONTEXT           Context
> +  );
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUintnToUint32(
> +  IN UNIT_TEST_CONTEXT           Context
> +  );
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUintnToIntn(
> +  IN UNIT_TEST_CONTEXT           Context
> +  );
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUintnToInt64(
> +  IN UNIT_TEST_CONTEXT           Context
> +  );
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeInt64ToIntn(
> +  IN UNIT_TEST_CONTEXT           Context
> +  );
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeInt64ToUintn(
> +  IN UNIT_TEST_CONTEXT           Context
> +  );
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUint64ToIntn(
> +  IN UNIT_TEST_CONTEXT           Context
> +  );
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUint64ToUintn(
> +  IN UNIT_TEST_CONTEXT           Context
> +  );
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUintnAdd(
> +  IN UNIT_TEST_CONTEXT           Context
> +  );
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeIntnAdd(
> +  IN UNIT_TEST_CONTEXT           Context
> +  );
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUintnSub(
> +  IN UNIT_TEST_CONTEXT           Context
> +  );
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeIntnSub(
> +  IN UNIT_TEST_CONTEXT           Context
> +  );
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUintnMult(
> +  IN UNIT_TEST_CONTEXT           Context
> +  );
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeIntnMult(
> +  IN UNIT_TEST_CONTEXT           Context
> +  );
> +
> +#endif
> diff --git a/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntLib.uni
> b/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntLib.uni
> new file mode 100644
> index 0000000000..956835c30d
> --- /dev/null
> +++ b/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntLib.uni
> @@ -0,0 +1,13 @@
> +// /** @file
> +// Application that Unit Tests the SafeIntLib
> +//
> +// Copyright (c) 2020, Intel Corporation. All rights reserved.<BR>
> +//
> +// SPDX-License-Identifier: BSD-2-Clause-Patent
> +//
> +// **/
> +
> +#string STR_MODULE_ABSTRACT             #language en-US "Application that Unit Tests the SafeIntLib"
> +
> +#string STR_MODULE_DESCRIPTION          #language en-US "Application that Unit Tests the SafeIntLib."
> +
> diff --git a/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntLibDxe.inf
> b/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntLibDxe.inf
> new file mode 100644
> index 0000000000..de67b04bd5
> --- /dev/null
> +++ b/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntLibDxe.inf
> @@ -0,0 +1,45 @@
> +## @file
> +# DXE Driver that Unit Tests the SafeIntLib
> +#
> +# Copyright (c) Microsoft Corporation.<BR>
> +# Copyright (c) 2019 - 2020, Intel Corporation. All rights reserved.<BR>
> +# SPDX-License-Identifier: BSD-2-Clause-Patent
> +##
> +
> +[Defines]
> +  INF_VERSION     = 0x00010005
> +  BASE_NAME       = TestBaseSafeIntLibDxe
> +  MODULE_UNI_FILE = TestBaseSafeIntLib.uni
> +  FILE_GUID       = 9729DB60-FB9D-4625-9EE1-93B21EC246B8
> +  MODULE_TYPE     = DXE_DRIVER
> +  VERSION_STRING  = 1.0
> +  ENTRY_POINT     = DxeEntryPoint
> +
> +#
> +# The following information is for reference only and not required by the build tools.
> +#
> +#  VALID_ARCHITECTURES           = IA32 X64
> +#
> +
> +[Sources]
> +  TestBaseSafeIntLib.c
> +  TestBaseSafeIntLib.h
> +
> +[Sources.Ia32, Sources.ARM]
> +  SafeIntLibUintnIntnUnitTests32.c
> +
> +[Sources.X64, Sources.AARCH64]
> +  SafeIntLibUintnIntnUnitTests64.c
> +
> +[Packages]
> +  MdePkg/MdePkg.dec
> +
> +[LibraryClasses]
> +  UefiDriverEntryPoint
> +  BaseLib
> +  DebugLib
> +  SafeIntLib
> +  UnitTestLib
> +
> +[Depex]
> +  TRUE
> diff --git a/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntLibHost.inf
> b/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntLibHost.inf
> new file mode 100644
> index 0000000000..35c93fdeac
> --- /dev/null
> +++ b/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntLibHost.inf
> @@ -0,0 +1,40 @@
> +## @file
> +# Host OS based Application that Unit Tests the SafeIntLib
> +#
> +# Copyright (c) Microsoft Corporation.<BR>
> +# Copyright (c) 2019 - 2020, Intel Corporation. All rights reserved.<BR>
> +# SPDX-License-Identifier: BSD-2-Clause-Patent
> +##
> +
> +[Defines]
> +  INF_VERSION     = 0x00010005
> +  BASE_NAME       = TestBaseSafeIntLibHost
> +  MODULE_UNI_FILE = TestBaseSafeIntLib.uni
> +  FILE_GUID       = 95487689-9E30-41AD-B773-3650C94BCBE2
> +  MODULE_TYPE     = HOST_APPLICATION
> +  VERSION_STRING  = 1.0
> +
> +#
> +# The following information is for reference only and not required by the build tools.
> +#
> +#  VALID_ARCHITECTURES           = IA32 X64
> +#
> +
> +[Sources]
> +  TestBaseSafeIntLib.c
> +  TestBaseSafeIntLib.h
> +
> +[Sources.Ia32, Sources.ARM]
> +  SafeIntLibUintnIntnUnitTests32.c
> +
> +[Sources.X64, Sources.AARCH64]
> +  SafeIntLibUintnIntnUnitTests64.c
> +
> +[Packages]
> +  MdePkg/MdePkg.dec
> +
> +[LibraryClasses]
> +  BaseLib
> +  DebugLib
> +  SafeIntLib
> +  UnitTestLib
> diff --git a/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntLibPei.inf
> b/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntLibPei.inf
> new file mode 100644
> index 0000000000..c8ba4f44ef
> --- /dev/null
> +++ b/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntLibPei.inf
> @@ -0,0 +1,45 @@
> +## @file
> +# PEIM that Unit Tests the SafeIntLib
> +#
> +# Copyright (c) Microsoft Corporation.<BR>
> +# Copyright (c) 2019 - 2020, Intel Corporation. All rights reserved.<BR>
> +# SPDX-License-Identifier: BSD-2-Clause-Patent
> +##
> +
> +[Defines]
> +  INF_VERSION     = 0x00010005
> +  BASE_NAME       = TestBaseSafeIntLibPei
> +  MODULE_UNI_FILE = TestBaseSafeIntLib.uni
> +  FILE_GUID       = 7D910602-ED53-45E6-826E-8266705B9734
> +  MODULE_TYPE     = PEIM
> +  VERSION_STRING  = 1.0
> +  ENTRY_POINT     = PeiEntryPoint
> +
> +#
> +# The following information is for reference only and not required by the build tools.
> +#
> +#  VALID_ARCHITECTURES           = IA32 X64
> +#
> +
> +[Sources]
> +  TestBaseSafeIntLib.c
> +  TestBaseSafeIntLib.h
> +
> +[Sources.Ia32, Sources.ARM]
> +  SafeIntLibUintnIntnUnitTests32.c
> +
> +[Sources.X64, Sources.AARCH64]
> +  SafeIntLibUintnIntnUnitTests64.c
> +
> +[Packages]
> +  MdePkg/MdePkg.dec
> +
> +[LibraryClasses]
> +  PeimEntryPoint
> +  BaseLib
> +  DebugLib
> +  SafeIntLib
> +  UnitTestLib
> +
> +[Depex]
> +  TRUE
> diff --git a/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntLibSmm.inf
> b/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntLibSmm.inf
> new file mode 100644
> index 0000000000..df7288501d
> --- /dev/null
> +++ b/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntLibSmm.inf
> @@ -0,0 +1,45 @@
> +## @file
> +# SMM Driver that Unit Tests the SafeIntLib
> +#
> +# Copyright (c) Microsoft Corporation.<BR>
> +# Copyright (c) 2019 - 2020, Intel Corporation. All rights reserved.<BR>
> +# SPDX-License-Identifier: BSD-2-Clause-Patent
> +##
> +
> +[Defines]
> +  INF_VERSION     = 0x00010005
> +  BASE_NAME       = TestBaseSafeIntLibSmm
> +  MODULE_UNI_FILE = TestBaseSafeIntLib.uni
> +  FILE_GUID       = 2F2A1907-B1B4-4E33-8B83-62A60AB4F0D4
> +  MODULE_TYPE     = DXE_SMM_DRIVER
> +  VERSION_STRING  = 1.0
> +  ENTRY_POINT     = DxeEntryPoint
> +
> +#
> +# The following information is for reference only and not required by the build tools.
> +#
> +#  VALID_ARCHITECTURES           = IA32 X64
> +#
> +
> +[Sources]
> +  TestBaseSafeIntLib.c
> +  TestBaseSafeIntLib.h
> +
> +[Sources.Ia32, Sources.ARM]
> +  SafeIntLibUintnIntnUnitTests32.c
> +
> +[Sources.X64, Sources.AARCH64]
> +  SafeIntLibUintnIntnUnitTests64.c
> +
> +[Packages]
> +  MdePkg/MdePkg.dec
> +
> +[LibraryClasses]
> +  UefiDriverEntryPoint
> +  BaseLib
> +  DebugLib
> +  SafeIntLib
> +  UnitTestLib
> +
> +[Depex]
> +  TRUE
> diff --git a/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntLibUefiShell.inf
> b/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntLibUefiShell.inf
> new file mode 100644
> index 0000000000..5a13c1c845
> --- /dev/null
> +++ b/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntLibUefiShell.inf
> @@ -0,0 +1,42 @@
> +## @file
> +# UEFI Shell based Application that Unit Tests the SafeIntLib
> +#
> +# Copyright (c) Microsoft Corporation.<BR>
> +# Copyright (c) 2019 - 2020, Intel Corporation. All rights reserved.<BR>
> +# SPDX-License-Identifier: BSD-2-Clause-Patent
> +##
> +
> +[Defines]
> +  INF_VERSION     = 0x00010005
> +  BASE_NAME       = TestBaseSafeIntLibUefiShell
> +  MODULE_UNI_FILE = TestBaseSafeIntLib.uni
> +  FILE_GUID       = 1F91B73E-5B6A-4317-80E8-E7C36A3C7AF4
> +  MODULE_TYPE     = UEFI_APPLICATION
> +  VERSION_STRING  = 1.0
> +  ENTRY_POINT     = DxeEntryPoint
> +
> +#
> +# The following information is for reference only and not required by the build tools.
> +#
> +#  VALID_ARCHITECTURES           = IA32 X64
> +#
> +
> +[Sources]
> +  TestBaseSafeIntLib.c
> +  TestBaseSafeIntLib.h
> +
> +[Sources.Ia32, Sources.ARM]
> +  SafeIntLibUintnIntnUnitTests32.c
> +
> +[Sources.X64, Sources.AARCH64]
> +  SafeIntLibUintnIntnUnitTests64.c
> +
> +[Packages]
> +  MdePkg/MdePkg.dec
> +
> +[LibraryClasses]
> +  UefiApplicationEntryPoint
> +  BaseLib
> +  DebugLib
> +  SafeIntLib
> +  UnitTestLib
> --
> 2.21.0.windows.1


  parent reply	other threads:[~2020-02-07  7:56 UTC|newest]

Thread overview: 33+ messages / expand[flat|nested]  mbox.gz  Atom feed  top
2020-01-24  2:10 [Patch 00/11] Add Unit Test Framework Michael D Kinney
2020-01-24  2:10 ` [Patch 01/11] .pytool: Add CI support for host based unit tests with results Michael D Kinney
2020-01-27 23:28   ` [edk2-devel] " brbarkel
2020-01-24  2:10 ` [Patch 02/11] BaseTools/Plugin: Add HostBasedUnitTestRunner plugin Michael D Kinney
2020-01-27 23:29   ` [edk2-devel] " brbarkel
2020-02-07  2:32   ` Bob Feng
2020-01-24  2:10 ` [Patch 03/11] MdePkg/Include/Library: Add UnitTestLib class Michael D Kinney
2020-01-27 23:42   ` [edk2-devel] " brbarkel
2020-02-07  0:49   ` Michael D Kinney
2020-02-07  1:22   ` Wu, Hao A
2020-02-07  5:43     ` Bret Barkelew
2020-01-24  2:10 ` [Patch 04/11] UnitTestFrameworkPkg: Add public and private interfaces Michael D Kinney
2020-01-27 23:42   ` [edk2-devel] " brbarkel
2020-01-24  2:10 ` [Patch 05/11] UnitTestFrameworkPkg/Library: Add library instances Michael D Kinney
2020-01-27 23:43   ` [edk2-devel] " brbarkel
2020-01-24  2:10 ` [Patch 06/11] UnitTestFrameworkPkg/Test: Add unit test samples Michael D Kinney
2020-01-27 23:43   ` [edk2-devel] " brbarkel
2020-01-24  2:10 ` [Patch 07/11] UnitTestFrameworkPkg: Add DSC, DSC INC, and YAML files Michael D Kinney
2020-01-27 23:43   ` [edk2-devel] " brbarkel
2020-01-24  2:10 ` [Patch 08/11] MdePkg/Test: Add SafeIntLib and BaseLib Base64 unit tests Michael D Kinney
2020-01-27 23:43   ` [edk2-devel] " brbarkel
2020-02-07  1:27   ` Wu, Hao A
2020-02-07  7:56   ` Liming Gao [this message]
2020-02-07 16:05     ` Michael D Kinney
2020-01-24  2:10 ` [Patch 09/11] MdeModulePkg: Add DxeResetSystemLib unit test Michael D Kinney
2020-01-27 23:43   ` [edk2-devel] " brbarkel
2020-02-07  1:25   ` Wu, Hao A
2020-01-24  2:10 ` [Patch 10/11] .azurepipelines: Enable CI for UnitTestFrameworkPkg and host tests Michael D Kinney
2020-01-27 23:44   ` [edk2-devel] " brbarkel
2020-01-24  2:10 ` [Patch 11/11] Maintainers.txt: Add UnitTestFrameworkPkg Michael D Kinney
2020-01-24 10:22   ` Laszlo Ersek
2020-01-27 23:44     ` [edk2-devel] " brbarkel
2020-01-27 23:28 ` [edk2-devel] [Patch 00/11] Add Unit Test Framework brbarkel

Reply instructions:

You may reply publicly to this message via plain-text email
using any one of the following methods:

* Save the following mbox file, import it into your mail client,
  and reply-to-list from there: mbox

  Avoid top-posting and favor interleaved quoting:
  https://en.wikipedia.org/wiki/Posting_style#Interleaved_style

* Reply using the --to, --cc, and --in-reply-to
  switches of git-send-email(1):

  git send-email \
    --in-reply-to=03ad7e4568304fde814f966e109372b6@intel.com \
    --to=devel@edk2.groups.io \
    /path/to/YOUR_REPLY

  https://kernel.org/pub/software/scm/git/docs/git-send-email.html

* If your mail client supports setting the In-Reply-To header
  via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line before the message body.
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox