From: "Michael D Kinney" <michael.d.kinney@intel.com>
To: "Gao, Liming" <liming.gao@intel.com>,
"devel@edk2.groups.io" <devel@edk2.groups.io>,
"Kinney, Michael D" <michael.d.kinney@intel.com>
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 16:05:26 +0000 [thread overview]
Message-ID: <E92EE9817A31E24EB0585FDF735412F5B9E896AF@ORSMSX113.amr.corp.intel.com> (raw)
In-Reply-To: <03ad7e4568304fde814f966e109372b6@intel.com>
Hi Liming,
Unit tests can be run as a host application.
If they do not use cmocka, it may be possible to run from the
UEFI Shell, depending on the attributes of the API under test.
If a unit test is specific to the PEI, SMM, or early DXE phase,
Then it cannot be run from the UEFI Shell. If a unit test is
for an API of type BASE or late DXE or UEFI, it can run from the
UEFI Shell.
There are samples in the UnitTestFrameworkPkg that show a single
sample can be built for host and all target environments.
The SafeIntLib and BaseLib examples could be built and run from the
UEFI Shell. This patch series only has a single DSC file to
build and run them from a host env, but a 2nd DSC could be added
to build them for the UEFI Shell. If a unit test can be run from
the host and get full coverage, then that is an easier environment
to do the testing. Unit tests that meet this criteria do not need
to be built for the target envs. This is why the SafeIntLib and
BaseLib unit tests provided in this series do not include the
DSC file for target environments.
Thanks,
Mike
> -----Original Message-----
> From: Gao, Liming <liming.gao@intel.com>
> Sent: Thursday, February 6, 2020 11:57 PM
> To: Kinney, Michael D <michael.d.kinney@intel.com>;
> 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
>
> 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/BaseLibUnitTestsHo
> st.inf
> > create mode 100644
> MdePkg/Test/UnitTest/Library/BaseLib/BaseLibUnitTestsUe
> fi.inf
> > create mode 100644
> MdePkg/Test/UnitTest/Library/BaseSafeIntLib/SafeIntLibU
> intnIntnUnitTests32.c
> > create mode 100644
> MdePkg/Test/UnitTest/Library/BaseSafeIntLib/SafeIntLibU
> intnIntnUnitTests64.c
> > create mode 100644
> MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSaf
> eIntLib.c
> > create mode 100644
> MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSaf
> eIntLib.h
> > create mode 100644
> MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSaf
> eIntLib.uni
> > create mode 100644
> MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSaf
> eIntLibDxe.inf
> > create mode 100644
> MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSaf
> eIntLibHost.inf
> > create mode 100644
> MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSaf
> eIntLibPei.inf
> > create mode 100644
> MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSaf
> eIntLibSmm.inf
> > create mode 100644
> MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSaf
> eIntLibUefiShell.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|0x8000
> 0000
> >
> gEfiMdePkgTokenSpaceGuid.PcdPciExpressBaseAddress|0xE00
> 00000
> >
> > +[LibraryClasses]
> > +
> SafeIntLib|MdePkg/Library/BaseSafeIntLib/BaseSafeIntLib
> .inf
> > +
> > [Components]
> >
> MdePkg/Library/UefiFileHandleLib/UefiFileHandleLib.inf
> >
> MdePkg/Library/BaseCacheMaintenanceLib/BaseCacheMainten
> anceLib.inf
> > @@ -115,6 +120,19 @@ [Components]
> >
> MdePkg/Library/StandaloneMmDriverEntryPoint/StandaloneM
> mDriverEntryPoint.inf
> >
> MdePkg/Library/StandaloneMmServicesTableLib/StandaloneM
> mServicesTableLib.inf
> >
> > + #
> > + # Add UEFI Target Based Unit Tests
> > + #
> > +
> MdePkg/Test/UnitTest/Library/BaseLib/BaseLibUnitTestsUe
> fi.inf
> > +
> > + #
> > + # Build PEIM, DXE_DRIVER, SMM_DRIVER, UEFI Shell
> components that test SafeIntLib
> > + #
> > +
> MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSaf
> eIntLibPei.inf
> > +
> MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSaf
> eIntLibDxe.inf
> > +
> MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSaf
> eIntLibSmm.inf
> > +
> MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSaf
> eIntLibUefiShell.inf
> > +
> > [Components.IA32, Components.X64]
> >
> MdePkg/Library/BaseIoLibIntrinsic/BaseIoLibIntrinsic.in
> f
> >
> 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/TestBaseSaf
> eIntLibHost.inf
> > +
> MdePkg/Test/UnitTest/Library/BaseLib/BaseLibUnitTestsHo
> st.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/BaseLibUnitTests
> Host.inf
> >
> b/MdePkg/Test/UnitTest/Library/BaseLib/BaseLibUnitTests
> Host.inf
> > new file mode 100644
> > index 0000000000..b31afae633
> > --- /dev/null
> > +++
> b/MdePkg/Test/UnitTest/Library/BaseLib/BaseLibUnitTests
> Host.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/BaseLibUnitTests
> Uefi.inf
> >
> b/MdePkg/Test/UnitTest/Library/BaseLib/BaseLibUnitTests
> Uefi.inf
> > new file mode 100644
> > index 0000000000..907503898a
> > --- /dev/null
> > +++
> b/MdePkg/Test/UnitTest/Library/BaseLib/BaseLibUnitTests
> Uefi.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/SafeIntLi
> bUintnIntnUnitTests32.c
> >
> b/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/SafeIntLi
> bUintnIntnUnitTests32.c
> > new file mode 100644
> > index 0000000000..be5c0e15d3
> > --- /dev/null
> > +++
> b/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/SafeIntLi
> bUintnIntnUnitTests32.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/SafeIntLi
> bUintnIntnUnitTests64.c
> >
> b/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/SafeIntLi
> bUintnIntnUnitTests64.c
> > new file mode 100644
> > index 0000000000..0fee298172
> > --- /dev/null
> > +++
> b/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/SafeIntLi
> bUintnIntnUnitTests64.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/TestBaseS
> afeIntLib.c
> >
> b/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseS
> afeIntLib.c
> > new file mode 100644
> > index 0000000000..2b1a2223a0
> > --- /dev/null
> > +++
> b/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseS
> afeIntLib.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/TestBaseS
> afeIntLib.h
> >
> b/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseS
> afeIntLib.h
> > new file mode 100644
> > index 0000000000..7957c99a85
> > --- /dev/null
> > +++
> b/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseS
> afeIntLib.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/TestBaseS
> afeIntLib.uni
> >
> b/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseS
> afeIntLib.uni
> > new file mode 100644
> > index 0000000000..956835c30d
> > --- /dev/null
> > +++
> b/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseS
> afeIntLib.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/TestBaseS
> afeIntLibDxe.inf
> >
> b/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseS
> afeIntLibDxe.inf
> > new file mode 100644
> > index 0000000000..de67b04bd5
> > --- /dev/null
> > +++
> b/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseS
> afeIntLibDxe.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/TestBaseS
> afeIntLibHost.inf
> >
> b/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseS
> afeIntLibHost.inf
> > new file mode 100644
> > index 0000000000..35c93fdeac
> > --- /dev/null
> > +++
> b/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseS
> afeIntLibHost.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/TestBaseS
> afeIntLibPei.inf
> >
> b/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseS
> afeIntLibPei.inf
> > new file mode 100644
> > index 0000000000..c8ba4f44ef
> > --- /dev/null
> > +++
> b/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseS
> afeIntLibPei.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/TestBaseS
> afeIntLibSmm.inf
> >
> b/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseS
> afeIntLibSmm.inf
> > new file mode 100644
> > index 0000000000..df7288501d
> > --- /dev/null
> > +++
> b/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseS
> afeIntLibSmm.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/TestBaseS
> afeIntLibUefiShell.inf
> >
> b/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseS
> afeIntLibUefiShell.inf
> > new file mode 100644
> > index 0000000000..5a13c1c845
> > --- /dev/null
> > +++
> b/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseS
> afeIntLibUefiShell.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
next prev parent reply other threads:[~2020-02-07 16:05 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
2020-02-07 16:05 ` Michael D Kinney [this message]
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=E92EE9817A31E24EB0585FDF735412F5B9E896AF@ORSMSX113.amr.corp.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