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