From mboxrd@z Thu Jan 1 00:00:00 1970 Received: from mga02.intel.com (mga02.intel.com [134.134.136.20]) by mx.groups.io with SMTP id smtpd.web11.1553.1581062199058377717 for ; Thu, 06 Feb 2020 23:56:39 -0800 Authentication-Results: mx.groups.io; dkim=missing; spf=pass (domain: intel.com, ip: 134.134.136.20, mailfrom: liming.gao@intel.com) X-Amp-Result: SKIPPED(no attachment in message) X-Amp-File-Uploaded: False Received: from fmsmga002.fm.intel.com ([10.253.24.26]) by orsmga101.jf.intel.com with ESMTP/TLS/DHE-RSA-AES256-GCM-SHA384; 06 Feb 2020 23:56:38 -0800 X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.70,412,1574150400"; d="scan'208";a="264910113" Received: from fmsmsx105.amr.corp.intel.com ([10.18.124.203]) by fmsmga002.fm.intel.com with ESMTP; 06 Feb 2020 23:56:38 -0800 Received: from shsmsx601.ccr.corp.intel.com (10.109.6.141) by FMSMSX105.amr.corp.intel.com (10.18.124.203) with Microsoft SMTP Server (TLS) id 14.3.439.0; Thu, 6 Feb 2020 23:56:37 -0800 Received: from shsmsx606.ccr.corp.intel.com (10.109.6.216) by SHSMSX601.ccr.corp.intel.com (10.109.6.141) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256) id 15.1.1713.5; Fri, 7 Feb 2020 15:56:35 +0800 Received: from shsmsx606.ccr.corp.intel.com ([10.109.6.216]) by SHSMSX606.ccr.corp.intel.com ([10.109.6.216]) with mapi id 15.01.1713.004; Fri, 7 Feb 2020 15:56:35 +0800 From: "Liming Gao" To: "Kinney, Michael D" , "devel@edk2.groups.io" CC: Sean Brogan , Bret Barkelew Subject: Re: [Patch 08/11] MdePkg/Test: Add SafeIntLib and BaseLib Base64 unit tests Thread-Topic: [Patch 08/11] MdePkg/Test: Add SafeIntLib and BaseLib Base64 unit tests Thread-Index: AQHV0lt7+u50NT88tkyz6Dqiq6dqgqgPcxFQ Date: Fri, 7 Feb 2020 07:56:35 +0000 Message-ID: <03ad7e4568304fde814f966e109372b6@intel.com> References: <20200124021032.13808-1-michael.d.kinney@intel.com> <20200124021032.13808-9-michael.d.kinney@intel.com> In-Reply-To: <20200124021032.13808-9-michael.d.kinney@intel.com> Accept-Language: en-US X-MS-Has-Attach: X-MS-TNEF-Correlator: dlp-version: 11.2.0.6 dlp-product: dlpe-windows dlp-reaction: no-action x-originating-ip: [10.239.127.36] MIME-Version: 1.0 Return-Path: liming.gao@intel.com Content-Language: en-US Content-Type: text/plain; charset="us-ascii" Content-Transfer-Encoding: quoted-printable Mike: Is there the ready UEFI shell environment to run target based tests? Is E= mulator used? Thanks Liming > -----Original Message----- > From: Kinney, Michael D > Sent: Friday, January 24, 2020 10:10 AM > To: devel@edk2.groups.io > Cc: Sean Brogan ; Bret Barkelew ; Gao, Liming > Subject: [Patch 08/11] MdePkg/Test: Add SafeIntLib and BaseLib Base64 uni= t tests >=20 > * 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 >=20 > Cc: Sean Brogan > Cc: Bret Barkelew > Cc: Liming Gao > Signed-off-by: Michael D Kinney > --- > 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/BaseLibUnitTests= Host.inf > create mode 100644 MdePkg/Test/UnitTest/Library/BaseLib/BaseLibUnitTests= Uefi.inf > create mode 100644 MdePkg/Test/UnitTest/Library/BaseSafeIntLib/SafeIntLi= bUintnIntnUnitTests32.c > create mode 100644 MdePkg/Test/UnitTest/Library/BaseSafeIntLib/SafeIntLi= bUintnIntnUnitTests64.c > create mode 100644 MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseS= afeIntLib.c > create mode 100644 MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseS= afeIntLib.h > create mode 100644 MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseS= afeIntLib.uni > create mode 100644 MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseS= afeIntLibDxe.inf > create mode 100644 MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseS= afeIntLibHost.inf > create mode 100644 MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseS= afeIntLibPei.inf > create mode 100644 MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseS= afeIntLibSmm.inf > create mode 100644 MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseS= afeIntLibUefiShell.inf >=20 > 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" > }, >=20 > + ## options defined ci/Plugin/HostUnitTestCompilerPlugin > + "HostUnitTestCompilerPlugin": { > + "DscPath": "Test/MdePkgHostTest.dsc" > + }, > + > ## options defined ci/Plugin/CharEncodingCheck > -"CharEncodingCheck": { > + "CharEncodingCheck": { > "IgnoreFiles": [] > }, >=20 > @@ -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 @@ >=20 > ## options defined ci/Plugin/DscCompleteCheck > "DscCompleteCheck": { > - "IgnoreInf": [], > + "IgnoreInf": [""], > "DscPath": "MdePkg.dsc" > }, >=20 > + ## 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 =3D DEBUG|RELEASE|NOOPT > SKUID_IDENTIFIER =3D DEFAULT >=20 > +!include UnitTestFrameworkPkg/UnitTestFrameworkPkgTarget.dsc.inc > + > [PcdsFeatureFlag] > gEfiMdePkgTokenSpaceGuid.PcdUgaConsumeSupport|TRUE >=20 > @@ -26,6 +28,9 @@ [PcdsFixedAtBuild] > gEfiMdePkgTokenSpaceGuid.PcdDebugPrintErrorLevel|0x80000000 > gEfiMdePkgTokenSpaceGuid.PcdPciExpressBaseAddress|0xE0000000 >=20 > +[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/StandaloneMmDriverEntryPoi= nt.inf > MdePkg/Library/StandaloneMmServicesTableLib/StandaloneMmServicesTableL= ib.inf >=20 > + # > + # 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/TestBaseSafeIntLibUefiShel= l.inf > + > [Components.IA32, Components.X64] > MdePkg/Library/BaseIoLibIntrinsic/BaseIoLibIntrinsic.inf > MdePkg/Library/BaseIoLibIntrinsic/BaseIoLibIntrinsicSev.inf > diff --git a/MdePkg/Test/MdePkgHostTest.dsc b/MdePkg/Test/MdePkgHostTest.= dsc > new file mode 100644 > index 0000000000..3d677ee75c > --- /dev/null > +++ b/MdePkg/Test/MdePkgHostTest.dsc > @@ -0,0 +1,30 @@ > +## @file > +# MdePkg DSC file used to build host-based unit tests. > +# > +# Copyright (c) 2019 - 2020, Intel Corporation. All rights reserved.
> +# Copyright (C) Microsoft Corporation. > +# SPDX-License-Identifier: BSD-2-Clause-Patent > +# > +## > + > +[Defines] > + PLATFORM_NAME =3D MdePkgHostTest > + PLATFORM_GUID =3D 50652B4C-88CB-4481-96E8-37F2D0034440 > + PLATFORM_VERSION =3D 0.1 > + DSC_SPECIFICATION =3D 0x00010005 > + OUTPUT_DIRECTORY =3D Build/MdePkg/HostTest > + SUPPORTED_ARCHITECTURES =3D IA32|X64 > + BUILD_TARGETS =3D NOOPT > + SKUID_IDENTIFIER =3D 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/MdeP= kg/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 > +#include > +#include > +#include > +#include > +#include > + > +#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("") =3D "" > + BASE64("f") =3D "Zg=3D=3D" > + BASE64("fo") =3D "Zm8=3D" > + BASE64("foo") =3D "Zm9v" > + BASE64("foob") =3D "Zm9vYg=3D=3D" > + BASE64("fooba") =3D "Zm9vYmE=3D" > + BASE64("foobar") =3D "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=3D=3D" > +#define BIN_TEST_2 "f" > + > +#define B64_TEST_3 "Zm8=3D" > +#define BIN_TEST_3 "fo" > + > +#define B64_TEST_4 "Zm9v" > +#define BIN_TEST_4 "foo" > + > +#define B64_TEST_5 "Zm9vYg=3D=3D" > +#define BIN_TEST_5 "foob" > + > +#define B64_TEST_6 "Zm9vYmE=3D" > +#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 af= terwards > +#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=3D" > + > +// Invalid characters in the string > +#define B64_ERROR_2 "Zm$vymFy" > + > +// Too many '=3D' characters > +#define B64_ERROR_3 "Z=3D=3D=3D" > + > +// Poorly placed '=3D' > +#define B64_ERROR_4 "Zm=3DvYmFy" > + > +#define MAX_TEST_STRING_SIZE (200) > + > +// ------------------------------------------------ Input----------Outpu= t-----------Result-------Free--Expected Output Size > +static BASIC_TEST_CONTEXT mBasicEncodeTest1 =3D {BIN_TEST_1, B64= _TEST_1, EFI_SUCCESS, NULL, sizeof(B64_TEST_1)}; > +static BASIC_TEST_CONTEXT mBasicEncodeTest2 =3D {BIN_TEST_2, B64= _TEST_2, EFI_SUCCESS, NULL, sizeof(B64_TEST_2)}; > +static BASIC_TEST_CONTEXT mBasicEncodeTest3 =3D {BIN_TEST_3, B64= _TEST_3, EFI_SUCCESS, NULL, sizeof(B64_TEST_3)}; > +static BASIC_TEST_CONTEXT mBasicEncodeTest4 =3D {BIN_TEST_4, B64= _TEST_4, EFI_SUCCESS, NULL, sizeof(B64_TEST_4)}; > +static BASIC_TEST_CONTEXT mBasicEncodeTest5 =3D {BIN_TEST_5, B64= _TEST_5, EFI_SUCCESS, NULL, sizeof(B64_TEST_5)}; > +static BASIC_TEST_CONTEXT mBasicEncodeTest6 =3D {BIN_TEST_6, B64= _TEST_6, EFI_SUCCESS, NULL, sizeof(B64_TEST_6)}; > +static BASIC_TEST_CONTEXT mBasicEncodeTest7 =3D {BIN_TEST_7, B64= _TEST_7, EFI_SUCCESS, NULL, sizeof(B64_TEST_7)}; > +static BASIC_TEST_CONTEXT mBasicEncodeError1 =3D {BIN_TEST_7, B64= _TEST_1, EFI_BUFFER_TOO_SMALL, NULL, > sizeof(B64_TEST_7)}; > + > +static BASIC_TEST_CONTEXT mBasicDecodeTest1 =3D {B64_TEST_1, BIN= _TEST_1, EFI_SUCCESS, NULL, sizeof(BIN_TEST_1)-1}; > +static BASIC_TEST_CONTEXT mBasicDecodeTest2 =3D {B64_TEST_2, BIN= _TEST_2, EFI_SUCCESS, NULL, sizeof(BIN_TEST_2)-1}; > +static BASIC_TEST_CONTEXT mBasicDecodeTest3 =3D {B64_TEST_3, BIN= _TEST_3, EFI_SUCCESS, NULL, sizeof(BIN_TEST_3)-1}; > +static BASIC_TEST_CONTEXT mBasicDecodeTest4 =3D {B64_TEST_4, BIN= _TEST_4, EFI_SUCCESS, NULL, sizeof(BIN_TEST_4)-1}; > +static BASIC_TEST_CONTEXT mBasicDecodeTest5 =3D {B64_TEST_5, BIN= _TEST_5, EFI_SUCCESS, NULL, sizeof(BIN_TEST_5)-1}; > +static BASIC_TEST_CONTEXT mBasicDecodeTest6 =3D {B64_TEST_6, BIN= _TEST_6, EFI_SUCCESS, NULL, sizeof(BIN_TEST_6)-1}; > +static BASIC_TEST_CONTEXT mBasicDecodeTest7 =3D {B64_TEST_7, BIN= _TEST_7, EFI_SUCCESS, NULL, sizeof(BIN_TEST_7)-1}; > +static BASIC_TEST_CONTEXT mBasicDecodeTest8 =3D {B64_TEST_8_IN, BIN= _TEST_8, EFI_SUCCESS, NULL, sizeof(BIN_TEST_8)-1}; > + > +static BASIC_TEST_CONTEXT mBasicDecodeError1 =3D {B64_ERROR_1, B64= _ERROR_1, EFI_INVALID_PARAMETER, NULL, 0}; > +static BASIC_TEST_CONTEXT mBasicDecodeError2 =3D {B64_ERROR_2, B64= _ERROR_2, EFI_INVALID_PARAMETER, NULL, 0}; > +static BASIC_TEST_CONTEXT mBasicDecodeError3 =3D {B64_ERROR_3, B64= _ERROR_3, EFI_INVALID_PARAMETER, NULL, 0}; > +static BASIC_TEST_CONTEXT mBasicDecodeError4 =3D {B64_ERROR_4, B64= _ERROR_4, EFI_INVALID_PARAMETER, NULL, 0}; > +static BASIC_TEST_CONTEXT mBasicDecodeError5 =3D {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 =3D (BASIC_TEST_CONTEXT *)Context; > + if (Btc !=3D NULL) { > + //free string if set > + if (Btc->BufferToFree !=3D NULL) { > + FreePool (Btc->BufferToFree); > + Btc->BufferToFree =3D 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 nee= d a > + reboot. This parameter is a VOID* and it is th= e > + responsibility of the test author to ensure tha= t 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 =3D (BASIC_TEST_CONTEXT *) Context; > + binString =3D Btc->TestInput; > + b64String =3D Btc->TestOutput; > + > + // > + // Only testing the the translate functionality, so preallocate the pr= oper > + // string buffer. > + // > + > + b64StringSize =3D AsciiStrnSizeS(b64String, MAX_TEST_STRING_SIZE); > + BinSize =3D AsciiStrnLenS(binString, MAX_TEST_STRING_SIZE); > + BinData =3D (UINT8 *) binString; > + > + b64WorkString =3D (CHAR8 *) AllocatePool(b64StringSize); > + UT_ASSERT_NOT_NULL(b64WorkString); > + > + Btc->BufferToFree =3D b64WorkString; > + ReturnSize =3D b64StringSize; > + > + Status =3D 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 !=3D 0) { > + CompareStatus =3D AsciiStrnCmp (b64String, b64WorkString, ReturnSi= ze); > + if (CompareStatus !=3D 0) { > + UT_LOG_ERROR ("b64 string compare error - size=3D%d\n", ReturnSi= ze); > + for (indx =3D 0; indx < ReturnSize; indx++) { > + UT_LOG_ERROR (" %2.2x", 0xff & b64String[indx]); > + } > + UT_LOG_ERROR ("\n b64 work string:\n"); > + for (indx =3D 0; indx < ReturnSize; indx++) { > + UT_LOG_ERROR (" %2.2x", 0xff & b64WorkString[indx]); > + } > + UT_LOG_ERROR ("\n"); > + } > + UT_ASSERT_EQUAL (CompareStatus, 0); > + } > + } > + > + Btc->BufferToFree =3D 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 nee= d a > + reboot. This parameter is a VOID* and it is th= e > + responsibility of the test author to ensure tha= t 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 =3D (BASIC_TEST_CONTEXT *)Context; > + b64String =3D Btc->TestInput; > + binString =3D Btc->TestOutput; > + > + // > + // Only testing the the translate functionality > + // > + > + b64StringLen =3D AsciiStrnLenS (b64String, MAX_TEST_STRING_SIZE); > + BinSize =3D AsciiStrnLenS (binString, MAX_TEST_STRING_SIZE); > + > + BinData =3D AllocatePool (BinSize); > + Btc->BufferToFree =3D BinData; > + > + ReturnSize =3D BinSize; > + Status =3D 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 =3D=3D EFI_BUFFER_TOO_SMALL) { > + UT_ASSERT_EQUAL (ReturnSize, Btc->ExpectedSize); > + } > + } else { > + UT_ASSERT_EQUAL (ReturnSize, Btc->ExpectedSize); > + if (ReturnSize !=3D 0) { > + CompareStatus =3D CompareMem (binString, BinData, ReturnSize); > + if (CompareStatus !=3D 0) { > + UT_LOG_ERROR ("bin string compare error - size=3D%d\n", ReturnSi= ze); > + for (indx =3D 0; indx < ReturnSize; indx++) { > + UT_LOG_ERROR (" %2.2x", 0xff & binString[indx]); > + } > + UT_LOG_ERROR ("\nBinData:\n"); > + for (indx =3D 0; indx < ReturnSize; indx++) { > + UT_LOG_ERROR (" %2.2x", 0xff & BinData[indx]); > + } > + UT_LOG_ERROR ("\n"); > + } > + UT_ASSERT_EQUAL (CompareStatus, 0); > + } > + } > + > + Btc->BufferToFree =3D 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 availabl= e 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 =3D NULL; > + > + DEBUG ((DEBUG_INFO, "%a v%a\n", UNIT_TEST_APP_NAME, UNIT_TEST_APP_VERS= ION)); > + > + // > + // Start setting up the test framework for running the tests. > + // > + Status =3D InitUnitTestFramework (&Fw, UNIT_TEST_APP_NAME, gEfiCallerB= aseName, UNIT_TEST_APP_VERSION); > + if (EFI_ERROR (Status)) { > + DEBUG ((DEBUG_ERROR, "Failed in InitUnitTestFramework. Status =3D = %r\n", Status)); > + goto EXIT; > + } > + > + // > + // Populate the B64 Encode Unit Test Suite. > + // > + Status =3D CreateUnitTestSuite (&b64EncodeTests, Fw, "b64 Encode binar= y to Ascii string", "BaseLib.b64Encode", NULL, NULL); > + if (EFI_ERROR (Status)) { > + DEBUG ((DEBUG_ERROR, "Failed in CreateUnitTestSuite for b64EncodeTes= ts\n")); > + Status =3D 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", RfcE= ncodeTest, NULL, CleanUpB64TestContext, > &mBasicEncodeTest2); > + AddTestCase (b64EncodeTests, "RFC 4686 Test Vector - fo", "Test3", Rfc= EncodeTest, NULL, CleanUpB64TestContext, > &mBasicEncodeTest3); > + AddTestCase (b64EncodeTests, "RFC 4686 Test Vector - foo", "Test4", Rf= cEncodeTest, NULL, CleanUpB64TestContext, > &mBasicEncodeTest4); > + AddTestCase (b64EncodeTests, "RFC 4686 Test Vector - foob", "Test5", R= fcEncodeTest, 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", R= fcEncodeTest, NULL, CleanUpB64TestContext, > &mBasicEncodeError1); > + // > + // Populate the B64 Decode Unit Test Suite. > + // > + Status =3D 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 =3D 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", Rfc= DecodeTest, NULL, CleanUpB64TestContext, > &mBasicDecodeTest2); > + AddTestCase (b64DecodeTests, "RFC 4686 Test Vector - fo", "Test3", Rf= cDecodeTest, NULL, CleanUpB64TestContext, > &mBasicDecodeTest3); > + AddTestCase (b64DecodeTests, "RFC 4686 Test Vector - foo", "Test4", R= fcDecodeTest, 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", RfcDe= codeTest, NULL, CleanUpB64TestContext, > &mBasicDecodeTest8); > + > + AddTestCase (b64DecodeTests, "Not a quantum multiple of 4", "Error1", = RfcDecodeTest, NULL, CleanUpB64TestContext, > &mBasicDecodeError1); > + AddTestCase (b64DecodeTests, "Invalid characters in the string", "Erro= r2", 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", R= fcDecodeTest, NULL, CleanUpB64TestContext, > &mBasicDecodeError5); > + > + // > + // Execute the tests. > + // > + Status =3D RunAllTestSuites (Fw); > + > +EXIT: > + if (Fw) { > + FreeUnitTestFramework (Fw); > + } > + > + return Status; > +} > + > +/** > + Standard UEFI entry point for target based unit test execution from UE= FI 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.in= f > 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 =3D 0x00010006 > + BASE_NAME =3D BaseLibUnitTestsHost > + FILE_GUID =3D 1d005f4c-4dfa-41b5-ab0c-be91fe12145= 9 > + MODULE_TYPE =3D HOST_APPLICATION > + VERSION_STRING =3D 1.0 > + > +# > +# The following information is for reference only and not required by th= e build tools. > +# > +# VALID_ARCHITECTURES =3D IA32 X64 > +# > + > +[Sources] > + Base64UnitTest.c > + > +[Packages] > + MdePkg/MdePkg.dec > + > +[LibraryClasses] > + BaseLib > + BaseMemoryLib > + DebugLib > + UnitTestLib > diff --git a/MdePkg/Test/UnitTest/Library/BaseLib/BaseLibUnitTestsUefi.in= f > 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 =3D 0x00010006 > + BASE_NAME =3D BaseLibUnitTestsUefi > + FILE_GUID =3D df5a6fed-8786-4a9d-9d02-eab39497b4a= 1 > + MODULE_TYPE =3D UEFI_APPLICATION > + VERSION_STRING =3D 1.0 > + ENTRY_POINT =3D BaseLibUnitTestAppEntry > + > +# > +# The following information is for reference only and not required by th= e build tools. > +# > +# VALID_ARCHITECTURES =3D IA32 X64 > +# > + > +[Sources] > + Base64UnitTest.c > + > +[Packages] > + MdePkg/MdePkg.dec > + > +[LibraryClasses] > + BaseLib > + BaseMemoryLib > + UefiApplicationEntryPoint > + DebugLib > + UnitTestLib > diff --git a/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/SafeIntLibUintnI= ntnUnitTests32.c > b/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/SafeIntLibUintnIntnUnitTest= s32.c > new file mode 100644 > index 0000000000..be5c0e15d3 > --- /dev/null > +++ b/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/SafeIntLibUintnIntnUnit= Tests32.c > @@ -0,0 +1,540 @@ > +/** @file > + IA32-specific functions for unit-testing INTN and UINTN functions in > + SafeIntLib. > + > + Copyright (c) Microsoft Corporation.
> + Copyright (c) 2019 - 2020, Intel Corporation. All rights reserved.
> + 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 =3D 0x5bababab; > + Result =3D 0; > + Status =3D SafeInt32ToUintn(Operand, &Result); > + UT_ASSERT_NOT_EFI_ERROR(Status); > + UT_ASSERT_EQUAL(0x5bababab, Result); > + > + // > + // Otherwise should result in an error status > + // > + Operand =3D (-1537977259); > + Status =3D 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 <=3D MAX_INTN, then it's a cast > + // > + Operand =3D 0x5bababab; > + Result =3D 0; > + Status =3D SafeUint32ToIntn(Operand, &Result); > + UT_ASSERT_NOT_EFI_ERROR(Status); > + UT_ASSERT_EQUAL(0x5bababab, Result); > + > + // > + // Otherwise should result in an error status > + // > + Operand =3D (0xabababab); > + Status =3D 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 =3D 0x5bababab; > + Result =3D 0; > + Status =3D 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 =3D 0x5bababab; > + Result =3D 0; > + Status =3D SafeIntnToUint32(Operand, &Result); > + UT_ASSERT_NOT_EFI_ERROR(Status); > + UT_ASSERT_EQUAL(0x5bababab, Result); > + > + // > + // Otherwise should result in an error status > + // > + Operand =3D (-1537977259); > + Status =3D 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 =3D 0xabababab; > + Result =3D 0; > + Status =3D 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 <=3D MAX_INTN, then it's a cast > + // > + Operand =3D 0x5bababab; > + Result =3D 0; > + Status =3D SafeUintnToIntn(Operand, &Result); > + UT_ASSERT_NOT_EFI_ERROR(Status); > + UT_ASSERT_EQUAL(0x5bababab, Result); > + > + // > + // Otherwise should result in an error status > + // > + Operand =3D (0xabababab); > + Status =3D 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 =3D 0xabababab; > + Result =3D 0; > + Status =3D 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 =3D 0x5bababab; > + Result =3D 0; > + Status =3D SafeInt64ToIntn(Operand, &Result); > + UT_ASSERT_NOT_EFI_ERROR(Status); > + UT_ASSERT_EQUAL(0x5bababab, Result); > + > + Operand =3D (-1537977259); > + Status =3D SafeInt64ToIntn(Operand, &Result); > + UT_ASSERT_NOT_EFI_ERROR(Status); > + UT_ASSERT_EQUAL((-1537977259), Result); > + > + // > + // Otherwise should result in an error status > + // > + Operand =3D (0x5babababefefefef); > + Status =3D SafeInt64ToIntn(Operand, &Result); > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status); > + > + Operand =3D (-6605562033422200815); > + Status =3D 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 =3D 0xabababab; > + Result =3D 0; > + Status =3D SafeInt64ToUintn(Operand, &Result); > + UT_ASSERT_NOT_EFI_ERROR(Status); > + UT_ASSERT_EQUAL(0xabababab, Result); > + > + // > + // Otherwise should result in an error status > + // > + Operand =3D (0x5babababefefefef); > + Status =3D SafeInt64ToUintn(Operand, &Result); > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status); > + > + Operand =3D (-6605562033422200815); > + Status =3D 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 <=3D MAX_INTN, then it's a cast > + // > + Operand =3D 0x5bababab; > + Result =3D 0; > + Status =3D SafeUint64ToIntn(Operand, &Result); > + UT_ASSERT_NOT_EFI_ERROR(Status); > + UT_ASSERT_EQUAL(0x5bababab, Result); > + > + // > + // Otherwise should result in an error status > + // > + Operand =3D (0xababababefefefef); > + Status =3D 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 <=3D MAX_UINTN, then it's a cast > + // > + Operand =3D 0xabababab; > + Result =3D 0; > + Status =3D SafeUint64ToUintn(Operand, &Result); > + UT_ASSERT_NOT_EFI_ERROR(Status); > + UT_ASSERT_EQUAL(0xabababab, Result); > + > + // > + // Otherwise should result in an error status > + // > + Operand =3D (0xababababefefefef); > + Status =3D 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 add= ition > + // > + Augend =3D 0x3a3a3a3a; > + Addend =3D 0x3a3a3a3a; > + Result =3D 0; > + Status =3D SafeUintnAdd(Augend, Addend, &Result); > + UT_ASSERT_NOT_EFI_ERROR(Status); > + UT_ASSERT_EQUAL(0x74747474, Result); > + > + // > + // Otherwise should result in an error status > + // > + Augend =3D 0xabababab; > + Addend =3D 0xbcbcbcbc; > + Status =3D 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 =3D 0x3a3a3a3a; > + Addend =3D 0x3a3a3a3a; > + Result =3D 0; > + Status =3D SafeIntnAdd(Augend, Addend, &Result); > + UT_ASSERT_NOT_EFI_ERROR(Status); > + UT_ASSERT_EQUAL(0x74747474, Result); > + > + Augend =3D (-976894522); > + Addend =3D (-976894522); > + Status =3D SafeIntnAdd(Augend, Addend, &Result); > + UT_ASSERT_NOT_EFI_ERROR(Status); > + UT_ASSERT_EQUAL((-1953789044), Result); > + > + // > + // Otherwise should result in an error status > + // > + Augend =3D 0x5a5a5a5a; > + Addend =3D 0x5a5a5a5a; > + Status =3D SafeIntnAdd(Augend, Addend, &Result); > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status); > + > + Augend =3D (-1515870810); > + Addend =3D (-1515870810); > + Status =3D 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 >=3D Subtrahend, then it's subtraction > + // > + Minuend =3D 0x5a5a5a5a; > + Subtrahend =3D 0x3b3b3b3b; > + Result =3D 0; > + Status =3D SafeUintnSub(Minuend, Subtrahend, &Result); > + UT_ASSERT_NOT_EFI_ERROR(Status); > + UT_ASSERT_EQUAL(0x1f1f1f1f, Result); > + > + // > + // Otherwise should result in an error status > + // > + Minuend =3D 0x5a5a5a5a; > + Subtrahend =3D 0x6d6d6d6d; > + Status =3D 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 =3D 0x5a5a5a5a; > + Subtrahend =3D 0x3a3a3a3a; > + Result =3D 0; > + Status =3D SafeIntnSub(Minuend, Subtrahend, &Result); > + UT_ASSERT_NOT_EFI_ERROR(Status); > + UT_ASSERT_EQUAL(0x20202020, Result); > + > + Minuend =3D 0x3a3a3a3a; > + Subtrahend =3D 0x5a5a5a5a; > + Status =3D SafeIntnSub(Minuend, Subtrahend, &Result); > + UT_ASSERT_NOT_EFI_ERROR(Status); > + UT_ASSERT_EQUAL((-538976288), Result); > + > + // > + // Otherwise should result in an error status > + // > + Minuend =3D (-2054847098); > + Subtrahend =3D 2054847098; > + Status =3D SafeIntnSub(Minuend, Subtrahend, &Result); > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status); > + > + Minuend =3D (2054847098); > + Subtrahend =3D (-2054847098); > + Status =3D 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 =3D 0xa122a; > + Multiplier =3D 0xd23; > + Result =3D 0; > + Status =3D SafeUintnMult(Multiplicand, Multiplier, &Result); > + UT_ASSERT_NOT_EFI_ERROR(Status); > + UT_ASSERT_EQUAL(0x844c9dbe, Result); > + > + // > + // Otherwise should result in an error status > + // > + Multiplicand =3D 0xa122a; > + Multiplier =3D 0xed23; > + Status =3D 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 =3D 0x123456; > + Multiplier =3D 0x678; > + Result =3D 0; > + Status =3D SafeIntnMult(Multiplicand, Multiplier, &Result); > + UT_ASSERT_NOT_EFI_ERROR(Status); > + UT_ASSERT_EQUAL(0x75c28c50, Result); > + > + // > + // Otherwise should result in an error status > + // > + Multiplicand =3D 0x123456; > + Multiplier =3D 0xabc; > + Status =3D SafeIntnMult(Multiplicand, Multiplier, &Result); > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status); > + > + return UNIT_TEST_PASSED; > +} > diff --git a/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/SafeIntLibUintnI= ntnUnitTests64.c > b/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/SafeIntLibUintnIntnUnitTest= s64.c > new file mode 100644 > index 0000000000..0fee298172 > --- /dev/null > +++ b/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/SafeIntLibUintnIntnUnit= Tests64.c > @@ -0,0 +1,544 @@ > +/** @file > + x64-specific functions for unit-testing INTN and UINTN functions in > + SafeIntLib. > + > + Copyright (c) Microsoft Corporation.
> + Copyright (c) 2019 - 2020, Intel Corporation. All rights reserved.
> + 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 =3D 0x5bababab; > + Result =3D 0; > + Status =3D SafeInt32ToUintn(Operand, &Result); > + UT_ASSERT_NOT_EFI_ERROR(Status); > + UT_ASSERT_EQUAL(0x5bababab, Result); > + > + // > + // Otherwise should result in an error status > + // > + Operand =3D (-1537977259); > + Status =3D 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 =3D 0xabababab; > + Result =3D 0; > + Status =3D 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 =3D 0x5bababab; > + Result =3D 0; > + Status =3D SafeIntnToInt32(Operand, &Result); > + UT_ASSERT_NOT_EFI_ERROR(Status); > + UT_ASSERT_EQUAL(0x5bababab, Result); > + > + Operand =3D (-1537977259); > + Status =3D SafeIntnToInt32(Operand, &Result); > + UT_ASSERT_NOT_EFI_ERROR(Status); > + UT_ASSERT_EQUAL((-1537977259), Result); > + > + // > + // Otherwise should result in an error status > + // > + Operand =3D (0x5babababefefefef); > + Status =3D SafeIntnToInt32(Operand, &Result); > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status); > + > + Operand =3D (-6605562033422200815); > + Status =3D 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 =3D 0xabababab; > + Result =3D 0; > + Status =3D SafeIntnToUint32(Operand, &Result); > + UT_ASSERT_NOT_EFI_ERROR(Status); > + UT_ASSERT_EQUAL(0xabababab, Result); > + > + // > + // Otherwise should result in an error status > + // > + Operand =3D (0x5babababefefefef); > + Status =3D SafeIntnToUint32(Operand, &Result); > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status); > + > + Operand =3D (-6605562033422200815); > + Status =3D 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 <=3D MAX_UINT32, then it's a cast > + // > + Operand =3D 0xabababab; > + Result =3D 0; > + Status =3D SafeUintnToUint32(Operand, &Result); > + UT_ASSERT_NOT_EFI_ERROR(Status); > + UT_ASSERT_EQUAL(0xabababab, Result); > + > + // > + // Otherwise should result in an error status > + // > + Operand =3D (0xababababefefefef); > + Status =3D 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 <=3D MAX_INTN (0x7fff_ffff_ffff_ffff), then it's a ca= st > + // > + Operand =3D 0x5babababefefefef; > + Result =3D 0; > + Status =3D SafeUintnToIntn(Operand, &Result); > + UT_ASSERT_NOT_EFI_ERROR(Status); > + UT_ASSERT_EQUAL(0x5babababefefefef, Result); > + > + // > + // Otherwise should result in an error status > + // > + Operand =3D (0xababababefefefef); > + Status =3D 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 <=3D MAX_INT64, then it's a cast > + // > + Operand =3D 0x5babababefefefef; > + Result =3D 0; > + Status =3D SafeUintnToInt64(Operand, &Result); > + UT_ASSERT_NOT_EFI_ERROR(Status); > + UT_ASSERT_EQUAL(0x5babababefefefef, Result); > + > + // > + // Otherwise should result in an error status > + // > + Operand =3D (0xababababefefefef); > + Status =3D 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 =3D 0x5babababefefefef; > + Result =3D 0; > + Status =3D 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 =3D 0x5babababefefefef; > + Result =3D 0; > + Status =3D SafeInt64ToUintn(Operand, &Result); > + UT_ASSERT_NOT_EFI_ERROR(Status); > + UT_ASSERT_EQUAL(0x5babababefefefef, Result); > + > + // > + // Otherwise should result in an error status > + // > + Operand =3D (-6605562033422200815); > + Status =3D 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 <=3D MAX_INTN (0x7fff_ffff_ffff_ffff), then it's a ca= st > + // > + Operand =3D 0x5babababefefefef; > + Result =3D 0; > + Status =3D SafeUint64ToIntn(Operand, &Result); > + UT_ASSERT_NOT_EFI_ERROR(Status); > + UT_ASSERT_EQUAL(0x5babababefefefef, Result); > + > + // > + // Otherwise should result in an error status > + // > + Operand =3D (0xababababefefefef); > + Status =3D 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 =3D 0xababababefefefef; > + Result =3D 0; > + Status =3D 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 add= ition > + // > + Augend =3D 0x3a3a3a3a12121212; > + Addend =3D 0x3a3a3a3a12121212; > + Result =3D 0; > + Status =3D SafeUintnAdd(Augend, Addend, &Result); > + UT_ASSERT_NOT_EFI_ERROR(Status); > + UT_ASSERT_EQUAL(0x7474747424242424, Result); > + > + // > + // Otherwise should result in an error status > + // > + Augend =3D 0xababababefefefef; > + Addend =3D 0xbcbcbcbcdededede; > + Status =3D 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 =3D 0x3a3a3a3a3a3a3a3a; > + Addend =3D 0x3a3a3a3a3a3a3a3a; > + Result =3D 0; > + Status =3D SafeIntnAdd(Augend, Addend, &Result); > + UT_ASSERT_NOT_EFI_ERROR(Status); > + UT_ASSERT_EQUAL(0x7474747474747474, Result); > + > + Augend =3D (-4195730024608447034); > + Addend =3D (-4195730024608447034); > + Status =3D SafeIntnAdd(Augend, Addend, &Result); > + UT_ASSERT_NOT_EFI_ERROR(Status); > + UT_ASSERT_EQUAL((-8391460049216894068), Result); > + > + // > + // Otherwise should result in an error status > + // > + Augend =3D 0x5a5a5a5a5a5a5a5a; > + Addend =3D 0x5a5a5a5a5a5a5a5a; > + Status =3D SafeIntnAdd(Augend, Addend, &Result); > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status); > + > + Augend =3D (-6510615555426900570); > + Addend =3D (-6510615555426900570); > + Status =3D 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 >=3D Subtrahend, then it's subtraction > + // > + Minuend =3D 0x5a5a5a5a5a5a5a5a; > + Subtrahend =3D 0x3b3b3b3b3b3b3b3b; > + Result =3D 0; > + Status =3D SafeUintnSub(Minuend, Subtrahend, &Result); > + UT_ASSERT_NOT_EFI_ERROR(Status); > + UT_ASSERT_EQUAL(0x1f1f1f1f1f1f1f1f, Result); > + > + // > + // Otherwise should result in an error status > + // > + Minuend =3D 0x5a5a5a5a5a5a5a5a; > + Subtrahend =3D 0x6d6d6d6d6d6d6d6d; > + Status =3D 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 =3D 0x5a5a5a5a5a5a5a5a; > + Subtrahend =3D 0x3a3a3a3a3a3a3a3a; > + Result =3D 0; > + Status =3D SafeIntnSub(Minuend, Subtrahend, &Result); > + UT_ASSERT_NOT_EFI_ERROR(Status); > + UT_ASSERT_EQUAL(0x2020202020202020, Result); > + > + Minuend =3D 0x3a3a3a3a3a3a3a3a; > + Subtrahend =3D 0x5a5a5a5a5a5a5a5a; > + Status =3D SafeIntnSub(Minuend, Subtrahend, &Result); > + UT_ASSERT_NOT_EFI_ERROR(Status); > + UT_ASSERT_EQUAL((-2314885530818453536), Result); > + > + // > + // Otherwise should result in an error status > + // > + Minuend =3D (-8825501086245354106); > + Subtrahend =3D 8825501086245354106; > + Status =3D SafeIntnSub(Minuend, Subtrahend, &Result); > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status); > + > + Minuend =3D (8825501086245354106); > + Subtrahend =3D (-8825501086245354106); > + Status =3D 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 =3D 0x123456789a; > + Multiplier =3D 0x1234567; > + Result =3D 0; > + Status =3D SafeUintnMult(Multiplicand, Multiplier, &Result); > + UT_ASSERT_NOT_EFI_ERROR(Status); > + UT_ASSERT_EQUAL(0x14b66db9745a07f6, Result); > + > + // > + // Otherwise should result in an error status > + // > + Multiplicand =3D 0x123456789a; > + Multiplier =3D 0x12345678; > + Status =3D 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 =3D 0x123456789; > + Multiplier =3D 0x6789abcd; > + Result =3D 0; > + Status =3D SafeIntnMult(Multiplicand, Multiplier, &Result); > + UT_ASSERT_NOT_EFI_ERROR(Status); > + UT_ASSERT_EQUAL(0x75cd9045220d6bb5, Result); > + > + // > + // Otherwise should result in an error status > + // > + Multiplicand =3D 0x123456789; > + Multiplier =3D 0xa789abcd; > + Status =3D SafeIntnMult(Multiplicand, Multiplier, &Result); > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status); > + > + return UNIT_TEST_PASSED; > +} > diff --git a/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntL= ib.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.
> + Copyright (c) 2018 - 2020, Intel Corporation. All rights reserved.
> + 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 =3D 0x5b; > + Result =3D 0; > + Status =3D SafeInt8ToUint8(Operand, &Result); > + UT_ASSERT_NOT_EFI_ERROR(Status); > + UT_ASSERT_EQUAL(0x5b, Result); > + > + // > + // Negative number should result in an error status > + // > + Operand =3D (-56); > + Status =3D 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 =3D 0x5b; > + Result =3D 0; > + Status =3D SafeInt8ToUint16(Operand, &Result); > + UT_ASSERT_NOT_EFI_ERROR(Status); > + UT_ASSERT_EQUAL(0x5b, Result); > + > + // > + // Negative number should result in an error status > + // > + Operand =3D (-56); > + Status =3D 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 =3D 0x5b; > + Result =3D 0; > + Status =3D SafeInt8ToUint32(Operand, &Result); > + UT_ASSERT_NOT_EFI_ERROR(Status); > + UT_ASSERT_EQUAL(0x5b, Result); > + > + // > + // Negative number should result in an error status > + // > + Operand =3D (-56); > + Status =3D 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 =3D 0x5b; > + Result =3D 0; > + Status =3D SafeInt8ToUintn(Operand, &Result); > + UT_ASSERT_NOT_EFI_ERROR(Status); > + UT_ASSERT_EQUAL(0x5b, Result); > + > + // > + // Negative number should result in an error status > + // > + Operand =3D (-56); > + Status =3D 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 =3D 0x5b; > + Result =3D 0; > + Status =3D SafeInt8ToUint64(Operand, &Result); > + UT_ASSERT_NOT_EFI_ERROR(Status); > + UT_ASSERT_EQUAL(0x5b, Result); > + > + // > + // Negative number should result in an error status > + // > + Operand =3D (-56); > + Status =3D 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 <=3D 0x7F (MAX_INT8) should result in a cast > + // > + Operand =3D 0x5b; > + Result =3D 0; > + Status =3D 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 =3D 0xaf; > + Status =3D 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 <=3D 0x7F (MAX_INT8) should result in a cast > + // > + Operand =3D 0x5b; > + Result =3D 0; > + Status =3D 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 =3D 0xaf; > + Status =3D 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 =3D 0x5b; > + Result =3D 0; > + Status =3D SafeInt16ToInt8(Operand, &Result); > + UT_ASSERT_NOT_EFI_ERROR(Status); > + UT_ASSERT_EQUAL(0x5b, Result); > + > + Operand =3D (-35); > + Status =3D SafeInt16ToInt8(Operand, &Result); > + UT_ASSERT_NOT_EFI_ERROR(Status); > + UT_ASSERT_EQUAL((-35), Result); > + > + // > + // Otherwise should result in an error status > + // > + Operand =3D 0x1234; > + Status =3D SafeInt16ToInt8(Operand, &Result); > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status); > + > + Operand =3D (-17835); > + Status =3D 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 =3D 0x5b; > + Result =3D 0; > + Status =3D SafeInt16ToChar8(Operand, &Result); > + UT_ASSERT_NOT_EFI_ERROR(Status); > + UT_ASSERT_EQUAL(0x5b, Result); > + > + Operand =3D 0; > + Result =3D 0; > + Status =3D SafeInt16ToChar8(Operand, &Result); > + UT_ASSERT_NOT_EFI_ERROR(Status); > + UT_ASSERT_EQUAL(0, Result); > + > + Operand =3D MAX_INT8; > + Result =3D 0; > + Status =3D SafeInt16ToChar8(Operand, &Result); > + UT_ASSERT_NOT_EFI_ERROR(Status); > + UT_ASSERT_EQUAL(MAX_INT8, Result); > + > + // > + // Otherwise should result in an error status > + // > + Operand =3D (-35); > + Status =3D SafeInt16ToChar8(Operand, &Result); > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status); > + > + Operand =3D 0x1234; > + Status =3D SafeInt16ToChar8(Operand, &Result); > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status); > + > + Operand =3D (-17835); > + Status =3D 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 =3D 0x5b; > + Result =3D 0; > + Status =3D SafeInt16ToUint8(Operand, &Result); > + UT_ASSERT_NOT_EFI_ERROR(Status); > + UT_ASSERT_EQUAL(0x5b, Result); > + > + // > + // Otherwise should result in an error status > + // > + Operand =3D 0x1234; > + Status =3D SafeInt16ToUint8(Operand, &Result); > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status); > + > + Operand =3D (-17835); > + Status =3D 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 =3D 0x5b5b; > + UINT16 Result =3D 0; > + > + // > + // If Operand is non-negative, then it's a cast > + // > + Status =3D SafeInt16ToUint16(Operand, &Result); > + UT_ASSERT_NOT_EFI_ERROR(Status); > + UT_ASSERT_EQUAL(0x5b5b, Result); > + > + // > + // Otherwise should result in an error status > + // > + Operand =3D (-17835); > + Status =3D 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 =3D 0x5b5b; > + Result =3D 0; > + Status =3D SafeInt16ToUint32(Operand, &Result); > + UT_ASSERT_NOT_EFI_ERROR(Status); > + UT_ASSERT_EQUAL(0x5b5b, Result); > + > + // > + // Otherwise should result in an error status > + // > + Operand =3D (-17835); > + Status =3D 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 =3D 0x5b5b; > + Result =3D 0; > + Status =3D SafeInt16ToUintn(Operand, &Result); > + UT_ASSERT_NOT_EFI_ERROR(Status); > + UT_ASSERT_EQUAL(0x5b5b, Result); > + > + // > + // Otherwise should result in an error status > + // > + Operand =3D (-17835); > + Status =3D 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 =3D 0x5b5b; > + Result =3D 0; > + Status =3D SafeInt16ToUint64(Operand, &Result); > + UT_ASSERT_NOT_EFI_ERROR(Status); > + UT_ASSERT_EQUAL(0x5b5b, Result); > + > + // > + // Otherwise should result in an error status > + // > + Operand =3D (-17835); > + Status =3D 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 <=3D MAX_INT8, it's a cast > + // > + Operand =3D 0x5b; > + Result =3D 0; > + Status =3D SafeUint16ToInt8(Operand, &Result); > + UT_ASSERT_NOT_EFI_ERROR(Status); > + UT_ASSERT_EQUAL(0x5b, Result); > + > + // > + // Otherwise should result in an error status > + // > + Operand =3D (0x5b5b); > + Status =3D 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 <=3D MAX_INT8, it's a cast > + // > + Operand =3D 0x5b; > + Result =3D 0; > + Status =3D SafeUint16ToChar8(Operand, &Result); > + UT_ASSERT_NOT_EFI_ERROR(Status); > + UT_ASSERT_EQUAL(0x5b, Result); > + > + // > + // Otherwise should result in an error status > + // > + Operand =3D (0x5b5b); > + Status =3D 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 <=3D MAX_UINT8 (0xff), it's a cast > + // > + Operand =3D 0xab; > + Result =3D 0; > + Status =3D SafeUint16ToUint8(Operand, &Result); > + UT_ASSERT_NOT_EFI_ERROR(Status); > + UT_ASSERT_EQUAL(0xab, Result); > + > + // > + // Otherwise should result in an error status > + // > + Operand =3D (0x5b5b); > + Status =3D 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 <=3D MAX_INT16 (0x7fff), it's a cast > + // > + Operand =3D 0x5b5b; > + Result =3D 0; > + Status =3D SafeUint16ToInt16(Operand, &Result); > + UT_ASSERT_NOT_EFI_ERROR(Status); > + UT_ASSERT_EQUAL(0x5b5b, Result); > + > + // > + // Otherwise should result in an error status > + // > + Operand =3D (0xabab); > + Status =3D 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 =3D 0x5b; > + Result =3D 0; > + Status =3D SafeInt32ToInt8(Operand, &Result); > + UT_ASSERT_NOT_EFI_ERROR(Status); > + UT_ASSERT_EQUAL(0x5b, Result); > + > + Operand =3D (-57); > + Status =3D SafeInt32ToInt8(Operand, &Result); > + UT_ASSERT_NOT_EFI_ERROR(Status); > + UT_ASSERT_EQUAL((-57), Result); > + > + // > + // Otherwise should result in an error status > + // > + Operand =3D (0x5bababab); > + Status =3D SafeInt32ToInt8(Operand, &Result); > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status); > + > + Operand =3D (-1537977259); > + Status =3D 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 =3D 0x5b; > + Result =3D 0; > + Status =3D SafeInt32ToChar8(Operand, &Result); > + UT_ASSERT_NOT_EFI_ERROR(Status); > + UT_ASSERT_EQUAL(0x5b, Result); > + > + Operand =3D 0; > + Result =3D 0; > + Status =3D SafeInt32ToChar8(Operand, &Result); > + UT_ASSERT_NOT_EFI_ERROR(Status); > + UT_ASSERT_EQUAL(0, Result); > + > + Operand =3D MAX_INT8; > + Result =3D 0; > + Status =3D SafeInt32ToChar8(Operand, &Result); > + UT_ASSERT_NOT_EFI_ERROR(Status); > + UT_ASSERT_EQUAL(MAX_INT8, Result); > + > + // > + // Otherwise should result in an error status > + // > + Operand =3D (-57); > + Status =3D SafeInt32ToChar8(Operand, &Result); > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status); > + > + Operand =3D (0x5bababab); > + Status =3D SafeInt32ToChar8(Operand, &Result); > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status); > + > + Operand =3D (-1537977259); > + Status =3D 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 =3D 0x5b; > + Result =3D 0; > + Status =3D SafeInt32ToUint8(Operand, &Result); > + UT_ASSERT_NOT_EFI_ERROR(Status); > + UT_ASSERT_EQUAL(0x5b, Result); > + > + // > + // Otherwise should result in an error status > + // > + Operand =3D (-57); > + Status =3D SafeInt32ToUint8(Operand, &Result); > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status); > + > + Operand =3D (0x5bababab); > + Status =3D SafeInt32ToUint8(Operand, &Result); > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status); > + > + Operand =3D (-1537977259); > + Status =3D 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 =3D 0x5b5b; > + Result =3D 0; > + Status =3D SafeInt32ToInt16(Operand, &Result); > + UT_ASSERT_NOT_EFI_ERROR(Status); > + UT_ASSERT_EQUAL(0x5b5b, Result); > + > + Operand =3D (-17857); > + Status =3D SafeInt32ToInt16(Operand, &Result); > + UT_ASSERT_NOT_EFI_ERROR(Status); > + UT_ASSERT_EQUAL((-17857), Result); > + > + // > + // Otherwise should result in an error status > + // > + Operand =3D (0x5bababab); > + Status =3D SafeInt32ToInt16(Operand, &Result); > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status); > + > + Operand =3D (-1537977259); > + Status =3D 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 =3D 0xabab; > + Result =3D 0; > + Status =3D SafeInt32ToUint16(Operand, &Result); > + UT_ASSERT_NOT_EFI_ERROR(Status); > + UT_ASSERT_EQUAL(0xabab, Result); > + > + // > + // Otherwise should result in an error status > + // > + Operand =3D (-17857); > + Status =3D SafeInt32ToUint16(Operand, &Result); > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status); > + > + Operand =3D (0x5bababab); > + Status =3D SafeInt32ToUint16(Operand, &Result); > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status); > + > + Operand =3D (-1537977259); > + Status =3D 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 =3D 0x5bababab; > + Result =3D 0; > + Status =3D SafeInt32ToUint32(Operand, &Result); > + UT_ASSERT_NOT_EFI_ERROR(Status); > + UT_ASSERT_EQUAL(0x5bababab, Result); > + > + // > + // Otherwise should result in an error status > + // > + Operand =3D (-1537977259); > + Status =3D 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 =3D 0x5bababab; > + Result =3D 0; > + Status =3D SafeInt32ToUint64(Operand, &Result); > + UT_ASSERT_NOT_EFI_ERROR(Status); > + UT_ASSERT_EQUAL(0x5bababab, Result); > + > + // > + // Otherwise should result in an error status > + // > + Operand =3D (-1537977259); > + Status =3D 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 <=3D MAX_INT8, then it's a cast > + // > + Operand =3D 0x5b; > + Result =3D 0; > + Status =3D SafeUint32ToInt8(Operand, &Result); > + UT_ASSERT_NOT_EFI_ERROR(Status); > + UT_ASSERT_EQUAL(0x5b, Result); > + > + // > + // Otherwise should result in an error status > + // > + Operand =3D (0x5bababab); > + Status =3D 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 <=3D MAX_INT8, then it's a cast > + // > + Operand =3D 0x5b; > + Result =3D 0; > + Status =3D SafeUint32ToChar8(Operand, &Result); > + UT_ASSERT_NOT_EFI_ERROR(Status); > + UT_ASSERT_EQUAL(0x5b, Result); > + > + // > + // Otherwise should result in an error status > + // > + Operand =3D (0x5bababab); > + Status =3D 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 <=3D MAX_UINT8, then it's a cast > + // > + Operand =3D 0xab; > + Result =3D 0; > + Status =3D SafeUint32ToUint8(Operand, &Result); > + UT_ASSERT_NOT_EFI_ERROR(Status); > + UT_ASSERT_EQUAL(0xab, Result); > + > + // > + // Otherwise should result in an error status > + // > + Operand =3D (0xabababab); > + Status =3D 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 <=3D MAX_INT16, then it's a cast > + // > + Operand =3D 0x5bab; > + Result =3D 0; > + Status =3D SafeUint32ToInt16(Operand, &Result); > + UT_ASSERT_NOT_EFI_ERROR(Status); > + UT_ASSERT_EQUAL(0x5bab, Result); > + > + // > + // Otherwise should result in an error status > + // > + Operand =3D (0xabababab); > + Status =3D 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 <=3D MAX_UINT16, then it's a cast > + // > + Operand =3D 0xabab; > + Result =3D 0; > + Status =3D SafeUint32ToUint16(Operand, &Result); > + UT_ASSERT_NOT_EFI_ERROR(Status); > + UT_ASSERT_EQUAL(0xabab, Result); > + > + // > + // Otherwise should result in an error status > + // > + Operand =3D (0xabababab); > + Status =3D 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 <=3D MAX_INT32, then it's a cast > + // > + Operand =3D 0x5bababab; > + Result =3D 0; > + Status =3D SafeUint32ToInt32(Operand, &Result); > + UT_ASSERT_NOT_EFI_ERROR(Status); > + UT_ASSERT_EQUAL(0x5bababab, Result); > + > + // > + // Otherwise should result in an error status > + // > + Operand =3D (0xabababab); > + Status =3D 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 =3D 0x5b; > + Result =3D 0; > + Status =3D SafeIntnToInt8(Operand, &Result); > + UT_ASSERT_NOT_EFI_ERROR(Status); > + UT_ASSERT_EQUAL(0x5b, Result); > + > + Operand =3D (-53); > + Status =3D SafeIntnToInt8(Operand, &Result); > + UT_ASSERT_NOT_EFI_ERROR(Status); > + UT_ASSERT_EQUAL((-53), Result); > + > + // > + // Otherwise should result in an error status > + // > + Operand =3D (0x5bababab); > + Status =3D SafeIntnToInt8(Operand, &Result); > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status); > + > + Operand =3D (-1537977259); > + Status =3D 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 =3D 0x5b; > + Result =3D 0; > + Status =3D SafeIntnToChar8(Operand, &Result); > + UT_ASSERT_NOT_EFI_ERROR(Status); > + UT_ASSERT_EQUAL(0x5b, Result); > + > + Operand =3D 0; > + Result =3D 0; > + Status =3D SafeIntnToChar8(Operand, &Result); > + UT_ASSERT_NOT_EFI_ERROR(Status); > + UT_ASSERT_EQUAL(0, Result); > + > + Operand =3D MAX_INT8; > + Result =3D 0; > + Status =3D SafeIntnToChar8(Operand, &Result); > + UT_ASSERT_NOT_EFI_ERROR(Status); > + UT_ASSERT_EQUAL(MAX_INT8, Result); > + > + // > + // Otherwise should result in an error status > + // > + Operand =3D (-53); > + Status =3D SafeIntnToChar8(Operand, &Result); > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status); > + > + Operand =3D (0x5bababab); > + Status =3D SafeIntnToChar8(Operand, &Result); > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status); > + > + Operand =3D (-1537977259); > + Status =3D 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 =3D 0xab; > + Result =3D 0; > + Status =3D SafeIntnToUint8(Operand, &Result); > + UT_ASSERT_NOT_EFI_ERROR(Status); > + UT_ASSERT_EQUAL(0xab, Result); > + > + // > + // Otherwise should result in an error status > + // > + Operand =3D (0x5bababab); > + Status =3D SafeIntnToUint8(Operand, &Result); > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status); > + > + Operand =3D (-1537977259); > + Status =3D 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 =3D 0x5bab; > + Result =3D 0; > + Status =3D SafeIntnToInt16(Operand, &Result); > + UT_ASSERT_NOT_EFI_ERROR(Status); > + UT_ASSERT_EQUAL(0x5bab, Result); > + > + Operand =3D (-23467); > + Status =3D SafeIntnToInt16(Operand, &Result); > + UT_ASSERT_NOT_EFI_ERROR(Status); > + UT_ASSERT_EQUAL((-23467), Result); > + > + // > + // Otherwise should result in an error status > + // > + Operand =3D (0x5bababab); > + Status =3D SafeIntnToInt16(Operand, &Result); > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status); > + > + Operand =3D (-1537977259); > + Status =3D 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 =3D 0xabab; > + Result =3D 0; > + Status =3D SafeIntnToUint16(Operand, &Result); > + UT_ASSERT_NOT_EFI_ERROR(Status); > + UT_ASSERT_EQUAL(0xabab, Result); > + > + // > + // Otherwise should result in an error status > + // > + Operand =3D (0x5bababab); > + Status =3D SafeIntnToUint16(Operand, &Result); > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status); > + > + Operand =3D (-1537977259); > + Status =3D 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 =3D 0x5bababab; > + Result =3D 0; > + Status =3D SafeIntnToUintn(Operand, &Result); > + UT_ASSERT_NOT_EFI_ERROR(Status); > + UT_ASSERT_EQUAL(0x5bababab, Result); > + > + // > + // Otherwise should result in an error status > + // > + Operand =3D (-1537977259); > + Status =3D 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 =3D 0x5bababab; > + Result =3D 0; > + Status =3D SafeIntnToUint64(Operand, &Result); > + UT_ASSERT_NOT_EFI_ERROR(Status); > + UT_ASSERT_EQUAL(0x5bababab, Result); > + > + // > + // Otherwise should result in an error status > + // > + Operand =3D (-1537977259); > + Status =3D 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 <=3D MAX_INT8, then it's a cast > + // > + Operand =3D 0x5b; > + Result =3D 0; > + Status =3D SafeUintnToInt8(Operand, &Result); > + UT_ASSERT_NOT_EFI_ERROR(Status); > + UT_ASSERT_EQUAL(0x5b, Result); > + > + // > + // Otherwise should result in an error status > + // > + Operand =3D (0xabab); > + Status =3D 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 <=3D MAX_INT8, then it's a cast > + // > + Operand =3D 0x5b; > + Result =3D 0; > + Status =3D SafeUintnToChar8(Operand, &Result); > + UT_ASSERT_NOT_EFI_ERROR(Status); > + UT_ASSERT_EQUAL(0x5b, Result); > + > + // > + // Otherwise should result in an error status > + // > + Operand =3D (0xabab); > + Status =3D 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 <=3D MAX_UINT8, then it's a cast > + // > + Operand =3D 0xab; > + Result =3D 0; > + Status =3D SafeUintnToUint8(Operand, &Result); > + UT_ASSERT_NOT_EFI_ERROR(Status); > + UT_ASSERT_EQUAL(0xab, Result); > + > + // > + // Otherwise should result in an error status > + // > + Operand =3D (0xabab); > + Status =3D 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 <=3D MAX_INT16, then it's a cast > + // > + Operand =3D 0x5bab; > + Result =3D 0; > + Status =3D SafeUintnToInt16(Operand, &Result); > + UT_ASSERT_NOT_EFI_ERROR(Status); > + UT_ASSERT_EQUAL(0x5bab, Result); > + > + // > + // Otherwise should result in an error status > + // > + Operand =3D (0xabab); > + Status =3D 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 <=3D MAX_UINT16, then it's a cast > + // > + Operand =3D 0xabab; > + Result =3D 0; > + Status =3D SafeUintnToUint16(Operand, &Result); > + UT_ASSERT_NOT_EFI_ERROR(Status); > + UT_ASSERT_EQUAL(0xabab, Result); > + > + // > + // Otherwise should result in an error status > + // > + Operand =3D (0xabababab); > + Status =3D 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 <=3D MAX_INT32, then it's a cast > + // > + Operand =3D 0x5bababab; > + Result =3D 0; > + Status =3D SafeUintnToInt32(Operand, &Result); > + UT_ASSERT_NOT_EFI_ERROR(Status); > + UT_ASSERT_EQUAL(0x5bababab, Result); > + > + // > + // Otherwise should result in an error status > + // > + Operand =3D (0xabababab); > + Status =3D 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 =3D 0x5b; > + Result =3D 0; > + Status =3D SafeInt64ToInt8(Operand, &Result); > + UT_ASSERT_NOT_EFI_ERROR(Status); > + UT_ASSERT_EQUAL(0x5b, Result); > + > + Operand =3D (-37); > + Status =3D SafeInt64ToInt8(Operand, &Result); > + UT_ASSERT_NOT_EFI_ERROR(Status); > + UT_ASSERT_EQUAL((-37), Result); > + > + // > + // Otherwise should result in an error status > + // > + Operand =3D (0x5babababefefefef); > + Status =3D SafeInt64ToInt8(Operand, &Result); > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status); > + > + Operand =3D (-6605562033422200815); > + Status =3D 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 =3D 0x5b; > + Result =3D 0; > + Status =3D SafeInt64ToChar8(Operand, &Result); > + UT_ASSERT_NOT_EFI_ERROR(Status); > + UT_ASSERT_EQUAL(0x5b, Result); > + > + Operand =3D 0; > + Result =3D 0; > + Status =3D SafeInt64ToChar8(Operand, &Result); > + UT_ASSERT_NOT_EFI_ERROR(Status); > + UT_ASSERT_EQUAL(0, Result); > + > + Operand =3D MAX_INT8; > + Result =3D 0; > + Status =3D SafeInt64ToChar8(Operand, &Result); > + UT_ASSERT_NOT_EFI_ERROR(Status); > + UT_ASSERT_EQUAL(MAX_INT8, Result); > + > + // > + // Otherwise should result in an error status > + // > + Operand =3D (-37); > + Status =3D SafeInt64ToChar8(Operand, &Result); > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status); > + > + Operand =3D (0x5babababefefefef); > + Status =3D SafeInt64ToChar8(Operand, &Result); > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status); > + > + Operand =3D (-6605562033422200815); > + Status =3D 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 =3D 0xab; > + Result =3D 0; > + Status =3D SafeInt64ToUint8(Operand, &Result); > + UT_ASSERT_NOT_EFI_ERROR(Status); > + UT_ASSERT_EQUAL(0xab, Result); > + > + // > + // Otherwise should result in an error status > + // > + Operand =3D (0x5babababefefefef); > + Status =3D SafeInt64ToUint8(Operand, &Result); > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status); > + > + Operand =3D (-6605562033422200815); > + Status =3D 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 =3D 0x5bab; > + Result =3D 0; > + Status =3D SafeInt64ToInt16(Operand, &Result); > + UT_ASSERT_NOT_EFI_ERROR(Status); > + UT_ASSERT_EQUAL(0x5bab, Result); > + > + Operand =3D (-23467); > + Status =3D SafeInt64ToInt16(Operand, &Result); > + UT_ASSERT_NOT_EFI_ERROR(Status); > + UT_ASSERT_EQUAL((-23467), Result); > + > + // > + // Otherwise should result in an error status > + // > + Operand =3D (0x5babababefefefef); > + Status =3D SafeInt64ToInt16(Operand, &Result); > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status); > + > + Operand =3D (-6605562033422200815); > + Status =3D 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 =3D 0xabab; > + Result =3D 0; > + Status =3D SafeInt64ToUint16(Operand, &Result); > + UT_ASSERT_NOT_EFI_ERROR(Status); > + UT_ASSERT_EQUAL(0xabab, Result); > + > + // > + // Otherwise should result in an error status > + // > + Operand =3D (0x5babababefefefef); > + Status =3D SafeInt64ToUint16(Operand, &Result); > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status); > + > + Operand =3D (-6605562033422200815); > + Status =3D 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 =3D 0x5bababab; > + Result =3D 0; > + Status =3D SafeInt64ToInt32(Operand, &Result); > + UT_ASSERT_NOT_EFI_ERROR(Status); > + UT_ASSERT_EQUAL(0x5bababab, Result); > + > + Operand =3D (-1537977259); > + Status =3D SafeInt64ToInt32(Operand, &Result); > + UT_ASSERT_NOT_EFI_ERROR(Status); > + UT_ASSERT_EQUAL((-1537977259), Result); > + > + // > + // Otherwise should result in an error status > + // > + Operand =3D (0x5babababefefefef); > + Status =3D SafeInt64ToInt32(Operand, &Result); > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status); > + > + Operand =3D (-6605562033422200815); > + Status =3D 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 =3D 0xabababab; > + Result =3D 0; > + Status =3D SafeInt64ToUint32(Operand, &Result); > + UT_ASSERT_NOT_EFI_ERROR(Status); > + UT_ASSERT_EQUAL(0xabababab, Result); > + > + // > + // Otherwise should result in an error status > + // > + Operand =3D (0x5babababefefefef); > + Status =3D SafeInt64ToUint32(Operand, &Result); > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status); > + > + Operand =3D (-6605562033422200815); > + Status =3D 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 =3D 0x5babababefefefef; > + Result =3D 0; > + Status =3D SafeInt64ToUint64(Operand, &Result); > + UT_ASSERT_NOT_EFI_ERROR(Status); > + UT_ASSERT_EQUAL(0x5babababefefefef, Result); > + > + // > + // Otherwise should result in an error status > + // > + Operand =3D (-6605562033422200815); > + Status =3D 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 <=3D MAX_INT8, then it's a cast > + // > + Operand =3D 0x5b; > + Result =3D 0; > + Status =3D SafeUint64ToInt8(Operand, &Result); > + UT_ASSERT_NOT_EFI_ERROR(Status); > + UT_ASSERT_EQUAL(0x5b, Result); > + > + // > + // Otherwise should result in an error status > + // > + Operand =3D (0xababababefefefef); > + Status =3D 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 <=3D MAX_INT8, then it's a cast > + // > + Operand =3D 0x5b; > + Result =3D 0; > + Status =3D SafeUint64ToChar8(Operand, &Result); > + UT_ASSERT_NOT_EFI_ERROR(Status); > + UT_ASSERT_EQUAL(0x5b, Result); > + > + // > + // Otherwise should result in an error status > + // > + Operand =3D (0xababababefefefef); > + Status =3D 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 <=3D MAX_UINT8, then it's a cast > + // > + Operand =3D 0xab; > + Result =3D 0; > + Status =3D SafeUint64ToUint8(Operand, &Result); > + UT_ASSERT_NOT_EFI_ERROR(Status); > + UT_ASSERT_EQUAL(0xab, Result); > + > + // > + // Otherwise should result in an error status > + // > + Operand =3D (0xababababefefefef); > + Status =3D 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 <=3D MAX_INT16, then it's a cast > + // > + Operand =3D 0x5bab; > + Result =3D 0; > + Status =3D SafeUint64ToInt16(Operand, &Result); > + UT_ASSERT_NOT_EFI_ERROR(Status); > + UT_ASSERT_EQUAL(0x5bab, Result); > + > + // > + // Otherwise should result in an error status > + // > + Operand =3D (0xababababefefefef); > + Status =3D 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 <=3D MAX_UINT16, then it's a cast > + // > + Operand =3D 0xabab; > + Result =3D 0; > + Status =3D SafeUint64ToUint16(Operand, &Result); > + UT_ASSERT_NOT_EFI_ERROR(Status); > + UT_ASSERT_EQUAL(0xabab, Result); > + > + // > + // Otherwise should result in an error status > + // > + Operand =3D (0xababababefefefef); > + Status =3D 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 <=3D MAX_INT32, then it's a cast > + // > + Operand =3D 0x5bababab; > + Result =3D 0; > + Status =3D SafeUint64ToInt32(Operand, &Result); > + UT_ASSERT_NOT_EFI_ERROR(Status); > + UT_ASSERT_EQUAL(0x5bababab, Result); > + > + // > + // Otherwise should result in an error status > + // > + Operand =3D (0xababababefefefef); > + Status =3D 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 <=3D MAX_UINT32, then it's a cast > + // > + Operand =3D 0xabababab; > + Result =3D 0; > + Status =3D SafeUint64ToUint32(Operand, &Result); > + UT_ASSERT_NOT_EFI_ERROR(Status); > + UT_ASSERT_EQUAL(0xabababab, Result); > + > + // > + // Otherwise should result in an error status > + // > + Operand =3D (0xababababefefefef); > + Status =3D 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 <=3D MAX_INT64, then it's a cast > + // > + Operand =3D 0x5babababefefefef; > + Result =3D 0; > + Status =3D SafeUint64ToInt64(Operand, &Result); > + UT_ASSERT_NOT_EFI_ERROR(Status); > + UT_ASSERT_EQUAL(0x5babababefefefef, Result); > + > + // > + // Otherwise should result in an error status > + // > + Operand =3D (0xababababefefefef); > + Status =3D 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 add= ition > + // > + Augend =3D 0x3a; > + Addend =3D 0x3a; > + Result =3D 0; > + Status =3D SafeUint8Add(Augend, Addend, &Result); > + UT_ASSERT_NOT_EFI_ERROR(Status); > + UT_ASSERT_EQUAL(0x74, Result); > + > + // > + // Otherwise should result in an error status > + // > + Augend =3D 0xab; > + Addend =3D 0xbc; > + Status =3D 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 =3D 0x3a3a; > + UINT16 Addend =3D 0x3a3a; > + UINT16 Result =3D 0; > + > + // > + // If the result of addition doesn't overflow MAX_UINT16, then it's ad= dition > + // > + Status =3D SafeUint16Add(Augend, Addend, &Result); > + UT_ASSERT_NOT_EFI_ERROR(Status); > + UT_ASSERT_EQUAL(0x7474, Result); > + > + // > + // Otherwise should result in an error status > + // > + Augend =3D 0xabab; > + Addend =3D 0xbcbc; > + Status =3D 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 ad= dition > + // > + Augend =3D 0x3a3a3a3a; > + Addend =3D 0x3a3a3a3a; > + Result =3D 0; > + Status =3D SafeUint32Add(Augend, Addend, &Result); > + UT_ASSERT_NOT_EFI_ERROR(Status); > + UT_ASSERT_EQUAL(0x74747474, Result); > + > + // > + // Otherwise should result in an error status > + // > + Augend =3D 0xabababab; > + Addend =3D 0xbcbcbcbc; > + Status =3D 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 ad= dition > + // > + Augend =3D 0x3a3a3a3a12121212; > + Addend =3D 0x3a3a3a3a12121212; > + Result =3D 0; > + Status =3D SafeUint64Add(Augend, Addend, &Result); > + UT_ASSERT_NOT_EFI_ERROR(Status); > + UT_ASSERT_EQUAL(0x7474747424242424, Result); > + > + // > + // Otherwise should result in an error status > + // > + Augend =3D 0xababababefefefef; > + Addend =3D 0xbcbcbcbcdededede; > + Status =3D 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 =3D 0x3a; > + Addend =3D 0x3a; > + Result =3D 0; > + Status =3D SafeInt8Add(Augend, Addend, &Result); > + UT_ASSERT_NOT_EFI_ERROR(Status); > + UT_ASSERT_EQUAL(0x74, Result); > + > + Augend =3D (-58); > + Addend =3D (-58); > + Status =3D SafeInt8Add(Augend, Addend, &Result); > + UT_ASSERT_NOT_EFI_ERROR(Status); > + UT_ASSERT_EQUAL((-116), Result); > + > + // > + // Otherwise should result in an error status > + // > + Augend =3D 0x5a; > + Addend =3D 0x5a; > + Status =3D SafeInt8Add(Augend, Addend, &Result); > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status); > + > + Augend =3D (-90); > + Addend =3D (-90); > + Status =3D 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 =3D 0x3a3a; > + Addend =3D 0x3a3a; > + Result =3D 0; > + Status =3D SafeInt16Add(Augend, Addend, &Result); > + UT_ASSERT_NOT_EFI_ERROR(Status); > + UT_ASSERT_EQUAL(0x7474, Result); > + > + Augend =3D (-14906); > + Addend =3D (-14906); > + Status =3D SafeInt16Add(Augend, Addend, &Result); > + UT_ASSERT_NOT_EFI_ERROR(Status); > + UT_ASSERT_EQUAL((-29812), Result); > + > + // > + // Otherwise should result in an error status > + // > + Augend =3D 0x5a5a; > + Addend =3D 0x5a5a; > + Status =3D SafeInt16Add(Augend, Addend, &Result); > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status); > + > + Augend =3D (-23130); > + Addend =3D (-23130); > + Status =3D 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 =3D 0x3a3a3a3a; > + Addend =3D 0x3a3a3a3a; > + Result =3D 0; > + Status =3D SafeInt32Add(Augend, Addend, &Result); > + UT_ASSERT_NOT_EFI_ERROR(Status); > + UT_ASSERT_EQUAL(0x74747474, Result); > + > + Augend =3D (-976894522); > + Addend =3D (-976894522); > + Status =3D SafeInt32Add(Augend, Addend, &Result); > + UT_ASSERT_NOT_EFI_ERROR(Status); > + UT_ASSERT_EQUAL((-1953789044), Result); > + > + // > + // Otherwise should result in an error status > + // > + Augend =3D 0x5a5a5a5a; > + Addend =3D 0x5a5a5a5a; > + Status =3D SafeInt32Add(Augend, Addend, &Result); > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status); > + > + Augend =3D (-1515870810); > + Addend =3D (-1515870810); > + Status =3D 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 =3D 0x3a3a3a3a3a3a3a3a; > + Addend =3D 0x3a3a3a3a3a3a3a3a; > + Result =3D 0; > + Status =3D SafeInt64Add(Augend, Addend, &Result); > + UT_ASSERT_NOT_EFI_ERROR(Status); > + UT_ASSERT_EQUAL(0x7474747474747474, Result); > + > + Augend =3D (-4195730024608447034); > + Addend =3D (-4195730024608447034); > + Status =3D SafeInt64Add(Augend, Addend, &Result); > + UT_ASSERT_NOT_EFI_ERROR(Status); > + UT_ASSERT_EQUAL((-8391460049216894068), Result); > + > + // > + // Otherwise should result in an error status > + // > + Augend =3D 0x5a5a5a5a5a5a5a5a; > + Addend =3D 0x5a5a5a5a5a5a5a5a; > + Status =3D SafeInt64Add(Augend, Addend, &Result); > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status); > + > + Augend =3D (-6510615555426900570); > + Addend =3D (-6510615555426900570); > + Status =3D 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 >=3D Subtrahend, then it's subtraction > + // > + Minuend =3D 0x5a; > + Subtrahend =3D 0x3b; > + Result =3D 0; > + Status =3D SafeUint8Sub(Minuend, Subtrahend, &Result); > + UT_ASSERT_NOT_EFI_ERROR(Status); > + UT_ASSERT_EQUAL(0x1f, Result); > + > + // > + // Otherwise should result in an error status > + // > + Minuend =3D 0x5a; > + Subtrahend =3D 0x6d; > + Status =3D 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 >=3D Subtrahend, then it's subtraction > + // > + Minuend =3D 0x5a5a; > + Subtrahend =3D 0x3b3b; > + Result =3D 0; > + Status =3D SafeUint16Sub(Minuend, Subtrahend, &Result); > + UT_ASSERT_NOT_EFI_ERROR(Status); > + UT_ASSERT_EQUAL(0x1f1f, Result); > + > + // > + // Otherwise should result in an error status > + // > + Minuend =3D 0x5a5a; > + Subtrahend =3D 0x6d6d; > + Status =3D 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 >=3D Subtrahend, then it's subtraction > + // > + Minuend =3D 0x5a5a5a5a; > + Subtrahend =3D 0x3b3b3b3b; > + Result =3D 0; > + Status =3D SafeUint32Sub(Minuend, Subtrahend, &Result); > + UT_ASSERT_NOT_EFI_ERROR(Status); > + UT_ASSERT_EQUAL(0x1f1f1f1f, Result); > + > + // > + // Otherwise should result in an error status > + // > + Minuend =3D 0x5a5a5a5a; > + Subtrahend =3D 0x6d6d6d6d; > + Status =3D 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 >=3D Subtrahend, then it's subtraction > + // > + Minuend =3D 0x5a5a5a5a5a5a5a5a; > + Subtrahend =3D 0x3b3b3b3b3b3b3b3b; > + Result =3D 0; > + Status =3D SafeUint64Sub(Minuend, Subtrahend, &Result); > + UT_ASSERT_NOT_EFI_ERROR(Status); > + UT_ASSERT_EQUAL(0x1f1f1f1f1f1f1f1f, Result); > + > + // > + // Otherwise should result in an error status > + // > + Minuend =3D 0x5a5a5a5a5a5a5a5a; > + Subtrahend =3D 0x6d6d6d6d6d6d6d6d; > + Status =3D 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 =3D 0x5a; > + Subtrahend =3D 0x3a; > + Result =3D 0; > + Status =3D SafeInt8Sub(Minuend, Subtrahend, &Result); > + UT_ASSERT_NOT_EFI_ERROR(Status); > + UT_ASSERT_EQUAL(0x20, Result); > + > + Minuend =3D 58; > + Subtrahend =3D 78; > + Status =3D SafeInt8Sub(Minuend, Subtrahend, &Result); > + UT_ASSERT_NOT_EFI_ERROR(Status); > + UT_ASSERT_EQUAL((-20), Result); > + > + // > + // Otherwise should result in an error status > + // > + Minuend =3D (-80); > + Subtrahend =3D 80; > + Status =3D SafeInt8Sub(Minuend, Subtrahend, &Result); > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status); > + > + Minuend =3D (80); > + Subtrahend =3D (-80); > + Status =3D 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 =3D 0x5a5a; > + Subtrahend =3D 0x3a3a; > + Result =3D 0; > + Status =3D SafeInt16Sub(Minuend, Subtrahend, &Result); > + UT_ASSERT_NOT_EFI_ERROR(Status); > + UT_ASSERT_EQUAL(0x2020, Result); > + > + Minuend =3D 0x3a3a; > + Subtrahend =3D 0x5a5a; > + Status =3D SafeInt16Sub(Minuend, Subtrahend, &Result); > + UT_ASSERT_NOT_EFI_ERROR(Status); > + UT_ASSERT_EQUAL((-8224), Result); > + > + // > + // Otherwise should result in an error status > + // > + Minuend =3D (-31354); > + Subtrahend =3D 31354; > + Status =3D SafeInt16Sub(Minuend, Subtrahend, &Result); > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status); > + > + Minuend =3D (31354); > + Subtrahend =3D (-31354); > + Status =3D 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 =3D 0x5a5a5a5a; > + Subtrahend =3D 0x3a3a3a3a; > + Result =3D 0; > + Status =3D SafeInt32Sub(Minuend, Subtrahend, &Result); > + UT_ASSERT_NOT_EFI_ERROR(Status); > + UT_ASSERT_EQUAL(0x20202020, Result); > + > + Minuend =3D 0x3a3a3a3a; > + Subtrahend =3D 0x5a5a5a5a; > + Status =3D SafeInt32Sub(Minuend, Subtrahend, &Result); > + UT_ASSERT_NOT_EFI_ERROR(Status); > + UT_ASSERT_EQUAL((-538976288), Result); > + > + // > + // Otherwise should result in an error status > + // > + Minuend =3D (-2054847098); > + Subtrahend =3D 2054847098; > + Status =3D SafeInt32Sub(Minuend, Subtrahend, &Result); > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status); > + > + Minuend =3D (2054847098); > + Subtrahend =3D (-2054847098); > + Status =3D 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 =3D 0x5a5a5a5a5a5a5a5a; > + Subtrahend =3D 0x3a3a3a3a3a3a3a3a; > + Result =3D 0; > + Status =3D SafeInt64Sub(Minuend, Subtrahend, &Result); > + UT_ASSERT_NOT_EFI_ERROR(Status); > + UT_ASSERT_EQUAL(0x2020202020202020, Result); > + > + Minuend =3D 0x3a3a3a3a3a3a3a3a; > + Subtrahend =3D 0x5a5a5a5a5a5a5a5a; > + Status =3D SafeInt64Sub(Minuend, Subtrahend, &Result); > + UT_ASSERT_NOT_EFI_ERROR(Status); > + UT_ASSERT_EQUAL((-2314885530818453536), Result); > + > + // > + // Otherwise should result in an error status > + // > + Minuend =3D (-8825501086245354106); > + Subtrahend =3D 8825501086245354106; > + Status =3D SafeInt64Sub(Minuend, Subtrahend, &Result); > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status); > + > + Minuend =3D (8825501086245354106); > + Subtrahend =3D (-8825501086245354106); > + Status =3D 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 =3D 0x12; > + Multiplier =3D 0xa; > + Result =3D 0; > + Status =3D SafeUint8Mult(Multiplicand, Multiplier, &Result); > + UT_ASSERT_NOT_EFI_ERROR(Status); > + UT_ASSERT_EQUAL(0xb4, Result); > + > + // > + // Otherwise should result in an error status > + // > + Multiplicand =3D 0x12; > + Multiplier =3D 0x23; > + Status =3D 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 wil= l succeed > + // > + Multiplicand =3D 0x212; > + Multiplier =3D 0x7a; > + Result =3D 0; > + Status =3D SafeUint16Mult(Multiplicand, Multiplier, &Result); > + UT_ASSERT_NOT_EFI_ERROR(Status); > + UT_ASSERT_EQUAL(0xfc94, Result); > + > + // > + // Otherwise should result in an error status > + // > + Multiplicand =3D 0x1234; > + Multiplier =3D 0x213; > + Status =3D 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 wil= l succeed > + // > + Multiplicand =3D 0xa122a; > + Multiplier =3D 0xd23; > + Result =3D 0; > + Status =3D SafeUint32Mult(Multiplicand, Multiplier, &Result); > + UT_ASSERT_NOT_EFI_ERROR(Status); > + UT_ASSERT_EQUAL(0x844c9dbe, Result); > + > + // > + // Otherwise should result in an error status > + // > + Multiplicand =3D 0xa122a; > + Multiplier =3D 0xed23; > + Status =3D 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 wil= l succeed > + // > + Multiplicand =3D 0x123456789a; > + Multiplier =3D 0x1234567; > + Result =3D 0; > + Status =3D SafeUint64Mult(Multiplicand, Multiplier, &Result); > + UT_ASSERT_NOT_EFI_ERROR(Status); > + UT_ASSERT_EQUAL(0x14b66db9745a07f6, Result); > + > + // > + // Otherwise should result in an error status > + // > + Multiplicand =3D 0x123456789a; > + Multiplier =3D 0x12345678; > + Status =3D 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 =3D 0x12; > + Multiplier =3D 0x7; > + Result =3D 0; > + Status =3D SafeInt8Mult(Multiplicand, Multiplier, &Result); > + UT_ASSERT_NOT_EFI_ERROR(Status); > + UT_ASSERT_EQUAL(0x7e, Result); > + > + // > + // Otherwise should result in an error status > + // > + Multiplicand =3D 0x12; > + Multiplier =3D 0xa; > + Status =3D 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 does= n't > + // underflow MIN_UINT16, it will succeed > + // > + Multiplicand =3D 0x123; > + Multiplier =3D 0x67; > + Result =3D 0; > + Status =3D SafeInt16Mult(Multiplicand, Multiplier, &Result); > + UT_ASSERT_NOT_EFI_ERROR(Status); > + UT_ASSERT_EQUAL(0x7515, Result); > + > + // > + // Otherwise should result in an error status > + // > + Multiplicand =3D 0x123; > + Multiplier =3D 0xab; > + Status =3D 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 does= n't > + // underflow MIN_UINT32, it will succeed > + // > + Multiplicand =3D 0x123456; > + Multiplier =3D 0x678; > + Result =3D 0; > + Status =3D SafeInt32Mult(Multiplicand, Multiplier, &Result); > + UT_ASSERT_NOT_EFI_ERROR(Status); > + UT_ASSERT_EQUAL(0x75c28c50, Result); > + > + // > + // Otherwise should result in an error status > + // > + Multiplicand =3D 0x123456; > + Multiplier =3D 0xabc; > + Status =3D 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 does= n't > + // underflow MIN_UINT64, it will succeed > + // > + Multiplicand =3D 0x123456789; > + Multiplier =3D 0x6789abcd; > + Result =3D 0; > + Status =3D SafeInt64Mult(Multiplicand, Multiplier, &Result); > + UT_ASSERT_NOT_EFI_ERROR(Status); > + UT_ASSERT_EQUAL(0x75cd9045220d6bb5, Result); > + > + // > + // Otherwise should result in an error status > + // > + Multiplicand =3D 0x123456789; > + Multiplier =3D 0xa789abcd; > + Status =3D 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 =3D NULL; > + ConversionTestSuite =3D NULL; > + AdditionSubtractionTestSuite =3D NULL; > + MultiplicationTestSuite =3D 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 =3D InitUnitTestFramework (&Framework, UNIT_TEST_NAME, gEfiCall= erBaseName, UNIT_TEST_VERSION); > + if (EFI_ERROR(Status)) { > + DEBUG((DEBUG_ERROR, "Failed in InitUnitTestFramework. Status =3D %r\= n", Status)); > + goto EXIT; > + } > + > + /// > + // Test the conversion functions > + // > + Status =3D 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 T= est Suite\n")); > + Status =3D EFI_OUT_OF_RESOURCES; > + goto EXIT; > + } > + AddTestCase(ConversionTestSuite, "Test SafeInt8ToUint8", "TestSafeI= nt8ToUint8", TestSafeInt8ToUint8, NULL, NULL, NULL); > + AddTestCase(ConversionTestSuite, "Test SafeInt8ToUint16", "TestSafeI= nt8ToUint16", TestSafeInt8ToUint16, NULL, NULL, NULL); > + AddTestCase(ConversionTestSuite, "Test SafeInt8ToUint32", "TestSafeI= nt8ToUint32", TestSafeInt8ToUint32, NULL, NULL, NULL); > + AddTestCase(ConversionTestSuite, "Test SafeInt8ToUintn", "TestSafeI= nt8ToUintn", TestSafeInt8ToUintn, NULL, NULL, NULL); > + AddTestCase(ConversionTestSuite, "Test SafeInt8ToUint64", "TestSafeI= nt8ToUint64", TestSafeInt8ToUint64, NULL, NULL, NULL); > + AddTestCase(ConversionTestSuite, "Test SafeUint8ToInt8", "TestSafeU= int8ToInt8", TestSafeUint8ToInt8, NULL, NULL, NULL); > + AddTestCase(ConversionTestSuite, "Test SafeUint8ToChar8", "TestSafeU= int8ToChar8", TestSafeUint8ToChar8, NULL, NULL, NULL); > + AddTestCase(ConversionTestSuite, "Test SafeInt16ToInt8", "TestSafeI= nt16ToInt8", TestSafeInt16ToInt8, NULL, NULL, NULL); > + AddTestCase(ConversionTestSuite, "Test SafeInt16ToChar8", "TestSafeI= nt16ToChar8", TestSafeInt16ToChar8, NULL, NULL, NULL); > + AddTestCase(ConversionTestSuite, "Test SafeInt16ToUint8", "TestSafeI= nt16ToUint8", TestSafeInt16ToUint8, NULL, NULL, NULL); > + AddTestCase(ConversionTestSuite, "Test SafeInt16ToUint16", "TestSafeI= nt16ToUint16", TestSafeInt16ToUint16, NULL, NULL, NULL); > + AddTestCase(ConversionTestSuite, "Test SafeInt16ToUint32", "TestSafeI= nt16ToUint32", TestSafeInt16ToUint32, NULL, NULL, NULL); > + AddTestCase(ConversionTestSuite, "Test SafeInt16ToUintn", "TestSafeI= nt16ToUintn", TestSafeInt16ToUintn, NULL, NULL, NULL); > + AddTestCase(ConversionTestSuite, "Test SafeInt16ToUint64", "TestSafeI= nt16ToUint64", TestSafeInt16ToUint64, NULL, NULL, NULL); > + AddTestCase(ConversionTestSuite, "Test SafeUint16ToInt8", "TestSafeU= int16ToInt8", TestSafeUint16ToInt8, NULL, NULL, NULL); > + AddTestCase(ConversionTestSuite, "Test SafeUint16ToChar8", "TestSafeU= int16ToChar8", TestSafeUint16ToChar8, NULL, NULL, NULL); > + AddTestCase(ConversionTestSuite, "Test SafeUint16ToUint8", "TestSafeU= int16ToUint8", TestSafeUint16ToUint8, NULL, NULL, NULL); > + AddTestCase(ConversionTestSuite, "Test SafeUint16ToInt16", "TestSafeU= int16ToInt16", TestSafeUint16ToInt16, NULL, NULL, NULL); > + AddTestCase(ConversionTestSuite, "Test SafeInt32ToInt8", "TestSafeI= nt32ToInt8", TestSafeInt32ToInt8, NULL, NULL, NULL); > + AddTestCase(ConversionTestSuite, "Test SafeInt32ToChar8", "TestSafeI= nt32ToChar8", TestSafeInt32ToChar8, NULL, NULL, NULL); > + AddTestCase(ConversionTestSuite, "Test SafeInt32ToUint8", "TestSafeI= nt32ToUint8", TestSafeInt32ToUint8, NULL, NULL, NULL); > + AddTestCase(ConversionTestSuite, "Test SafeInt32ToInt16", "TestSafeI= nt32ToInt16", TestSafeInt32ToInt16, NULL, NULL, NULL); > + AddTestCase(ConversionTestSuite, "Test SafeInt32ToUint16", "TestSafeI= nt32ToUint16", TestSafeInt32ToUint16, NULL, NULL, NULL); > + AddTestCase(ConversionTestSuite, "Test SafeInt32ToUint32", "TestSafeI= nt32ToUint32", TestSafeInt32ToUint32, NULL, NULL, NULL); > + AddTestCase(ConversionTestSuite, "Test SafeInt32ToUintn", "TestSafeI= nt32ToUintn", TestSafeInt32ToUintn, NULL, NULL, NULL); > + AddTestCase(ConversionTestSuite, "Test SafeInt32ToUint64", "TestSafeI= nt32ToUint64", TestSafeInt32ToUint64, NULL, NULL, NULL); > + AddTestCase(ConversionTestSuite, "Test SafeUint32ToInt8", "TestSafeU= int32ToInt8", TestSafeUint32ToInt8, NULL, NULL, NULL); > + AddTestCase(ConversionTestSuite, "Test SafeUint32ToChar8", "TestSafeU= int32ToChar8", TestSafeUint32ToChar8, NULL, NULL, NULL); > + AddTestCase(ConversionTestSuite, "Test SafeUint32ToUint8", "TestSafeU= int32ToUint8", TestSafeUint32ToUint8, NULL, NULL, NULL); > + AddTestCase(ConversionTestSuite, "Test SafeUint32ToInt16", "TestSafeU= int32ToInt16", TestSafeUint32ToInt16, NULL, NULL, NULL); > + AddTestCase(ConversionTestSuite, "Test SafeUint32ToUint16", "TestSafeU= int32ToUint16", TestSafeUint32ToUint16, NULL, NULL, > NULL); > + AddTestCase(ConversionTestSuite, "Test SafeUint32ToInt32", "TestSafeU= int32ToInt32", TestSafeUint32ToInt32, NULL, NULL, NULL); > + AddTestCase(ConversionTestSuite, "Test SafeUint32ToIntn", "TestSafeU= int32ToIntn", TestSafeUint32ToIntn, NULL, NULL, NULL); > + AddTestCase(ConversionTestSuite, "Test SafeIntnToInt8", "TestSafeI= ntnToInt8", TestSafeIntnToInt8, NULL, NULL, NULL); > + AddTestCase(ConversionTestSuite, "Test SafeIntnToChar8", "TestSafeI= ntnToChar8", TestSafeIntnToChar8, NULL, NULL, NULL); > + AddTestCase(ConversionTestSuite, "Test SafeIntnToUint8", "TestSafeI= ntnToUint8", TestSafeIntnToUint8, NULL, NULL, NULL); > + AddTestCase(ConversionTestSuite, "Test SafeIntnToInt16", "TestSafeI= ntnToInt16", TestSafeIntnToInt16, NULL, NULL, NULL); > + AddTestCase(ConversionTestSuite, "Test SafeIntnToUint16", "TestSafeI= ntnToUint16", TestSafeIntnToUint16, NULL, NULL, NULL); > + AddTestCase(ConversionTestSuite, "Test SafeIntnToInt32", "TestSafeI= ntnToInt32", TestSafeIntnToInt32, NULL, NULL, NULL); > + AddTestCase(ConversionTestSuite, "Test SafeIntnToUint32", "TestSafeI= ntnToUint32", TestSafeIntnToUint32, NULL, NULL, NULL); > + AddTestCase(ConversionTestSuite, "Test SafeIntnToUintn", "TestSafeI= ntnToUintn", TestSafeIntnToUintn, NULL, NULL, NULL); > + AddTestCase(ConversionTestSuite, "Test SafeIntnToUint64", "TestSafeI= ntnToUint64", TestSafeIntnToUint64, NULL, NULL, NULL); > + AddTestCase(ConversionTestSuite, "Test SafeUintnToInt8", "TestSafeU= intnToInt8", TestSafeUintnToInt8, NULL, NULL, NULL); > + AddTestCase(ConversionTestSuite, "Test SafeUintnToChar8", "TestSafeU= intnToChar8", TestSafeUintnToChar8, NULL, NULL, NULL); > + AddTestCase(ConversionTestSuite, "Test SafeUintnToUint8", "TestSafeU= intnToUint8", TestSafeUintnToUint8, NULL, NULL, NULL); > + AddTestCase(ConversionTestSuite, "Test SafeUintnToInt16", "TestSafeU= intnToInt16", TestSafeUintnToInt16, NULL, NULL, NULL); > + AddTestCase(ConversionTestSuite, "Test SafeUintnToUint16", "TestSafeU= intnToUint16", TestSafeUintnToUint16, NULL, NULL, NULL); > + AddTestCase(ConversionTestSuite, "Test SafeUintnToInt32", "TestSafeU= intnToInt32", TestSafeUintnToInt32, NULL, NULL, NULL); > + AddTestCase(ConversionTestSuite, "Test SafeUintnToUint32", "TestSafeU= intnToUint32", TestSafeUintnToUint32, NULL, NULL, NULL); > + AddTestCase(ConversionTestSuite, "Test SafeUintnToIntn", "TestSafeU= intnToIntn", TestSafeUintnToIntn, NULL, NULL, NULL); > + AddTestCase(ConversionTestSuite, "Test SafeUintnToInt64", "TestSafeU= intnToInt64", TestSafeUintnToInt64, NULL, NULL, NULL); > + AddTestCase(ConversionTestSuite, "Test SafeInt64ToInt8", "TestSafeI= nt64ToInt8", TestSafeInt64ToInt8, NULL, NULL, NULL); > + AddTestCase(ConversionTestSuite, "Test SafeInt64ToChar8", "TestSafeI= nt64ToChar8", TestSafeInt64ToChar8, NULL, NULL, NULL); > + AddTestCase(ConversionTestSuite, "Test SafeInt64ToUint8", "TestSafeI= nt64ToUint8", TestSafeInt64ToUint8, NULL, NULL, NULL); > + AddTestCase(ConversionTestSuite, "Test SafeInt64ToInt16", "TestSafeI= nt64ToInt16", TestSafeInt64ToInt16, NULL, NULL, NULL); > + AddTestCase(ConversionTestSuite, "Test SafeInt64ToUint16", "TestSafeI= nt64ToUint16", TestSafeInt64ToUint16, NULL, NULL, NULL); > + AddTestCase(ConversionTestSuite, "Test SafeInt64ToInt32", "TestSafeI= nt64ToInt32", TestSafeInt64ToInt32, NULL, NULL, NULL); > + AddTestCase(ConversionTestSuite, "Test SafeInt64ToUint32", "TestSafeI= nt64ToUint32", TestSafeInt64ToUint32, NULL, NULL, NULL); > + AddTestCase(ConversionTestSuite, "Test SafeInt64ToIntn", "TestSafeI= nt64ToIntn", TestSafeInt64ToIntn, NULL, NULL, NULL); > + AddTestCase(ConversionTestSuite, "Test SafeInt64ToUintn", "TestSafeI= nt64ToUintn", TestSafeInt64ToUintn, NULL, NULL, NULL); > + AddTestCase(ConversionTestSuite, "Test SafeInt64ToUint64", "TestSafeI= nt64ToUint64", TestSafeInt64ToUint64, NULL, NULL, NULL); > + AddTestCase(ConversionTestSuite, "Test SafeUint64ToInt8", "TestSafeU= int64ToInt8", TestSafeUint64ToInt8, NULL, NULL, NULL); > + AddTestCase(ConversionTestSuite, "Test SafeUint64ToChar8", "TestSafeU= int64ToChar8", TestSafeUint64ToChar8, NULL, NULL, NULL); > + AddTestCase(ConversionTestSuite, "Test SafeUint64ToUint8", "TestSafeU= int64ToUint8", TestSafeUint64ToUint8, NULL, NULL, NULL); > + AddTestCase(ConversionTestSuite, "Test SafeUint64ToInt16", "TestSafeU= int64ToInt16", TestSafeUint64ToInt16, NULL, NULL, NULL); > + AddTestCase(ConversionTestSuite, "Test SafeUint64ToUint16", "TestSafeU= int64ToUint16", TestSafeUint64ToUint16, NULL, NULL, > NULL); > + AddTestCase(ConversionTestSuite, "Test SafeUint64ToInt32", "TestSafeU= int64ToInt32", TestSafeUint64ToInt32, NULL, NULL, NULL); > + AddTestCase(ConversionTestSuite, "Test SafeUint64ToUint32", "TestSafeU= int64ToUint32", TestSafeUint64ToUint32, NULL, NULL, > NULL); > + AddTestCase(ConversionTestSuite, "Test SafeUint64ToIntn", "TestSafeU= int64ToIntn", TestSafeUint64ToIntn, NULL, NULL, NULL); > + AddTestCase(ConversionTestSuite, "Test SafeUint64ToUintn", "TestSafeU= int64ToUintn", TestSafeUint64ToUintn, NULL, NULL, NULL); > + AddTestCase(ConversionTestSuite, "Test SafeUint64ToInt64", "TestSafeU= int64ToInt64", TestSafeUint64ToInt64, NULL, NULL, NULL); > + > + // > + // Test the addition and subtraction functions > + // > + Status =3D CreateUnitTestSuite(&AdditionSubtractionTestSuite, Framewor= k, "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 =3D EFI_OUT_OF_RESOURCES; > + goto EXIT; > + } > + AddTestCase(AdditionSubtractionTestSuite, "Test SafeUint8Add", "TestS= afeUint8Add", TestSafeUint8Add, NULL, NULL, NULL); > + AddTestCase(AdditionSubtractionTestSuite, "Test SafeUint16Add", "TestS= afeUint16Add", TestSafeUint16Add, NULL, NULL, NULL); > + AddTestCase(AdditionSubtractionTestSuite, "Test SafeUint32Add", "TestS= afeUint32Add", TestSafeUint32Add, NULL, NULL, NULL); > + AddTestCase(AdditionSubtractionTestSuite, "Test SafeUintnAdd", "TestS= afeUintnAdd", TestSafeUintnAdd, NULL, NULL, NULL); > + AddTestCase(AdditionSubtractionTestSuite, "Test SafeUint64Add", "TestS= afeUint64Add", TestSafeUint64Add, NULL, NULL, NULL); > + AddTestCase(AdditionSubtractionTestSuite, "Test SafeInt8Add", "TestS= afeInt8Add", TestSafeInt8Add, NULL, NULL, NULL); > + AddTestCase(AdditionSubtractionTestSuite, "Test SafeInt16Add", "TestS= afeInt16Add", TestSafeInt16Add, NULL, NULL, NULL); > + AddTestCase(AdditionSubtractionTestSuite, "Test SafeInt32Add", "TestS= afeInt32Add", TestSafeInt32Add, NULL, NULL, NULL); > + AddTestCase(AdditionSubtractionTestSuite, "Test SafeIntnAdd", "TestS= afeIntnAdd", TestSafeIntnAdd, NULL, NULL, NULL); > + AddTestCase(AdditionSubtractionTestSuite, "Test SafeInt64Add", "TestS= afeInt64Add", TestSafeInt64Add, NULL, NULL, NULL); > + AddTestCase(AdditionSubtractionTestSuite, "Test SafeUint8Sub", "TestS= afeUint8Sub", TestSafeUint8Sub, NULL, NULL, NULL); > + AddTestCase(AdditionSubtractionTestSuite, "Test SafeUint16Sub", "TestS= afeUint16Sub", TestSafeUint16Sub, NULL, NULL, NULL); > + AddTestCase(AdditionSubtractionTestSuite, "Test SafeUint32Sub", "TestS= afeUint32Sub", TestSafeUint32Sub, NULL, NULL, NULL); > + AddTestCase(AdditionSubtractionTestSuite, "Test SafeUintnSub", "TestS= afeUintnSub", TestSafeUintnSub, NULL, NULL, NULL); > + AddTestCase(AdditionSubtractionTestSuite, "Test SafeUint64Sub", "TestS= afeUint64Sub", TestSafeUint64Sub, NULL, NULL, NULL); > + AddTestCase(AdditionSubtractionTestSuite, "Test SafeInt8Sub", "TestS= afeInt8Sub", TestSafeInt8Sub, NULL, NULL, NULL); > + AddTestCase(AdditionSubtractionTestSuite, "Test SafeInt16Sub", "TestS= afeInt16Sub", TestSafeInt16Sub, NULL, NULL, NULL); > + AddTestCase(AdditionSubtractionTestSuite, "Test SafeInt32Sub", "TestS= afeInt32Sub", TestSafeInt32Sub, NULL, NULL, NULL); > + AddTestCase(AdditionSubtractionTestSuite, "Test SafeIntnSub", "TestS= afeIntnSub", TestSafeIntnSub, NULL, NULL, NULL); > + AddTestCase(AdditionSubtractionTestSuite, "Test SafeInt64Sub", "TestS= afeInt64Sub", TestSafeInt64Sub, NULL, NULL, NULL); > + > + // > + // Test the multiplication functions > + // > + Status =3D CreateUnitTestSuite(&MultiplicationTestSuite, Framework, "I= nt Safe Multiply Test Suite", "Common.SafeInt.Multiply", NULL, > NULL); > + if (EFI_ERROR(Status)) { > + DEBUG((DEBUG_ERROR, "Failed in CreateUnitTestSuite for Int Safe Mult= iply Test Suite\n")); > + Status =3D EFI_OUT_OF_RESOURCES; > + goto EXIT; > + } > + AddTestCase(MultiplicationTestSuite, "Test SafeUint8Mult", "TestSafeU= int8Mult", TestSafeUint8Mult, NULL, NULL, NULL); > + AddTestCase(MultiplicationTestSuite, "Test SafeUint16Mult", "TestSafeU= int16Mult", TestSafeUint16Mult, NULL, NULL, NULL); > + AddTestCase(MultiplicationTestSuite, "Test SafeUint32Mult", "TestSafeU= int32Mult", TestSafeUint32Mult, NULL, NULL, NULL); > + AddTestCase(MultiplicationTestSuite, "Test SafeUintnMult", "TestSafeU= intnMult", TestSafeUintnMult, NULL, NULL, NULL); > + AddTestCase(MultiplicationTestSuite, "Test SafeUint64Mult", "TestSafeU= int64Mult", TestSafeUint64Mult, NULL, NULL, NULL); > + AddTestCase(MultiplicationTestSuite, "Test SafeInt8Mult", "TestSafeI= nt8Mult", TestSafeInt8Mult, NULL, NULL, NULL); > + AddTestCase(MultiplicationTestSuite, "Test SafeInt16Mult", "TestSafeI= nt16Mult", TestSafeInt16Mult, NULL, NULL, NULL); > + AddTestCase(MultiplicationTestSuite, "Test SafeInt32Mult", "TestSafeI= nt32Mult", TestSafeInt32Mult, NULL, NULL, NULL); > + AddTestCase(MultiplicationTestSuite, "Test SafeIntnMult", "TestSafeI= ntnMult", TestSafeIntnMult, NULL, NULL, NULL); > + AddTestCase(MultiplicationTestSuite, "Test SafeInt64Mult", "TestSafeI= nt64Mult", TestSafeInt64Mult, NULL, NULL, NULL); > + > + // > + // Execute the tests. > + // > + Status =3D RunAllTestSuites(Framework); > + > +EXIT: > + if (Framework !=3D 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/TestBaseSafeIntL= ib.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.
> + Copyright (c) 2018 - 2020, Intel Corporation. All rights reserved.
> + SPDX-License-Identifier: BSD-2-Clause-Patent > + > +**/ > + > +#ifndef _TEST_BASE_SAFE_INT_LIB_H_ > +#define _TEST_BASE_SAFE_INT_LIB_H_ > + > +#include > +#include > +#include > +#include > +#include > +#include > +#include > + > +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/TestBaseSafeIntL= ib.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.
> +// > +// SPDX-License-Identifier: BSD-2-Clause-Patent > +// > +// **/ > + > +#string STR_MODULE_ABSTRACT #language en-US "Application tha= t Unit Tests the SafeIntLib" > + > +#string STR_MODULE_DESCRIPTION #language en-US "Application tha= t Unit Tests the SafeIntLib." > + > diff --git a/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntL= ibDxe.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.i= nf > @@ -0,0 +1,45 @@ > +## @file > +# DXE Driver that Unit Tests the SafeIntLib > +# > +# Copyright (c) Microsoft Corporation.
> +# Copyright (c) 2019 - 2020, Intel Corporation. All rights reserved.
> +# SPDX-License-Identifier: BSD-2-Clause-Patent > +## > + > +[Defines] > + INF_VERSION =3D 0x00010005 > + BASE_NAME =3D TestBaseSafeIntLibDxe > + MODULE_UNI_FILE =3D TestBaseSafeIntLib.uni > + FILE_GUID =3D 9729DB60-FB9D-4625-9EE1-93B21EC246B8 > + MODULE_TYPE =3D DXE_DRIVER > + VERSION_STRING =3D 1.0 > + ENTRY_POINT =3D DxeEntryPoint > + > +# > +# The following information is for reference only and not required by th= e build tools. > +# > +# VALID_ARCHITECTURES =3D 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/TestBaseSafeIntL= ibHost.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.
> +# Copyright (c) 2019 - 2020, Intel Corporation. All rights reserved.
> +# SPDX-License-Identifier: BSD-2-Clause-Patent > +## > + > +[Defines] > + INF_VERSION =3D 0x00010005 > + BASE_NAME =3D TestBaseSafeIntLibHost > + MODULE_UNI_FILE =3D TestBaseSafeIntLib.uni > + FILE_GUID =3D 95487689-9E30-41AD-B773-3650C94BCBE2 > + MODULE_TYPE =3D HOST_APPLICATION > + VERSION_STRING =3D 1.0 > + > +# > +# The following information is for reference only and not required by th= e build tools. > +# > +# VALID_ARCHITECTURES =3D 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/TestBaseSafeIntL= ibPei.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.i= nf > @@ -0,0 +1,45 @@ > +## @file > +# PEIM that Unit Tests the SafeIntLib > +# > +# Copyright (c) Microsoft Corporation.
> +# Copyright (c) 2019 - 2020, Intel Corporation. All rights reserved.
> +# SPDX-License-Identifier: BSD-2-Clause-Patent > +## > + > +[Defines] > + INF_VERSION =3D 0x00010005 > + BASE_NAME =3D TestBaseSafeIntLibPei > + MODULE_UNI_FILE =3D TestBaseSafeIntLib.uni > + FILE_GUID =3D 7D910602-ED53-45E6-826E-8266705B9734 > + MODULE_TYPE =3D PEIM > + VERSION_STRING =3D 1.0 > + ENTRY_POINT =3D PeiEntryPoint > + > +# > +# The following information is for reference only and not required by th= e build tools. > +# > +# VALID_ARCHITECTURES =3D 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/TestBaseSafeIntL= ibSmm.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.i= nf > @@ -0,0 +1,45 @@ > +## @file > +# SMM Driver that Unit Tests the SafeIntLib > +# > +# Copyright (c) Microsoft Corporation.
> +# Copyright (c) 2019 - 2020, Intel Corporation. All rights reserved.
> +# SPDX-License-Identifier: BSD-2-Clause-Patent > +## > + > +[Defines] > + INF_VERSION =3D 0x00010005 > + BASE_NAME =3D TestBaseSafeIntLibSmm > + MODULE_UNI_FILE =3D TestBaseSafeIntLib.uni > + FILE_GUID =3D 2F2A1907-B1B4-4E33-8B83-62A60AB4F0D4 > + MODULE_TYPE =3D DXE_SMM_DRIVER > + VERSION_STRING =3D 1.0 > + ENTRY_POINT =3D DxeEntryPoint > + > +# > +# The following information is for reference only and not required by th= e build tools. > +# > +# VALID_ARCHITECTURES =3D 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/TestBaseSafeIntL= ibUefiShell.inf > b/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntLibUefiShell= .inf > new file mode 100644 > index 0000000000..5a13c1c845 > --- /dev/null > +++ b/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntLibUefiS= hell.inf > @@ -0,0 +1,42 @@ > +## @file > +# UEFI Shell based Application that Unit Tests the SafeIntLib > +# > +# Copyright (c) Microsoft Corporation.
> +# Copyright (c) 2019 - 2020, Intel Corporation. All rights reserved.
> +# SPDX-License-Identifier: BSD-2-Clause-Patent > +## > + > +[Defines] > + INF_VERSION =3D 0x00010005 > + BASE_NAME =3D TestBaseSafeIntLibUefiShell > + MODULE_UNI_FILE =3D TestBaseSafeIntLib.uni > + FILE_GUID =3D 1F91B73E-5B6A-4317-80E8-E7C36A3C7AF4 > + MODULE_TYPE =3D UEFI_APPLICATION > + VERSION_STRING =3D 1.0 > + ENTRY_POINT =3D DxeEntryPoint > + > +# > +# The following information is for reference only and not required by th= e build tools. > +# > +# VALID_ARCHITECTURES =3D 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