From nobody Tue Feb 3 16:35:31 2026 Delivered-To: importer@patchew.org Received-SPF: pass (zohomail.com: domain of groups.io designates 66.175.222.12 as permitted sender) client-ip=66.175.222.12; envelope-from=bounce+27952+53466+1787277+3901457@groups.io; helo=web01.groups.io; Authentication-Results: mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of groups.io designates 66.175.222.12 as permitted sender) smtp.mailfrom=bounce+27952+53466+1787277+3901457@groups.io; dmarc=fail(p=none dis=none) header.from=intel.com ARC-Seal: i=1; a=rsa-sha256; t=1579831840; cv=none; d=zohomail.com; s=zohoarc; b=YgltfAV3R1nNRFZYoM0cWZ6kgfCSmm3MzAuc0u6gWsWcudBY4B6HaQ9K7Y24EiXZ/YC0pSc3sDsQkHl+07qwmLukq3nH6gtHPxcabtaUZ0hzGN/wGDcahG/yriKMOE+xzUAXAxE/lgjJMbgnTLagK6lMk9fb2aOq4Cq1+p4PUaM= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1579831840; h=Content-Transfer-Encoding:Cc:Date:From:In-Reply-To:List-Id:List-Unsubscribe:MIME-Version:Message-ID:Reply-To:References:Sender:Subject:To; bh=iMwqtOsrJOvEouub1UnRGig890glGUGaRC+9dRWqlmg=; b=iTqN6YpdTs1Q/aF4V1eP0xdLZAAV+sBRw/DE/fGr+OUztYPDjoHFOuUNmjOk2nl8YXrR6QfBlcArCk7XjvtNp67HvJYiMbOSNC8ZquiBS6dGmIEmCvh8CsC0fZnSnluUR1fr4sLYpnPNYnNXX8Fra5GcfdasCClWLvb0qlHdDoU= ARC-Authentication-Results: i=1; mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of groups.io designates 66.175.222.12 as permitted sender) smtp.mailfrom=bounce+27952+53466+1787277+3901457@groups.io; dmarc=fail header.from= (p=none dis=none) header.from= Received: from web01.groups.io (web01.groups.io [66.175.222.12]) by mx.zohomail.com with SMTPS id 1579831840894836.8885528414614; Thu, 23 Jan 2020 18:10:40 -0800 (PST) Return-Path: X-Received: by 127.0.0.2 with SMTP id a7SKYY1788612xUu0ZtUZH4A; Thu, 23 Jan 2020 18:10:39 -0800 X-Received: from mga09.intel.com (mga09.intel.com [134.134.136.24]) by mx.groups.io with SMTP id smtpd.web12.7270.1579831837643775076 for ; Thu, 23 Jan 2020 18:10:37 -0800 X-Amp-Result: SKIPPED(no attachment in message) X-Amp-File-Uploaded: False X-Received: from orsmga004.jf.intel.com ([10.7.209.38]) by orsmga102.jf.intel.com with ESMTP/TLS/DHE-RSA-AES256-GCM-SHA384; 23 Jan 2020 18:10:36 -0800 X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.70,356,1574150400"; d="scan'208";a="375395302" X-Received: from unknown (HELO mdkinney-MOBL2.amr.corp.intel.com) ([10.241.98.74]) by orsmga004.jf.intel.com with ESMTP; 23 Jan 2020 18:10:36 -0800 From: "Michael D Kinney" To: devel@edk2.groups.io Cc: Sean Brogan , Bret Barkelew , Liming Gao Subject: [edk2-devel] [Patch 08/11] MdePkg/Test: Add SafeIntLib and BaseLib Base64 unit tests Date: Thu, 23 Jan 2020 18:10:29 -0800 Message-Id: <20200124021032.13808-9-michael.d.kinney@intel.com> In-Reply-To: <20200124021032.13808-1-michael.d.kinney@intel.com> References: <20200124021032.13808-1-michael.d.kinney@intel.com> MIME-Version: 1.0 Precedence: Bulk List-Unsubscribe: Sender: devel@edk2.groups.io List-Id: Mailing-List: list devel@edk2.groups.io; contact devel+owner@edk2.groups.io Reply-To: devel@edk2.groups.io,michael.d.kinney@intel.com X-Gm-Message-State: o2LLWfd0yuuUnkDYbwLTN4bSx1787277AA= Content-Transfer-Encoding: quoted-printable DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=groups.io; q=dns/txt; s=20140610; t=1579831839; bh=3KLKzXuICSFxWdmzl9o++9rvXseIWK0/HQcZZhB/yfc=; h=Cc:Date:From:Reply-To:Subject:To; b=VFO5PZr+e9ySjOLlp1WAcw3S64Kr+sD6SQXRJbKzmQ1oJr0BPoOnV0JZwypzlw3YXoQ qsdRR6vfU4oEBGarnvMKjhL2huJU0FToD6SI5f2wdj0wDCYNIOX2qQ2yHK7++GAo3Ivxf 0aiaB2wo0fXDrgniGZ1yiv1+a7u4SXnZTJY= X-ZohoMail-DKIM: pass (identity @groups.io) Content-Type: text/plain; charset="utf-8" * Add unit tests for SafeIntLib class * Add unit tests for BaseLib Base64 conversion APIs. * Add Test/MdePkgHostTest.dsc -to build host based unit tests * Update MdePkg.dsc to build target based tests for SafeIntLib and BaseLib * Update MdePkg.ci.yaml to build and run host based tests for SafeIntLib and BaseLib Cc: Sean Brogan Cc: Bret Barkelew Cc: Liming Gao Signed-off-by: Michael D Kinney Acked-by: Hao A Wu Reviewed-by: Bret Barkelew --- MdePkg/MdePkg.ci.yaml | 19 +- MdePkg/MdePkg.dsc | 18 + MdePkg/Test/MdePkgHostTest.dsc | 30 + .../UnitTest/Library/BaseLib/Base64UnitTest.c | 404 +++ .../Library/BaseLib/BaseLibUnitTestsHost.inf | 32 + .../Library/BaseLib/BaseLibUnitTestsUefi.inf | 33 + .../SafeIntLibUintnIntnUnitTests32.c | 540 +++ .../SafeIntLibUintnIntnUnitTests64.c | 544 +++ .../BaseSafeIntLib/TestBaseSafeIntLib.c | 3064 +++++++++++++++++ .../BaseSafeIntLib/TestBaseSafeIntLib.h | 123 + .../BaseSafeIntLib/TestBaseSafeIntLib.uni | 13 + .../BaseSafeIntLib/TestBaseSafeIntLibDxe.inf | 45 + .../BaseSafeIntLib/TestBaseSafeIntLibHost.inf | 40 + .../BaseSafeIntLib/TestBaseSafeIntLibPei.inf | 45 + .../BaseSafeIntLib/TestBaseSafeIntLibSmm.inf | 45 + .../TestBaseSafeIntLibUefiShell.inf | 42 + 16 files changed, 5034 insertions(+), 3 deletions(-) create mode 100644 MdePkg/Test/MdePkgHostTest.dsc create mode 100644 MdePkg/Test/UnitTest/Library/BaseLib/Base64UnitTest.c create mode 100644 MdePkg/Test/UnitTest/Library/BaseLib/BaseLibUnitTestsHo= st.inf create mode 100644 MdePkg/Test/UnitTest/Library/BaseLib/BaseLibUnitTestsUe= fi.inf create mode 100644 MdePkg/Test/UnitTest/Library/BaseSafeIntLib/SafeIntLibU= intnIntnUnitTests32.c create mode 100644 MdePkg/Test/UnitTest/Library/BaseSafeIntLib/SafeIntLibU= intnIntnUnitTests64.c create mode 100644 MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSaf= eIntLib.c create mode 100644 MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSaf= eIntLib.h create mode 100644 MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSaf= eIntLib.uni create mode 100644 MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSaf= eIntLibDxe.inf create mode 100644 MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSaf= eIntLibHost.inf create mode 100644 MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSaf= eIntLibPei.inf create mode 100644 MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSaf= eIntLibSmm.inf create mode 100644 MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSaf= eIntLibUefiShell.inf diff --git a/MdePkg/MdePkg.ci.yaml b/MdePkg/MdePkg.ci.yaml index 65c4ec3bec..88e490fcb6 100644 --- a/MdePkg/MdePkg.ci.yaml +++ b/MdePkg/MdePkg.ci.yaml @@ -10,8 +10,13 @@ "DscPath": "MdePkg.dsc" }, =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/StandaloneMmDriverEntryPoint= .inf MdePkg/Library/StandaloneMmServicesTableLib/StandaloneMmServicesTableLib= .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 Sa= feIntLib + # + MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntLibPei.inf + MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntLibDxe.inf + MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntLibSmm.inf + MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntLibUefiShell.= inf + [Components.IA32, Components.X64] MdePkg/Library/BaseIoLibIntrinsic/BaseIoLibIntrinsic.inf MdePkg/Library/BaseIoLibIntrinsic/BaseIoLibIntrinsicSev.inf diff --git a/MdePkg/Test/MdePkgHostTest.dsc b/MdePkg/Test/MdePkgHostTest.dsc new file mode 100644 index 0000000000..3d677ee75c --- /dev/null +++ b/MdePkg/Test/MdePkgHostTest.dsc @@ -0,0 +1,30 @@ +## @file +# MdePkg DSC file used to build host-based unit tests. +# +# Copyright (c) 2019 - 2020, Intel Corporation. All rights reserved.
+# 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/MdePkg= /Test/UnitTest/Library/BaseLib/Base64UnitTest.c new file mode 100644 index 0000000000..0ad078155c --- /dev/null +++ b/MdePkg/Test/UnitTest/Library/BaseLib/Base64UnitTest.c @@ -0,0 +1,404 @@ +/** @file + Unit tests of Base64 conversion APIs in BaseLib. + + Copyright (C) Microsoft Corporation. + SPDX-License-Identifier: BSD-2-Clause-Patent + +**/ + +#include +#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 afte= rwards +#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----------Output-= ----------Result-------Free--Expected Output Size +static BASIC_TEST_CONTEXT mBasicEncodeTest1 =3D {BIN_TEST_1, B64_T= EST_1, EFI_SUCCESS, NULL, sizeof(B64_TEST_1)}; +static BASIC_TEST_CONTEXT mBasicEncodeTest2 =3D {BIN_TEST_2, B64_T= EST_2, EFI_SUCCESS, NULL, sizeof(B64_TEST_2)}; +static BASIC_TEST_CONTEXT mBasicEncodeTest3 =3D {BIN_TEST_3, B64_T= EST_3, EFI_SUCCESS, NULL, sizeof(B64_TEST_3)}; +static BASIC_TEST_CONTEXT mBasicEncodeTest4 =3D {BIN_TEST_4, B64_T= EST_4, EFI_SUCCESS, NULL, sizeof(B64_TEST_4)}; +static BASIC_TEST_CONTEXT mBasicEncodeTest5 =3D {BIN_TEST_5, B64_T= EST_5, EFI_SUCCESS, NULL, sizeof(B64_TEST_5)}; +static BASIC_TEST_CONTEXT mBasicEncodeTest6 =3D {BIN_TEST_6, B64_T= EST_6, EFI_SUCCESS, NULL, sizeof(B64_TEST_6)}; +static BASIC_TEST_CONTEXT mBasicEncodeTest7 =3D {BIN_TEST_7, B64_T= EST_7, EFI_SUCCESS, NULL, sizeof(B64_TEST_7)}; +static BASIC_TEST_CONTEXT mBasicEncodeError1 =3D {BIN_TEST_7, B64_T= EST_1, EFI_BUFFER_TOO_SMALL, NULL, sizeof(B64_TEST_7)}; + +static BASIC_TEST_CONTEXT mBasicDecodeTest1 =3D {B64_TEST_1, BIN_T= EST_1, EFI_SUCCESS, NULL, sizeof(BIN_TEST_1)-1}; +static BASIC_TEST_CONTEXT mBasicDecodeTest2 =3D {B64_TEST_2, BIN_T= EST_2, EFI_SUCCESS, NULL, sizeof(BIN_TEST_2)-1}; +static BASIC_TEST_CONTEXT mBasicDecodeTest3 =3D {B64_TEST_3, BIN_T= EST_3, EFI_SUCCESS, NULL, sizeof(BIN_TEST_3)-1}; +static BASIC_TEST_CONTEXT mBasicDecodeTest4 =3D {B64_TEST_4, BIN_T= EST_4, EFI_SUCCESS, NULL, sizeof(BIN_TEST_4)-1}; +static BASIC_TEST_CONTEXT mBasicDecodeTest5 =3D {B64_TEST_5, BIN_T= EST_5, EFI_SUCCESS, NULL, sizeof(BIN_TEST_5)-1}; +static BASIC_TEST_CONTEXT mBasicDecodeTest6 =3D {B64_TEST_6, BIN_T= EST_6, EFI_SUCCESS, NULL, sizeof(BIN_TEST_6)-1}; +static BASIC_TEST_CONTEXT mBasicDecodeTest7 =3D {B64_TEST_7, BIN_T= EST_7, EFI_SUCCESS, NULL, sizeof(BIN_TEST_7)-1}; +static BASIC_TEST_CONTEXT mBasicDecodeTest8 =3D {B64_TEST_8_IN, BIN_T= EST_8, EFI_SUCCESS, NULL, sizeof(BIN_TEST_8)-1}; + +static BASIC_TEST_CONTEXT mBasicDecodeError1 =3D {B64_ERROR_1, B64_E= RROR_1, EFI_INVALID_PARAMETER, NULL, 0}; +static BASIC_TEST_CONTEXT mBasicDecodeError2 =3D {B64_ERROR_2, B64_E= RROR_2, EFI_INVALID_PARAMETER, NULL, 0}; +static BASIC_TEST_CONTEXT mBasicDecodeError3 =3D {B64_ERROR_3, B64_E= RROR_3, EFI_INVALID_PARAMETER, NULL, 0}; +static BASIC_TEST_CONTEXT mBasicDecodeError4 =3D {B64_ERROR_4, B64_E= RROR_4, EFI_INVALID_PARAMETER, NULL, 0}; +static BASIC_TEST_CONTEXT mBasicDecodeError5 =3D {B64_TEST_7, BIN_T= EST_1, EFI_BUFFER_TOO_SMALL, NULL, sizeof(BIN_TEST_7)-1}; + +/** + Simple clean up method to make sure tests clean up even if interrupted a= nd 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 need a + reboot. This parameter is a VOID* and it is the + responsibility of the test author to ensure that = the + contents are well understood by all test cases th= at may + consume it. + + @retval UNIT_TEST_PASSED The Unit test has completed and th= e 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 prop= er + // 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, ReturnSize= ); + if (CompareStatus !=3D 0) { + UT_LOG_ERROR ("b64 string compare error - size=3D%d\n", ReturnSize= ); + 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 need a + reboot. This parameter is a VOID* and it is the + responsibility of the test author to ensure that = the + contents are well understood by all test cases th= at may + consume it. + + @retval UNIT_TEST_PASSED The Unit test has completed and th= e 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", ReturnSize= ); + 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 available = to + initialize the unit tests. +**/ +STATIC +EFI_STATUS +EFIAPI +UnitTestingEntry ( + VOID + ) +{ + EFI_STATUS Status; + UNIT_TEST_FRAMEWORK_HANDLE Fw; + UNIT_TEST_SUITE_HANDLE b64EncodeTests; + UNIT_TEST_SUITE_HANDLE b64DecodeTests; + + Fw =3D NULL; + + DEBUG ((DEBUG_INFO, "%a v%a\n", UNIT_TEST_APP_NAME, UNIT_TEST_APP_VERSIO= N)); + + // + // Start setting up the test framework for running the tests. + // + Status =3D InitUnitTestFramework (&Fw, UNIT_TEST_APP_NAME, gEfiCallerBas= eName, 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 binary = to Ascii string", "BaseLib.b64Encode", NULL, NULL); + if (EFI_ERROR (Status)) { + DEBUG ((DEBUG_ERROR, "Failed in CreateUnitTestSuite for b64EncodeTests= \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", Rf= cEncodeTest, NULL, CleanUpB64TestContext, &mBasicEncodeTest1); + AddTestCase (b64EncodeTests, "RFC 4686 Test Vector - f", "Test2", RfcEnc= odeTest, NULL, CleanUpB64TestContext, &mBasicEncodeTest2); + AddTestCase (b64EncodeTests, "RFC 4686 Test Vector - fo", "Test3", RfcEn= codeTest, NULL, CleanUpB64TestContext, &mBasicEncodeTest3); + AddTestCase (b64EncodeTests, "RFC 4686 Test Vector - foo", "Test4", RfcE= ncodeTest, NULL, CleanUpB64TestContext, &mBasicEncodeTest4); + AddTestCase (b64EncodeTests, "RFC 4686 Test Vector - foob", "Test5", Rfc= EncodeTest, NULL, CleanUpB64TestContext, &mBasicEncodeTest5); + AddTestCase (b64EncodeTests, "RFC 4686 Test Vector - fooba", "Test6", Rf= cEncodeTest, NULL, CleanUpB64TestContext, &mBasicEncodeTest6); + AddTestCase (b64EncodeTests, "RFC 4686 Test Vector - foobar", "Test7", R= fcEncodeTest, NULL, CleanUpB64TestContext, &mBasicEncodeTest7); + AddTestCase (b64EncodeTests, "Too small of output buffer", "Error1", Rfc= EncodeTest, NULL, CleanUpB64TestContext, &mBasicEncodeError1); + // + // Populate the B64 Decode Unit Test Suite. + // + Status =3D CreateUnitTestSuite (&b64DecodeTests, Fw, "b64 Decode Ascii s= tring to binary", "BaseLib.b64Decode", NULL, NULL); + if (EFI_ERROR (Status)) { + DEBUG ((DEBUG_ERROR, "Failed in CreateUnitTestSuite for b64Decode Te= sts\n")); + Status =3D EFI_OUT_OF_RESOURCES; + goto EXIT; + } + + AddTestCase (b64DecodeTests, "RFC 4686 Test Vector - Empty", "Test1", R= fcDecodeTest, NULL, CleanUpB64TestContext, &mBasicDecodeTest1); + AddTestCase (b64DecodeTests, "RFC 4686 Test Vector - f", "Test2", RfcDe= codeTest, NULL, CleanUpB64TestContext, &mBasicDecodeTest2); + AddTestCase (b64DecodeTests, "RFC 4686 Test Vector - fo", "Test3", RfcD= ecodeTest, NULL, CleanUpB64TestContext, &mBasicDecodeTest3); + AddTestCase (b64DecodeTests, "RFC 4686 Test Vector - foo", "Test4", Rfc= DecodeTest, NULL, CleanUpB64TestContext, &mBasicDecodeTest4); + AddTestCase (b64DecodeTests, "RFC 4686 Test Vector - foob", "Test5", Rf= cDecodeTest, NULL, CleanUpB64TestContext, &mBasicDecodeTest5); + AddTestCase (b64DecodeTests, "RFC 4686 Test Vector - fooba", "Test6", R= fcDecodeTest, NULL, CleanUpB64TestContext, &mBasicDecodeTest6); + AddTestCase (b64DecodeTests, "RFC 4686 Test Vector - foobar", "Test7", = RfcDecodeTest, NULL, CleanUpB64TestContext, &mBasicDecodeTest7); + AddTestCase (b64DecodeTests, "Ignore Whitespace test", "Test8", RfcDeco= deTest, NULL, CleanUpB64TestContext, &mBasicDecodeTest8); + + AddTestCase (b64DecodeTests, "Not a quantum multiple of 4", "Error1", Rf= cDecodeTest, NULL, CleanUpB64TestContext, &mBasicDecodeError1); + AddTestCase (b64DecodeTests, "Invalid characters in the string", "Error2= ", RfcDecodeTest, NULL, CleanUpB64TestContext, &mBasicDecodeError2); + AddTestCase (b64DecodeTests, "Too many padding characters", "Error3", Rf= cDecodeTest, NULL, CleanUpB64TestContext, &mBasicDecodeError3); + AddTestCase (b64DecodeTests, "Incorrectly placed padding character", "Er= ror4", RfcDecodeTest, NULL, CleanUpB64TestContext, &mBasicDecodeError4); + AddTestCase (b64DecodeTests, "Too small of output buffer", "Error5", Rfc= DecodeTest, 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 UEFI= Shell. +**/ +EFI_STATUS +EFIAPI +BaseLibUnitTestAppEntry ( + IN EFI_HANDLE ImageHandle, + IN EFI_SYSTEM_TABLE *SystemTable + ) +{ + return UnitTestingEntry (); +} + +/** + Standard POSIX C entry point for host based unit test execution. +**/ +int +main ( + int argc, + char *argv[] + ) +{ + return UnitTestingEntry (); +} diff --git a/MdePkg/Test/UnitTest/Library/BaseLib/BaseLibUnitTestsHost.inf = b/MdePkg/Test/UnitTest/Library/BaseLib/BaseLibUnitTestsHost.inf new file mode 100644 index 0000000000..b31afae633 --- /dev/null +++ b/MdePkg/Test/UnitTest/Library/BaseLib/BaseLibUnitTestsHost.inf @@ -0,0 +1,32 @@ +## @file +# Unit tests of Base64 conversion APIs in BaseLib that are run from host +# environment. +# +# Copyright (C) Microsoft Corporation. +# SPDX-License-Identifier: BSD-2-Clause-Patent +## + +[Defines] + INF_VERSION =3D 0x00010006 + BASE_NAME =3D BaseLibUnitTestsHost + FILE_GUID =3D 1d005f4c-4dfa-41b5-ab0c-be91fe121459 + MODULE_TYPE =3D HOST_APPLICATION + VERSION_STRING =3D 1.0 + +# +# The following information is for reference only and not required by the = 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.inf = b/MdePkg/Test/UnitTest/Library/BaseLib/BaseLibUnitTestsUefi.inf new file mode 100644 index 0000000000..907503898a --- /dev/null +++ b/MdePkg/Test/UnitTest/Library/BaseLib/BaseLibUnitTestsUefi.inf @@ -0,0 +1,33 @@ +## @file +# Unit tests of Base64 conversion APIs in BaseLib that are run from UEFI S= hell. +# +# 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-eab39497b4a1 + 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 the = 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/SafeIntLibUintnInt= nUnitTests32.c b/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/SafeIntLibUint= nIntnUnitTests32.c new file mode 100644 index 0000000000..be5c0e15d3 --- /dev/null +++ b/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/SafeIntLibUintnIntnUnitTe= sts32.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 addit= ion + // + 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 s= ucceed + // + 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/SafeIntLibUintnInt= nUnitTests64.c b/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/SafeIntLibUint= nIntnUnitTests64.c new file mode 100644 index 0000000000..0fee298172 --- /dev/null +++ b/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/SafeIntLibUintnIntnUnitTe= sts64.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 cast + // + 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 cast + // + 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 addit= ion + // + 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 s= ucceed + // + 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/TestBaseSafeIntLib= .c b/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntLib.c new file mode 100644 index 0000000000..2b1a2223a0 --- /dev/null +++ b/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntLib.c @@ -0,0 +1,3064 @@ +/** @file + UEFI OS based application for unit testing the SafeIntLib. + + Copyright (c) Microsoft Corporation.
+ 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 ca= st + // + 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 an= d 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 ca= st + // + 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 an= d 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 ca= st + // + 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 an= d MAX_INT8. + // + + // + // If Operand is between MIN_INT8 and MAX_INT8 inclusive, then it's a ca= st + // + 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 c= ast + // + 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 an= d MAX_INT8. + // + + // + // If Operand is between MIN_INT8 and MAX_INT8 inclusive, then it's a c= ast + // + 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 addit= ion + // + 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 addi= tion + // + 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 addi= tion + // + 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 addi= tion + // + 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 s= ucceed + // + 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 will = 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 will = 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 will = 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 doesn'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 doesn'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 doesn'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, gEfiCaller= BaseName, 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 Sa= fe Conversions Test Suite", "Common.SafeInt.Convert", NULL, NULL); + if (EFI_ERROR(Status)) { + DEBUG((DEBUG_ERROR, "Failed in CreateUnitTestSuite for Conversions Tes= t Suite\n")); + Status =3D EFI_OUT_OF_RESOURCES; + goto EXIT; + } + AddTestCase(ConversionTestSuite, "Test SafeInt8ToUint8", "TestSafeInt= 8ToUint8", TestSafeInt8ToUint8, NULL, NULL, NULL); + AddTestCase(ConversionTestSuite, "Test SafeInt8ToUint16", "TestSafeInt= 8ToUint16", TestSafeInt8ToUint16, NULL, NULL, NULL); + AddTestCase(ConversionTestSuite, "Test SafeInt8ToUint32", "TestSafeInt= 8ToUint32", TestSafeInt8ToUint32, NULL, NULL, NULL); + AddTestCase(ConversionTestSuite, "Test SafeInt8ToUintn", "TestSafeInt= 8ToUintn", TestSafeInt8ToUintn, NULL, NULL, NULL); + AddTestCase(ConversionTestSuite, "Test SafeInt8ToUint64", "TestSafeInt= 8ToUint64", TestSafeInt8ToUint64, NULL, NULL, NULL); + AddTestCase(ConversionTestSuite, "Test SafeUint8ToInt8", "TestSafeUin= t8ToInt8", TestSafeUint8ToInt8, NULL, NULL, NULL); + AddTestCase(ConversionTestSuite, "Test SafeUint8ToChar8", "TestSafeUin= t8ToChar8", TestSafeUint8ToChar8, NULL, NULL, NULL); + AddTestCase(ConversionTestSuite, "Test SafeInt16ToInt8", "TestSafeInt= 16ToInt8", TestSafeInt16ToInt8, NULL, NULL, NULL); + AddTestCase(ConversionTestSuite, "Test SafeInt16ToChar8", "TestSafeInt= 16ToChar8", TestSafeInt16ToChar8, NULL, NULL, NULL); + AddTestCase(ConversionTestSuite, "Test SafeInt16ToUint8", "TestSafeInt= 16ToUint8", TestSafeInt16ToUint8, NULL, NULL, NULL); + AddTestCase(ConversionTestSuite, "Test SafeInt16ToUint16", "TestSafeInt= 16ToUint16", TestSafeInt16ToUint16, NULL, NULL, NULL); + AddTestCase(ConversionTestSuite, "Test SafeInt16ToUint32", "TestSafeInt= 16ToUint32", TestSafeInt16ToUint32, NULL, NULL, NULL); + AddTestCase(ConversionTestSuite, "Test SafeInt16ToUintn", "TestSafeInt= 16ToUintn", TestSafeInt16ToUintn, NULL, NULL, NULL); + AddTestCase(ConversionTestSuite, "Test SafeInt16ToUint64", "TestSafeInt= 16ToUint64", TestSafeInt16ToUint64, NULL, NULL, NULL); + AddTestCase(ConversionTestSuite, "Test SafeUint16ToInt8", "TestSafeUin= t16ToInt8", TestSafeUint16ToInt8, NULL, NULL, NULL); + AddTestCase(ConversionTestSuite, "Test SafeUint16ToChar8", "TestSafeUin= t16ToChar8", TestSafeUint16ToChar8, NULL, NULL, NULL); + AddTestCase(ConversionTestSuite, "Test SafeUint16ToUint8", "TestSafeUin= t16ToUint8", TestSafeUint16ToUint8, NULL, NULL, NULL); + AddTestCase(ConversionTestSuite, "Test SafeUint16ToInt16", "TestSafeUin= t16ToInt16", TestSafeUint16ToInt16, NULL, NULL, NULL); + AddTestCase(ConversionTestSuite, "Test SafeInt32ToInt8", "TestSafeInt= 32ToInt8", TestSafeInt32ToInt8, NULL, NULL, NULL); + AddTestCase(ConversionTestSuite, "Test SafeInt32ToChar8", "TestSafeInt= 32ToChar8", TestSafeInt32ToChar8, NULL, NULL, NULL); + AddTestCase(ConversionTestSuite, "Test SafeInt32ToUint8", "TestSafeInt= 32ToUint8", TestSafeInt32ToUint8, NULL, NULL, NULL); + AddTestCase(ConversionTestSuite, "Test SafeInt32ToInt16", "TestSafeInt= 32ToInt16", TestSafeInt32ToInt16, NULL, NULL, NULL); + AddTestCase(ConversionTestSuite, "Test SafeInt32ToUint16", "TestSafeInt= 32ToUint16", TestSafeInt32ToUint16, NULL, NULL, NULL); + AddTestCase(ConversionTestSuite, "Test SafeInt32ToUint32", "TestSafeInt= 32ToUint32", TestSafeInt32ToUint32, NULL, NULL, NULL); + AddTestCase(ConversionTestSuite, "Test SafeInt32ToUintn", "TestSafeInt= 32ToUintn", TestSafeInt32ToUintn, NULL, NULL, NULL); + AddTestCase(ConversionTestSuite, "Test SafeInt32ToUint64", "TestSafeInt= 32ToUint64", TestSafeInt32ToUint64, NULL, NULL, NULL); + AddTestCase(ConversionTestSuite, "Test SafeUint32ToInt8", "TestSafeUin= t32ToInt8", TestSafeUint32ToInt8, NULL, NULL, NULL); + AddTestCase(ConversionTestSuite, "Test SafeUint32ToChar8", "TestSafeUin= t32ToChar8", TestSafeUint32ToChar8, NULL, NULL, NULL); + AddTestCase(ConversionTestSuite, "Test SafeUint32ToUint8", "TestSafeUin= t32ToUint8", TestSafeUint32ToUint8, NULL, NULL, NULL); + AddTestCase(ConversionTestSuite, "Test SafeUint32ToInt16", "TestSafeUin= t32ToInt16", TestSafeUint32ToInt16, NULL, NULL, NULL); + AddTestCase(ConversionTestSuite, "Test SafeUint32ToUint16", "TestSafeUin= t32ToUint16", TestSafeUint32ToUint16, NULL, NULL, NULL); + AddTestCase(ConversionTestSuite, "Test SafeUint32ToInt32", "TestSafeUin= t32ToInt32", TestSafeUint32ToInt32, NULL, NULL, NULL); + AddTestCase(ConversionTestSuite, "Test SafeUint32ToIntn", "TestSafeUin= t32ToIntn", TestSafeUint32ToIntn, NULL, NULL, NULL); + AddTestCase(ConversionTestSuite, "Test SafeIntnToInt8", "TestSafeInt= nToInt8", TestSafeIntnToInt8, NULL, NULL, NULL); + AddTestCase(ConversionTestSuite, "Test SafeIntnToChar8", "TestSafeInt= nToChar8", TestSafeIntnToChar8, NULL, NULL, NULL); + AddTestCase(ConversionTestSuite, "Test SafeIntnToUint8", "TestSafeInt= nToUint8", TestSafeIntnToUint8, NULL, NULL, NULL); + AddTestCase(ConversionTestSuite, "Test SafeIntnToInt16", "TestSafeInt= nToInt16", TestSafeIntnToInt16, NULL, NULL, NULL); + AddTestCase(ConversionTestSuite, "Test SafeIntnToUint16", "TestSafeInt= nToUint16", TestSafeIntnToUint16, NULL, NULL, NULL); + AddTestCase(ConversionTestSuite, "Test SafeIntnToInt32", "TestSafeInt= nToInt32", TestSafeIntnToInt32, NULL, NULL, NULL); + AddTestCase(ConversionTestSuite, "Test SafeIntnToUint32", "TestSafeInt= nToUint32", TestSafeIntnToUint32, NULL, NULL, NULL); + AddTestCase(ConversionTestSuite, "Test SafeIntnToUintn", "TestSafeInt= nToUintn", TestSafeIntnToUintn, NULL, NULL, NULL); + AddTestCase(ConversionTestSuite, "Test SafeIntnToUint64", "TestSafeInt= nToUint64", TestSafeIntnToUint64, NULL, NULL, NULL); + AddTestCase(ConversionTestSuite, "Test SafeUintnToInt8", "TestSafeUin= tnToInt8", TestSafeUintnToInt8, NULL, NULL, NULL); + AddTestCase(ConversionTestSuite, "Test SafeUintnToChar8", "TestSafeUin= tnToChar8", TestSafeUintnToChar8, NULL, NULL, NULL); + AddTestCase(ConversionTestSuite, "Test SafeUintnToUint8", "TestSafeUin= tnToUint8", TestSafeUintnToUint8, NULL, NULL, NULL); + AddTestCase(ConversionTestSuite, "Test SafeUintnToInt16", "TestSafeUin= tnToInt16", TestSafeUintnToInt16, NULL, NULL, NULL); + AddTestCase(ConversionTestSuite, "Test SafeUintnToUint16", "TestSafeUin= tnToUint16", TestSafeUintnToUint16, NULL, NULL, NULL); + AddTestCase(ConversionTestSuite, "Test SafeUintnToInt32", "TestSafeUin= tnToInt32", TestSafeUintnToInt32, NULL, NULL, NULL); + AddTestCase(ConversionTestSuite, "Test SafeUintnToUint32", "TestSafeUin= tnToUint32", TestSafeUintnToUint32, NULL, NULL, NULL); + AddTestCase(ConversionTestSuite, "Test SafeUintnToIntn", "TestSafeUin= tnToIntn", TestSafeUintnToIntn, NULL, NULL, NULL); + AddTestCase(ConversionTestSuite, "Test SafeUintnToInt64", "TestSafeUin= tnToInt64", TestSafeUintnToInt64, NULL, NULL, NULL); + AddTestCase(ConversionTestSuite, "Test SafeInt64ToInt8", "TestSafeInt= 64ToInt8", TestSafeInt64ToInt8, NULL, NULL, NULL); + AddTestCase(ConversionTestSuite, "Test SafeInt64ToChar8", "TestSafeInt= 64ToChar8", TestSafeInt64ToChar8, NULL, NULL, NULL); + AddTestCase(ConversionTestSuite, "Test SafeInt64ToUint8", "TestSafeInt= 64ToUint8", TestSafeInt64ToUint8, NULL, NULL, NULL); + AddTestCase(ConversionTestSuite, "Test SafeInt64ToInt16", "TestSafeInt= 64ToInt16", TestSafeInt64ToInt16, NULL, NULL, NULL); + AddTestCase(ConversionTestSuite, "Test SafeInt64ToUint16", "TestSafeInt= 64ToUint16", TestSafeInt64ToUint16, NULL, NULL, NULL); + AddTestCase(ConversionTestSuite, "Test SafeInt64ToInt32", "TestSafeInt= 64ToInt32", TestSafeInt64ToInt32, NULL, NULL, NULL); + AddTestCase(ConversionTestSuite, "Test SafeInt64ToUint32", "TestSafeInt= 64ToUint32", TestSafeInt64ToUint32, NULL, NULL, NULL); + AddTestCase(ConversionTestSuite, "Test SafeInt64ToIntn", "TestSafeInt= 64ToIntn", TestSafeInt64ToIntn, NULL, NULL, NULL); + AddTestCase(ConversionTestSuite, "Test SafeInt64ToUintn", "TestSafeInt= 64ToUintn", TestSafeInt64ToUintn, NULL, NULL, NULL); + AddTestCase(ConversionTestSuite, "Test SafeInt64ToUint64", "TestSafeInt= 64ToUint64", TestSafeInt64ToUint64, NULL, NULL, NULL); + AddTestCase(ConversionTestSuite, "Test SafeUint64ToInt8", "TestSafeUin= t64ToInt8", TestSafeUint64ToInt8, NULL, NULL, NULL); + AddTestCase(ConversionTestSuite, "Test SafeUint64ToChar8", "TestSafeUin= t64ToChar8", TestSafeUint64ToChar8, NULL, NULL, NULL); + AddTestCase(ConversionTestSuite, "Test SafeUint64ToUint8", "TestSafeUin= t64ToUint8", TestSafeUint64ToUint8, NULL, NULL, NULL); + AddTestCase(ConversionTestSuite, "Test SafeUint64ToInt16", "TestSafeUin= t64ToInt16", TestSafeUint64ToInt16, NULL, NULL, NULL); + AddTestCase(ConversionTestSuite, "Test SafeUint64ToUint16", "TestSafeUin= t64ToUint16", TestSafeUint64ToUint16, NULL, NULL, NULL); + AddTestCase(ConversionTestSuite, "Test SafeUint64ToInt32", "TestSafeUin= t64ToInt32", TestSafeUint64ToInt32, NULL, NULL, NULL); + AddTestCase(ConversionTestSuite, "Test SafeUint64ToUint32", "TestSafeUin= t64ToUint32", TestSafeUint64ToUint32, NULL, NULL, NULL); + AddTestCase(ConversionTestSuite, "Test SafeUint64ToIntn", "TestSafeUin= t64ToIntn", TestSafeUint64ToIntn, NULL, NULL, NULL); + AddTestCase(ConversionTestSuite, "Test SafeUint64ToUintn", "TestSafeUin= t64ToUintn", TestSafeUint64ToUintn, NULL, NULL, NULL); + AddTestCase(ConversionTestSuite, "Test SafeUint64ToInt64", "TestSafeUin= t64ToInt64", TestSafeUint64ToInt64, NULL, NULL, NULL); + + // + // Test the addition and subtraction functions + // + Status =3D CreateUnitTestSuite(&AdditionSubtractionTestSuite, Framework,= "Int Safe Add/Subtract Test Suite", "Common.SafeInt.AddSubtract", NULL, NU= LL); + if (EFI_ERROR(Status)) { + DEBUG((DEBUG_ERROR, "Failed in CreateUnitTestSuite for Int Safe Add/Su= btract Test Suite\n")); + Status =3D EFI_OUT_OF_RESOURCES; + goto EXIT; + } + AddTestCase(AdditionSubtractionTestSuite, "Test SafeUint8Add", "TestSaf= eUint8Add", TestSafeUint8Add, NULL, NULL, NULL); + AddTestCase(AdditionSubtractionTestSuite, "Test SafeUint16Add", "TestSaf= eUint16Add", TestSafeUint16Add, NULL, NULL, NULL); + AddTestCase(AdditionSubtractionTestSuite, "Test SafeUint32Add", "TestSaf= eUint32Add", TestSafeUint32Add, NULL, NULL, NULL); + AddTestCase(AdditionSubtractionTestSuite, "Test SafeUintnAdd", "TestSaf= eUintnAdd", TestSafeUintnAdd, NULL, NULL, NULL); + AddTestCase(AdditionSubtractionTestSuite, "Test SafeUint64Add", "TestSaf= eUint64Add", TestSafeUint64Add, NULL, NULL, NULL); + AddTestCase(AdditionSubtractionTestSuite, "Test SafeInt8Add", "TestSaf= eInt8Add", TestSafeInt8Add, NULL, NULL, NULL); + AddTestCase(AdditionSubtractionTestSuite, "Test SafeInt16Add", "TestSaf= eInt16Add", TestSafeInt16Add, NULL, NULL, NULL); + AddTestCase(AdditionSubtractionTestSuite, "Test SafeInt32Add", "TestSaf= eInt32Add", TestSafeInt32Add, NULL, NULL, NULL); + AddTestCase(AdditionSubtractionTestSuite, "Test SafeIntnAdd", "TestSaf= eIntnAdd", TestSafeIntnAdd, NULL, NULL, NULL); + AddTestCase(AdditionSubtractionTestSuite, "Test SafeInt64Add", "TestSaf= eInt64Add", TestSafeInt64Add, NULL, NULL, NULL); + AddTestCase(AdditionSubtractionTestSuite, "Test SafeUint8Sub", "TestSaf= eUint8Sub", TestSafeUint8Sub, NULL, NULL, NULL); + AddTestCase(AdditionSubtractionTestSuite, "Test SafeUint16Sub", "TestSaf= eUint16Sub", TestSafeUint16Sub, NULL, NULL, NULL); + AddTestCase(AdditionSubtractionTestSuite, "Test SafeUint32Sub", "TestSaf= eUint32Sub", TestSafeUint32Sub, NULL, NULL, NULL); + AddTestCase(AdditionSubtractionTestSuite, "Test SafeUintnSub", "TestSaf= eUintnSub", TestSafeUintnSub, NULL, NULL, NULL); + AddTestCase(AdditionSubtractionTestSuite, "Test SafeUint64Sub", "TestSaf= eUint64Sub", TestSafeUint64Sub, NULL, NULL, NULL); + AddTestCase(AdditionSubtractionTestSuite, "Test SafeInt8Sub", "TestSaf= eInt8Sub", TestSafeInt8Sub, NULL, NULL, NULL); + AddTestCase(AdditionSubtractionTestSuite, "Test SafeInt16Sub", "TestSaf= eInt16Sub", TestSafeInt16Sub, NULL, NULL, NULL); + AddTestCase(AdditionSubtractionTestSuite, "Test SafeInt32Sub", "TestSaf= eInt32Sub", TestSafeInt32Sub, NULL, NULL, NULL); + AddTestCase(AdditionSubtractionTestSuite, "Test SafeIntnSub", "TestSaf= eIntnSub", TestSafeIntnSub, NULL, NULL, NULL); + AddTestCase(AdditionSubtractionTestSuite, "Test SafeInt64Sub", "TestSaf= eInt64Sub", TestSafeInt64Sub, NULL, NULL, NULL); + + // + // Test the multiplication functions + // + Status =3D CreateUnitTestSuite(&MultiplicationTestSuite, Framework, "Int= Safe Multiply Test Suite", "Common.SafeInt.Multiply", NULL, NULL); + if (EFI_ERROR(Status)) { + DEBUG((DEBUG_ERROR, "Failed in CreateUnitTestSuite for Int Safe Multip= ly Test Suite\n")); + Status =3D EFI_OUT_OF_RESOURCES; + goto EXIT; + } + AddTestCase(MultiplicationTestSuite, "Test SafeUint8Mult", "TestSafeUin= t8Mult", TestSafeUint8Mult, NULL, NULL, NULL); + AddTestCase(MultiplicationTestSuite, "Test SafeUint16Mult", "TestSafeUin= t16Mult", TestSafeUint16Mult, NULL, NULL, NULL); + AddTestCase(MultiplicationTestSuite, "Test SafeUint32Mult", "TestSafeUin= t32Mult", TestSafeUint32Mult, NULL, NULL, NULL); + AddTestCase(MultiplicationTestSuite, "Test SafeUintnMult", "TestSafeUin= tnMult", TestSafeUintnMult, NULL, NULL, NULL); + AddTestCase(MultiplicationTestSuite, "Test SafeUint64Mult", "TestSafeUin= t64Mult", TestSafeUint64Mult, NULL, NULL, NULL); + AddTestCase(MultiplicationTestSuite, "Test SafeInt8Mult", "TestSafeInt= 8Mult", TestSafeInt8Mult, NULL, NULL, NULL); + AddTestCase(MultiplicationTestSuite, "Test SafeInt16Mult", "TestSafeInt= 16Mult", TestSafeInt16Mult, NULL, NULL, NULL); + AddTestCase(MultiplicationTestSuite, "Test SafeInt32Mult", "TestSafeInt= 32Mult", TestSafeInt32Mult, NULL, NULL, NULL); + AddTestCase(MultiplicationTestSuite, "Test SafeIntnMult", "TestSafeInt= nMult", TestSafeIntnMult, NULL, NULL, NULL); + AddTestCase(MultiplicationTestSuite, "Test SafeInt64Mult", "TestSafeInt= 64Mult", 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/TestBaseSafeIntLib= .h b/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntLib.h new file mode 100644 index 0000000000..7957c99a85 --- /dev/null +++ b/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntLib.h @@ -0,0 +1,123 @@ +/** @file + UEFI OS based application for unit testing the SafeIntLib. + + Copyright (c) Microsoft Corporation.
+ 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/TestBaseSafeIntLib= .uni b/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntLib.uni new file mode 100644 index 0000000000..956835c30d --- /dev/null +++ b/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntLib.uni @@ -0,0 +1,13 @@ +// /** @file +// Application that Unit Tests the SafeIntLib +// +// Copyright (c) 2020, Intel Corporation. All rights reserved.
+// +// SPDX-License-Identifier: BSD-2-Clause-Patent +// +// **/ + +#string STR_MODULE_ABSTRACT #language en-US "Application that = Unit Tests the SafeIntLib" + +#string STR_MODULE_DESCRIPTION #language en-US "Application that = Unit Tests the SafeIntLib." + diff --git a/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntLib= Dxe.inf b/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntLibDxe= .inf new file mode 100644 index 0000000000..de67b04bd5 --- /dev/null +++ b/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntLibDxe.inf @@ -0,0 +1,45 @@ +## @file +# DXE Driver that Unit Tests the SafeIntLib +# +# Copyright (c) Microsoft Corporation.
+# 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 the = 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/TestBaseSafeIntLib= Host.inf b/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntLibHo= st.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 the = 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/TestBaseSafeIntLib= Pei.inf b/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntLibPei= .inf new file mode 100644 index 0000000000..c8ba4f44ef --- /dev/null +++ b/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntLibPei.inf @@ -0,0 +1,45 @@ +## @file +# PEIM that Unit Tests the SafeIntLib +# +# Copyright (c) Microsoft Corporation.
+# 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 the = 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/TestBaseSafeIntLib= Smm.inf b/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntLibSmm= .inf new file mode 100644 index 0000000000..df7288501d --- /dev/null +++ b/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntLibSmm.inf @@ -0,0 +1,45 @@ +## @file +# SMM Driver that Unit Tests the SafeIntLib +# +# Copyright (c) Microsoft Corporation.
+# 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 the = 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/TestBaseSafeIntLib= UefiShell.inf b/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeInt= LibUefiShell.inf new file mode 100644 index 0000000000..5a13c1c845 --- /dev/null +++ b/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntLibUefiShe= ll.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 the = 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 --=20 2.21.0.windows.1 -=3D-=3D-=3D-=3D-=3D-=3D-=3D-=3D-=3D-=3D-=3D- Groups.io Links: You receive all messages sent to this group. View/Reply Online (#53466): https://edk2.groups.io/g/devel/message/53466 Mute This Topic: https://groups.io/mt/70061168/1787277 Group Owner: devel+owner@edk2.groups.io Unsubscribe: https://edk2.groups.io/g/devel/unsub [importer@patchew.org] -=3D-=3D-=3D-=3D-=3D-=3D-=3D-=3D-=3D-=3D-=3D-