* Add unit tests for SafeIntLib class
* Add unit tests for BaseLib Base64 conversion APIs.
* Add Test/MdePkgHostTest.dsc -to build host based unit
tests
* Update MdePkg.dsc to build target based tests for
SafeIntLib and BaseLib
* Update MdePkg.ci.yaml to build and run host based
tests for SafeIntLib and BaseLib
Cc: Sean Brogan <sean.brogan@microsoft.com>
Cc: Bret Barkelew <Bret.Barkelew@microsoft.com>
Cc: Liming Gao <liming.gao@intel.com>
Signed-off-by: Michael D Kinney <michael.d.kinney@intel.com>
---
MdePkg/MdePkg.ci.yaml | 19 +-
MdePkg/MdePkg.dsc | 18 +
MdePkg/Test/MdePkgHostTest.dsc | 30 +
.../UnitTest/Library/BaseLib/Base64UnitTest.c | 404 +++
.../Library/BaseLib/BaseLibUnitTestsHost.inf | 32 +
.../Library/BaseLib/BaseLibUnitTestsUefi.inf | 33 +
.../SafeIntLibUintnIntnUnitTests32.c | 540 +++
.../SafeIntLibUintnIntnUnitTests64.c | 544 +++
.../BaseSafeIntLib/TestBaseSafeIntLib.c | 3064 +++++++++++++++++
.../BaseSafeIntLib/TestBaseSafeIntLib.h | 123 +
.../BaseSafeIntLib/TestBaseSafeIntLib.uni | 13 +
.../BaseSafeIntLib/TestBaseSafeIntLibDxe.inf | 45 +
.../BaseSafeIntLib/TestBaseSafeIntLibHost.inf | 40 +
.../BaseSafeIntLib/TestBaseSafeIntLibPei.inf | 45 +
.../BaseSafeIntLib/TestBaseSafeIntLibSmm.inf | 45 +
.../TestBaseSafeIntLibUefiShell.inf | 42 +
16 files changed, 5034 insertions(+), 3 deletions(-)
create mode 100644 MdePkg/Test/MdePkgHostTest.dsc
create mode 100644 MdePkg/Test/UnitTest/Library/BaseLib/Base64UnitTest.c
create mode 100644 MdePkg/Test/UnitTest/Library/BaseLib/BaseLibUnitTestsHost.inf
create mode 100644 MdePkg/Test/UnitTest/Library/BaseLib/BaseLibUnitTestsUefi.inf
create mode 100644 MdePkg/Test/UnitTest/Library/BaseSafeIntLib/SafeIntLibUintnIntnUnitTests32.c
create mode 100644 MdePkg/Test/UnitTest/Library/BaseSafeIntLib/SafeIntLibUintnIntnUnitTests64.c
create mode 100644 MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntLib.c
create mode 100644 MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntLib.h
create mode 100644 MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntLib.uni
create mode 100644 MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntLibDxe.inf
create mode 100644 MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntLibHost.inf
create mode 100644 MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntLibPei.inf
create mode 100644 MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntLibSmm.inf
create mode 100644 MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntLibUefiShell.inf
diff --git a/MdePkg/MdePkg.ci.yaml b/MdePkg/MdePkg.ci.yaml
index 65c4ec3bec..88e490fcb6 100644
--- a/MdePkg/MdePkg.ci.yaml
+++ b/MdePkg/MdePkg.ci.yaml
@@ -10,8 +10,13 @@
"DscPath": "MdePkg.dsc"
},
+ ## options defined ci/Plugin/HostUnitTestCompilerPlugin
+ "HostUnitTestCompilerPlugin": {
+ "DscPath": "Test/MdePkgHostTest.dsc"
+ },
+
## options defined ci/Plugin/CharEncodingCheck
-"CharEncodingCheck": {
+ "CharEncodingCheck": {
"IgnoreFiles": []
},
@@ -21,7 +26,9 @@
"MdePkg/MdePkg.dec"
],
# For host based unit tests
- "AcceptableDependencies-HOST_APPLICATION":[],
+ "AcceptableDependencies-HOST_APPLICATION":[
+ "UnitTestFrameworkPkg/UnitTestFrameworkPkg.dec"
+ ],
# For UEFI shell based apps
"AcceptableDependencies-UEFI_APPLICATION":[],
"IgnoreInf": []
@@ -29,10 +36,16 @@
## options defined ci/Plugin/DscCompleteCheck
"DscCompleteCheck": {
- "IgnoreInf": [],
+ "IgnoreInf": [""],
"DscPath": "MdePkg.dsc"
},
+ ## options defined ci/Plugin/HostUnitTestDscCompleteCheck
+ "HostUnitTestDscCompleteCheck": {
+ "IgnoreInf": [""],
+ "DscPath": "Test/MdePkgHostTest.dsc"
+ },
+
## options defined ci/Plugin/GuidCheck
"GuidCheck": {
"IgnoreGuidName": [
diff --git a/MdePkg/MdePkg.dsc b/MdePkg/MdePkg.dsc
index 0aeafaaacc..87af740853 100644
--- a/MdePkg/MdePkg.dsc
+++ b/MdePkg/MdePkg.dsc
@@ -18,6 +18,8 @@ [Defines]
BUILD_TARGETS = DEBUG|RELEASE|NOOPT
SKUID_IDENTIFIER = DEFAULT
+!include UnitTestFrameworkPkg/UnitTestFrameworkPkgTarget.dsc.inc
+
[PcdsFeatureFlag]
gEfiMdePkgTokenSpaceGuid.PcdUgaConsumeSupport|TRUE
@@ -26,6 +28,9 @@ [PcdsFixedAtBuild]
gEfiMdePkgTokenSpaceGuid.PcdDebugPrintErrorLevel|0x80000000
gEfiMdePkgTokenSpaceGuid.PcdPciExpressBaseAddress|0xE0000000
+[LibraryClasses]
+ SafeIntLib|MdePkg/Library/BaseSafeIntLib/BaseSafeIntLib.inf
+
[Components]
MdePkg/Library/UefiFileHandleLib/UefiFileHandleLib.inf
MdePkg/Library/BaseCacheMaintenanceLib/BaseCacheMaintenanceLib.inf
@@ -115,6 +120,19 @@ [Components]
MdePkg/Library/StandaloneMmDriverEntryPoint/StandaloneMmDriverEntryPoint.inf
MdePkg/Library/StandaloneMmServicesTableLib/StandaloneMmServicesTableLib.inf
+ #
+ # Add UEFI Target Based Unit Tests
+ #
+ MdePkg/Test/UnitTest/Library/BaseLib/BaseLibUnitTestsUefi.inf
+
+ #
+ # Build PEIM, DXE_DRIVER, SMM_DRIVER, UEFI Shell components that test SafeIntLib
+ #
+ MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntLibPei.inf
+ MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntLibDxe.inf
+ MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntLibSmm.inf
+ MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntLibUefiShell.inf
+
[Components.IA32, Components.X64]
MdePkg/Library/BaseIoLibIntrinsic/BaseIoLibIntrinsic.inf
MdePkg/Library/BaseIoLibIntrinsic/BaseIoLibIntrinsicSev.inf
diff --git a/MdePkg/Test/MdePkgHostTest.dsc b/MdePkg/Test/MdePkgHostTest.dsc
new file mode 100644
index 0000000000..3d677ee75c
--- /dev/null
+++ b/MdePkg/Test/MdePkgHostTest.dsc
@@ -0,0 +1,30 @@
+## @file
+# MdePkg DSC file used to build host-based unit tests.
+#
+# Copyright (c) 2019 - 2020, Intel Corporation. All rights reserved.<BR>
+# Copyright (C) Microsoft Corporation.
+# SPDX-License-Identifier: BSD-2-Clause-Patent
+#
+##
+
+[Defines]
+ PLATFORM_NAME = MdePkgHostTest
+ PLATFORM_GUID = 50652B4C-88CB-4481-96E8-37F2D0034440
+ PLATFORM_VERSION = 0.1
+ DSC_SPECIFICATION = 0x00010005
+ OUTPUT_DIRECTORY = Build/MdePkg/HostTest
+ SUPPORTED_ARCHITECTURES = IA32|X64
+ BUILD_TARGETS = NOOPT
+ SKUID_IDENTIFIER = DEFAULT
+
+!include UnitTestFrameworkPkg/UnitTestFrameworkPkgHost.dsc.inc
+
+[LibraryClasses]
+ SafeIntLib|MdePkg/Library/BaseSafeIntLib/BaseSafeIntLib.inf
+
+[Components]
+ #
+ # Build HOST_APPLICATION that tests the SafeIntLib
+ #
+ MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntLibHost.inf
+ MdePkg/Test/UnitTest/Library/BaseLib/BaseLibUnitTestsHost.inf
diff --git a/MdePkg/Test/UnitTest/Library/BaseLib/Base64UnitTest.c b/MdePkg/Test/UnitTest/Library/BaseLib/Base64UnitTest.c
new file mode 100644
index 0000000000..0ad078155c
--- /dev/null
+++ b/MdePkg/Test/UnitTest/Library/BaseLib/Base64UnitTest.c
@@ -0,0 +1,404 @@
+/** @file
+ Unit tests of Base64 conversion APIs in BaseLib.
+
+ Copyright (C) Microsoft Corporation.
+ SPDX-License-Identifier: BSD-2-Clause-Patent
+
+**/
+
+#include <Uefi.h>
+#include <Library/BaseLib.h>
+#include <Library/BaseMemoryLib.h>
+#include <Library/DebugLib.h>
+#include <Library/MemoryAllocationLib.h>
+#include <Library/UnitTestLib.h>
+
+#define UNIT_TEST_APP_NAME "BaseLib Unit Test Application"
+#define UNIT_TEST_APP_VERSION "1.0"
+
+/**
+ RFC 4648 https://tools.ietf.org/html/rfc4648 test vectors
+
+ BASE64("") = ""
+ BASE64("f") = "Zg=="
+ BASE64("fo") = "Zm8="
+ BASE64("foo") = "Zm9v"
+ BASE64("foob") = "Zm9vYg=="
+ BASE64("fooba") = "Zm9vYmE="
+ BASE64("foobar") = "Zm9vYmFy"
+
+ The test vectors are using ascii strings for the binary data
+ */
+
+typedef struct {
+ CHAR8 *TestInput;
+ CHAR8 *TestOutput;
+ EFI_STATUS ExpectedStatus;
+ VOID *BufferToFree;
+ UINTN ExpectedSize;
+} BASIC_TEST_CONTEXT;
+
+#define B64_TEST_1 ""
+#define BIN_TEST_1 ""
+
+#define B64_TEST_2 "Zg=="
+#define BIN_TEST_2 "f"
+
+#define B64_TEST_3 "Zm8="
+#define BIN_TEST_3 "fo"
+
+#define B64_TEST_4 "Zm9v"
+#define BIN_TEST_4 "foo"
+
+#define B64_TEST_5 "Zm9vYg=="
+#define BIN_TEST_5 "foob"
+
+#define B64_TEST_6 "Zm9vYmE="
+#define BIN_TEST_6 "fooba"
+
+#define B64_TEST_7 "Zm9vYmFy"
+#define BIN_TEST_7 "foobar"
+
+// Adds all white space - also ends the last quantum with only spaces afterwards
+#define B64_TEST_8_IN " \t\v Zm9\r\nvYmFy \f "
+#define BIN_TEST_8 "foobar"
+
+// Not a quantum multiple of 4
+#define B64_ERROR_1 "Zm9vymFy="
+
+// Invalid characters in the string
+#define B64_ERROR_2 "Zm$vymFy"
+
+// Too many '=' characters
+#define B64_ERROR_3 "Z==="
+
+// Poorly placed '='
+#define B64_ERROR_4 "Zm=vYmFy"
+
+#define MAX_TEST_STRING_SIZE (200)
+
+// ------------------------------------------------ Input----------Output-----------Result-------Free--Expected Output Size
+static BASIC_TEST_CONTEXT mBasicEncodeTest1 = {BIN_TEST_1, B64_TEST_1, EFI_SUCCESS, NULL, sizeof(B64_TEST_1)};
+static BASIC_TEST_CONTEXT mBasicEncodeTest2 = {BIN_TEST_2, B64_TEST_2, EFI_SUCCESS, NULL, sizeof(B64_TEST_2)};
+static BASIC_TEST_CONTEXT mBasicEncodeTest3 = {BIN_TEST_3, B64_TEST_3, EFI_SUCCESS, NULL, sizeof(B64_TEST_3)};
+static BASIC_TEST_CONTEXT mBasicEncodeTest4 = {BIN_TEST_4, B64_TEST_4, EFI_SUCCESS, NULL, sizeof(B64_TEST_4)};
+static BASIC_TEST_CONTEXT mBasicEncodeTest5 = {BIN_TEST_5, B64_TEST_5, EFI_SUCCESS, NULL, sizeof(B64_TEST_5)};
+static BASIC_TEST_CONTEXT mBasicEncodeTest6 = {BIN_TEST_6, B64_TEST_6, EFI_SUCCESS, NULL, sizeof(B64_TEST_6)};
+static BASIC_TEST_CONTEXT mBasicEncodeTest7 = {BIN_TEST_7, B64_TEST_7, EFI_SUCCESS, NULL, sizeof(B64_TEST_7)};
+static BASIC_TEST_CONTEXT mBasicEncodeError1 = {BIN_TEST_7, B64_TEST_1, EFI_BUFFER_TOO_SMALL, NULL, sizeof(B64_TEST_7)};
+
+static BASIC_TEST_CONTEXT mBasicDecodeTest1 = {B64_TEST_1, BIN_TEST_1, EFI_SUCCESS, NULL, sizeof(BIN_TEST_1)-1};
+static BASIC_TEST_CONTEXT mBasicDecodeTest2 = {B64_TEST_2, BIN_TEST_2, EFI_SUCCESS, NULL, sizeof(BIN_TEST_2)-1};
+static BASIC_TEST_CONTEXT mBasicDecodeTest3 = {B64_TEST_3, BIN_TEST_3, EFI_SUCCESS, NULL, sizeof(BIN_TEST_3)-1};
+static BASIC_TEST_CONTEXT mBasicDecodeTest4 = {B64_TEST_4, BIN_TEST_4, EFI_SUCCESS, NULL, sizeof(BIN_TEST_4)-1};
+static BASIC_TEST_CONTEXT mBasicDecodeTest5 = {B64_TEST_5, BIN_TEST_5, EFI_SUCCESS, NULL, sizeof(BIN_TEST_5)-1};
+static BASIC_TEST_CONTEXT mBasicDecodeTest6 = {B64_TEST_6, BIN_TEST_6, EFI_SUCCESS, NULL, sizeof(BIN_TEST_6)-1};
+static BASIC_TEST_CONTEXT mBasicDecodeTest7 = {B64_TEST_7, BIN_TEST_7, EFI_SUCCESS, NULL, sizeof(BIN_TEST_7)-1};
+static BASIC_TEST_CONTEXT mBasicDecodeTest8 = {B64_TEST_8_IN, BIN_TEST_8, EFI_SUCCESS, NULL, sizeof(BIN_TEST_8)-1};
+
+static BASIC_TEST_CONTEXT mBasicDecodeError1 = {B64_ERROR_1, B64_ERROR_1, EFI_INVALID_PARAMETER, NULL, 0};
+static BASIC_TEST_CONTEXT mBasicDecodeError2 = {B64_ERROR_2, B64_ERROR_2, EFI_INVALID_PARAMETER, NULL, 0};
+static BASIC_TEST_CONTEXT mBasicDecodeError3 = {B64_ERROR_3, B64_ERROR_3, EFI_INVALID_PARAMETER, NULL, 0};
+static BASIC_TEST_CONTEXT mBasicDecodeError4 = {B64_ERROR_4, B64_ERROR_4, EFI_INVALID_PARAMETER, NULL, 0};
+static BASIC_TEST_CONTEXT mBasicDecodeError5 = {B64_TEST_7, BIN_TEST_1, EFI_BUFFER_TOO_SMALL, NULL, sizeof(BIN_TEST_7)-1};
+
+/**
+ Simple clean up method to make sure tests clean up even if interrupted and fail
+ in the middle.
+**/
+STATIC
+VOID
+EFIAPI
+CleanUpB64TestContext (
+ IN UNIT_TEST_CONTEXT Context
+ )
+{
+ BASIC_TEST_CONTEXT *Btc;
+
+ Btc = (BASIC_TEST_CONTEXT *)Context;
+ if (Btc != NULL) {
+ //free string if set
+ if (Btc->BufferToFree != NULL) {
+ FreePool (Btc->BufferToFree);
+ Btc->BufferToFree = NULL;
+ }
+ }
+}
+
+/**
+ Unit test for Base64 encode APIs of BaseLib.
+
+ @param[in] Context [Optional] An optional paramter that enables:
+ 1) test-case reuse with varied parameters and
+ 2) test-case re-entry for Target tests that need a
+ reboot. This parameter is a VOID* and it is the
+ responsibility of the test author to ensure that the
+ contents are well understood by all test cases that may
+ consume it.
+
+ @retval UNIT_TEST_PASSED The Unit test has completed and the test
+ case was successful.
+ @retval UNIT_TEST_ERROR_TEST_FAILED A test case assertion has failed.
+**/
+STATIC
+UNIT_TEST_STATUS
+EFIAPI
+RfcEncodeTest (
+ IN UNIT_TEST_CONTEXT Context
+ )
+{
+ BASIC_TEST_CONTEXT *Btc;
+ CHAR8 *b64String;
+ CHAR8 *binString;
+ UINTN b64StringSize;
+ EFI_STATUS Status;
+ UINT8 *BinData;
+ UINTN BinSize;
+ CHAR8 *b64WorkString;
+ UINTN ReturnSize;
+ INTN CompareStatus;
+ UINTN indx;
+
+ Btc = (BASIC_TEST_CONTEXT *) Context;
+ binString = Btc->TestInput;
+ b64String = Btc->TestOutput;
+
+ //
+ // Only testing the the translate functionality, so preallocate the proper
+ // string buffer.
+ //
+
+ b64StringSize = AsciiStrnSizeS(b64String, MAX_TEST_STRING_SIZE);
+ BinSize = AsciiStrnLenS(binString, MAX_TEST_STRING_SIZE);
+ BinData = (UINT8 *) binString;
+
+ b64WorkString = (CHAR8 *) AllocatePool(b64StringSize);
+ UT_ASSERT_NOT_NULL(b64WorkString);
+
+ Btc->BufferToFree = b64WorkString;
+ ReturnSize = b64StringSize;
+
+ Status = Base64Encode(BinData, BinSize, b64WorkString, &ReturnSize);
+
+ UT_ASSERT_STATUS_EQUAL(Status, Btc->ExpectedStatus);
+
+ UT_ASSERT_EQUAL(ReturnSize, Btc->ExpectedSize);
+
+ if (!EFI_ERROR (Btc->ExpectedStatus)) {
+ if (ReturnSize != 0) {
+ CompareStatus = AsciiStrnCmp (b64String, b64WorkString, ReturnSize);
+ if (CompareStatus != 0) {
+ UT_LOG_ERROR ("b64 string compare error - size=%d\n", ReturnSize);
+ for (indx = 0; indx < ReturnSize; indx++) {
+ UT_LOG_ERROR (" %2.2x", 0xff & b64String[indx]);
+ }
+ UT_LOG_ERROR ("\n b64 work string:\n");
+ for (indx = 0; indx < ReturnSize; indx++) {
+ UT_LOG_ERROR (" %2.2x", 0xff & b64WorkString[indx]);
+ }
+ UT_LOG_ERROR ("\n");
+ }
+ UT_ASSERT_EQUAL (CompareStatus, 0);
+ }
+ }
+
+ Btc->BufferToFree = NULL;
+ FreePool (b64WorkString);
+ return UNIT_TEST_PASSED;
+}
+
+/**
+ Unit test for Base64 decode APIs of BaseLib.
+
+ @param[in] Context [Optional] An optional paramter that enables:
+ 1) test-case reuse with varied parameters and
+ 2) test-case re-entry for Target tests that need a
+ reboot. This parameter is a VOID* and it is the
+ responsibility of the test author to ensure that the
+ contents are well understood by all test cases that may
+ consume it.
+
+ @retval UNIT_TEST_PASSED The Unit test has completed and the test
+ case was successful.
+ @retval UNIT_TEST_ERROR_TEST_FAILED A test case assertion has failed.
+**/
+STATIC
+UNIT_TEST_STATUS
+EFIAPI
+RfcDecodeTest(
+ IN UNIT_TEST_CONTEXT Context
+ )
+{
+ BASIC_TEST_CONTEXT *Btc;
+ CHAR8 *b64String;
+ CHAR8 *binString;
+ EFI_STATUS Status;
+ UINTN b64StringLen;
+ UINTN ReturnSize;
+ UINT8 *BinData;
+ UINTN BinSize;
+ INTN CompareStatus;
+ UINTN indx;
+
+ Btc = (BASIC_TEST_CONTEXT *)Context;
+ b64String = Btc->TestInput;
+ binString = Btc->TestOutput;
+
+ //
+ // Only testing the the translate functionality
+ //
+
+ b64StringLen = AsciiStrnLenS (b64String, MAX_TEST_STRING_SIZE);
+ BinSize = AsciiStrnLenS (binString, MAX_TEST_STRING_SIZE);
+
+ BinData = AllocatePool (BinSize);
+ Btc->BufferToFree = BinData;
+
+ ReturnSize = BinSize;
+ Status = Base64Decode (b64String, b64StringLen, BinData, &ReturnSize);
+
+ UT_ASSERT_STATUS_EQUAL (Status, Btc->ExpectedStatus);
+
+ // If an error is not expected, check the results
+ if (EFI_ERROR (Btc->ExpectedStatus)) {
+ if (Btc->ExpectedStatus == EFI_BUFFER_TOO_SMALL) {
+ UT_ASSERT_EQUAL (ReturnSize, Btc->ExpectedSize);
+ }
+ } else {
+ UT_ASSERT_EQUAL (ReturnSize, Btc->ExpectedSize);
+ if (ReturnSize != 0) {
+ CompareStatus = CompareMem (binString, BinData, ReturnSize);
+ if (CompareStatus != 0) {
+ UT_LOG_ERROR ("bin string compare error - size=%d\n", ReturnSize);
+ for (indx = 0; indx < ReturnSize; indx++) {
+ UT_LOG_ERROR (" %2.2x", 0xff & binString[indx]);
+ }
+ UT_LOG_ERROR ("\nBinData:\n");
+ for (indx = 0; indx < ReturnSize; indx++) {
+ UT_LOG_ERROR (" %2.2x", 0xff & BinData[indx]);
+ }
+ UT_LOG_ERROR ("\n");
+ }
+ UT_ASSERT_EQUAL (CompareStatus, 0);
+ }
+ }
+
+ Btc->BufferToFree = NULL;
+ FreePool (BinData);
+ return UNIT_TEST_PASSED;
+}
+
+/**
+ Initialze the unit test framework, suite, and unit tests for the
+ Base64 conversion APIs of BaseLib and run the unit tests.
+
+ @retval EFI_SUCCESS All test cases were dispached.
+ @retval EFI_OUT_OF_RESOURCES There are not enough resources available to
+ initialize the unit tests.
+**/
+STATIC
+EFI_STATUS
+EFIAPI
+UnitTestingEntry (
+ VOID
+ )
+{
+ EFI_STATUS Status;
+ UNIT_TEST_FRAMEWORK_HANDLE Fw;
+ UNIT_TEST_SUITE_HANDLE b64EncodeTests;
+ UNIT_TEST_SUITE_HANDLE b64DecodeTests;
+
+ Fw = NULL;
+
+ DEBUG ((DEBUG_INFO, "%a v%a\n", UNIT_TEST_APP_NAME, UNIT_TEST_APP_VERSION));
+
+ //
+ // Start setting up the test framework for running the tests.
+ //
+ Status = InitUnitTestFramework (&Fw, UNIT_TEST_APP_NAME, gEfiCallerBaseName, UNIT_TEST_APP_VERSION);
+ if (EFI_ERROR (Status)) {
+ DEBUG ((DEBUG_ERROR, "Failed in InitUnitTestFramework. Status = %r\n", Status));
+ goto EXIT;
+ }
+
+ //
+ // Populate the B64 Encode Unit Test Suite.
+ //
+ Status = CreateUnitTestSuite (&b64EncodeTests, Fw, "b64 Encode binary to Ascii string", "BaseLib.b64Encode", NULL, NULL);
+ if (EFI_ERROR (Status)) {
+ DEBUG ((DEBUG_ERROR, "Failed in CreateUnitTestSuite for b64EncodeTests\n"));
+ Status = EFI_OUT_OF_RESOURCES;
+ goto EXIT;
+ }
+
+ // --------------Suite-----------Description--------------Class Name----------Function--------Pre---Post-------------------Context-----------
+ AddTestCase (b64EncodeTests, "RFC 4686 Test Vector - Empty", "Test1", RfcEncodeTest, NULL, CleanUpB64TestContext, &mBasicEncodeTest1);
+ AddTestCase (b64EncodeTests, "RFC 4686 Test Vector - f", "Test2", RfcEncodeTest, NULL, CleanUpB64TestContext, &mBasicEncodeTest2);
+ AddTestCase (b64EncodeTests, "RFC 4686 Test Vector - fo", "Test3", RfcEncodeTest, NULL, CleanUpB64TestContext, &mBasicEncodeTest3);
+ AddTestCase (b64EncodeTests, "RFC 4686 Test Vector - foo", "Test4", RfcEncodeTest, NULL, CleanUpB64TestContext, &mBasicEncodeTest4);
+ AddTestCase (b64EncodeTests, "RFC 4686 Test Vector - foob", "Test5", RfcEncodeTest, NULL, CleanUpB64TestContext, &mBasicEncodeTest5);
+ AddTestCase (b64EncodeTests, "RFC 4686 Test Vector - fooba", "Test6", RfcEncodeTest, NULL, CleanUpB64TestContext, &mBasicEncodeTest6);
+ AddTestCase (b64EncodeTests, "RFC 4686 Test Vector - foobar", "Test7", RfcEncodeTest, NULL, CleanUpB64TestContext, &mBasicEncodeTest7);
+ AddTestCase (b64EncodeTests, "Too small of output buffer", "Error1", RfcEncodeTest, NULL, CleanUpB64TestContext, &mBasicEncodeError1);
+ //
+ // Populate the B64 Decode Unit Test Suite.
+ //
+ Status = CreateUnitTestSuite (&b64DecodeTests, Fw, "b64 Decode Ascii string to binary", "BaseLib.b64Decode", NULL, NULL);
+ if (EFI_ERROR (Status)) {
+ DEBUG ((DEBUG_ERROR, "Failed in CreateUnitTestSuite for b64Decode Tests\n"));
+ Status = EFI_OUT_OF_RESOURCES;
+ goto EXIT;
+ }
+
+ AddTestCase (b64DecodeTests, "RFC 4686 Test Vector - Empty", "Test1", RfcDecodeTest, NULL, CleanUpB64TestContext, &mBasicDecodeTest1);
+ AddTestCase (b64DecodeTests, "RFC 4686 Test Vector - f", "Test2", RfcDecodeTest, NULL, CleanUpB64TestContext, &mBasicDecodeTest2);
+ AddTestCase (b64DecodeTests, "RFC 4686 Test Vector - fo", "Test3", RfcDecodeTest, NULL, CleanUpB64TestContext, &mBasicDecodeTest3);
+ AddTestCase (b64DecodeTests, "RFC 4686 Test Vector - foo", "Test4", RfcDecodeTest, NULL, CleanUpB64TestContext, &mBasicDecodeTest4);
+ AddTestCase (b64DecodeTests, "RFC 4686 Test Vector - foob", "Test5", RfcDecodeTest, NULL, CleanUpB64TestContext, &mBasicDecodeTest5);
+ AddTestCase (b64DecodeTests, "RFC 4686 Test Vector - fooba", "Test6", RfcDecodeTest, NULL, CleanUpB64TestContext, &mBasicDecodeTest6);
+ AddTestCase (b64DecodeTests, "RFC 4686 Test Vector - foobar", "Test7", RfcDecodeTest, NULL, CleanUpB64TestContext, &mBasicDecodeTest7);
+ AddTestCase (b64DecodeTests, "Ignore Whitespace test", "Test8", RfcDecodeTest, NULL, CleanUpB64TestContext, &mBasicDecodeTest8);
+
+ AddTestCase (b64DecodeTests, "Not a quantum multiple of 4", "Error1", RfcDecodeTest, NULL, CleanUpB64TestContext, &mBasicDecodeError1);
+ AddTestCase (b64DecodeTests, "Invalid characters in the string", "Error2", RfcDecodeTest, NULL, CleanUpB64TestContext, &mBasicDecodeError2);
+ AddTestCase (b64DecodeTests, "Too many padding characters", "Error3", RfcDecodeTest, NULL, CleanUpB64TestContext, &mBasicDecodeError3);
+ AddTestCase (b64DecodeTests, "Incorrectly placed padding character", "Error4", RfcDecodeTest, NULL, CleanUpB64TestContext, &mBasicDecodeError4);
+ AddTestCase (b64DecodeTests, "Too small of output buffer", "Error5", RfcDecodeTest, NULL, CleanUpB64TestContext, &mBasicDecodeError5);
+
+ //
+ // Execute the tests.
+ //
+ Status = RunAllTestSuites (Fw);
+
+EXIT:
+ if (Fw) {
+ FreeUnitTestFramework (Fw);
+ }
+
+ return Status;
+}
+
+/**
+ Standard UEFI entry point for target based unit test execution from UEFI Shell.
+**/
+EFI_STATUS
+EFIAPI
+BaseLibUnitTestAppEntry (
+ IN EFI_HANDLE ImageHandle,
+ IN EFI_SYSTEM_TABLE *SystemTable
+ )
+{
+ return UnitTestingEntry ();
+}
+
+/**
+ Standard POSIX C entry point for host based unit test execution.
+**/
+int
+main (
+ int argc,
+ char *argv[]
+ )
+{
+ return UnitTestingEntry ();
+}
diff --git a/MdePkg/Test/UnitTest/Library/BaseLib/BaseLibUnitTestsHost.inf b/MdePkg/Test/UnitTest/Library/BaseLib/BaseLibUnitTestsHost.inf
new file mode 100644
index 0000000000..b31afae633
--- /dev/null
+++ b/MdePkg/Test/UnitTest/Library/BaseLib/BaseLibUnitTestsHost.inf
@@ -0,0 +1,32 @@
+## @file
+# Unit tests of Base64 conversion APIs in BaseLib that are run from host
+# environment.
+#
+# Copyright (C) Microsoft Corporation.
+# SPDX-License-Identifier: BSD-2-Clause-Patent
+##
+
+[Defines]
+ INF_VERSION = 0x00010006
+ BASE_NAME = BaseLibUnitTestsHost
+ FILE_GUID = 1d005f4c-4dfa-41b5-ab0c-be91fe121459
+ MODULE_TYPE = HOST_APPLICATION
+ VERSION_STRING = 1.0
+
+#
+# The following information is for reference only and not required by the build tools.
+#
+# VALID_ARCHITECTURES = IA32 X64
+#
+
+[Sources]
+ Base64UnitTest.c
+
+[Packages]
+ MdePkg/MdePkg.dec
+
+[LibraryClasses]
+ BaseLib
+ BaseMemoryLib
+ DebugLib
+ UnitTestLib
diff --git a/MdePkg/Test/UnitTest/Library/BaseLib/BaseLibUnitTestsUefi.inf b/MdePkg/Test/UnitTest/Library/BaseLib/BaseLibUnitTestsUefi.inf
new file mode 100644
index 0000000000..907503898a
--- /dev/null
+++ b/MdePkg/Test/UnitTest/Library/BaseLib/BaseLibUnitTestsUefi.inf
@@ -0,0 +1,33 @@
+## @file
+# Unit tests of Base64 conversion APIs in BaseLib that are run from UEFI Shell.
+#
+# Copyright (C) Microsoft Corporation.
+# SPDX-License-Identifier: BSD-2-Clause-Patent
+##
+
+[Defines]
+ INF_VERSION = 0x00010006
+ BASE_NAME = BaseLibUnitTestsUefi
+ FILE_GUID = df5a6fed-8786-4a9d-9d02-eab39497b4a1
+ MODULE_TYPE = UEFI_APPLICATION
+ VERSION_STRING = 1.0
+ ENTRY_POINT = BaseLibUnitTestAppEntry
+
+#
+# The following information is for reference only and not required by the build tools.
+#
+# VALID_ARCHITECTURES = IA32 X64
+#
+
+[Sources]
+ Base64UnitTest.c
+
+[Packages]
+ MdePkg/MdePkg.dec
+
+[LibraryClasses]
+ BaseLib
+ BaseMemoryLib
+ UefiApplicationEntryPoint
+ DebugLib
+ UnitTestLib
diff --git a/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/SafeIntLibUintnIntnUnitTests32.c b/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/SafeIntLibUintnIntnUnitTests32.c
new file mode 100644
index 0000000000..be5c0e15d3
--- /dev/null
+++ b/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/SafeIntLibUintnIntnUnitTests32.c
@@ -0,0 +1,540 @@
+/** @file
+ IA32-specific functions for unit-testing INTN and UINTN functions in
+ SafeIntLib.
+
+ Copyright (c) Microsoft Corporation.<BR>
+ Copyright (c) 2019 - 2020, Intel Corporation. All rights reserved.<BR>
+ SPDX-License-Identifier: BSD-2-Clause-Patent
+
+**/
+
+#include "TestBaseSafeIntLib.h"
+
+UNIT_TEST_STATUS
+EFIAPI
+TestSafeInt32ToUintn (
+ IN UNIT_TEST_CONTEXT Context
+ )
+{
+ EFI_STATUS Status;
+ INT32 Operand;
+ UINTN Result;
+
+ //
+ // If Operand is non-negative, then it's a cast
+ //
+ Operand = 0x5bababab;
+ Result = 0;
+ Status = SafeInt32ToUintn(Operand, &Result);
+ UT_ASSERT_NOT_EFI_ERROR(Status);
+ UT_ASSERT_EQUAL(0x5bababab, Result);
+
+ //
+ // Otherwise should result in an error status
+ //
+ Operand = (-1537977259);
+ Status = SafeInt32ToUintn(Operand, &Result);
+ UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
+
+ return UNIT_TEST_PASSED;
+}
+
+UNIT_TEST_STATUS
+EFIAPI
+TestSafeUint32ToIntn (
+ IN UNIT_TEST_CONTEXT Context
+ )
+{
+ EFI_STATUS Status;
+ UINT32 Operand;
+ INTN Result;
+
+ //
+ // If Operand is <= MAX_INTN, then it's a cast
+ //
+ Operand = 0x5bababab;
+ Result = 0;
+ Status = SafeUint32ToIntn(Operand, &Result);
+ UT_ASSERT_NOT_EFI_ERROR(Status);
+ UT_ASSERT_EQUAL(0x5bababab, Result);
+
+ //
+ // Otherwise should result in an error status
+ //
+ Operand = (0xabababab);
+ Status = SafeUint32ToIntn(Operand, &Result);
+ UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
+
+ return UNIT_TEST_PASSED;
+}
+
+UNIT_TEST_STATUS
+EFIAPI
+TestSafeIntnToInt32 (
+ IN UNIT_TEST_CONTEXT Context
+ )
+{
+ EFI_STATUS Status;
+ INTN Operand;
+ INT32 Result;
+
+ //
+ // INTN is same as INT32 in IA32, so this is just a cast
+ //
+ Operand = 0x5bababab;
+ Result = 0;
+ Status = SafeIntnToInt32(Operand, &Result);
+ UT_ASSERT_NOT_EFI_ERROR(Status);
+ UT_ASSERT_EQUAL(0x5bababab, Result);
+
+ return UNIT_TEST_PASSED;
+}
+
+UNIT_TEST_STATUS
+EFIAPI
+TestSafeIntnToUint32 (
+ IN UNIT_TEST_CONTEXT Context
+ )
+{
+ EFI_STATUS Status;
+ INTN Operand;
+ UINT32 Result;
+
+ //
+ // If Operand is non-negative, then it's a cast
+ //
+ Operand = 0x5bababab;
+ Result = 0;
+ Status = SafeIntnToUint32(Operand, &Result);
+ UT_ASSERT_NOT_EFI_ERROR(Status);
+ UT_ASSERT_EQUAL(0x5bababab, Result);
+
+ //
+ // Otherwise should result in an error status
+ //
+ Operand = (-1537977259);
+ Status = SafeIntnToUint32(Operand, &Result);
+ UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
+
+ return UNIT_TEST_PASSED;
+}
+
+UNIT_TEST_STATUS
+EFIAPI
+TestSafeUintnToUint32 (
+ IN UNIT_TEST_CONTEXT Context
+ )
+{
+ EFI_STATUS Status;
+ UINTN Operand;
+ UINT32 Result;
+
+ //
+ // UINTN is same as UINT32 in IA32, so this is just a cast
+ //
+ Operand = 0xabababab;
+ Result = 0;
+ Status = SafeUintnToUint32(Operand, &Result);
+ UT_ASSERT_NOT_EFI_ERROR(Status);
+ UT_ASSERT_EQUAL(0xabababab, Result);
+
+ return UNIT_TEST_PASSED;
+}
+
+UNIT_TEST_STATUS
+EFIAPI
+TestSafeUintnToIntn (
+ IN UNIT_TEST_CONTEXT Context
+ )
+{
+ EFI_STATUS Status;
+ UINTN Operand;
+ INTN Result;
+
+ //
+ // If Operand is <= MAX_INTN, then it's a cast
+ //
+ Operand = 0x5bababab;
+ Result = 0;
+ Status = SafeUintnToIntn(Operand, &Result);
+ UT_ASSERT_NOT_EFI_ERROR(Status);
+ UT_ASSERT_EQUAL(0x5bababab, Result);
+
+ //
+ // Otherwise should result in an error status
+ //
+ Operand = (0xabababab);
+ Status = SafeUintnToIntn(Operand, &Result);
+ UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
+
+ return UNIT_TEST_PASSED;
+}
+
+UNIT_TEST_STATUS
+EFIAPI
+TestSafeUintnToInt64 (
+ IN UNIT_TEST_CONTEXT Context
+ )
+{
+ EFI_STATUS Status;
+ UINTN Operand;
+ INT64 Result;
+
+ //
+ // UINTN is same as UINT32 in IA32, and UINT32 is a subset of
+ // INT64, so this is just a cast
+ //
+ Operand = 0xabababab;
+ Result = 0;
+ Status = SafeUintnToInt64(Operand, &Result);
+ UT_ASSERT_NOT_EFI_ERROR(Status);
+ UT_ASSERT_EQUAL(0xabababab, Result);
+
+ return UNIT_TEST_PASSED;
+}
+
+UNIT_TEST_STATUS
+EFIAPI
+TestSafeInt64ToIntn (
+ IN UNIT_TEST_CONTEXT Context
+ )
+{
+ EFI_STATUS Status;
+ INT64 Operand;
+ INTN Result;
+
+ //
+ // If Operand is between MIN_INTN and MAX_INTN2 inclusive, then it's a cast
+ //
+ Operand = 0x5bababab;
+ Result = 0;
+ Status = SafeInt64ToIntn(Operand, &Result);
+ UT_ASSERT_NOT_EFI_ERROR(Status);
+ UT_ASSERT_EQUAL(0x5bababab, Result);
+
+ Operand = (-1537977259);
+ Status = SafeInt64ToIntn(Operand, &Result);
+ UT_ASSERT_NOT_EFI_ERROR(Status);
+ UT_ASSERT_EQUAL((-1537977259), Result);
+
+ //
+ // Otherwise should result in an error status
+ //
+ Operand = (0x5babababefefefef);
+ Status = SafeInt64ToIntn(Operand, &Result);
+ UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
+
+ Operand = (-6605562033422200815);
+ Status = SafeInt64ToIntn(Operand, &Result);
+ UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
+
+ return UNIT_TEST_PASSED;
+}
+
+UNIT_TEST_STATUS
+EFIAPI
+TestSafeInt64ToUintn (
+ IN UNIT_TEST_CONTEXT Context
+ )
+{
+ EFI_STATUS Status;
+ INT64 Operand;
+ UINTN Result;
+
+ //
+ // If Operand is between 0 and MAX_UINTN inclusive, then it's a cast
+ //
+ Operand = 0xabababab;
+ Result = 0;
+ Status = SafeInt64ToUintn(Operand, &Result);
+ UT_ASSERT_NOT_EFI_ERROR(Status);
+ UT_ASSERT_EQUAL(0xabababab, Result);
+
+ //
+ // Otherwise should result in an error status
+ //
+ Operand = (0x5babababefefefef);
+ Status = SafeInt64ToUintn(Operand, &Result);
+ UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
+
+ Operand = (-6605562033422200815);
+ Status = SafeInt64ToUintn(Operand, &Result);
+ UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
+
+ return UNIT_TEST_PASSED;
+}
+
+UNIT_TEST_STATUS
+EFIAPI
+TestSafeUint64ToIntn (
+ IN UNIT_TEST_CONTEXT Context
+ )
+{
+ EFI_STATUS Status;
+ UINT64 Operand;
+ INTN Result;
+
+ //
+ // If Operand is <= MAX_INTN, then it's a cast
+ //
+ Operand = 0x5bababab;
+ Result = 0;
+ Status = SafeUint64ToIntn(Operand, &Result);
+ UT_ASSERT_NOT_EFI_ERROR(Status);
+ UT_ASSERT_EQUAL(0x5bababab, Result);
+
+ //
+ // Otherwise should result in an error status
+ //
+ Operand = (0xababababefefefef);
+ Status = SafeUint64ToIntn(Operand, &Result);
+ UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
+
+ return UNIT_TEST_PASSED;
+}
+
+UNIT_TEST_STATUS
+EFIAPI
+TestSafeUint64ToUintn (
+ IN UNIT_TEST_CONTEXT Context
+ )
+{
+ EFI_STATUS Status;
+ UINT64 Operand;
+ UINTN Result;
+
+ //
+ // If Operand is <= MAX_UINTN, then it's a cast
+ //
+ Operand = 0xabababab;
+ Result = 0;
+ Status = SafeUint64ToUintn(Operand, &Result);
+ UT_ASSERT_NOT_EFI_ERROR(Status);
+ UT_ASSERT_EQUAL(0xabababab, Result);
+
+ //
+ // Otherwise should result in an error status
+ //
+ Operand = (0xababababefefefef);
+ Status = SafeUint64ToUintn(Operand, &Result);
+ UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
+
+ return UNIT_TEST_PASSED;
+}
+
+UNIT_TEST_STATUS
+EFIAPI
+TestSafeUintnAdd (
+ IN UNIT_TEST_CONTEXT Context
+ )
+{
+ EFI_STATUS Status;
+ UINTN Augend;
+ UINTN Addend;
+ UINTN Result;
+
+ //
+ // If the result of addition doesn't overflow MAX_UINTN, then it's addition
+ //
+ Augend = 0x3a3a3a3a;
+ Addend = 0x3a3a3a3a;
+ Result = 0;
+ Status = SafeUintnAdd(Augend, Addend, &Result);
+ UT_ASSERT_NOT_EFI_ERROR(Status);
+ UT_ASSERT_EQUAL(0x74747474, Result);
+
+ //
+ // Otherwise should result in an error status
+ //
+ Augend = 0xabababab;
+ Addend = 0xbcbcbcbc;
+ Status = SafeUintnAdd(Augend, Addend, &Result);
+ UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
+
+ return UNIT_TEST_PASSED;
+}
+
+UNIT_TEST_STATUS
+EFIAPI
+TestSafeIntnAdd (
+ IN UNIT_TEST_CONTEXT Context
+ )
+{
+ EFI_STATUS Status;
+ INTN Augend;
+ INTN Addend;
+ INTN Result;
+
+ //
+ // If the result of addition doesn't overflow MAX_INTN
+ // and doesn't underflow MIN_INTN, then it's addition
+ //
+ Augend = 0x3a3a3a3a;
+ Addend = 0x3a3a3a3a;
+ Result = 0;
+ Status = SafeIntnAdd(Augend, Addend, &Result);
+ UT_ASSERT_NOT_EFI_ERROR(Status);
+ UT_ASSERT_EQUAL(0x74747474, Result);
+
+ Augend = (-976894522);
+ Addend = (-976894522);
+ Status = SafeIntnAdd(Augend, Addend, &Result);
+ UT_ASSERT_NOT_EFI_ERROR(Status);
+ UT_ASSERT_EQUAL((-1953789044), Result);
+
+ //
+ // Otherwise should result in an error status
+ //
+ Augend = 0x5a5a5a5a;
+ Addend = 0x5a5a5a5a;
+ Status = SafeIntnAdd(Augend, Addend, &Result);
+ UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
+
+ Augend = (-1515870810);
+ Addend = (-1515870810);
+ Status = SafeIntnAdd(Augend, Addend, &Result);
+ UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
+
+ return UNIT_TEST_PASSED;
+}
+
+UNIT_TEST_STATUS
+EFIAPI
+TestSafeUintnSub (
+ IN UNIT_TEST_CONTEXT Context
+ )
+{
+ EFI_STATUS Status;
+ UINTN Minuend;
+ UINTN Subtrahend;
+ UINTN Result;
+
+ //
+ // If Minuend >= Subtrahend, then it's subtraction
+ //
+ Minuend = 0x5a5a5a5a;
+ Subtrahend = 0x3b3b3b3b;
+ Result = 0;
+ Status = SafeUintnSub(Minuend, Subtrahend, &Result);
+ UT_ASSERT_NOT_EFI_ERROR(Status);
+ UT_ASSERT_EQUAL(0x1f1f1f1f, Result);
+
+ //
+ // Otherwise should result in an error status
+ //
+ Minuend = 0x5a5a5a5a;
+ Subtrahend = 0x6d6d6d6d;
+ Status = SafeUintnSub(Minuend, Subtrahend, &Result);
+ UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
+
+ return UNIT_TEST_PASSED;
+}
+
+UNIT_TEST_STATUS
+EFIAPI
+TestSafeIntnSub (
+ IN UNIT_TEST_CONTEXT Context
+ )
+{
+ EFI_STATUS Status;
+ INTN Minuend;
+ INTN Subtrahend;
+ INTN Result;
+
+ //
+ // If the result of subtractions doesn't overflow MAX_INTN or
+ // underflow MIN_INTN, then it's subtraction
+ //
+ Minuend = 0x5a5a5a5a;
+ Subtrahend = 0x3a3a3a3a;
+ Result = 0;
+ Status = SafeIntnSub(Minuend, Subtrahend, &Result);
+ UT_ASSERT_NOT_EFI_ERROR(Status);
+ UT_ASSERT_EQUAL(0x20202020, Result);
+
+ Minuend = 0x3a3a3a3a;
+ Subtrahend = 0x5a5a5a5a;
+ Status = SafeIntnSub(Minuend, Subtrahend, &Result);
+ UT_ASSERT_NOT_EFI_ERROR(Status);
+ UT_ASSERT_EQUAL((-538976288), Result);
+
+ //
+ // Otherwise should result in an error status
+ //
+ Minuend = (-2054847098);
+ Subtrahend = 2054847098;
+ Status = SafeIntnSub(Minuend, Subtrahend, &Result);
+ UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
+
+ Minuend = (2054847098);
+ Subtrahend = (-2054847098);
+ Status = SafeIntnSub(Minuend, Subtrahend, &Result);
+ UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
+
+ return UNIT_TEST_PASSED;
+}
+
+UNIT_TEST_STATUS
+EFIAPI
+TestSafeUintnMult (
+ IN UNIT_TEST_CONTEXT Context
+ )
+{
+ EFI_STATUS Status;
+ UINTN Multiplicand;
+ UINTN Multiplier;
+ UINTN Result;
+
+ //
+ // If the result of multiplication doesn't overflow MAX_UINTN, it will succeed
+ //
+ Multiplicand = 0xa122a;
+ Multiplier = 0xd23;
+ Result = 0;
+ Status = SafeUintnMult(Multiplicand, Multiplier, &Result);
+ UT_ASSERT_NOT_EFI_ERROR(Status);
+ UT_ASSERT_EQUAL(0x844c9dbe, Result);
+
+ //
+ // Otherwise should result in an error status
+ //
+ Multiplicand = 0xa122a;
+ Multiplier = 0xed23;
+ Status = SafeUintnMult(Multiplicand, Multiplier, &Result);
+ UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
+
+ return UNIT_TEST_PASSED;
+}
+
+UNIT_TEST_STATUS
+EFIAPI
+TestSafeIntnMult (
+ IN UNIT_TEST_CONTEXT Context
+ )
+{
+ EFI_STATUS Status;
+ INTN Multiplicand;
+ INTN Multiplier;
+ INTN Result;
+
+ //
+ // If the result of multiplication doesn't overflow MAX_INTN and doesn't
+ // underflow MIN_UINTN, it will succeed
+ //
+ Multiplicand = 0x123456;
+ Multiplier = 0x678;
+ Result = 0;
+ Status = SafeIntnMult(Multiplicand, Multiplier, &Result);
+ UT_ASSERT_NOT_EFI_ERROR(Status);
+ UT_ASSERT_EQUAL(0x75c28c50, Result);
+
+ //
+ // Otherwise should result in an error status
+ //
+ Multiplicand = 0x123456;
+ Multiplier = 0xabc;
+ Status = SafeIntnMult(Multiplicand, Multiplier, &Result);
+ UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
+
+ return UNIT_TEST_PASSED;
+}
diff --git a/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/SafeIntLibUintnIntnUnitTests64.c b/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/SafeIntLibUintnIntnUnitTests64.c
new file mode 100644
index 0000000000..0fee298172
--- /dev/null
+++ b/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/SafeIntLibUintnIntnUnitTests64.c
@@ -0,0 +1,544 @@
+/** @file
+ x64-specific functions for unit-testing INTN and UINTN functions in
+ SafeIntLib.
+
+ Copyright (c) Microsoft Corporation.<BR>
+ Copyright (c) 2019 - 2020, Intel Corporation. All rights reserved.<BR>
+ SPDX-License-Identifier: BSD-2-Clause-Patent
+
+**/
+
+#include "TestBaseSafeIntLib.h"
+
+UNIT_TEST_STATUS
+EFIAPI
+TestSafeInt32ToUintn (
+ IN UNIT_TEST_CONTEXT Context
+ )
+{
+ EFI_STATUS Status;
+ INT32 Operand;
+ UINTN Result;
+
+ //
+ // If Operand is non-negative, then it's a cast
+ //
+ Operand = 0x5bababab;
+ Result = 0;
+ Status = SafeInt32ToUintn(Operand, &Result);
+ UT_ASSERT_NOT_EFI_ERROR(Status);
+ UT_ASSERT_EQUAL(0x5bababab, Result);
+
+ //
+ // Otherwise should result in an error status
+ //
+ Operand = (-1537977259);
+ Status = SafeInt32ToUintn(Operand, &Result);
+ UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
+
+ return UNIT_TEST_PASSED;
+}
+
+UNIT_TEST_STATUS
+EFIAPI
+TestSafeUint32ToIntn (
+ IN UNIT_TEST_CONTEXT Context
+ )
+{
+ EFI_STATUS Status;
+ UINT32 Operand;
+ INTN Result;
+
+ //
+ // For x64, INTN is same as INT64 which is a superset of INT32
+ // This is just a cast then, and it'll never fail
+ //
+
+ //
+ // If Operand is non-negative, then it's a cast
+ //
+ Operand = 0xabababab;
+ Result = 0;
+ Status = SafeUint32ToIntn(Operand, &Result);
+ UT_ASSERT_NOT_EFI_ERROR(Status);
+ UT_ASSERT_EQUAL(0xabababab, Result);
+
+ return UNIT_TEST_PASSED;
+}
+
+UNIT_TEST_STATUS
+EFIAPI
+TestSafeIntnToInt32 (
+ IN UNIT_TEST_CONTEXT Context
+ )
+{
+ EFI_STATUS Status;
+ INTN Operand;
+ INT32 Result;
+
+ //
+ // If Operand is between MIN_INT32 and MAX_INT32 inclusive, then it's a cast
+ //
+ Operand = 0x5bababab;
+ Result = 0;
+ Status = SafeIntnToInt32(Operand, &Result);
+ UT_ASSERT_NOT_EFI_ERROR(Status);
+ UT_ASSERT_EQUAL(0x5bababab, Result);
+
+ Operand = (-1537977259);
+ Status = SafeIntnToInt32(Operand, &Result);
+ UT_ASSERT_NOT_EFI_ERROR(Status);
+ UT_ASSERT_EQUAL((-1537977259), Result);
+
+ //
+ // Otherwise should result in an error status
+ //
+ Operand = (0x5babababefefefef);
+ Status = SafeIntnToInt32(Operand, &Result);
+ UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
+
+ Operand = (-6605562033422200815);
+ Status = SafeIntnToInt32(Operand, &Result);
+ UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
+
+ return UNIT_TEST_PASSED;
+}
+
+UNIT_TEST_STATUS
+EFIAPI
+TestSafeIntnToUint32 (
+ IN UNIT_TEST_CONTEXT Context
+ )
+{
+ EFI_STATUS Status;
+ INTN Operand;
+ UINT32 Result;
+
+ //
+ // If Operand is between 0 and MAX_UINT32 inclusive, then it's a cast
+ //
+ Operand = 0xabababab;
+ Result = 0;
+ Status = SafeIntnToUint32(Operand, &Result);
+ UT_ASSERT_NOT_EFI_ERROR(Status);
+ UT_ASSERT_EQUAL(0xabababab, Result);
+
+ //
+ // Otherwise should result in an error status
+ //
+ Operand = (0x5babababefefefef);
+ Status = SafeIntnToUint32(Operand, &Result);
+ UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
+
+ Operand = (-6605562033422200815);
+ Status = SafeIntnToUint32(Operand, &Result);
+ UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
+
+ return UNIT_TEST_PASSED;
+}
+
+UNIT_TEST_STATUS
+EFIAPI
+TestSafeUintnToUint32 (
+ IN UNIT_TEST_CONTEXT Context
+ )
+{
+ EFI_STATUS Status;
+ UINTN Operand;
+ UINT32 Result;
+
+ //
+ // If Operand is <= MAX_UINT32, then it's a cast
+ //
+ Operand = 0xabababab;
+ Result = 0;
+ Status = SafeUintnToUint32(Operand, &Result);
+ UT_ASSERT_NOT_EFI_ERROR(Status);
+ UT_ASSERT_EQUAL(0xabababab, Result);
+
+ //
+ // Otherwise should result in an error status
+ //
+ Operand = (0xababababefefefef);
+ Status = SafeUintnToUint32(Operand, &Result);
+ UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
+
+ return UNIT_TEST_PASSED;
+}
+
+UNIT_TEST_STATUS
+EFIAPI
+TestSafeUintnToIntn (
+ IN UNIT_TEST_CONTEXT Context
+ )
+{
+ EFI_STATUS Status;
+ UINTN Operand;
+ INTN Result;
+
+ //
+ // If Operand is <= MAX_INTN (0x7fff_ffff_ffff_ffff), then it's a cast
+ //
+ Operand = 0x5babababefefefef;
+ Result = 0;
+ Status = SafeUintnToIntn(Operand, &Result);
+ UT_ASSERT_NOT_EFI_ERROR(Status);
+ UT_ASSERT_EQUAL(0x5babababefefefef, Result);
+
+ //
+ // Otherwise should result in an error status
+ //
+ Operand = (0xababababefefefef);
+ Status = SafeUintnToIntn(Operand, &Result);
+ UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
+
+ return UNIT_TEST_PASSED;
+}
+
+UNIT_TEST_STATUS
+EFIAPI
+TestSafeUintnToInt64 (
+ IN UNIT_TEST_CONTEXT Context
+ )
+{
+ EFI_STATUS Status;
+ UINTN Operand;
+ INT64 Result;
+
+ //
+ // If Operand is <= MAX_INT64, then it's a cast
+ //
+ Operand = 0x5babababefefefef;
+ Result = 0;
+ Status = SafeUintnToInt64(Operand, &Result);
+ UT_ASSERT_NOT_EFI_ERROR(Status);
+ UT_ASSERT_EQUAL(0x5babababefefefef, Result);
+
+ //
+ // Otherwise should result in an error status
+ //
+ Operand = (0xababababefefefef);
+ Status = SafeUintnToInt64(Operand, &Result);
+ UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
+
+ return UNIT_TEST_PASSED;
+}
+
+UNIT_TEST_STATUS
+EFIAPI
+TestSafeInt64ToIntn (
+ IN UNIT_TEST_CONTEXT Context
+ )
+{
+ EFI_STATUS Status;
+ INT64 Operand;
+ INTN Result;
+
+ //
+ // INTN is same as INT64 in x64, so this is just a cast
+ //
+ Operand = 0x5babababefefefef;
+ Result = 0;
+ Status = SafeInt64ToIntn(Operand, &Result);
+ UT_ASSERT_NOT_EFI_ERROR(Status);
+ UT_ASSERT_EQUAL(0x5babababefefefef, Result);
+
+ return UNIT_TEST_PASSED;
+}
+
+UNIT_TEST_STATUS
+EFIAPI
+TestSafeInt64ToUintn (
+ IN UNIT_TEST_CONTEXT Context
+ )
+{
+ EFI_STATUS Status;
+ INT64 Operand;
+ UINTN Result;
+
+ //
+ // If Operand is non-negative, then it's a cast
+ //
+ Operand = 0x5babababefefefef;
+ Result = 0;
+ Status = SafeInt64ToUintn(Operand, &Result);
+ UT_ASSERT_NOT_EFI_ERROR(Status);
+ UT_ASSERT_EQUAL(0x5babababefefefef, Result);
+
+ //
+ // Otherwise should result in an error status
+ //
+ Operand = (-6605562033422200815);
+ Status = SafeInt64ToUintn(Operand, &Result);
+ UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
+
+ return UNIT_TEST_PASSED;
+}
+
+UNIT_TEST_STATUS
+EFIAPI
+TestSafeUint64ToIntn (
+ IN UNIT_TEST_CONTEXT Context
+ )
+{
+ EFI_STATUS Status;
+ UINT64 Operand;
+ INTN Result;
+
+ //
+ // If Operand is <= MAX_INTN (0x7fff_ffff_ffff_ffff), then it's a cast
+ //
+ Operand = 0x5babababefefefef;
+ Result = 0;
+ Status = SafeUint64ToIntn(Operand, &Result);
+ UT_ASSERT_NOT_EFI_ERROR(Status);
+ UT_ASSERT_EQUAL(0x5babababefefefef, Result);
+
+ //
+ // Otherwise should result in an error status
+ //
+ Operand = (0xababababefefefef);
+ Status = SafeUint64ToIntn(Operand, &Result);
+ UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
+
+ return UNIT_TEST_PASSED;
+}
+
+UNIT_TEST_STATUS
+EFIAPI
+TestSafeUint64ToUintn (
+ IN UNIT_TEST_CONTEXT Context
+ )
+{
+ EFI_STATUS Status;
+ UINT64 Operand;
+ UINTN Result;
+
+ //
+ // UINTN is same as UINT64 in x64, so this is just a cast
+ //
+ Operand = 0xababababefefefef;
+ Result = 0;
+ Status = SafeUint64ToUintn(Operand, &Result);
+ UT_ASSERT_NOT_EFI_ERROR(Status);
+ UT_ASSERT_EQUAL(0xababababefefefef, Result);
+
+ return UNIT_TEST_PASSED;
+}
+
+UNIT_TEST_STATUS
+EFIAPI
+TestSafeUintnAdd (
+ IN UNIT_TEST_CONTEXT Context
+ )
+{
+ EFI_STATUS Status;
+ UINTN Augend;
+ UINTN Addend;
+ UINTN Result;
+
+ //
+ // If the result of addition doesn't overflow MAX_UINTN, then it's addition
+ //
+ Augend = 0x3a3a3a3a12121212;
+ Addend = 0x3a3a3a3a12121212;
+ Result = 0;
+ Status = SafeUintnAdd(Augend, Addend, &Result);
+ UT_ASSERT_NOT_EFI_ERROR(Status);
+ UT_ASSERT_EQUAL(0x7474747424242424, Result);
+
+ //
+ // Otherwise should result in an error status
+ //
+ Augend = 0xababababefefefef;
+ Addend = 0xbcbcbcbcdededede;
+ Status = SafeUintnAdd(Augend, Addend, &Result);
+ UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
+
+ return UNIT_TEST_PASSED;
+}
+
+UNIT_TEST_STATUS
+EFIAPI
+TestSafeIntnAdd (
+ IN UNIT_TEST_CONTEXT Context
+ )
+{
+ EFI_STATUS Status;
+ INTN Augend;
+ INTN Addend;
+ INTN Result;
+
+ //
+ // If the result of addition doesn't overflow MAX_INTN
+ // and doesn't underflow MIN_INTN, then it's addition
+ //
+ Augend = 0x3a3a3a3a3a3a3a3a;
+ Addend = 0x3a3a3a3a3a3a3a3a;
+ Result = 0;
+ Status = SafeIntnAdd(Augend, Addend, &Result);
+ UT_ASSERT_NOT_EFI_ERROR(Status);
+ UT_ASSERT_EQUAL(0x7474747474747474, Result);
+
+ Augend = (-4195730024608447034);
+ Addend = (-4195730024608447034);
+ Status = SafeIntnAdd(Augend, Addend, &Result);
+ UT_ASSERT_NOT_EFI_ERROR(Status);
+ UT_ASSERT_EQUAL((-8391460049216894068), Result);
+
+ //
+ // Otherwise should result in an error status
+ //
+ Augend = 0x5a5a5a5a5a5a5a5a;
+ Addend = 0x5a5a5a5a5a5a5a5a;
+ Status = SafeIntnAdd(Augend, Addend, &Result);
+ UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
+
+ Augend = (-6510615555426900570);
+ Addend = (-6510615555426900570);
+ Status = SafeIntnAdd(Augend, Addend, &Result);
+ UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
+
+ return UNIT_TEST_PASSED;
+}
+
+UNIT_TEST_STATUS
+EFIAPI
+TestSafeUintnSub (
+ IN UNIT_TEST_CONTEXT Context
+ )
+{
+ EFI_STATUS Status;
+ UINTN Minuend;
+ UINTN Subtrahend;
+ UINTN Result;
+
+ //
+ // If Minuend >= Subtrahend, then it's subtraction
+ //
+ Minuend = 0x5a5a5a5a5a5a5a5a;
+ Subtrahend = 0x3b3b3b3b3b3b3b3b;
+ Result = 0;
+ Status = SafeUintnSub(Minuend, Subtrahend, &Result);
+ UT_ASSERT_NOT_EFI_ERROR(Status);
+ UT_ASSERT_EQUAL(0x1f1f1f1f1f1f1f1f, Result);
+
+ //
+ // Otherwise should result in an error status
+ //
+ Minuend = 0x5a5a5a5a5a5a5a5a;
+ Subtrahend = 0x6d6d6d6d6d6d6d6d;
+ Status = SafeUintnSub(Minuend, Subtrahend, &Result);
+ UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
+
+ return UNIT_TEST_PASSED;
+}
+
+UNIT_TEST_STATUS
+EFIAPI
+TestSafeIntnSub (
+ IN UNIT_TEST_CONTEXT Context
+ )
+{
+ EFI_STATUS Status;
+ INTN Minuend;
+ INTN Subtrahend;
+ INTN Result;
+
+ //
+ // If the result of subtractions doesn't overflow MAX_INTN or
+ // underflow MIN_INTN, then it's subtraction
+ //
+ Minuend = 0x5a5a5a5a5a5a5a5a;
+ Subtrahend = 0x3a3a3a3a3a3a3a3a;
+ Result = 0;
+ Status = SafeIntnSub(Minuend, Subtrahend, &Result);
+ UT_ASSERT_NOT_EFI_ERROR(Status);
+ UT_ASSERT_EQUAL(0x2020202020202020, Result);
+
+ Minuend = 0x3a3a3a3a3a3a3a3a;
+ Subtrahend = 0x5a5a5a5a5a5a5a5a;
+ Status = SafeIntnSub(Minuend, Subtrahend, &Result);
+ UT_ASSERT_NOT_EFI_ERROR(Status);
+ UT_ASSERT_EQUAL((-2314885530818453536), Result);
+
+ //
+ // Otherwise should result in an error status
+ //
+ Minuend = (-8825501086245354106);
+ Subtrahend = 8825501086245354106;
+ Status = SafeIntnSub(Minuend, Subtrahend, &Result);
+ UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
+
+ Minuend = (8825501086245354106);
+ Subtrahend = (-8825501086245354106);
+ Status = SafeIntnSub(Minuend, Subtrahend, &Result);
+ UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
+
+ return UNIT_TEST_PASSED;
+}
+
+UNIT_TEST_STATUS
+EFIAPI
+TestSafeUintnMult (
+ IN UNIT_TEST_CONTEXT Context
+ )
+{
+ EFI_STATUS Status;
+ UINTN Multiplicand;
+ UINTN Multiplier;
+ UINTN Result;
+
+ //
+ // If the result of multiplication doesn't overflow MAX_UINTN, it will succeed
+ //
+ Multiplicand = 0x123456789a;
+ Multiplier = 0x1234567;
+ Result = 0;
+ Status = SafeUintnMult(Multiplicand, Multiplier, &Result);
+ UT_ASSERT_NOT_EFI_ERROR(Status);
+ UT_ASSERT_EQUAL(0x14b66db9745a07f6, Result);
+
+ //
+ // Otherwise should result in an error status
+ //
+ Multiplicand = 0x123456789a;
+ Multiplier = 0x12345678;
+ Status = SafeUintnMult(Multiplicand, Multiplier, &Result);
+ UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
+
+ return UNIT_TEST_PASSED;
+}
+
+UNIT_TEST_STATUS
+EFIAPI
+TestSafeIntnMult (
+ IN UNIT_TEST_CONTEXT Context
+ )
+{
+ EFI_STATUS Status;
+ INTN Multiplicand;
+ INTN Multiplier;
+ INTN Result;
+
+ //
+ // If the result of multiplication doesn't overflow MAX_INTN and doesn't
+ // underflow MIN_UINTN, it will succeed
+ //
+ Multiplicand = 0x123456789;
+ Multiplier = 0x6789abcd;
+ Result = 0;
+ Status = SafeIntnMult(Multiplicand, Multiplier, &Result);
+ UT_ASSERT_NOT_EFI_ERROR(Status);
+ UT_ASSERT_EQUAL(0x75cd9045220d6bb5, Result);
+
+ //
+ // Otherwise should result in an error status
+ //
+ Multiplicand = 0x123456789;
+ Multiplier = 0xa789abcd;
+ Status = SafeIntnMult(Multiplicand, Multiplier, &Result);
+ UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
+
+ return UNIT_TEST_PASSED;
+}
diff --git a/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntLib.c b/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntLib.c
new file mode 100644
index 0000000000..2b1a2223a0
--- /dev/null
+++ b/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntLib.c
@@ -0,0 +1,3064 @@
+/** @file
+ UEFI OS based application for unit testing the SafeIntLib.
+
+ Copyright (c) Microsoft Corporation.<BR>
+ Copyright (c) 2018 - 2020, Intel Corporation. All rights reserved.<BR>
+ SPDX-License-Identifier: BSD-2-Clause-Patent
+
+**/
+
+#include "TestBaseSafeIntLib.h"
+
+#define UNIT_TEST_NAME "Int Safe Lib Unit Test Application"
+#define UNIT_TEST_VERSION "0.1"
+
+//
+// Conversion function tests:
+//
+UNIT_TEST_STATUS
+EFIAPI
+TestSafeInt8ToUint8 (
+ IN UNIT_TEST_CONTEXT Context
+ )
+{
+ EFI_STATUS Status;
+ INT8 Operand;
+ UINT8 Result;
+
+ //
+ // Positive UINT8 should result in just a cast
+ //
+ Operand = 0x5b;
+ Result = 0;
+ Status = SafeInt8ToUint8(Operand, &Result);
+ UT_ASSERT_NOT_EFI_ERROR(Status);
+ UT_ASSERT_EQUAL(0x5b, Result);
+
+ //
+ // Negative number should result in an error status
+ //
+ Operand = (-56);
+ Status = SafeInt8ToUint8(Operand, &Result);
+ UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
+
+ return UNIT_TEST_PASSED;
+}
+
+UNIT_TEST_STATUS
+EFIAPI
+TestSafeInt8ToUint16 (
+ IN UNIT_TEST_CONTEXT Context
+ )
+{
+ EFI_STATUS Status;
+ INT8 Operand;
+ UINT16 Result;
+
+ //
+ // Positive UINT8 should result in just a cast
+ //
+ Operand = 0x5b;
+ Result = 0;
+ Status = SafeInt8ToUint16(Operand, &Result);
+ UT_ASSERT_NOT_EFI_ERROR(Status);
+ UT_ASSERT_EQUAL(0x5b, Result);
+
+ //
+ // Negative number should result in an error status
+ //
+ Operand = (-56);
+ Status = SafeInt8ToUint16(Operand, &Result);
+ UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
+
+ return UNIT_TEST_PASSED;
+}
+
+UNIT_TEST_STATUS
+EFIAPI
+TestSafeInt8ToUint32 (
+ IN UNIT_TEST_CONTEXT Context
+ )
+{
+ EFI_STATUS Status;
+ INT8 Operand;
+ UINT32 Result;
+
+ //
+ // Positive UINT8 should result in just a cast
+ //
+ Operand = 0x5b;
+ Result = 0;
+ Status = SafeInt8ToUint32(Operand, &Result);
+ UT_ASSERT_NOT_EFI_ERROR(Status);
+ UT_ASSERT_EQUAL(0x5b, Result);
+
+ //
+ // Negative number should result in an error status
+ //
+ Operand = (-56);
+ Status = SafeInt8ToUint32(Operand, &Result);
+ UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
+
+ return UNIT_TEST_PASSED;
+}
+
+UNIT_TEST_STATUS
+EFIAPI
+TestSafeInt8ToUintn (
+ IN UNIT_TEST_CONTEXT Context
+ )
+{
+ EFI_STATUS Status;
+ INT8 Operand;
+ UINTN Result;
+
+ //
+ // Positive UINT8 should result in just a cast
+ //
+ Operand = 0x5b;
+ Result = 0;
+ Status = SafeInt8ToUintn(Operand, &Result);
+ UT_ASSERT_NOT_EFI_ERROR(Status);
+ UT_ASSERT_EQUAL(0x5b, Result);
+
+ //
+ // Negative number should result in an error status
+ //
+ Operand = (-56);
+ Status = SafeInt8ToUintn(Operand, &Result);
+ UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
+
+ return UNIT_TEST_PASSED;
+}
+
+UNIT_TEST_STATUS
+EFIAPI
+TestSafeInt8ToUint64 (
+ IN UNIT_TEST_CONTEXT Context
+ )
+{
+ EFI_STATUS Status;
+ INT8 Operand;
+ UINT64 Result;
+
+ //
+ // Positive UINT8 should result in just a cast
+ //
+ Operand = 0x5b;
+ Result = 0;
+ Status = SafeInt8ToUint64(Operand, &Result);
+ UT_ASSERT_NOT_EFI_ERROR(Status);
+ UT_ASSERT_EQUAL(0x5b, Result);
+
+ //
+ // Negative number should result in an error status
+ //
+ Operand = (-56);
+ Status = SafeInt8ToUint64(Operand, &Result);
+ UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
+
+ return UNIT_TEST_PASSED;
+}
+
+UNIT_TEST_STATUS
+EFIAPI
+TestSafeUint8ToInt8 (
+ IN UNIT_TEST_CONTEXT Context
+ )
+{
+ EFI_STATUS Status;
+ UINT8 Operand;
+ INT8 Result;
+
+ //
+ // Operand <= 0x7F (MAX_INT8) should result in a cast
+ //
+ Operand = 0x5b;
+ Result = 0;
+ Status = SafeUint8ToInt8(Operand, &Result);
+ UT_ASSERT_NOT_EFI_ERROR(Status);
+ UT_ASSERT_EQUAL(0x5b, Result);
+
+ //
+ // Operand larger than 0x7f should result in an error status
+ //
+ Operand = 0xaf;
+ Status = SafeUint8ToInt8(Operand, &Result);
+ UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
+
+ return UNIT_TEST_PASSED;
+}
+
+UNIT_TEST_STATUS
+EFIAPI
+TestSafeUint8ToChar8 (
+ IN UNIT_TEST_CONTEXT Context
+ )
+{
+ EFI_STATUS Status;
+ UINT8 Operand;
+ CHAR8 Result;
+
+ //
+ // CHAR8 is typedefed as char, which by default is signed, thus
+ // CHAR8 is same as INT8, so same tests as above:
+ //
+
+ //
+ // Operand <= 0x7F (MAX_INT8) should result in a cast
+ //
+ Operand = 0x5b;
+ Result = 0;
+ Status = SafeUint8ToChar8(Operand, &Result);
+ UT_ASSERT_NOT_EFI_ERROR(Status);
+ UT_ASSERT_EQUAL(0x5b, Result);
+
+ //
+ // Operand larger than 0x7f should result in an error status
+ //
+ Operand = 0xaf;
+ Status = SafeUint8ToChar8(Operand, &Result);
+ UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
+
+ return UNIT_TEST_PASSED;
+}
+
+UNIT_TEST_STATUS
+EFIAPI
+TestSafeInt16ToInt8 (
+ IN UNIT_TEST_CONTEXT Context
+ )
+{
+ EFI_STATUS Status;
+ INT16 Operand;
+ INT8 Result;
+
+ //
+ // If Operand is between MIN_INT8 and MAX_INT8 inclusive, then it's a cast
+ //
+ Operand = 0x5b;
+ Result = 0;
+ Status = SafeInt16ToInt8(Operand, &Result);
+ UT_ASSERT_NOT_EFI_ERROR(Status);
+ UT_ASSERT_EQUAL(0x5b, Result);
+
+ Operand = (-35);
+ Status = SafeInt16ToInt8(Operand, &Result);
+ UT_ASSERT_NOT_EFI_ERROR(Status);
+ UT_ASSERT_EQUAL((-35), Result);
+
+ //
+ // Otherwise should result in an error status
+ //
+ Operand = 0x1234;
+ Status = SafeInt16ToInt8(Operand, &Result);
+ UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
+
+ Operand = (-17835);
+ Status = SafeInt16ToInt8(Operand, &Result);
+ UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
+
+ return UNIT_TEST_PASSED;
+}
+
+UNIT_TEST_STATUS
+EFIAPI
+TestSafeInt16ToChar8 (
+ IN UNIT_TEST_CONTEXT Context
+ )
+{
+ EFI_STATUS Status;
+ INT16 Operand;
+ CHAR8 Result;
+
+ //
+ // CHAR8 is typedefed as char, which may be signed or unsigned based
+ // on the compiler. Thus, for compatibility CHAR8 should be between 0 and MAX_INT8.
+ //
+
+ //
+ // If Operand is between 0 and MAX_INT8 inclusive, then it's a cast
+ //
+ Operand = 0x5b;
+ Result = 0;
+ Status = SafeInt16ToChar8(Operand, &Result);
+ UT_ASSERT_NOT_EFI_ERROR(Status);
+ UT_ASSERT_EQUAL(0x5b, Result);
+
+ Operand = 0;
+ Result = 0;
+ Status = SafeInt16ToChar8(Operand, &Result);
+ UT_ASSERT_NOT_EFI_ERROR(Status);
+ UT_ASSERT_EQUAL(0, Result);
+
+ Operand = MAX_INT8;
+ Result = 0;
+ Status = SafeInt16ToChar8(Operand, &Result);
+ UT_ASSERT_NOT_EFI_ERROR(Status);
+ UT_ASSERT_EQUAL(MAX_INT8, Result);
+
+ //
+ // Otherwise should result in an error status
+ //
+ Operand = (-35);
+ Status = SafeInt16ToChar8(Operand, &Result);
+ UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
+
+ Operand = 0x1234;
+ Status = SafeInt16ToChar8(Operand, &Result);
+ UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
+
+ Operand = (-17835);
+ Status = SafeInt16ToChar8(Operand, &Result);
+ UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
+
+ return UNIT_TEST_PASSED;
+}
+
+UNIT_TEST_STATUS
+EFIAPI
+TestSafeInt16ToUint8 (
+ IN UNIT_TEST_CONTEXT Context
+ )
+{
+ EFI_STATUS Status;
+ INT16 Operand;
+ UINT8 Result;
+
+ //
+ // If Operand is between 0 and MAX_INT8 inclusive, then it's a cast
+ //
+ Operand = 0x5b;
+ Result = 0;
+ Status = SafeInt16ToUint8(Operand, &Result);
+ UT_ASSERT_NOT_EFI_ERROR(Status);
+ UT_ASSERT_EQUAL(0x5b, Result);
+
+ //
+ // Otherwise should result in an error status
+ //
+ Operand = 0x1234;
+ Status = SafeInt16ToUint8(Operand, &Result);
+ UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
+
+ Operand = (-17835);
+ Status = SafeInt16ToUint8(Operand, &Result);
+ UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
+
+ return UNIT_TEST_PASSED;
+}
+
+UNIT_TEST_STATUS
+EFIAPI
+TestSafeInt16ToUint16 (
+ IN UNIT_TEST_CONTEXT Context
+ )
+{
+ EFI_STATUS Status;
+ INT16 Operand = 0x5b5b;
+ UINT16 Result = 0;
+
+ //
+ // If Operand is non-negative, then it's a cast
+ //
+ Status = SafeInt16ToUint16(Operand, &Result);
+ UT_ASSERT_NOT_EFI_ERROR(Status);
+ UT_ASSERT_EQUAL(0x5b5b, Result);
+
+ //
+ // Otherwise should result in an error status
+ //
+ Operand = (-17835);
+ Status = SafeInt16ToUint16(Operand, &Result);
+ UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
+
+ return UNIT_TEST_PASSED;
+}
+
+UNIT_TEST_STATUS
+EFIAPI
+TestSafeInt16ToUint32 (
+ IN UNIT_TEST_CONTEXT Context
+ )
+{
+ EFI_STATUS Status;
+ INT16 Operand;
+ UINT32 Result;
+
+ //
+ // If Operand is non-negative, then it's a cast
+ //
+ Operand = 0x5b5b;
+ Result = 0;
+ Status = SafeInt16ToUint32(Operand, &Result);
+ UT_ASSERT_NOT_EFI_ERROR(Status);
+ UT_ASSERT_EQUAL(0x5b5b, Result);
+
+ //
+ // Otherwise should result in an error status
+ //
+ Operand = (-17835);
+ Status = SafeInt16ToUint32(Operand, &Result);
+ UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
+
+ return UNIT_TEST_PASSED;
+}
+
+UNIT_TEST_STATUS
+EFIAPI
+TestSafeInt16ToUintn (
+ IN UNIT_TEST_CONTEXT Context
+ )
+{
+ EFI_STATUS Status;
+ INT16 Operand;
+ UINTN Result;
+
+ //
+ // If Operand is non-negative, then it's a cast
+ //
+ Operand = 0x5b5b;
+ Result = 0;
+ Status = SafeInt16ToUintn(Operand, &Result);
+ UT_ASSERT_NOT_EFI_ERROR(Status);
+ UT_ASSERT_EQUAL(0x5b5b, Result);
+
+ //
+ // Otherwise should result in an error status
+ //
+ Operand = (-17835);
+ Status = SafeInt16ToUintn(Operand, &Result);
+ UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
+
+ return UNIT_TEST_PASSED;
+}
+
+UNIT_TEST_STATUS
+EFIAPI
+TestSafeInt16ToUint64 (
+ IN UNIT_TEST_CONTEXT Context
+ )
+{
+ EFI_STATUS Status;
+ INT16 Operand;
+ UINT64 Result;
+
+ //
+ // If Operand is non-negative, then it's a cast
+ //
+ Operand = 0x5b5b;
+ Result = 0;
+ Status = SafeInt16ToUint64(Operand, &Result);
+ UT_ASSERT_NOT_EFI_ERROR(Status);
+ UT_ASSERT_EQUAL(0x5b5b, Result);
+
+ //
+ // Otherwise should result in an error status
+ //
+ Operand = (-17835);
+ Status = SafeInt16ToUint64(Operand, &Result);
+ UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
+
+ return UNIT_TEST_PASSED;
+}
+
+UNIT_TEST_STATUS
+EFIAPI
+TestSafeUint16ToInt8 (
+ IN UNIT_TEST_CONTEXT Context
+ )
+{
+ EFI_STATUS Status;
+ UINT16 Operand;
+ INT8 Result;
+
+ //
+ // If Operand is <= MAX_INT8, it's a cast
+ //
+ Operand = 0x5b;
+ Result = 0;
+ Status = SafeUint16ToInt8(Operand, &Result);
+ UT_ASSERT_NOT_EFI_ERROR(Status);
+ UT_ASSERT_EQUAL(0x5b, Result);
+
+ //
+ // Otherwise should result in an error status
+ //
+ Operand = (0x5b5b);
+ Status = SafeUint16ToInt8(Operand, &Result);
+ UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
+
+ return UNIT_TEST_PASSED;
+}
+
+UNIT_TEST_STATUS
+EFIAPI
+TestSafeUint16ToChar8 (
+ IN UNIT_TEST_CONTEXT Context
+ )
+{
+ EFI_STATUS Status;
+ UINT16 Operand;
+ CHAR8 Result;
+
+ // CHAR8 is typedefed as char, which by default is signed, thus
+ // CHAR8 is same as INT8, so same tests as above:
+
+ //
+ // If Operand is <= MAX_INT8, it's a cast
+ //
+ Operand = 0x5b;
+ Result = 0;
+ Status = SafeUint16ToChar8(Operand, &Result);
+ UT_ASSERT_NOT_EFI_ERROR(Status);
+ UT_ASSERT_EQUAL(0x5b, Result);
+
+ //
+ // Otherwise should result in an error status
+ //
+ Operand = (0x5b5b);
+ Status = SafeUint16ToChar8(Operand, &Result);
+ UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
+
+ return UNIT_TEST_PASSED;
+}
+
+UNIT_TEST_STATUS
+EFIAPI
+TestSafeUint16ToUint8 (
+ IN UNIT_TEST_CONTEXT Context
+ )
+{
+ EFI_STATUS Status;
+ UINT16 Operand;
+ UINT8 Result;
+
+ //
+ // If Operand is <= MAX_UINT8 (0xff), it's a cast
+ //
+ Operand = 0xab;
+ Result = 0;
+ Status = SafeUint16ToUint8(Operand, &Result);
+ UT_ASSERT_NOT_EFI_ERROR(Status);
+ UT_ASSERT_EQUAL(0xab, Result);
+
+ //
+ // Otherwise should result in an error status
+ //
+ Operand = (0x5b5b);
+ Status = SafeUint16ToUint8(Operand, &Result);
+ UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
+
+ return UNIT_TEST_PASSED;
+}
+
+UNIT_TEST_STATUS
+EFIAPI
+TestSafeUint16ToInt16 (
+ IN UNIT_TEST_CONTEXT Context
+ )
+{
+ EFI_STATUS Status;
+ UINT16 Operand;
+ INT16 Result;
+
+ //
+ // If Operand is <= MAX_INT16 (0x7fff), it's a cast
+ //
+ Operand = 0x5b5b;
+ Result = 0;
+ Status = SafeUint16ToInt16(Operand, &Result);
+ UT_ASSERT_NOT_EFI_ERROR(Status);
+ UT_ASSERT_EQUAL(0x5b5b, Result);
+
+ //
+ // Otherwise should result in an error status
+ //
+ Operand = (0xabab);
+ Status = SafeUint16ToInt16(Operand, &Result);
+ UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
+
+ return UNIT_TEST_PASSED;
+}
+
+UNIT_TEST_STATUS
+EFIAPI
+TestSafeInt32ToInt8 (
+ IN UNIT_TEST_CONTEXT Context
+ )
+{
+ EFI_STATUS Status;
+ INT32 Operand;
+ INT8 Result;
+
+ //
+ // If Operand is between MIN_INT8 and MAX_INT8 inclusive, then it's a cast
+ //
+ Operand = 0x5b;
+ Result = 0;
+ Status = SafeInt32ToInt8(Operand, &Result);
+ UT_ASSERT_NOT_EFI_ERROR(Status);
+ UT_ASSERT_EQUAL(0x5b, Result);
+
+ Operand = (-57);
+ Status = SafeInt32ToInt8(Operand, &Result);
+ UT_ASSERT_NOT_EFI_ERROR(Status);
+ UT_ASSERT_EQUAL((-57), Result);
+
+ //
+ // Otherwise should result in an error status
+ //
+ Operand = (0x5bababab);
+ Status = SafeInt32ToInt8(Operand, &Result);
+ UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
+
+ Operand = (-1537977259);
+ Status = SafeInt32ToInt8(Operand, &Result);
+ UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
+
+ return UNIT_TEST_PASSED;
+}
+
+UNIT_TEST_STATUS
+EFIAPI
+TestSafeInt32ToChar8 (
+ IN UNIT_TEST_CONTEXT Context
+ )
+{
+ EFI_STATUS Status;
+ INT32 Operand;
+ CHAR8 Result;
+
+ //
+ // CHAR8 is typedefed as char, which may be signed or unsigned based
+ // on the compiler. Thus, for compatibility CHAR8 should be between 0 and MAX_INT8.
+ //
+
+ //
+ // If Operand is between 0 and MAX_INT8 inclusive, then it's a cast
+ //
+ Operand = 0x5b;
+ Result = 0;
+ Status = SafeInt32ToChar8(Operand, &Result);
+ UT_ASSERT_NOT_EFI_ERROR(Status);
+ UT_ASSERT_EQUAL(0x5b, Result);
+
+ Operand = 0;
+ Result = 0;
+ Status = SafeInt32ToChar8(Operand, &Result);
+ UT_ASSERT_NOT_EFI_ERROR(Status);
+ UT_ASSERT_EQUAL(0, Result);
+
+ Operand = MAX_INT8;
+ Result = 0;
+ Status = SafeInt32ToChar8(Operand, &Result);
+ UT_ASSERT_NOT_EFI_ERROR(Status);
+ UT_ASSERT_EQUAL(MAX_INT8, Result);
+
+ //
+ // Otherwise should result in an error status
+ //
+ Operand = (-57);
+ Status = SafeInt32ToChar8(Operand, &Result);
+ UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
+
+ Operand = (0x5bababab);
+ Status = SafeInt32ToChar8(Operand, &Result);
+ UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
+
+ Operand = (-1537977259);
+ Status = SafeInt32ToChar8(Operand, &Result);
+ UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
+
+ return UNIT_TEST_PASSED;
+}
+
+UNIT_TEST_STATUS
+EFIAPI
+TestSafeInt32ToUint8 (
+ IN UNIT_TEST_CONTEXT Context
+ )
+{
+ EFI_STATUS Status;
+ INT32 Operand;
+ UINT8 Result;
+
+ //
+ // If Operand is between 0 and MAX_INT8 inclusive, then it's a cast
+ //
+ Operand = 0x5b;
+ Result = 0;
+ Status = SafeInt32ToUint8(Operand, &Result);
+ UT_ASSERT_NOT_EFI_ERROR(Status);
+ UT_ASSERT_EQUAL(0x5b, Result);
+
+ //
+ // Otherwise should result in an error status
+ //
+ Operand = (-57);
+ Status = SafeInt32ToUint8(Operand, &Result);
+ UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
+
+ Operand = (0x5bababab);
+ Status = SafeInt32ToUint8(Operand, &Result);
+ UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
+
+ Operand = (-1537977259);
+ Status = SafeInt32ToUint8(Operand, &Result);
+ UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
+
+ return UNIT_TEST_PASSED;
+}
+
+UNIT_TEST_STATUS
+EFIAPI
+TestSafeInt32ToInt16 (
+ IN UNIT_TEST_CONTEXT Context
+ )
+{
+ EFI_STATUS Status;
+ INT32 Operand;
+ INT16 Result;
+
+ //
+ // If Operand is between MIN_INT16 and MAX_INT16 inclusive, then it's a cast
+ //
+ Operand = 0x5b5b;
+ Result = 0;
+ Status = SafeInt32ToInt16(Operand, &Result);
+ UT_ASSERT_NOT_EFI_ERROR(Status);
+ UT_ASSERT_EQUAL(0x5b5b, Result);
+
+ Operand = (-17857);
+ Status = SafeInt32ToInt16(Operand, &Result);
+ UT_ASSERT_NOT_EFI_ERROR(Status);
+ UT_ASSERT_EQUAL((-17857), Result);
+
+ //
+ // Otherwise should result in an error status
+ //
+ Operand = (0x5bababab);
+ Status = SafeInt32ToInt16(Operand, &Result);
+ UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
+
+ Operand = (-1537977259);
+ Status = SafeInt32ToInt16(Operand, &Result);
+ UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
+
+ return UNIT_TEST_PASSED;
+}
+
+UNIT_TEST_STATUS
+EFIAPI
+TestSafeInt32ToUint16 (
+ IN UNIT_TEST_CONTEXT Context
+ )
+{
+ EFI_STATUS Status;
+ INT32 Operand;
+ UINT16 Result;
+
+ //
+ // If Operand is between 0 and MAX_UINT16 inclusive, then it's a cast
+ //
+ Operand = 0xabab;
+ Result = 0;
+ Status = SafeInt32ToUint16(Operand, &Result);
+ UT_ASSERT_NOT_EFI_ERROR(Status);
+ UT_ASSERT_EQUAL(0xabab, Result);
+
+ //
+ // Otherwise should result in an error status
+ //
+ Operand = (-17857);
+ Status = SafeInt32ToUint16(Operand, &Result);
+ UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
+
+ Operand = (0x5bababab);
+ Status = SafeInt32ToUint16(Operand, &Result);
+ UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
+
+ Operand = (-1537977259);
+ Status = SafeInt32ToUint16(Operand, &Result);
+ UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
+
+ return UNIT_TEST_PASSED;
+}
+
+UNIT_TEST_STATUS
+EFIAPI
+TestSafeInt32ToUint32 (
+ IN UNIT_TEST_CONTEXT Context
+ )
+{
+ EFI_STATUS Status;
+ INT32 Operand;
+ UINT32 Result;
+
+ //
+ // If Operand is non-negative, then it's a cast
+ //
+ Operand = 0x5bababab;
+ Result = 0;
+ Status = SafeInt32ToUint32(Operand, &Result);
+ UT_ASSERT_NOT_EFI_ERROR(Status);
+ UT_ASSERT_EQUAL(0x5bababab, Result);
+
+ //
+ // Otherwise should result in an error status
+ //
+ Operand = (-1537977259);
+ Status = SafeInt32ToUint32(Operand, &Result);
+ UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
+
+ return UNIT_TEST_PASSED;
+}
+
+UNIT_TEST_STATUS
+EFIAPI
+TestSafeInt32ToUint64 (
+ IN UNIT_TEST_CONTEXT Context
+ )
+{
+ EFI_STATUS Status;
+ INT32 Operand;
+ UINT64 Result;
+
+ //
+ // If Operand is non-negative, then it's a cast
+ //
+ Operand = 0x5bababab;
+ Result = 0;
+ Status = SafeInt32ToUint64(Operand, &Result);
+ UT_ASSERT_NOT_EFI_ERROR(Status);
+ UT_ASSERT_EQUAL(0x5bababab, Result);
+
+ //
+ // Otherwise should result in an error status
+ //
+ Operand = (-1537977259);
+ Status = SafeInt32ToUint64(Operand, &Result);
+ UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
+
+ return UNIT_TEST_PASSED;
+}
+
+UNIT_TEST_STATUS
+EFIAPI
+TestSafeUint32ToInt8 (
+ IN UNIT_TEST_CONTEXT Context
+ )
+{
+ EFI_STATUS Status;
+ UINT32 Operand;
+ INT8 Result;
+
+ //
+ // If Operand is <= MAX_INT8, then it's a cast
+ //
+ Operand = 0x5b;
+ Result = 0;
+ Status = SafeUint32ToInt8(Operand, &Result);
+ UT_ASSERT_NOT_EFI_ERROR(Status);
+ UT_ASSERT_EQUAL(0x5b, Result);
+
+ //
+ // Otherwise should result in an error status
+ //
+ Operand = (0x5bababab);
+ Status = SafeUint32ToInt8(Operand, &Result);
+ UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
+
+ return UNIT_TEST_PASSED;
+}
+
+UNIT_TEST_STATUS
+EFIAPI
+TestSafeUint32ToChar8 (
+ IN UNIT_TEST_CONTEXT Context
+ )
+{
+ EFI_STATUS Status;
+ UINT32 Operand;
+ CHAR8 Result;
+
+ // CHAR8 is typedefed as char, which by default is signed, thus
+ // CHAR8 is same as INT8, so same tests as above:
+
+ //
+ // If Operand is <= MAX_INT8, then it's a cast
+ //
+ Operand = 0x5b;
+ Result = 0;
+ Status = SafeUint32ToChar8(Operand, &Result);
+ UT_ASSERT_NOT_EFI_ERROR(Status);
+ UT_ASSERT_EQUAL(0x5b, Result);
+
+ //
+ // Otherwise should result in an error status
+ //
+ Operand = (0x5bababab);
+ Status = SafeUint32ToChar8(Operand, &Result);
+ UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
+
+ return UNIT_TEST_PASSED;
+}
+
+UNIT_TEST_STATUS
+EFIAPI
+TestSafeUint32ToUint8 (
+ IN UNIT_TEST_CONTEXT Context
+ )
+{
+ EFI_STATUS Status;
+ UINT32 Operand;
+ UINT8 Result;
+
+ //
+ // If Operand is <= MAX_UINT8, then it's a cast
+ //
+ Operand = 0xab;
+ Result = 0;
+ Status = SafeUint32ToUint8(Operand, &Result);
+ UT_ASSERT_NOT_EFI_ERROR(Status);
+ UT_ASSERT_EQUAL(0xab, Result);
+
+ //
+ // Otherwise should result in an error status
+ //
+ Operand = (0xabababab);
+ Status = SafeUint32ToUint8(Operand, &Result);
+ UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
+
+ return UNIT_TEST_PASSED;
+}
+
+UNIT_TEST_STATUS
+EFIAPI
+TestSafeUint32ToInt16 (
+ IN UNIT_TEST_CONTEXT Context
+ )
+{
+ EFI_STATUS Status;
+ UINT32 Operand;
+ INT16 Result;
+
+ //
+ // If Operand is <= MAX_INT16, then it's a cast
+ //
+ Operand = 0x5bab;
+ Result = 0;
+ Status = SafeUint32ToInt16(Operand, &Result);
+ UT_ASSERT_NOT_EFI_ERROR(Status);
+ UT_ASSERT_EQUAL(0x5bab, Result);
+
+ //
+ // Otherwise should result in an error status
+ //
+ Operand = (0xabababab);
+ Status = SafeUint32ToInt16(Operand, &Result);
+ UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
+
+ return UNIT_TEST_PASSED;
+}
+
+UNIT_TEST_STATUS
+EFIAPI
+TestSafeUint32ToUint16 (
+ IN UNIT_TEST_CONTEXT Context
+ )
+{
+ EFI_STATUS Status;
+ UINT32 Operand;
+ UINT16 Result;
+
+ //
+ // If Operand is <= MAX_UINT16, then it's a cast
+ //
+ Operand = 0xabab;
+ Result = 0;
+ Status = SafeUint32ToUint16(Operand, &Result);
+ UT_ASSERT_NOT_EFI_ERROR(Status);
+ UT_ASSERT_EQUAL(0xabab, Result);
+
+ //
+ // Otherwise should result in an error status
+ //
+ Operand = (0xabababab);
+ Status = SafeUint32ToUint16(Operand, &Result);
+ UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
+
+ return UNIT_TEST_PASSED;
+}
+
+UNIT_TEST_STATUS
+EFIAPI
+TestSafeUint32ToInt32 (
+ IN UNIT_TEST_CONTEXT Context
+ )
+{
+ EFI_STATUS Status;
+ UINT32 Operand;
+ INT32 Result;
+
+ //
+ // If Operand is <= MAX_INT32, then it's a cast
+ //
+ Operand = 0x5bababab;
+ Result = 0;
+ Status = SafeUint32ToInt32(Operand, &Result);
+ UT_ASSERT_NOT_EFI_ERROR(Status);
+ UT_ASSERT_EQUAL(0x5bababab, Result);
+
+ //
+ // Otherwise should result in an error status
+ //
+ Operand = (0xabababab);
+ Status = SafeUint32ToInt32(Operand, &Result);
+ UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
+
+ return UNIT_TEST_PASSED;
+}
+
+UNIT_TEST_STATUS
+EFIAPI
+TestSafeIntnToInt8 (
+ IN UNIT_TEST_CONTEXT Context
+ )
+{
+ EFI_STATUS Status;
+ INTN Operand;
+ INT8 Result;
+
+ //
+ // If Operand is between MIN_INT8 and MAX_INT8 inclusive, then it's a cast
+ //
+ Operand = 0x5b;
+ Result = 0;
+ Status = SafeIntnToInt8(Operand, &Result);
+ UT_ASSERT_NOT_EFI_ERROR(Status);
+ UT_ASSERT_EQUAL(0x5b, Result);
+
+ Operand = (-53);
+ Status = SafeIntnToInt8(Operand, &Result);
+ UT_ASSERT_NOT_EFI_ERROR(Status);
+ UT_ASSERT_EQUAL((-53), Result);
+
+ //
+ // Otherwise should result in an error status
+ //
+ Operand = (0x5bababab);
+ Status = SafeIntnToInt8(Operand, &Result);
+ UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
+
+ Operand = (-1537977259);
+ Status = SafeIntnToInt8(Operand, &Result);
+ UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
+
+ return UNIT_TEST_PASSED;
+}
+
+UNIT_TEST_STATUS
+EFIAPI
+TestSafeIntnToChar8 (
+ IN UNIT_TEST_CONTEXT Context
+ )
+{
+ EFI_STATUS Status;
+ INTN Operand;
+ CHAR8 Result;
+
+ //
+ // CHAR8 is typedefed as char, which may be signed or unsigned based
+ // on the compiler. Thus, for compatibility CHAR8 should be between 0 and MAX_INT8.
+ //
+
+ //
+ // If Operand is between MIN_INT8 and MAX_INT8 inclusive, then it's a cast
+ //
+ Operand = 0x5b;
+ Result = 0;
+ Status = SafeIntnToChar8(Operand, &Result);
+ UT_ASSERT_NOT_EFI_ERROR(Status);
+ UT_ASSERT_EQUAL(0x5b, Result);
+
+ Operand = 0;
+ Result = 0;
+ Status = SafeIntnToChar8(Operand, &Result);
+ UT_ASSERT_NOT_EFI_ERROR(Status);
+ UT_ASSERT_EQUAL(0, Result);
+
+ Operand = MAX_INT8;
+ Result = 0;
+ Status = SafeIntnToChar8(Operand, &Result);
+ UT_ASSERT_NOT_EFI_ERROR(Status);
+ UT_ASSERT_EQUAL(MAX_INT8, Result);
+
+ //
+ // Otherwise should result in an error status
+ //
+ Operand = (-53);
+ Status = SafeIntnToChar8(Operand, &Result);
+ UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
+
+ Operand = (0x5bababab);
+ Status = SafeIntnToChar8(Operand, &Result);
+ UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
+
+ Operand = (-1537977259);
+ Status = SafeIntnToChar8(Operand, &Result);
+ UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
+
+ return UNIT_TEST_PASSED;
+}
+
+UNIT_TEST_STATUS
+EFIAPI
+TestSafeIntnToUint8 (
+ IN UNIT_TEST_CONTEXT Context
+ )
+{
+ EFI_STATUS Status;
+ INTN Operand;
+ UINT8 Result;
+
+ //
+ // If Operand is between 0 and MAX_UINT8 inclusive, then it's a cast
+ //
+ Operand = 0xab;
+ Result = 0;
+ Status = SafeIntnToUint8(Operand, &Result);
+ UT_ASSERT_NOT_EFI_ERROR(Status);
+ UT_ASSERT_EQUAL(0xab, Result);
+
+ //
+ // Otherwise should result in an error status
+ //
+ Operand = (0x5bababab);
+ Status = SafeIntnToUint8(Operand, &Result);
+ UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
+
+ Operand = (-1537977259);
+ Status = SafeIntnToUint8(Operand, &Result);
+ UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
+
+ return UNIT_TEST_PASSED;
+}
+
+UNIT_TEST_STATUS
+EFIAPI
+TestSafeIntnToInt16 (
+ IN UNIT_TEST_CONTEXT Context
+ )
+{
+ EFI_STATUS Status;
+ INTN Operand;
+ INT16 Result;
+
+ //
+ // If Operand is between MIN_INT16 and MAX_INT16 inclusive, then it's a cast
+ //
+ Operand = 0x5bab;
+ Result = 0;
+ Status = SafeIntnToInt16(Operand, &Result);
+ UT_ASSERT_NOT_EFI_ERROR(Status);
+ UT_ASSERT_EQUAL(0x5bab, Result);
+
+ Operand = (-23467);
+ Status = SafeIntnToInt16(Operand, &Result);
+ UT_ASSERT_NOT_EFI_ERROR(Status);
+ UT_ASSERT_EQUAL((-23467), Result);
+
+ //
+ // Otherwise should result in an error status
+ //
+ Operand = (0x5bababab);
+ Status = SafeIntnToInt16(Operand, &Result);
+ UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
+
+ Operand = (-1537977259);
+ Status = SafeIntnToInt16(Operand, &Result);
+ UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
+
+ return UNIT_TEST_PASSED;
+}
+
+UNIT_TEST_STATUS
+EFIAPI
+TestSafeIntnToUint16 (
+ IN UNIT_TEST_CONTEXT Context
+ )
+{
+ EFI_STATUS Status;
+ INTN Operand;
+ UINT16 Result;
+
+ //
+ // If Operand is between 0 and MAX_UINT16 inclusive, then it's a cast
+ //
+ Operand = 0xabab;
+ Result = 0;
+ Status = SafeIntnToUint16(Operand, &Result);
+ UT_ASSERT_NOT_EFI_ERROR(Status);
+ UT_ASSERT_EQUAL(0xabab, Result);
+
+ //
+ // Otherwise should result in an error status
+ //
+ Operand = (0x5bababab);
+ Status = SafeIntnToUint16(Operand, &Result);
+ UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
+
+ Operand = (-1537977259);
+ Status = SafeIntnToUint16(Operand, &Result);
+ UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
+
+ return UNIT_TEST_PASSED;
+}
+
+UNIT_TEST_STATUS
+EFIAPI
+TestSafeIntnToUintn (
+ IN UNIT_TEST_CONTEXT Context
+ )
+{
+ EFI_STATUS Status;
+ INTN Operand;
+ UINTN Result;
+
+ //
+ // If Operand is non-negative, then it's a cast
+ //
+ Operand = 0x5bababab;
+ Result = 0;
+ Status = SafeIntnToUintn(Operand, &Result);
+ UT_ASSERT_NOT_EFI_ERROR(Status);
+ UT_ASSERT_EQUAL(0x5bababab, Result);
+
+ //
+ // Otherwise should result in an error status
+ //
+ Operand = (-1537977259);
+ Status = SafeIntnToUintn(Operand, &Result);
+ UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
+
+ return UNIT_TEST_PASSED;
+}
+
+UNIT_TEST_STATUS
+EFIAPI
+TestSafeIntnToUint64 (
+ IN UNIT_TEST_CONTEXT Context
+ )
+{
+ EFI_STATUS Status;
+ INTN Operand;
+ UINT64 Result;
+
+ //
+ // If Operand is non-negative, then it's a cast
+ //
+ Operand = 0x5bababab;
+ Result = 0;
+ Status = SafeIntnToUint64(Operand, &Result);
+ UT_ASSERT_NOT_EFI_ERROR(Status);
+ UT_ASSERT_EQUAL(0x5bababab, Result);
+
+ //
+ // Otherwise should result in an error status
+ //
+ Operand = (-1537977259);
+ Status = SafeIntnToUint64(Operand, &Result);
+ UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
+
+ return UNIT_TEST_PASSED;
+}
+
+UNIT_TEST_STATUS
+EFIAPI
+TestSafeUintnToInt8 (
+ IN UNIT_TEST_CONTEXT Context
+ )
+{
+ EFI_STATUS Status;
+ UINTN Operand;
+ INT8 Result;
+
+ //
+ // If Operand is <= MAX_INT8, then it's a cast
+ //
+ Operand = 0x5b;
+ Result = 0;
+ Status = SafeUintnToInt8(Operand, &Result);
+ UT_ASSERT_NOT_EFI_ERROR(Status);
+ UT_ASSERT_EQUAL(0x5b, Result);
+
+ //
+ // Otherwise should result in an error status
+ //
+ Operand = (0xabab);
+ Status = SafeUintnToInt8(Operand, &Result);
+ UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
+
+ return UNIT_TEST_PASSED;
+}
+
+UNIT_TEST_STATUS
+EFIAPI
+TestSafeUintnToChar8 (
+ IN UNIT_TEST_CONTEXT Context
+ )
+{
+ EFI_STATUS Status;
+ UINTN Operand;
+ CHAR8 Result;
+
+ // CHAR8 is typedefed as char, which by default is signed, thus
+ // CHAR8 is same as INT8, so same tests as above:
+
+ //
+ // If Operand is <= MAX_INT8, then it's a cast
+ //
+ Operand = 0x5b;
+ Result = 0;
+ Status = SafeUintnToChar8(Operand, &Result);
+ UT_ASSERT_NOT_EFI_ERROR(Status);
+ UT_ASSERT_EQUAL(0x5b, Result);
+
+ //
+ // Otherwise should result in an error status
+ //
+ Operand = (0xabab);
+ Status = SafeUintnToChar8(Operand, &Result);
+ UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
+
+ return UNIT_TEST_PASSED;
+}
+
+UNIT_TEST_STATUS
+EFIAPI
+TestSafeUintnToUint8 (
+ IN UNIT_TEST_CONTEXT Context
+ )
+{
+ EFI_STATUS Status;
+ UINTN Operand;
+ UINT8 Result;
+
+ //
+ // If Operand is <= MAX_UINT8, then it's a cast
+ //
+ Operand = 0xab;
+ Result = 0;
+ Status = SafeUintnToUint8(Operand, &Result);
+ UT_ASSERT_NOT_EFI_ERROR(Status);
+ UT_ASSERT_EQUAL(0xab, Result);
+
+ //
+ // Otherwise should result in an error status
+ //
+ Operand = (0xabab);
+ Status = SafeUintnToUint8(Operand, &Result);
+ UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
+
+ return UNIT_TEST_PASSED;
+}
+
+UNIT_TEST_STATUS
+EFIAPI
+TestSafeUintnToInt16 (
+ IN UNIT_TEST_CONTEXT Context
+ )
+{
+ EFI_STATUS Status;
+ UINTN Operand;
+ INT16 Result;
+
+ //
+ // If Operand is <= MAX_INT16, then it's a cast
+ //
+ Operand = 0x5bab;
+ Result = 0;
+ Status = SafeUintnToInt16(Operand, &Result);
+ UT_ASSERT_NOT_EFI_ERROR(Status);
+ UT_ASSERT_EQUAL(0x5bab, Result);
+
+ //
+ // Otherwise should result in an error status
+ //
+ Operand = (0xabab);
+ Status = SafeUintnToInt16(Operand, &Result);
+ UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
+
+ return UNIT_TEST_PASSED;
+}
+
+UNIT_TEST_STATUS
+EFIAPI
+TestSafeUintnToUint16 (
+ IN UNIT_TEST_CONTEXT Context
+ )
+{
+ EFI_STATUS Status;
+ UINTN Operand;
+ UINT16 Result;
+
+ //
+ // If Operand is <= MAX_UINT16, then it's a cast
+ //
+ Operand = 0xabab;
+ Result = 0;
+ Status = SafeUintnToUint16(Operand, &Result);
+ UT_ASSERT_NOT_EFI_ERROR(Status);
+ UT_ASSERT_EQUAL(0xabab, Result);
+
+ //
+ // Otherwise should result in an error status
+ //
+ Operand = (0xabababab);
+ Status = SafeUintnToUint16(Operand, &Result);
+ UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
+
+ return UNIT_TEST_PASSED;
+}
+
+UNIT_TEST_STATUS
+EFIAPI
+TestSafeUintnToInt32 (
+ IN UNIT_TEST_CONTEXT Context
+ )
+{
+ EFI_STATUS Status;
+ UINTN Operand;
+ INT32 Result;
+
+ //
+ // If Operand is <= MAX_INT32, then it's a cast
+ //
+ Operand = 0x5bababab;
+ Result = 0;
+ Status = SafeUintnToInt32(Operand, &Result);
+ UT_ASSERT_NOT_EFI_ERROR(Status);
+ UT_ASSERT_EQUAL(0x5bababab, Result);
+
+ //
+ // Otherwise should result in an error status
+ //
+ Operand = (0xabababab);
+ Status = SafeUintnToInt32(Operand, &Result);
+ UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
+
+ return UNIT_TEST_PASSED;
+}
+
+UNIT_TEST_STATUS
+EFIAPI
+TestSafeInt64ToInt8 (
+ IN UNIT_TEST_CONTEXT Context
+ )
+{
+ EFI_STATUS Status;
+ INT64 Operand;
+ INT8 Result;
+
+ //
+ // If Operand is between MIN_INT8 and MAX_INT8 inclusive, then it's a cast
+ //
+ Operand = 0x5b;
+ Result = 0;
+ Status = SafeInt64ToInt8(Operand, &Result);
+ UT_ASSERT_NOT_EFI_ERROR(Status);
+ UT_ASSERT_EQUAL(0x5b, Result);
+
+ Operand = (-37);
+ Status = SafeInt64ToInt8(Operand, &Result);
+ UT_ASSERT_NOT_EFI_ERROR(Status);
+ UT_ASSERT_EQUAL((-37), Result);
+
+ //
+ // Otherwise should result in an error status
+ //
+ Operand = (0x5babababefefefef);
+ Status = SafeInt64ToInt8(Operand, &Result);
+ UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
+
+ Operand = (-6605562033422200815);
+ Status = SafeInt64ToInt8(Operand, &Result);
+ UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
+
+ return UNIT_TEST_PASSED;
+}
+
+UNIT_TEST_STATUS
+EFIAPI
+TestSafeInt64ToChar8 (
+ IN UNIT_TEST_CONTEXT Context
+ )
+{
+ EFI_STATUS Status;
+ INT64 Operand;
+ CHAR8 Result;
+
+ //
+ // CHAR8 is typedefed as char, which may be signed or unsigned based
+ // on the compiler. Thus, for compatibility CHAR8 should be between 0 and MAX_INT8.
+ //
+
+ //
+ // If Operand is between MIN_INT8 and MAX_INT8 inclusive, then it's a cast
+ //
+ Operand = 0x5b;
+ Result = 0;
+ Status = SafeInt64ToChar8(Operand, &Result);
+ UT_ASSERT_NOT_EFI_ERROR(Status);
+ UT_ASSERT_EQUAL(0x5b, Result);
+
+ Operand = 0;
+ Result = 0;
+ Status = SafeInt64ToChar8(Operand, &Result);
+ UT_ASSERT_NOT_EFI_ERROR(Status);
+ UT_ASSERT_EQUAL(0, Result);
+
+ Operand = MAX_INT8;
+ Result = 0;
+ Status = SafeInt64ToChar8(Operand, &Result);
+ UT_ASSERT_NOT_EFI_ERROR(Status);
+ UT_ASSERT_EQUAL(MAX_INT8, Result);
+
+ //
+ // Otherwise should result in an error status
+ //
+ Operand = (-37);
+ Status = SafeInt64ToChar8(Operand, &Result);
+ UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
+
+ Operand = (0x5babababefefefef);
+ Status = SafeInt64ToChar8(Operand, &Result);
+ UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
+
+ Operand = (-6605562033422200815);
+ Status = SafeInt64ToChar8(Operand, &Result);
+ UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
+
+ return UNIT_TEST_PASSED;
+}
+
+UNIT_TEST_STATUS
+EFIAPI
+TestSafeInt64ToUint8 (
+ IN UNIT_TEST_CONTEXT Context
+ )
+{
+ EFI_STATUS Status;
+ INT64 Operand;
+ UINT8 Result;
+
+ //
+ // If Operand is between 0 and MAX_UINT8 inclusive, then it's a cast
+ //
+ Operand = 0xab;
+ Result = 0;
+ Status = SafeInt64ToUint8(Operand, &Result);
+ UT_ASSERT_NOT_EFI_ERROR(Status);
+ UT_ASSERT_EQUAL(0xab, Result);
+
+ //
+ // Otherwise should result in an error status
+ //
+ Operand = (0x5babababefefefef);
+ Status = SafeInt64ToUint8(Operand, &Result);
+ UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
+
+ Operand = (-6605562033422200815);
+ Status = SafeInt64ToUint8(Operand, &Result);
+ UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
+
+ return UNIT_TEST_PASSED;
+}
+
+UNIT_TEST_STATUS
+EFIAPI
+TestSafeInt64ToInt16 (
+ IN UNIT_TEST_CONTEXT Context
+ )
+{
+ EFI_STATUS Status;
+ INT64 Operand;
+ INT16 Result;
+
+ //
+ // If Operand is between MIN_INT16 and MAX_INT16 inclusive, then it's a cast
+ //
+ Operand = 0x5bab;
+ Result = 0;
+ Status = SafeInt64ToInt16(Operand, &Result);
+ UT_ASSERT_NOT_EFI_ERROR(Status);
+ UT_ASSERT_EQUAL(0x5bab, Result);
+
+ Operand = (-23467);
+ Status = SafeInt64ToInt16(Operand, &Result);
+ UT_ASSERT_NOT_EFI_ERROR(Status);
+ UT_ASSERT_EQUAL((-23467), Result);
+
+ //
+ // Otherwise should result in an error status
+ //
+ Operand = (0x5babababefefefef);
+ Status = SafeInt64ToInt16(Operand, &Result);
+ UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
+
+ Operand = (-6605562033422200815);
+ Status = SafeInt64ToInt16(Operand, &Result);
+ UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
+
+ return UNIT_TEST_PASSED;
+}
+
+UNIT_TEST_STATUS
+EFIAPI
+TestSafeInt64ToUint16 (
+ IN UNIT_TEST_CONTEXT Context
+ )
+{
+ EFI_STATUS Status;
+ INT64 Operand;
+ UINT16 Result;
+
+ //
+ // If Operand is between 0 and MAX_UINT16 inclusive, then it's a cast
+ //
+ Operand = 0xabab;
+ Result = 0;
+ Status = SafeInt64ToUint16(Operand, &Result);
+ UT_ASSERT_NOT_EFI_ERROR(Status);
+ UT_ASSERT_EQUAL(0xabab, Result);
+
+ //
+ // Otherwise should result in an error status
+ //
+ Operand = (0x5babababefefefef);
+ Status = SafeInt64ToUint16(Operand, &Result);
+ UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
+
+ Operand = (-6605562033422200815);
+ Status = SafeInt64ToUint16(Operand, &Result);
+ UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
+
+ return UNIT_TEST_PASSED;
+}
+
+UNIT_TEST_STATUS
+EFIAPI
+TestSafeInt64ToInt32 (
+ IN UNIT_TEST_CONTEXT Context
+ )
+{
+ EFI_STATUS Status;
+ INT64 Operand;
+ INT32 Result;
+
+ //
+ // If Operand is between MIN_INT32 and MAX_INT32 inclusive, then it's a cast
+ //
+ Operand = 0x5bababab;
+ Result = 0;
+ Status = SafeInt64ToInt32(Operand, &Result);
+ UT_ASSERT_NOT_EFI_ERROR(Status);
+ UT_ASSERT_EQUAL(0x5bababab, Result);
+
+ Operand = (-1537977259);
+ Status = SafeInt64ToInt32(Operand, &Result);
+ UT_ASSERT_NOT_EFI_ERROR(Status);
+ UT_ASSERT_EQUAL((-1537977259), Result);
+
+ //
+ // Otherwise should result in an error status
+ //
+ Operand = (0x5babababefefefef);
+ Status = SafeInt64ToInt32(Operand, &Result);
+ UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
+
+ Operand = (-6605562033422200815);
+ Status = SafeInt64ToInt32(Operand, &Result);
+ UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
+
+ return UNIT_TEST_PASSED;
+}
+
+UNIT_TEST_STATUS
+EFIAPI
+TestSafeInt64ToUint32 (
+ IN UNIT_TEST_CONTEXT Context
+ )
+{
+ EFI_STATUS Status;
+ INT64 Operand;
+ UINT32 Result;
+
+ //
+ // If Operand is between 0 and MAX_UINT32 inclusive, then it's a cast
+ //
+ Operand = 0xabababab;
+ Result = 0;
+ Status = SafeInt64ToUint32(Operand, &Result);
+ UT_ASSERT_NOT_EFI_ERROR(Status);
+ UT_ASSERT_EQUAL(0xabababab, Result);
+
+ //
+ // Otherwise should result in an error status
+ //
+ Operand = (0x5babababefefefef);
+ Status = SafeInt64ToUint32(Operand, &Result);
+ UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
+
+ Operand = (-6605562033422200815);
+ Status = SafeInt64ToUint32(Operand, &Result);
+ UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
+
+ return UNIT_TEST_PASSED;
+}
+
+UNIT_TEST_STATUS
+EFIAPI
+TestSafeInt64ToUint64 (
+ IN UNIT_TEST_CONTEXT Context
+ )
+{
+ EFI_STATUS Status;
+ INT64 Operand;
+ UINT64 Result;
+
+ //
+ // If Operand is non-negative, then it's a cast
+ //
+ Operand = 0x5babababefefefef;
+ Result = 0;
+ Status = SafeInt64ToUint64(Operand, &Result);
+ UT_ASSERT_NOT_EFI_ERROR(Status);
+ UT_ASSERT_EQUAL(0x5babababefefefef, Result);
+
+ //
+ // Otherwise should result in an error status
+ //
+ Operand = (-6605562033422200815);
+ Status = SafeInt64ToUint64(Operand, &Result);
+ UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
+
+ return UNIT_TEST_PASSED;
+}
+
+UNIT_TEST_STATUS
+EFIAPI
+TestSafeUint64ToInt8 (
+ IN UNIT_TEST_CONTEXT Context
+ )
+{
+ EFI_STATUS Status;
+ UINT64 Operand;
+ INT8 Result;
+
+ //
+ // If Operand is <= MAX_INT8, then it's a cast
+ //
+ Operand = 0x5b;
+ Result = 0;
+ Status = SafeUint64ToInt8(Operand, &Result);
+ UT_ASSERT_NOT_EFI_ERROR(Status);
+ UT_ASSERT_EQUAL(0x5b, Result);
+
+ //
+ // Otherwise should result in an error status
+ //
+ Operand = (0xababababefefefef);
+ Status = SafeUint64ToInt8(Operand, &Result);
+ UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
+
+ return UNIT_TEST_PASSED;
+}
+
+UNIT_TEST_STATUS
+EFIAPI
+TestSafeUint64ToChar8 (
+ IN UNIT_TEST_CONTEXT Context
+ )
+{
+ EFI_STATUS Status;
+ UINT64 Operand;
+ CHAR8 Result;
+
+ // CHAR8 is typedefed as char, which by default is signed, thus
+ // CHAR8 is same as INT8, so same tests as above:
+
+ //
+ // If Operand is <= MAX_INT8, then it's a cast
+ //
+ Operand = 0x5b;
+ Result = 0;
+ Status = SafeUint64ToChar8(Operand, &Result);
+ UT_ASSERT_NOT_EFI_ERROR(Status);
+ UT_ASSERT_EQUAL(0x5b, Result);
+
+ //
+ // Otherwise should result in an error status
+ //
+ Operand = (0xababababefefefef);
+ Status = SafeUint64ToChar8(Operand, &Result);
+ UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
+
+ return UNIT_TEST_PASSED;
+}
+
+UNIT_TEST_STATUS
+EFIAPI
+TestSafeUint64ToUint8 (
+ IN UNIT_TEST_CONTEXT Context
+ )
+{
+ EFI_STATUS Status;
+ UINT64 Operand;
+ UINT8 Result;
+
+ //
+ // If Operand is <= MAX_UINT8, then it's a cast
+ //
+ Operand = 0xab;
+ Result = 0;
+ Status = SafeUint64ToUint8(Operand, &Result);
+ UT_ASSERT_NOT_EFI_ERROR(Status);
+ UT_ASSERT_EQUAL(0xab, Result);
+
+ //
+ // Otherwise should result in an error status
+ //
+ Operand = (0xababababefefefef);
+ Status = SafeUint64ToUint8(Operand, &Result);
+ UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
+
+ return UNIT_TEST_PASSED;
+}
+
+UNIT_TEST_STATUS
+EFIAPI
+TestSafeUint64ToInt16 (
+ IN UNIT_TEST_CONTEXT Context
+ )
+{
+ EFI_STATUS Status;
+ UINT64 Operand;
+ INT16 Result;
+
+ //
+ // If Operand is <= MAX_INT16, then it's a cast
+ //
+ Operand = 0x5bab;
+ Result = 0;
+ Status = SafeUint64ToInt16(Operand, &Result);
+ UT_ASSERT_NOT_EFI_ERROR(Status);
+ UT_ASSERT_EQUAL(0x5bab, Result);
+
+ //
+ // Otherwise should result in an error status
+ //
+ Operand = (0xababababefefefef);
+ Status = SafeUint64ToInt16(Operand, &Result);
+ UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
+
+ return UNIT_TEST_PASSED;
+}
+
+UNIT_TEST_STATUS
+EFIAPI
+TestSafeUint64ToUint16 (
+ IN UNIT_TEST_CONTEXT Context
+ )
+{
+ EFI_STATUS Status;
+ UINT64 Operand;
+ UINT16 Result;
+
+ //
+ // If Operand is <= MAX_UINT16, then it's a cast
+ //
+ Operand = 0xabab;
+ Result = 0;
+ Status = SafeUint64ToUint16(Operand, &Result);
+ UT_ASSERT_NOT_EFI_ERROR(Status);
+ UT_ASSERT_EQUAL(0xabab, Result);
+
+ //
+ // Otherwise should result in an error status
+ //
+ Operand = (0xababababefefefef);
+ Status = SafeUint64ToUint16(Operand, &Result);
+ UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
+
+ return UNIT_TEST_PASSED;
+}
+
+UNIT_TEST_STATUS
+EFIAPI
+TestSafeUint64ToInt32 (
+ IN UNIT_TEST_CONTEXT Context
+ )
+{
+ EFI_STATUS Status;
+ UINT64 Operand;
+ INT32 Result;
+
+ //
+ // If Operand is <= MAX_INT32, then it's a cast
+ //
+ Operand = 0x5bababab;
+ Result = 0;
+ Status = SafeUint64ToInt32(Operand, &Result);
+ UT_ASSERT_NOT_EFI_ERROR(Status);
+ UT_ASSERT_EQUAL(0x5bababab, Result);
+
+ //
+ // Otherwise should result in an error status
+ //
+ Operand = (0xababababefefefef);
+ Status = SafeUint64ToInt32(Operand, &Result);
+ UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
+
+ return UNIT_TEST_PASSED;
+}
+
+UNIT_TEST_STATUS
+EFIAPI
+TestSafeUint64ToUint32 (
+ IN UNIT_TEST_CONTEXT Context
+ )
+{
+ EFI_STATUS Status;
+ UINT64 Operand;
+ UINT32 Result;
+
+ //
+ // If Operand is <= MAX_UINT32, then it's a cast
+ //
+ Operand = 0xabababab;
+ Result = 0;
+ Status = SafeUint64ToUint32(Operand, &Result);
+ UT_ASSERT_NOT_EFI_ERROR(Status);
+ UT_ASSERT_EQUAL(0xabababab, Result);
+
+ //
+ // Otherwise should result in an error status
+ //
+ Operand = (0xababababefefefef);
+ Status = SafeUint64ToUint32(Operand, &Result);
+ UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
+
+ return UNIT_TEST_PASSED;
+}
+
+UNIT_TEST_STATUS
+EFIAPI
+TestSafeUint64ToInt64 (
+ IN UNIT_TEST_CONTEXT Context
+ )
+{
+ EFI_STATUS Status;
+ UINT64 Operand;
+ INT64 Result;
+
+ //
+ // If Operand is <= MAX_INT64, then it's a cast
+ //
+ Operand = 0x5babababefefefef;
+ Result = 0;
+ Status = SafeUint64ToInt64(Operand, &Result);
+ UT_ASSERT_NOT_EFI_ERROR(Status);
+ UT_ASSERT_EQUAL(0x5babababefefefef, Result);
+
+ //
+ // Otherwise should result in an error status
+ //
+ Operand = (0xababababefefefef);
+ Status = SafeUint64ToInt64(Operand, &Result);
+ UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
+
+ return UNIT_TEST_PASSED;
+}
+
+//
+// Addition function tests:
+//
+UNIT_TEST_STATUS
+EFIAPI
+TestSafeUint8Add (
+ IN UNIT_TEST_CONTEXT Context
+ )
+{
+ EFI_STATUS Status;
+ UINT8 Augend;
+ UINT8 Addend;
+ UINT8 Result;
+
+ //
+ // If the result of addition doesn't overflow MAX_UINT8, then it's addition
+ //
+ Augend = 0x3a;
+ Addend = 0x3a;
+ Result = 0;
+ Status = SafeUint8Add(Augend, Addend, &Result);
+ UT_ASSERT_NOT_EFI_ERROR(Status);
+ UT_ASSERT_EQUAL(0x74, Result);
+
+ //
+ // Otherwise should result in an error status
+ //
+ Augend = 0xab;
+ Addend = 0xbc;
+ Status = SafeUint8Add(Augend, Addend, &Result);
+ UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
+
+ return UNIT_TEST_PASSED;
+}
+
+UNIT_TEST_STATUS
+EFIAPI
+TestSafeUint16Add (
+ IN UNIT_TEST_CONTEXT Context
+ )
+{
+ EFI_STATUS Status;
+ UINT16 Augend = 0x3a3a;
+ UINT16 Addend = 0x3a3a;
+ UINT16 Result = 0;
+
+ //
+ // If the result of addition doesn't overflow MAX_UINT16, then it's addition
+ //
+ Status = SafeUint16Add(Augend, Addend, &Result);
+ UT_ASSERT_NOT_EFI_ERROR(Status);
+ UT_ASSERT_EQUAL(0x7474, Result);
+
+ //
+ // Otherwise should result in an error status
+ //
+ Augend = 0xabab;
+ Addend = 0xbcbc;
+ Status = SafeUint16Add(Augend, Addend, &Result);
+ UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
+
+ return UNIT_TEST_PASSED;
+}
+
+UNIT_TEST_STATUS
+EFIAPI
+TestSafeUint32Add (
+ IN UNIT_TEST_CONTEXT Context
+ )
+{
+ EFI_STATUS Status;
+ UINT32 Augend;
+ UINT32 Addend;
+ UINT32 Result;
+
+ //
+ // If the result of addition doesn't overflow MAX_UINT32, then it's addition
+ //
+ Augend = 0x3a3a3a3a;
+ Addend = 0x3a3a3a3a;
+ Result = 0;
+ Status = SafeUint32Add(Augend, Addend, &Result);
+ UT_ASSERT_NOT_EFI_ERROR(Status);
+ UT_ASSERT_EQUAL(0x74747474, Result);
+
+ //
+ // Otherwise should result in an error status
+ //
+ Augend = 0xabababab;
+ Addend = 0xbcbcbcbc;
+ Status = SafeUint32Add(Augend, Addend, &Result);
+ UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
+
+ return UNIT_TEST_PASSED;
+}
+
+UNIT_TEST_STATUS
+EFIAPI
+TestSafeUint64Add (
+ IN UNIT_TEST_CONTEXT Context
+ )
+{
+ EFI_STATUS Status;
+ UINT64 Augend;
+ UINT64 Addend;
+ UINT64 Result;
+
+ //
+ // If the result of addition doesn't overflow MAX_UINT64, then it's addition
+ //
+ Augend = 0x3a3a3a3a12121212;
+ Addend = 0x3a3a3a3a12121212;
+ Result = 0;
+ Status = SafeUint64Add(Augend, Addend, &Result);
+ UT_ASSERT_NOT_EFI_ERROR(Status);
+ UT_ASSERT_EQUAL(0x7474747424242424, Result);
+
+ //
+ // Otherwise should result in an error status
+ //
+ Augend = 0xababababefefefef;
+ Addend = 0xbcbcbcbcdededede;
+ Status = SafeUint64Add(Augend, Addend, &Result);
+ UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
+
+ return UNIT_TEST_PASSED;
+}
+
+UNIT_TEST_STATUS
+EFIAPI
+TestSafeInt8Add (
+ IN UNIT_TEST_CONTEXT Context
+ )
+{
+ EFI_STATUS Status;
+ INT8 Augend;
+ INT8 Addend;
+ INT8 Result;
+
+ //
+ // If the result of addition doesn't overflow MAX_INT8
+ // and doesn't underflow MIN_INT8, then it's addition
+ //
+ Augend = 0x3a;
+ Addend = 0x3a;
+ Result = 0;
+ Status = SafeInt8Add(Augend, Addend, &Result);
+ UT_ASSERT_NOT_EFI_ERROR(Status);
+ UT_ASSERT_EQUAL(0x74, Result);
+
+ Augend = (-58);
+ Addend = (-58);
+ Status = SafeInt8Add(Augend, Addend, &Result);
+ UT_ASSERT_NOT_EFI_ERROR(Status);
+ UT_ASSERT_EQUAL((-116), Result);
+
+ //
+ // Otherwise should result in an error status
+ //
+ Augend = 0x5a;
+ Addend = 0x5a;
+ Status = SafeInt8Add(Augend, Addend, &Result);
+ UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
+
+ Augend = (-90);
+ Addend = (-90);
+ Status = SafeInt8Add(Augend, Addend, &Result);
+ UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
+
+ return UNIT_TEST_PASSED;
+
+}
+
+UNIT_TEST_STATUS
+EFIAPI
+TestSafeInt16Add (
+ IN UNIT_TEST_CONTEXT Context
+ )
+{
+ EFI_STATUS Status;
+ INT16 Augend;
+ INT16 Addend;
+ INT16 Result;
+
+ //
+ // If the result of addition doesn't overflow MAX_INT16
+ // and doesn't underflow MIN_INT16, then it's addition
+ //
+ Augend = 0x3a3a;
+ Addend = 0x3a3a;
+ Result = 0;
+ Status = SafeInt16Add(Augend, Addend, &Result);
+ UT_ASSERT_NOT_EFI_ERROR(Status);
+ UT_ASSERT_EQUAL(0x7474, Result);
+
+ Augend = (-14906);
+ Addend = (-14906);
+ Status = SafeInt16Add(Augend, Addend, &Result);
+ UT_ASSERT_NOT_EFI_ERROR(Status);
+ UT_ASSERT_EQUAL((-29812), Result);
+
+ //
+ // Otherwise should result in an error status
+ //
+ Augend = 0x5a5a;
+ Addend = 0x5a5a;
+ Status = SafeInt16Add(Augend, Addend, &Result);
+ UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
+
+ Augend = (-23130);
+ Addend = (-23130);
+ Status = SafeInt16Add(Augend, Addend, &Result);
+ UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
+
+ return UNIT_TEST_PASSED;
+}
+
+UNIT_TEST_STATUS
+EFIAPI
+TestSafeInt32Add (
+ IN UNIT_TEST_CONTEXT Context
+ )
+{
+ EFI_STATUS Status;
+ INT32 Augend;
+ INT32 Addend;
+ INT32 Result;
+
+ //
+ // If the result of addition doesn't overflow MAX_INT32
+ // and doesn't underflow MIN_INT32, then it's addition
+ //
+ Augend = 0x3a3a3a3a;
+ Addend = 0x3a3a3a3a;
+ Result = 0;
+ Status = SafeInt32Add(Augend, Addend, &Result);
+ UT_ASSERT_NOT_EFI_ERROR(Status);
+ UT_ASSERT_EQUAL(0x74747474, Result);
+
+ Augend = (-976894522);
+ Addend = (-976894522);
+ Status = SafeInt32Add(Augend, Addend, &Result);
+ UT_ASSERT_NOT_EFI_ERROR(Status);
+ UT_ASSERT_EQUAL((-1953789044), Result);
+
+ //
+ // Otherwise should result in an error status
+ //
+ Augend = 0x5a5a5a5a;
+ Addend = 0x5a5a5a5a;
+ Status = SafeInt32Add(Augend, Addend, &Result);
+ UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
+
+ Augend = (-1515870810);
+ Addend = (-1515870810);
+ Status = SafeInt32Add(Augend, Addend, &Result);
+ UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
+
+ return UNIT_TEST_PASSED;
+}
+
+UNIT_TEST_STATUS
+EFIAPI
+TestSafeInt64Add (
+ IN UNIT_TEST_CONTEXT Context
+ )
+{
+ EFI_STATUS Status;
+ INT64 Augend;
+ INT64 Addend;
+ INT64 Result;
+
+ //
+ // If the result of addition doesn't overflow MAX_INT64
+ // and doesn't underflow MIN_INT64, then it's addition
+ //
+ Augend = 0x3a3a3a3a3a3a3a3a;
+ Addend = 0x3a3a3a3a3a3a3a3a;
+ Result = 0;
+ Status = SafeInt64Add(Augend, Addend, &Result);
+ UT_ASSERT_NOT_EFI_ERROR(Status);
+ UT_ASSERT_EQUAL(0x7474747474747474, Result);
+
+ Augend = (-4195730024608447034);
+ Addend = (-4195730024608447034);
+ Status = SafeInt64Add(Augend, Addend, &Result);
+ UT_ASSERT_NOT_EFI_ERROR(Status);
+ UT_ASSERT_EQUAL((-8391460049216894068), Result);
+
+ //
+ // Otherwise should result in an error status
+ //
+ Augend = 0x5a5a5a5a5a5a5a5a;
+ Addend = 0x5a5a5a5a5a5a5a5a;
+ Status = SafeInt64Add(Augend, Addend, &Result);
+ UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
+
+ Augend = (-6510615555426900570);
+ Addend = (-6510615555426900570);
+ Status = SafeInt64Add(Augend, Addend, &Result);
+ UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
+
+ return UNIT_TEST_PASSED;
+}
+
+//
+// Subtraction function tests:
+//
+UNIT_TEST_STATUS
+EFIAPI
+TestSafeUint8Sub (
+ IN UNIT_TEST_CONTEXT Context
+ )
+{
+ EFI_STATUS Status;
+ UINT8 Minuend;
+ UINT8 Subtrahend;
+ UINT8 Result;
+
+ //
+ // If Minuend >= Subtrahend, then it's subtraction
+ //
+ Minuend = 0x5a;
+ Subtrahend = 0x3b;
+ Result = 0;
+ Status = SafeUint8Sub(Minuend, Subtrahend, &Result);
+ UT_ASSERT_NOT_EFI_ERROR(Status);
+ UT_ASSERT_EQUAL(0x1f, Result);
+
+ //
+ // Otherwise should result in an error status
+ //
+ Minuend = 0x5a;
+ Subtrahend = 0x6d;
+ Status = SafeUint8Sub(Minuend, Subtrahend, &Result);
+ UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
+
+ return UNIT_TEST_PASSED;
+}
+
+UNIT_TEST_STATUS
+EFIAPI
+TestSafeUint16Sub (
+ IN UNIT_TEST_CONTEXT Context
+ )
+{
+ EFI_STATUS Status;
+ UINT16 Minuend;
+ UINT16 Subtrahend;
+ UINT16 Result;
+
+ //
+ // If Minuend >= Subtrahend, then it's subtraction
+ //
+ Minuend = 0x5a5a;
+ Subtrahend = 0x3b3b;
+ Result = 0;
+ Status = SafeUint16Sub(Minuend, Subtrahend, &Result);
+ UT_ASSERT_NOT_EFI_ERROR(Status);
+ UT_ASSERT_EQUAL(0x1f1f, Result);
+
+ //
+ // Otherwise should result in an error status
+ //
+ Minuend = 0x5a5a;
+ Subtrahend = 0x6d6d;
+ Status = SafeUint16Sub(Minuend, Subtrahend, &Result);
+ UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
+
+ return UNIT_TEST_PASSED;
+}
+
+UNIT_TEST_STATUS
+EFIAPI
+TestSafeUint32Sub (
+ IN UNIT_TEST_CONTEXT Context
+ )
+{
+ EFI_STATUS Status;
+ UINT32 Minuend;
+ UINT32 Subtrahend;
+ UINT32 Result;
+
+ //
+ // If Minuend >= Subtrahend, then it's subtraction
+ //
+ Minuend = 0x5a5a5a5a;
+ Subtrahend = 0x3b3b3b3b;
+ Result = 0;
+ Status = SafeUint32Sub(Minuend, Subtrahend, &Result);
+ UT_ASSERT_NOT_EFI_ERROR(Status);
+ UT_ASSERT_EQUAL(0x1f1f1f1f, Result);
+
+ //
+ // Otherwise should result in an error status
+ //
+ Minuend = 0x5a5a5a5a;
+ Subtrahend = 0x6d6d6d6d;
+ Status = SafeUint32Sub(Minuend, Subtrahend, &Result);
+ UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
+
+ return UNIT_TEST_PASSED;
+}
+
+UNIT_TEST_STATUS
+EFIAPI
+TestSafeUint64Sub (
+ IN UNIT_TEST_CONTEXT Context
+ )
+{
+ EFI_STATUS Status;
+ UINT64 Minuend;
+ UINT64 Subtrahend;
+ UINT64 Result;
+
+ //
+ // If Minuend >= Subtrahend, then it's subtraction
+ //
+ Minuend = 0x5a5a5a5a5a5a5a5a;
+ Subtrahend = 0x3b3b3b3b3b3b3b3b;
+ Result = 0;
+ Status = SafeUint64Sub(Minuend, Subtrahend, &Result);
+ UT_ASSERT_NOT_EFI_ERROR(Status);
+ UT_ASSERT_EQUAL(0x1f1f1f1f1f1f1f1f, Result);
+
+ //
+ // Otherwise should result in an error status
+ //
+ Minuend = 0x5a5a5a5a5a5a5a5a;
+ Subtrahend = 0x6d6d6d6d6d6d6d6d;
+ Status = SafeUint64Sub(Minuend, Subtrahend, &Result);
+ UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
+
+ return UNIT_TEST_PASSED;
+}
+
+UNIT_TEST_STATUS
+EFIAPI
+TestSafeInt8Sub (
+ IN UNIT_TEST_CONTEXT Context
+ )
+{
+ EFI_STATUS Status;
+ INT8 Minuend;
+ INT8 Subtrahend;
+ INT8 Result;
+
+ //
+ // If the result of subtractions doesn't overflow MAX_INT8 or
+ // underflow MIN_INT8, then it's subtraction
+ //
+ Minuend = 0x5a;
+ Subtrahend = 0x3a;
+ Result = 0;
+ Status = SafeInt8Sub(Minuend, Subtrahend, &Result);
+ UT_ASSERT_NOT_EFI_ERROR(Status);
+ UT_ASSERT_EQUAL(0x20, Result);
+
+ Minuend = 58;
+ Subtrahend = 78;
+ Status = SafeInt8Sub(Minuend, Subtrahend, &Result);
+ UT_ASSERT_NOT_EFI_ERROR(Status);
+ UT_ASSERT_EQUAL((-20), Result);
+
+ //
+ // Otherwise should result in an error status
+ //
+ Minuend = (-80);
+ Subtrahend = 80;
+ Status = SafeInt8Sub(Minuend, Subtrahend, &Result);
+ UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
+
+ Minuend = (80);
+ Subtrahend = (-80);
+ Status = SafeInt8Sub(Minuend, Subtrahend, &Result);
+ UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
+
+ return UNIT_TEST_PASSED;
+}
+
+UNIT_TEST_STATUS
+EFIAPI
+TestSafeInt16Sub (
+ IN UNIT_TEST_CONTEXT Context
+ )
+{
+ EFI_STATUS Status;
+ INT16 Minuend;
+ INT16 Subtrahend;
+ INT16 Result;
+
+ //
+ // If the result of subtractions doesn't overflow MAX_INT16 or
+ // underflow MIN_INT16, then it's subtraction
+ //
+ Minuend = 0x5a5a;
+ Subtrahend = 0x3a3a;
+ Result = 0;
+ Status = SafeInt16Sub(Minuend, Subtrahend, &Result);
+ UT_ASSERT_NOT_EFI_ERROR(Status);
+ UT_ASSERT_EQUAL(0x2020, Result);
+
+ Minuend = 0x3a3a;
+ Subtrahend = 0x5a5a;
+ Status = SafeInt16Sub(Minuend, Subtrahend, &Result);
+ UT_ASSERT_NOT_EFI_ERROR(Status);
+ UT_ASSERT_EQUAL((-8224), Result);
+
+ //
+ // Otherwise should result in an error status
+ //
+ Minuend = (-31354);
+ Subtrahend = 31354;
+ Status = SafeInt16Sub(Minuend, Subtrahend, &Result);
+ UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
+
+ Minuend = (31354);
+ Subtrahend = (-31354);
+ Status = SafeInt16Sub(Minuend, Subtrahend, &Result);
+ UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
+
+ return UNIT_TEST_PASSED;
+}
+
+UNIT_TEST_STATUS
+EFIAPI
+TestSafeInt32Sub (
+ IN UNIT_TEST_CONTEXT Context
+ )
+{
+ EFI_STATUS Status;
+ INT32 Minuend;
+ INT32 Subtrahend;
+ INT32 Result;
+
+ //
+ // If the result of subtractions doesn't overflow MAX_INT32 or
+ // underflow MIN_INT32, then it's subtraction
+ //
+ Minuend = 0x5a5a5a5a;
+ Subtrahend = 0x3a3a3a3a;
+ Result = 0;
+ Status = SafeInt32Sub(Minuend, Subtrahend, &Result);
+ UT_ASSERT_NOT_EFI_ERROR(Status);
+ UT_ASSERT_EQUAL(0x20202020, Result);
+
+ Minuend = 0x3a3a3a3a;
+ Subtrahend = 0x5a5a5a5a;
+ Status = SafeInt32Sub(Minuend, Subtrahend, &Result);
+ UT_ASSERT_NOT_EFI_ERROR(Status);
+ UT_ASSERT_EQUAL((-538976288), Result);
+
+ //
+ // Otherwise should result in an error status
+ //
+ Minuend = (-2054847098);
+ Subtrahend = 2054847098;
+ Status = SafeInt32Sub(Minuend, Subtrahend, &Result);
+ UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
+
+ Minuend = (2054847098);
+ Subtrahend = (-2054847098);
+ Status = SafeInt32Sub(Minuend, Subtrahend, &Result);
+ UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
+
+ return UNIT_TEST_PASSED;
+}
+
+UNIT_TEST_STATUS
+EFIAPI
+TestSafeInt64Sub (
+ IN UNIT_TEST_CONTEXT Context
+ )
+{
+ EFI_STATUS Status;
+ INT64 Minuend;
+ INT64 Subtrahend;
+ INT64 Result;
+
+ //
+ // If the result of subtractions doesn't overflow MAX_INT64 or
+ // underflow MIN_INT64, then it's subtraction
+ //
+ Minuend = 0x5a5a5a5a5a5a5a5a;
+ Subtrahend = 0x3a3a3a3a3a3a3a3a;
+ Result = 0;
+ Status = SafeInt64Sub(Minuend, Subtrahend, &Result);
+ UT_ASSERT_NOT_EFI_ERROR(Status);
+ UT_ASSERT_EQUAL(0x2020202020202020, Result);
+
+ Minuend = 0x3a3a3a3a3a3a3a3a;
+ Subtrahend = 0x5a5a5a5a5a5a5a5a;
+ Status = SafeInt64Sub(Minuend, Subtrahend, &Result);
+ UT_ASSERT_NOT_EFI_ERROR(Status);
+ UT_ASSERT_EQUAL((-2314885530818453536), Result);
+
+ //
+ // Otherwise should result in an error status
+ //
+ Minuend = (-8825501086245354106);
+ Subtrahend = 8825501086245354106;
+ Status = SafeInt64Sub(Minuend, Subtrahend, &Result);
+ UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
+
+ Minuend = (8825501086245354106);
+ Subtrahend = (-8825501086245354106);
+ Status = SafeInt64Sub(Minuend, Subtrahend, &Result);
+ UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
+
+ return UNIT_TEST_PASSED;
+}
+
+//
+// Multiplication function tests:
+//
+UNIT_TEST_STATUS
+EFIAPI
+TestSafeUint8Mult (
+ IN UNIT_TEST_CONTEXT Context
+ )
+{
+ EFI_STATUS Status;
+ UINT8 Multiplicand;
+ UINT8 Multiplier;
+ UINT8 Result;
+
+ //
+ // If the result of multiplication doesn't overflow MAX_UINT8, it will succeed
+ //
+ Multiplicand = 0x12;
+ Multiplier = 0xa;
+ Result = 0;
+ Status = SafeUint8Mult(Multiplicand, Multiplier, &Result);
+ UT_ASSERT_NOT_EFI_ERROR(Status);
+ UT_ASSERT_EQUAL(0xb4, Result);
+
+ //
+ // Otherwise should result in an error status
+ //
+ Multiplicand = 0x12;
+ Multiplier = 0x23;
+ Status = SafeUint8Mult(Multiplicand, Multiplier, &Result);
+ UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
+
+ return UNIT_TEST_PASSED;
+}
+
+UNIT_TEST_STATUS
+EFIAPI
+TestSafeUint16Mult (
+ IN UNIT_TEST_CONTEXT Context
+ )
+{
+ EFI_STATUS Status;
+ UINT16 Multiplicand;
+ UINT16 Multiplier;
+ UINT16 Result;
+
+ //
+ // If the result of multiplication doesn't overflow MAX_UINT16, it will succeed
+ //
+ Multiplicand = 0x212;
+ Multiplier = 0x7a;
+ Result = 0;
+ Status = SafeUint16Mult(Multiplicand, Multiplier, &Result);
+ UT_ASSERT_NOT_EFI_ERROR(Status);
+ UT_ASSERT_EQUAL(0xfc94, Result);
+
+ //
+ // Otherwise should result in an error status
+ //
+ Multiplicand = 0x1234;
+ Multiplier = 0x213;
+ Status = SafeUint16Mult(Multiplicand, Multiplier, &Result);
+ UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
+
+ return UNIT_TEST_PASSED;
+}
+
+UNIT_TEST_STATUS
+EFIAPI
+TestSafeUint32Mult (
+ IN UNIT_TEST_CONTEXT Context
+ )
+{
+ EFI_STATUS Status;
+ UINT32 Multiplicand;
+ UINT32 Multiplier;
+ UINT32 Result;
+
+ //
+ // If the result of multiplication doesn't overflow MAX_UINT32, it will succeed
+ //
+ Multiplicand = 0xa122a;
+ Multiplier = 0xd23;
+ Result = 0;
+ Status = SafeUint32Mult(Multiplicand, Multiplier, &Result);
+ UT_ASSERT_NOT_EFI_ERROR(Status);
+ UT_ASSERT_EQUAL(0x844c9dbe, Result);
+
+ //
+ // Otherwise should result in an error status
+ //
+ Multiplicand = 0xa122a;
+ Multiplier = 0xed23;
+ Status = SafeUint32Mult(Multiplicand, Multiplier, &Result);
+ UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
+
+ return UNIT_TEST_PASSED;
+}
+
+UNIT_TEST_STATUS
+EFIAPI
+TestSafeUint64Mult (
+ IN UNIT_TEST_CONTEXT Context
+ )
+{
+ EFI_STATUS Status;
+ UINT64 Multiplicand;
+ UINT64 Multiplier;
+ UINT64 Result;
+
+ //
+ // If the result of multiplication doesn't overflow MAX_UINT64, it will succeed
+ //
+ Multiplicand = 0x123456789a;
+ Multiplier = 0x1234567;
+ Result = 0;
+ Status = SafeUint64Mult(Multiplicand, Multiplier, &Result);
+ UT_ASSERT_NOT_EFI_ERROR(Status);
+ UT_ASSERT_EQUAL(0x14b66db9745a07f6, Result);
+
+ //
+ // Otherwise should result in an error status
+ //
+ Multiplicand = 0x123456789a;
+ Multiplier = 0x12345678;
+ Status = SafeUint64Mult(Multiplicand, Multiplier, &Result);
+ UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
+
+ return UNIT_TEST_PASSED;
+}
+
+UNIT_TEST_STATUS
+EFIAPI
+TestSafeInt8Mult (
+ IN UNIT_TEST_CONTEXT Context
+ )
+{
+ EFI_STATUS Status;
+ INT8 Multiplicand;
+ INT8 Multiplier;
+ INT8 Result;
+
+ //
+ // If the result of multiplication doesn't overflow MAX_INT8 and doesn't
+ // underflow MIN_UINT8, it will succeed
+ //
+ Multiplicand = 0x12;
+ Multiplier = 0x7;
+ Result = 0;
+ Status = SafeInt8Mult(Multiplicand, Multiplier, &Result);
+ UT_ASSERT_NOT_EFI_ERROR(Status);
+ UT_ASSERT_EQUAL(0x7e, Result);
+
+ //
+ // Otherwise should result in an error status
+ //
+ Multiplicand = 0x12;
+ Multiplier = 0xa;
+ Status = SafeInt8Mult(Multiplicand, Multiplier, &Result);
+ UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
+
+ return UNIT_TEST_PASSED;
+}
+
+UNIT_TEST_STATUS
+EFIAPI
+TestSafeInt16Mult (
+ IN UNIT_TEST_CONTEXT Context
+ )
+{
+ EFI_STATUS Status;
+ INT16 Multiplicand;
+ INT16 Multiplier;
+ INT16 Result;
+
+ //
+ // If the result of multiplication doesn't overflow MAX_INT16 and doesn't
+ // underflow MIN_UINT16, it will succeed
+ //
+ Multiplicand = 0x123;
+ Multiplier = 0x67;
+ Result = 0;
+ Status = SafeInt16Mult(Multiplicand, Multiplier, &Result);
+ UT_ASSERT_NOT_EFI_ERROR(Status);
+ UT_ASSERT_EQUAL(0x7515, Result);
+
+ //
+ // Otherwise should result in an error status
+ //
+ Multiplicand = 0x123;
+ Multiplier = 0xab;
+ Status = SafeInt16Mult(Multiplicand, Multiplier, &Result);
+ UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
+
+ return UNIT_TEST_PASSED;
+}
+
+UNIT_TEST_STATUS
+EFIAPI
+TestSafeInt32Mult (
+ IN UNIT_TEST_CONTEXT Context
+ )
+{
+ EFI_STATUS Status;
+ INT32 Multiplicand;
+ INT32 Multiplier;
+ INT32 Result;
+
+ //
+ // If the result of multiplication doesn't overflow MAX_INT32 and doesn't
+ // underflow MIN_UINT32, it will succeed
+ //
+ Multiplicand = 0x123456;
+ Multiplier = 0x678;
+ Result = 0;
+ Status = SafeInt32Mult(Multiplicand, Multiplier, &Result);
+ UT_ASSERT_NOT_EFI_ERROR(Status);
+ UT_ASSERT_EQUAL(0x75c28c50, Result);
+
+ //
+ // Otherwise should result in an error status
+ //
+ Multiplicand = 0x123456;
+ Multiplier = 0xabc;
+ Status = SafeInt32Mult(Multiplicand, Multiplier, &Result);
+ UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
+
+ return UNIT_TEST_PASSED;
+}
+
+UNIT_TEST_STATUS
+EFIAPI
+TestSafeInt64Mult (
+ IN UNIT_TEST_CONTEXT Context
+ )
+{
+ EFI_STATUS Status;
+ INT64 Multiplicand;
+ INT64 Multiplier;
+ INT64 Result;
+
+ //
+ // If the result of multiplication doesn't overflow MAX_INT64 and doesn't
+ // underflow MIN_UINT64, it will succeed
+ //
+ Multiplicand = 0x123456789;
+ Multiplier = 0x6789abcd;
+ Result = 0;
+ Status = SafeInt64Mult(Multiplicand, Multiplier, &Result);
+ UT_ASSERT_NOT_EFI_ERROR(Status);
+ UT_ASSERT_EQUAL(0x75cd9045220d6bb5, Result);
+
+ //
+ // Otherwise should result in an error status
+ //
+ Multiplicand = 0x123456789;
+ Multiplier = 0xa789abcd;
+ Status = SafeInt64Mult(Multiplicand, Multiplier, &Result);
+ UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
+
+ return UNIT_TEST_PASSED;
+}
+
+/**
+
+ Main fuction sets up the unit test environment
+
+**/
+EFI_STATUS
+EFIAPI
+UefiTestMain (
+ VOID
+ )
+{
+ EFI_STATUS Status;
+ UNIT_TEST_FRAMEWORK_HANDLE Framework;
+ UNIT_TEST_SUITE_HANDLE ConversionTestSuite;
+ UNIT_TEST_SUITE_HANDLE AdditionSubtractionTestSuite;
+ UNIT_TEST_SUITE_HANDLE MultiplicationTestSuite;
+
+ Framework = NULL;
+ ConversionTestSuite = NULL;
+ AdditionSubtractionTestSuite = NULL;
+ MultiplicationTestSuite = NULL;
+
+ DEBUG((DEBUG_INFO, "%a v%a\n", UNIT_TEST_NAME, UNIT_TEST_VERSION));
+
+ //
+ // Start setting up the test framework for running the tests.
+ //
+ Status = InitUnitTestFramework (&Framework, UNIT_TEST_NAME, gEfiCallerBaseName, UNIT_TEST_VERSION);
+ if (EFI_ERROR(Status)) {
+ DEBUG((DEBUG_ERROR, "Failed in InitUnitTestFramework. Status = %r\n", Status));
+ goto EXIT;
+ }
+
+ ///
+ // Test the conversion functions
+ //
+ Status = CreateUnitTestSuite (&ConversionTestSuite, Framework, "Int Safe Conversions Test Suite", "Common.SafeInt.Convert", NULL, NULL);
+ if (EFI_ERROR(Status)) {
+ DEBUG((DEBUG_ERROR, "Failed in CreateUnitTestSuite for Conversions Test Suite\n"));
+ Status = EFI_OUT_OF_RESOURCES;
+ goto EXIT;
+ }
+ AddTestCase(ConversionTestSuite, "Test SafeInt8ToUint8", "TestSafeInt8ToUint8", TestSafeInt8ToUint8, NULL, NULL, NULL);
+ AddTestCase(ConversionTestSuite, "Test SafeInt8ToUint16", "TestSafeInt8ToUint16", TestSafeInt8ToUint16, NULL, NULL, NULL);
+ AddTestCase(ConversionTestSuite, "Test SafeInt8ToUint32", "TestSafeInt8ToUint32", TestSafeInt8ToUint32, NULL, NULL, NULL);
+ AddTestCase(ConversionTestSuite, "Test SafeInt8ToUintn", "TestSafeInt8ToUintn", TestSafeInt8ToUintn, NULL, NULL, NULL);
+ AddTestCase(ConversionTestSuite, "Test SafeInt8ToUint64", "TestSafeInt8ToUint64", TestSafeInt8ToUint64, NULL, NULL, NULL);
+ AddTestCase(ConversionTestSuite, "Test SafeUint8ToInt8", "TestSafeUint8ToInt8", TestSafeUint8ToInt8, NULL, NULL, NULL);
+ AddTestCase(ConversionTestSuite, "Test SafeUint8ToChar8", "TestSafeUint8ToChar8", TestSafeUint8ToChar8, NULL, NULL, NULL);
+ AddTestCase(ConversionTestSuite, "Test SafeInt16ToInt8", "TestSafeInt16ToInt8", TestSafeInt16ToInt8, NULL, NULL, NULL);
+ AddTestCase(ConversionTestSuite, "Test SafeInt16ToChar8", "TestSafeInt16ToChar8", TestSafeInt16ToChar8, NULL, NULL, NULL);
+ AddTestCase(ConversionTestSuite, "Test SafeInt16ToUint8", "TestSafeInt16ToUint8", TestSafeInt16ToUint8, NULL, NULL, NULL);
+ AddTestCase(ConversionTestSuite, "Test SafeInt16ToUint16", "TestSafeInt16ToUint16", TestSafeInt16ToUint16, NULL, NULL, NULL);
+ AddTestCase(ConversionTestSuite, "Test SafeInt16ToUint32", "TestSafeInt16ToUint32", TestSafeInt16ToUint32, NULL, NULL, NULL);
+ AddTestCase(ConversionTestSuite, "Test SafeInt16ToUintn", "TestSafeInt16ToUintn", TestSafeInt16ToUintn, NULL, NULL, NULL);
+ AddTestCase(ConversionTestSuite, "Test SafeInt16ToUint64", "TestSafeInt16ToUint64", TestSafeInt16ToUint64, NULL, NULL, NULL);
+ AddTestCase(ConversionTestSuite, "Test SafeUint16ToInt8", "TestSafeUint16ToInt8", TestSafeUint16ToInt8, NULL, NULL, NULL);
+ AddTestCase(ConversionTestSuite, "Test SafeUint16ToChar8", "TestSafeUint16ToChar8", TestSafeUint16ToChar8, NULL, NULL, NULL);
+ AddTestCase(ConversionTestSuite, "Test SafeUint16ToUint8", "TestSafeUint16ToUint8", TestSafeUint16ToUint8, NULL, NULL, NULL);
+ AddTestCase(ConversionTestSuite, "Test SafeUint16ToInt16", "TestSafeUint16ToInt16", TestSafeUint16ToInt16, NULL, NULL, NULL);
+ AddTestCase(ConversionTestSuite, "Test SafeInt32ToInt8", "TestSafeInt32ToInt8", TestSafeInt32ToInt8, NULL, NULL, NULL);
+ AddTestCase(ConversionTestSuite, "Test SafeInt32ToChar8", "TestSafeInt32ToChar8", TestSafeInt32ToChar8, NULL, NULL, NULL);
+ AddTestCase(ConversionTestSuite, "Test SafeInt32ToUint8", "TestSafeInt32ToUint8", TestSafeInt32ToUint8, NULL, NULL, NULL);
+ AddTestCase(ConversionTestSuite, "Test SafeInt32ToInt16", "TestSafeInt32ToInt16", TestSafeInt32ToInt16, NULL, NULL, NULL);
+ AddTestCase(ConversionTestSuite, "Test SafeInt32ToUint16", "TestSafeInt32ToUint16", TestSafeInt32ToUint16, NULL, NULL, NULL);
+ AddTestCase(ConversionTestSuite, "Test SafeInt32ToUint32", "TestSafeInt32ToUint32", TestSafeInt32ToUint32, NULL, NULL, NULL);
+ AddTestCase(ConversionTestSuite, "Test SafeInt32ToUintn", "TestSafeInt32ToUintn", TestSafeInt32ToUintn, NULL, NULL, NULL);
+ AddTestCase(ConversionTestSuite, "Test SafeInt32ToUint64", "TestSafeInt32ToUint64", TestSafeInt32ToUint64, NULL, NULL, NULL);
+ AddTestCase(ConversionTestSuite, "Test SafeUint32ToInt8", "TestSafeUint32ToInt8", TestSafeUint32ToInt8, NULL, NULL, NULL);
+ AddTestCase(ConversionTestSuite, "Test SafeUint32ToChar8", "TestSafeUint32ToChar8", TestSafeUint32ToChar8, NULL, NULL, NULL);
+ AddTestCase(ConversionTestSuite, "Test SafeUint32ToUint8", "TestSafeUint32ToUint8", TestSafeUint32ToUint8, NULL, NULL, NULL);
+ AddTestCase(ConversionTestSuite, "Test SafeUint32ToInt16", "TestSafeUint32ToInt16", TestSafeUint32ToInt16, NULL, NULL, NULL);
+ AddTestCase(ConversionTestSuite, "Test SafeUint32ToUint16", "TestSafeUint32ToUint16", TestSafeUint32ToUint16, NULL, NULL, NULL);
+ AddTestCase(ConversionTestSuite, "Test SafeUint32ToInt32", "TestSafeUint32ToInt32", TestSafeUint32ToInt32, NULL, NULL, NULL);
+ AddTestCase(ConversionTestSuite, "Test SafeUint32ToIntn", "TestSafeUint32ToIntn", TestSafeUint32ToIntn, NULL, NULL, NULL);
+ AddTestCase(ConversionTestSuite, "Test SafeIntnToInt8", "TestSafeIntnToInt8", TestSafeIntnToInt8, NULL, NULL, NULL);
+ AddTestCase(ConversionTestSuite, "Test SafeIntnToChar8", "TestSafeIntnToChar8", TestSafeIntnToChar8, NULL, NULL, NULL);
+ AddTestCase(ConversionTestSuite, "Test SafeIntnToUint8", "TestSafeIntnToUint8", TestSafeIntnToUint8, NULL, NULL, NULL);
+ AddTestCase(ConversionTestSuite, "Test SafeIntnToInt16", "TestSafeIntnToInt16", TestSafeIntnToInt16, NULL, NULL, NULL);
+ AddTestCase(ConversionTestSuite, "Test SafeIntnToUint16", "TestSafeIntnToUint16", TestSafeIntnToUint16, NULL, NULL, NULL);
+ AddTestCase(ConversionTestSuite, "Test SafeIntnToInt32", "TestSafeIntnToInt32", TestSafeIntnToInt32, NULL, NULL, NULL);
+ AddTestCase(ConversionTestSuite, "Test SafeIntnToUint32", "TestSafeIntnToUint32", TestSafeIntnToUint32, NULL, NULL, NULL);
+ AddTestCase(ConversionTestSuite, "Test SafeIntnToUintn", "TestSafeIntnToUintn", TestSafeIntnToUintn, NULL, NULL, NULL);
+ AddTestCase(ConversionTestSuite, "Test SafeIntnToUint64", "TestSafeIntnToUint64", TestSafeIntnToUint64, NULL, NULL, NULL);
+ AddTestCase(ConversionTestSuite, "Test SafeUintnToInt8", "TestSafeUintnToInt8", TestSafeUintnToInt8, NULL, NULL, NULL);
+ AddTestCase(ConversionTestSuite, "Test SafeUintnToChar8", "TestSafeUintnToChar8", TestSafeUintnToChar8, NULL, NULL, NULL);
+ AddTestCase(ConversionTestSuite, "Test SafeUintnToUint8", "TestSafeUintnToUint8", TestSafeUintnToUint8, NULL, NULL, NULL);
+ AddTestCase(ConversionTestSuite, "Test SafeUintnToInt16", "TestSafeUintnToInt16", TestSafeUintnToInt16, NULL, NULL, NULL);
+ AddTestCase(ConversionTestSuite, "Test SafeUintnToUint16", "TestSafeUintnToUint16", TestSafeUintnToUint16, NULL, NULL, NULL);
+ AddTestCase(ConversionTestSuite, "Test SafeUintnToInt32", "TestSafeUintnToInt32", TestSafeUintnToInt32, NULL, NULL, NULL);
+ AddTestCase(ConversionTestSuite, "Test SafeUintnToUint32", "TestSafeUintnToUint32", TestSafeUintnToUint32, NULL, NULL, NULL);
+ AddTestCase(ConversionTestSuite, "Test SafeUintnToIntn", "TestSafeUintnToIntn", TestSafeUintnToIntn, NULL, NULL, NULL);
+ AddTestCase(ConversionTestSuite, "Test SafeUintnToInt64", "TestSafeUintnToInt64", TestSafeUintnToInt64, NULL, NULL, NULL);
+ AddTestCase(ConversionTestSuite, "Test SafeInt64ToInt8", "TestSafeInt64ToInt8", TestSafeInt64ToInt8, NULL, NULL, NULL);
+ AddTestCase(ConversionTestSuite, "Test SafeInt64ToChar8", "TestSafeInt64ToChar8", TestSafeInt64ToChar8, NULL, NULL, NULL);
+ AddTestCase(ConversionTestSuite, "Test SafeInt64ToUint8", "TestSafeInt64ToUint8", TestSafeInt64ToUint8, NULL, NULL, NULL);
+ AddTestCase(ConversionTestSuite, "Test SafeInt64ToInt16", "TestSafeInt64ToInt16", TestSafeInt64ToInt16, NULL, NULL, NULL);
+ AddTestCase(ConversionTestSuite, "Test SafeInt64ToUint16", "TestSafeInt64ToUint16", TestSafeInt64ToUint16, NULL, NULL, NULL);
+ AddTestCase(ConversionTestSuite, "Test SafeInt64ToInt32", "TestSafeInt64ToInt32", TestSafeInt64ToInt32, NULL, NULL, NULL);
+ AddTestCase(ConversionTestSuite, "Test SafeInt64ToUint32", "TestSafeInt64ToUint32", TestSafeInt64ToUint32, NULL, NULL, NULL);
+ AddTestCase(ConversionTestSuite, "Test SafeInt64ToIntn", "TestSafeInt64ToIntn", TestSafeInt64ToIntn, NULL, NULL, NULL);
+ AddTestCase(ConversionTestSuite, "Test SafeInt64ToUintn", "TestSafeInt64ToUintn", TestSafeInt64ToUintn, NULL, NULL, NULL);
+ AddTestCase(ConversionTestSuite, "Test SafeInt64ToUint64", "TestSafeInt64ToUint64", TestSafeInt64ToUint64, NULL, NULL, NULL);
+ AddTestCase(ConversionTestSuite, "Test SafeUint64ToInt8", "TestSafeUint64ToInt8", TestSafeUint64ToInt8, NULL, NULL, NULL);
+ AddTestCase(ConversionTestSuite, "Test SafeUint64ToChar8", "TestSafeUint64ToChar8", TestSafeUint64ToChar8, NULL, NULL, NULL);
+ AddTestCase(ConversionTestSuite, "Test SafeUint64ToUint8", "TestSafeUint64ToUint8", TestSafeUint64ToUint8, NULL, NULL, NULL);
+ AddTestCase(ConversionTestSuite, "Test SafeUint64ToInt16", "TestSafeUint64ToInt16", TestSafeUint64ToInt16, NULL, NULL, NULL);
+ AddTestCase(ConversionTestSuite, "Test SafeUint64ToUint16", "TestSafeUint64ToUint16", TestSafeUint64ToUint16, NULL, NULL, NULL);
+ AddTestCase(ConversionTestSuite, "Test SafeUint64ToInt32", "TestSafeUint64ToInt32", TestSafeUint64ToInt32, NULL, NULL, NULL);
+ AddTestCase(ConversionTestSuite, "Test SafeUint64ToUint32", "TestSafeUint64ToUint32", TestSafeUint64ToUint32, NULL, NULL, NULL);
+ AddTestCase(ConversionTestSuite, "Test SafeUint64ToIntn", "TestSafeUint64ToIntn", TestSafeUint64ToIntn, NULL, NULL, NULL);
+ AddTestCase(ConversionTestSuite, "Test SafeUint64ToUintn", "TestSafeUint64ToUintn", TestSafeUint64ToUintn, NULL, NULL, NULL);
+ AddTestCase(ConversionTestSuite, "Test SafeUint64ToInt64", "TestSafeUint64ToInt64", TestSafeUint64ToInt64, NULL, NULL, NULL);
+
+ //
+ // Test the addition and subtraction functions
+ //
+ Status = CreateUnitTestSuite(&AdditionSubtractionTestSuite, Framework, "Int Safe Add/Subtract Test Suite", "Common.SafeInt.AddSubtract", NULL, NULL);
+ if (EFI_ERROR(Status)) {
+ DEBUG((DEBUG_ERROR, "Failed in CreateUnitTestSuite for Int Safe Add/Subtract Test Suite\n"));
+ Status = EFI_OUT_OF_RESOURCES;
+ goto EXIT;
+ }
+ AddTestCase(AdditionSubtractionTestSuite, "Test SafeUint8Add", "TestSafeUint8Add", TestSafeUint8Add, NULL, NULL, NULL);
+ AddTestCase(AdditionSubtractionTestSuite, "Test SafeUint16Add", "TestSafeUint16Add", TestSafeUint16Add, NULL, NULL, NULL);
+ AddTestCase(AdditionSubtractionTestSuite, "Test SafeUint32Add", "TestSafeUint32Add", TestSafeUint32Add, NULL, NULL, NULL);
+ AddTestCase(AdditionSubtractionTestSuite, "Test SafeUintnAdd", "TestSafeUintnAdd", TestSafeUintnAdd, NULL, NULL, NULL);
+ AddTestCase(AdditionSubtractionTestSuite, "Test SafeUint64Add", "TestSafeUint64Add", TestSafeUint64Add, NULL, NULL, NULL);
+ AddTestCase(AdditionSubtractionTestSuite, "Test SafeInt8Add", "TestSafeInt8Add", TestSafeInt8Add, NULL, NULL, NULL);
+ AddTestCase(AdditionSubtractionTestSuite, "Test SafeInt16Add", "TestSafeInt16Add", TestSafeInt16Add, NULL, NULL, NULL);
+ AddTestCase(AdditionSubtractionTestSuite, "Test SafeInt32Add", "TestSafeInt32Add", TestSafeInt32Add, NULL, NULL, NULL);
+ AddTestCase(AdditionSubtractionTestSuite, "Test SafeIntnAdd", "TestSafeIntnAdd", TestSafeIntnAdd, NULL, NULL, NULL);
+ AddTestCase(AdditionSubtractionTestSuite, "Test SafeInt64Add", "TestSafeInt64Add", TestSafeInt64Add, NULL, NULL, NULL);
+ AddTestCase(AdditionSubtractionTestSuite, "Test SafeUint8Sub", "TestSafeUint8Sub", TestSafeUint8Sub, NULL, NULL, NULL);
+ AddTestCase(AdditionSubtractionTestSuite, "Test SafeUint16Sub", "TestSafeUint16Sub", TestSafeUint16Sub, NULL, NULL, NULL);
+ AddTestCase(AdditionSubtractionTestSuite, "Test SafeUint32Sub", "TestSafeUint32Sub", TestSafeUint32Sub, NULL, NULL, NULL);
+ AddTestCase(AdditionSubtractionTestSuite, "Test SafeUintnSub", "TestSafeUintnSub", TestSafeUintnSub, NULL, NULL, NULL);
+ AddTestCase(AdditionSubtractionTestSuite, "Test SafeUint64Sub", "TestSafeUint64Sub", TestSafeUint64Sub, NULL, NULL, NULL);
+ AddTestCase(AdditionSubtractionTestSuite, "Test SafeInt8Sub", "TestSafeInt8Sub", TestSafeInt8Sub, NULL, NULL, NULL);
+ AddTestCase(AdditionSubtractionTestSuite, "Test SafeInt16Sub", "TestSafeInt16Sub", TestSafeInt16Sub, NULL, NULL, NULL);
+ AddTestCase(AdditionSubtractionTestSuite, "Test SafeInt32Sub", "TestSafeInt32Sub", TestSafeInt32Sub, NULL, NULL, NULL);
+ AddTestCase(AdditionSubtractionTestSuite, "Test SafeIntnSub", "TestSafeIntnSub", TestSafeIntnSub, NULL, NULL, NULL);
+ AddTestCase(AdditionSubtractionTestSuite, "Test SafeInt64Sub", "TestSafeInt64Sub", TestSafeInt64Sub, NULL, NULL, NULL);
+
+ //
+ // Test the multiplication functions
+ //
+ Status = CreateUnitTestSuite(&MultiplicationTestSuite, Framework, "Int Safe Multiply Test Suite", "Common.SafeInt.Multiply", NULL, NULL);
+ if (EFI_ERROR(Status)) {
+ DEBUG((DEBUG_ERROR, "Failed in CreateUnitTestSuite for Int Safe Multiply Test Suite\n"));
+ Status = EFI_OUT_OF_RESOURCES;
+ goto EXIT;
+ }
+ AddTestCase(MultiplicationTestSuite, "Test SafeUint8Mult", "TestSafeUint8Mult", TestSafeUint8Mult, NULL, NULL, NULL);
+ AddTestCase(MultiplicationTestSuite, "Test SafeUint16Mult", "TestSafeUint16Mult", TestSafeUint16Mult, NULL, NULL, NULL);
+ AddTestCase(MultiplicationTestSuite, "Test SafeUint32Mult", "TestSafeUint32Mult", TestSafeUint32Mult, NULL, NULL, NULL);
+ AddTestCase(MultiplicationTestSuite, "Test SafeUintnMult", "TestSafeUintnMult", TestSafeUintnMult, NULL, NULL, NULL);
+ AddTestCase(MultiplicationTestSuite, "Test SafeUint64Mult", "TestSafeUint64Mult", TestSafeUint64Mult, NULL, NULL, NULL);
+ AddTestCase(MultiplicationTestSuite, "Test SafeInt8Mult", "TestSafeInt8Mult", TestSafeInt8Mult, NULL, NULL, NULL);
+ AddTestCase(MultiplicationTestSuite, "Test SafeInt16Mult", "TestSafeInt16Mult", TestSafeInt16Mult, NULL, NULL, NULL);
+ AddTestCase(MultiplicationTestSuite, "Test SafeInt32Mult", "TestSafeInt32Mult", TestSafeInt32Mult, NULL, NULL, NULL);
+ AddTestCase(MultiplicationTestSuite, "Test SafeIntnMult", "TestSafeIntnMult", TestSafeIntnMult, NULL, NULL, NULL);
+ AddTestCase(MultiplicationTestSuite, "Test SafeInt64Mult", "TestSafeInt64Mult", TestSafeInt64Mult, NULL, NULL, NULL);
+
+ //
+ // Execute the tests.
+ //
+ Status = RunAllTestSuites(Framework);
+
+EXIT:
+ if (Framework != NULL) {
+ FreeUnitTestFramework(Framework);
+ }
+
+ return Status;
+}
+
+EFI_STATUS
+EFIAPI
+PeiEntryPoint (
+ IN EFI_PEI_FILE_HANDLE FileHandle,
+ IN CONST EFI_PEI_SERVICES **PeiServices
+ )
+{
+ return UefiTestMain ();
+}
+
+EFI_STATUS
+EFIAPI
+DxeEntryPoint (
+ IN EFI_HANDLE ImageHandle,
+ IN EFI_SYSTEM_TABLE *SystemTable
+ )
+{
+ return UefiTestMain ();
+}
+
+int
+main (
+ int argc,
+ char *argv[]
+ )
+{
+ return UefiTestMain ();
+}
diff --git a/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntLib.h b/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntLib.h
new file mode 100644
index 0000000000..7957c99a85
--- /dev/null
+++ b/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntLib.h
@@ -0,0 +1,123 @@
+/** @file
+ UEFI OS based application for unit testing the SafeIntLib.
+
+ Copyright (c) Microsoft Corporation.<BR>
+ Copyright (c) 2018 - 2020, Intel Corporation. All rights reserved.<BR>
+ SPDX-License-Identifier: BSD-2-Clause-Patent
+
+**/
+
+#ifndef _TEST_BASE_SAFE_INT_LIB_H_
+#define _TEST_BASE_SAFE_INT_LIB_H_
+
+#include <PiPei.h>
+#include <Uefi.h>
+#include <Library/UefiLib.h>
+#include <Library/DebugLib.h>
+#include <Library/MemoryAllocationLib.h>
+#include <Library/UnitTestLib.h>
+#include <Library/SafeIntLib.h>
+
+UNIT_TEST_STATUS
+EFIAPI
+TestSafeInt32ToUintn(
+ IN UNIT_TEST_CONTEXT Context
+ );
+
+UNIT_TEST_STATUS
+EFIAPI
+TestSafeUint32ToIntn(
+ IN UNIT_TEST_CONTEXT Context
+ );
+
+UNIT_TEST_STATUS
+EFIAPI
+TestSafeIntnToInt32(
+ IN UNIT_TEST_CONTEXT Context
+ );
+
+UNIT_TEST_STATUS
+EFIAPI
+TestSafeIntnToUint32(
+ IN UNIT_TEST_CONTEXT Context
+ );
+
+UNIT_TEST_STATUS
+EFIAPI
+TestSafeUintnToUint32(
+ IN UNIT_TEST_CONTEXT Context
+ );
+
+UNIT_TEST_STATUS
+EFIAPI
+TestSafeUintnToIntn(
+ IN UNIT_TEST_CONTEXT Context
+ );
+
+UNIT_TEST_STATUS
+EFIAPI
+TestSafeUintnToInt64(
+ IN UNIT_TEST_CONTEXT Context
+ );
+
+UNIT_TEST_STATUS
+EFIAPI
+TestSafeInt64ToIntn(
+ IN UNIT_TEST_CONTEXT Context
+ );
+
+UNIT_TEST_STATUS
+EFIAPI
+TestSafeInt64ToUintn(
+ IN UNIT_TEST_CONTEXT Context
+ );
+
+UNIT_TEST_STATUS
+EFIAPI
+TestSafeUint64ToIntn(
+ IN UNIT_TEST_CONTEXT Context
+ );
+
+UNIT_TEST_STATUS
+EFIAPI
+TestSafeUint64ToUintn(
+ IN UNIT_TEST_CONTEXT Context
+ );
+
+UNIT_TEST_STATUS
+EFIAPI
+TestSafeUintnAdd(
+ IN UNIT_TEST_CONTEXT Context
+ );
+
+UNIT_TEST_STATUS
+EFIAPI
+TestSafeIntnAdd(
+ IN UNIT_TEST_CONTEXT Context
+ );
+
+UNIT_TEST_STATUS
+EFIAPI
+TestSafeUintnSub(
+ IN UNIT_TEST_CONTEXT Context
+ );
+
+UNIT_TEST_STATUS
+EFIAPI
+TestSafeIntnSub(
+ IN UNIT_TEST_CONTEXT Context
+ );
+
+UNIT_TEST_STATUS
+EFIAPI
+TestSafeUintnMult(
+ IN UNIT_TEST_CONTEXT Context
+ );
+
+UNIT_TEST_STATUS
+EFIAPI
+TestSafeIntnMult(
+ IN UNIT_TEST_CONTEXT Context
+ );
+
+#endif
diff --git a/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntLib.uni b/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntLib.uni
new file mode 100644
index 0000000000..956835c30d
--- /dev/null
+++ b/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntLib.uni
@@ -0,0 +1,13 @@
+// /** @file
+// Application that Unit Tests the SafeIntLib
+//
+// Copyright (c) 2020, Intel Corporation. All rights reserved.<BR>
+//
+// SPDX-License-Identifier: BSD-2-Clause-Patent
+//
+// **/
+
+#string STR_MODULE_ABSTRACT #language en-US "Application that Unit Tests the SafeIntLib"
+
+#string STR_MODULE_DESCRIPTION #language en-US "Application that Unit Tests the SafeIntLib."
+
diff --git a/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntLibDxe.inf b/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntLibDxe.inf
new file mode 100644
index 0000000000..de67b04bd5
--- /dev/null
+++ b/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntLibDxe.inf
@@ -0,0 +1,45 @@
+## @file
+# DXE Driver that Unit Tests the SafeIntLib
+#
+# Copyright (c) Microsoft Corporation.<BR>
+# Copyright (c) 2019 - 2020, Intel Corporation. All rights reserved.<BR>
+# SPDX-License-Identifier: BSD-2-Clause-Patent
+##
+
+[Defines]
+ INF_VERSION = 0x00010005
+ BASE_NAME = TestBaseSafeIntLibDxe
+ MODULE_UNI_FILE = TestBaseSafeIntLib.uni
+ FILE_GUID = 9729DB60-FB9D-4625-9EE1-93B21EC246B8
+ MODULE_TYPE = DXE_DRIVER
+ VERSION_STRING = 1.0
+ ENTRY_POINT = DxeEntryPoint
+
+#
+# The following information is for reference only and not required by the build tools.
+#
+# VALID_ARCHITECTURES = IA32 X64
+#
+
+[Sources]
+ TestBaseSafeIntLib.c
+ TestBaseSafeIntLib.h
+
+[Sources.Ia32, Sources.ARM]
+ SafeIntLibUintnIntnUnitTests32.c
+
+[Sources.X64, Sources.AARCH64]
+ SafeIntLibUintnIntnUnitTests64.c
+
+[Packages]
+ MdePkg/MdePkg.dec
+
+[LibraryClasses]
+ UefiDriverEntryPoint
+ BaseLib
+ DebugLib
+ SafeIntLib
+ UnitTestLib
+
+[Depex]
+ TRUE
diff --git a/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntLibHost.inf b/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntLibHost.inf
new file mode 100644
index 0000000000..35c93fdeac
--- /dev/null
+++ b/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntLibHost.inf
@@ -0,0 +1,40 @@
+## @file
+# Host OS based Application that Unit Tests the SafeIntLib
+#
+# Copyright (c) Microsoft Corporation.<BR>
+# Copyright (c) 2019 - 2020, Intel Corporation. All rights reserved.<BR>
+# SPDX-License-Identifier: BSD-2-Clause-Patent
+##
+
+[Defines]
+ INF_VERSION = 0x00010005
+ BASE_NAME = TestBaseSafeIntLibHost
+ MODULE_UNI_FILE = TestBaseSafeIntLib.uni
+ FILE_GUID = 95487689-9E30-41AD-B773-3650C94BCBE2
+ MODULE_TYPE = HOST_APPLICATION
+ VERSION_STRING = 1.0
+
+#
+# The following information is for reference only and not required by the build tools.
+#
+# VALID_ARCHITECTURES = IA32 X64
+#
+
+[Sources]
+ TestBaseSafeIntLib.c
+ TestBaseSafeIntLib.h
+
+[Sources.Ia32, Sources.ARM]
+ SafeIntLibUintnIntnUnitTests32.c
+
+[Sources.X64, Sources.AARCH64]
+ SafeIntLibUintnIntnUnitTests64.c
+
+[Packages]
+ MdePkg/MdePkg.dec
+
+[LibraryClasses]
+ BaseLib
+ DebugLib
+ SafeIntLib
+ UnitTestLib
diff --git a/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntLibPei.inf b/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntLibPei.inf
new file mode 100644
index 0000000000..c8ba4f44ef
--- /dev/null
+++ b/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntLibPei.inf
@@ -0,0 +1,45 @@
+## @file
+# PEIM that Unit Tests the SafeIntLib
+#
+# Copyright (c) Microsoft Corporation.<BR>
+# Copyright (c) 2019 - 2020, Intel Corporation. All rights reserved.<BR>
+# SPDX-License-Identifier: BSD-2-Clause-Patent
+##
+
+[Defines]
+ INF_VERSION = 0x00010005
+ BASE_NAME = TestBaseSafeIntLibPei
+ MODULE_UNI_FILE = TestBaseSafeIntLib.uni
+ FILE_GUID = 7D910602-ED53-45E6-826E-8266705B9734
+ MODULE_TYPE = PEIM
+ VERSION_STRING = 1.0
+ ENTRY_POINT = PeiEntryPoint
+
+#
+# The following information is for reference only and not required by the build tools.
+#
+# VALID_ARCHITECTURES = IA32 X64
+#
+
+[Sources]
+ TestBaseSafeIntLib.c
+ TestBaseSafeIntLib.h
+
+[Sources.Ia32, Sources.ARM]
+ SafeIntLibUintnIntnUnitTests32.c
+
+[Sources.X64, Sources.AARCH64]
+ SafeIntLibUintnIntnUnitTests64.c
+
+[Packages]
+ MdePkg/MdePkg.dec
+
+[LibraryClasses]
+ PeimEntryPoint
+ BaseLib
+ DebugLib
+ SafeIntLib
+ UnitTestLib
+
+[Depex]
+ TRUE
diff --git a/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntLibSmm.inf b/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntLibSmm.inf
new file mode 100644
index 0000000000..df7288501d
--- /dev/null
+++ b/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntLibSmm.inf
@@ -0,0 +1,45 @@
+## @file
+# SMM Driver that Unit Tests the SafeIntLib
+#
+# Copyright (c) Microsoft Corporation.<BR>
+# Copyright (c) 2019 - 2020, Intel Corporation. All rights reserved.<BR>
+# SPDX-License-Identifier: BSD-2-Clause-Patent
+##
+
+[Defines]
+ INF_VERSION = 0x00010005
+ BASE_NAME = TestBaseSafeIntLibSmm
+ MODULE_UNI_FILE = TestBaseSafeIntLib.uni
+ FILE_GUID = 2F2A1907-B1B4-4E33-8B83-62A60AB4F0D4
+ MODULE_TYPE = DXE_SMM_DRIVER
+ VERSION_STRING = 1.0
+ ENTRY_POINT = DxeEntryPoint
+
+#
+# The following information is for reference only and not required by the build tools.
+#
+# VALID_ARCHITECTURES = IA32 X64
+#
+
+[Sources]
+ TestBaseSafeIntLib.c
+ TestBaseSafeIntLib.h
+
+[Sources.Ia32, Sources.ARM]
+ SafeIntLibUintnIntnUnitTests32.c
+
+[Sources.X64, Sources.AARCH64]
+ SafeIntLibUintnIntnUnitTests64.c
+
+[Packages]
+ MdePkg/MdePkg.dec
+
+[LibraryClasses]
+ UefiDriverEntryPoint
+ BaseLib
+ DebugLib
+ SafeIntLib
+ UnitTestLib
+
+[Depex]
+ TRUE
diff --git a/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntLibUefiShell.inf b/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntLibUefiShell.inf
new file mode 100644
index 0000000000..5a13c1c845
--- /dev/null
+++ b/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntLibUefiShell.inf
@@ -0,0 +1,42 @@
+## @file
+# UEFI Shell based Application that Unit Tests the SafeIntLib
+#
+# Copyright (c) Microsoft Corporation.<BR>
+# Copyright (c) 2019 - 2020, Intel Corporation. All rights reserved.<BR>
+# SPDX-License-Identifier: BSD-2-Clause-Patent
+##
+
+[Defines]
+ INF_VERSION = 0x00010005
+ BASE_NAME = TestBaseSafeIntLibUefiShell
+ MODULE_UNI_FILE = TestBaseSafeIntLib.uni
+ FILE_GUID = 1F91B73E-5B6A-4317-80E8-E7C36A3C7AF4
+ MODULE_TYPE = UEFI_APPLICATION
+ VERSION_STRING = 1.0
+ ENTRY_POINT = DxeEntryPoint
+
+#
+# The following information is for reference only and not required by the build tools.
+#
+# VALID_ARCHITECTURES = IA32 X64
+#
+
+[Sources]
+ TestBaseSafeIntLib.c
+ TestBaseSafeIntLib.h
+
+[Sources.Ia32, Sources.ARM]
+ SafeIntLibUintnIntnUnitTests32.c
+
+[Sources.X64, Sources.AARCH64]
+ SafeIntLibUintnIntnUnitTests64.c
+
+[Packages]
+ MdePkg/MdePkg.dec
+
+[LibraryClasses]
+ UefiApplicationEntryPoint
+ BaseLib
+ DebugLib
+ SafeIntLib
+ UnitTestLib
--
2.21.0.windows.1
-=-=-=-=-=-=-=-=-=-=-=-
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]
-=-=-=-=-=-=-=-=-=-=-=-
Reviewed-by: Bret Barkelew <bret.barkelew@microsoft.com> -=-=-=-=-=-=-=-=-=-=-=- Groups.io Links: You receive all messages sent to this group. View/Reply Online (#53496): https://edk2.groups.io/g/devel/message/53496 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] -=-=-=-=-=-=-=-=-=-=-=-
> -----Original Message-----
> From: devel@edk2.groups.io [mailto:devel@edk2.groups.io] On Behalf Of
> Michael D Kinney
> Sent: Friday, January 24, 2020 10:10 AM
> To: devel@edk2.groups.io
> Cc: Sean Brogan; Bret Barkelew; Gao, Liming
> Subject: [edk2-devel] [Patch 08/11] MdePkg/Test: Add SafeIntLib and
> BaseLib Base64 unit tests
>
> * Add unit tests for SafeIntLib class
> * Add unit tests for BaseLib Base64 conversion APIs.
> * Add Test/MdePkgHostTest.dsc -to build host based unit
> tests
> * Update MdePkg.dsc to build target based tests for
> SafeIntLib and BaseLib
> * Update MdePkg.ci.yaml to build and run host based
> tests for SafeIntLib and BaseLib
Acked-by: Hao A Wu <hao.a.wu@intel.com>
Best Regards,
Hao Wu
>
> Cc: Sean Brogan <sean.brogan@microsoft.com>
> Cc: Bret Barkelew <Bret.Barkelew@microsoft.com>
> Cc: Liming Gao <liming.gao@intel.com>
> Signed-off-by: Michael D Kinney <michael.d.kinney@intel.com>
> ---
> MdePkg/MdePkg.ci.yaml | 19 +-
> MdePkg/MdePkg.dsc | 18 +
> MdePkg/Test/MdePkgHostTest.dsc | 30 +
> .../UnitTest/Library/BaseLib/Base64UnitTest.c | 404 +++
> .../Library/BaseLib/BaseLibUnitTestsHost.inf | 32 +
> .../Library/BaseLib/BaseLibUnitTestsUefi.inf | 33 +
> .../SafeIntLibUintnIntnUnitTests32.c | 540 +++
> .../SafeIntLibUintnIntnUnitTests64.c | 544 +++
> .../BaseSafeIntLib/TestBaseSafeIntLib.c | 3064 +++++++++++++++++
> .../BaseSafeIntLib/TestBaseSafeIntLib.h | 123 +
> .../BaseSafeIntLib/TestBaseSafeIntLib.uni | 13 +
> .../BaseSafeIntLib/TestBaseSafeIntLibDxe.inf | 45 +
> .../BaseSafeIntLib/TestBaseSafeIntLibHost.inf | 40 +
> .../BaseSafeIntLib/TestBaseSafeIntLibPei.inf | 45 +
> .../BaseSafeIntLib/TestBaseSafeIntLibSmm.inf | 45 +
> .../TestBaseSafeIntLibUefiShell.inf | 42 +
> 16 files changed, 5034 insertions(+), 3 deletions(-)
> create mode 100644 MdePkg/Test/MdePkgHostTest.dsc
> create mode 100644
> MdePkg/Test/UnitTest/Library/BaseLib/Base64UnitTest.c
> create mode 100644
> MdePkg/Test/UnitTest/Library/BaseLib/BaseLibUnitTestsHost.inf
> create mode 100644
> MdePkg/Test/UnitTest/Library/BaseLib/BaseLibUnitTestsUefi.inf
> create mode 100644
> MdePkg/Test/UnitTest/Library/BaseSafeIntLib/SafeIntLibUintnIntnUnitTests
> 32.c
> create mode 100644
> MdePkg/Test/UnitTest/Library/BaseSafeIntLib/SafeIntLibUintnIntnUnitTests
> 64.c
> create mode 100644
> MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntLib.c
> create mode 100644
> MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntLib.h
> create mode 100644
> MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntLib.uni
> create mode 100644
> MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntLibDxe.inf
> create mode 100644
> MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntLibHost.inf
> create mode 100644
> MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntLibPei.inf
> create mode 100644
> MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntLibSmm.inf
> create mode 100644
> MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntLibUefiShell.i
> nf
>
> diff --git a/MdePkg/MdePkg.ci.yaml b/MdePkg/MdePkg.ci.yaml
> index 65c4ec3bec..88e490fcb6 100644
> --- a/MdePkg/MdePkg.ci.yaml
> +++ b/MdePkg/MdePkg.ci.yaml
> @@ -10,8 +10,13 @@
> "DscPath": "MdePkg.dsc"
> },
>
> + ## options defined ci/Plugin/HostUnitTestCompilerPlugin
> + "HostUnitTestCompilerPlugin": {
> + "DscPath": "Test/MdePkgHostTest.dsc"
> + },
> +
> ## options defined ci/Plugin/CharEncodingCheck
> -"CharEncodingCheck": {
> + "CharEncodingCheck": {
> "IgnoreFiles": []
> },
>
> @@ -21,7 +26,9 @@
> "MdePkg/MdePkg.dec"
> ],
> # For host based unit tests
> - "AcceptableDependencies-HOST_APPLICATION":[],
> + "AcceptableDependencies-HOST_APPLICATION":[
> + "UnitTestFrameworkPkg/UnitTestFrameworkPkg.dec"
> + ],
> # For UEFI shell based apps
> "AcceptableDependencies-UEFI_APPLICATION":[],
> "IgnoreInf": []
> @@ -29,10 +36,16 @@
>
> ## options defined ci/Plugin/DscCompleteCheck
> "DscCompleteCheck": {
> - "IgnoreInf": [],
> + "IgnoreInf": [""],
> "DscPath": "MdePkg.dsc"
> },
>
> + ## options defined ci/Plugin/HostUnitTestDscCompleteCheck
> + "HostUnitTestDscCompleteCheck": {
> + "IgnoreInf": [""],
> + "DscPath": "Test/MdePkgHostTest.dsc"
> + },
> +
> ## options defined ci/Plugin/GuidCheck
> "GuidCheck": {
> "IgnoreGuidName": [
> diff --git a/MdePkg/MdePkg.dsc b/MdePkg/MdePkg.dsc
> index 0aeafaaacc..87af740853 100644
> --- a/MdePkg/MdePkg.dsc
> +++ b/MdePkg/MdePkg.dsc
> @@ -18,6 +18,8 @@ [Defines]
> BUILD_TARGETS = DEBUG|RELEASE|NOOPT
> SKUID_IDENTIFIER = DEFAULT
>
> +!include UnitTestFrameworkPkg/UnitTestFrameworkPkgTarget.dsc.inc
> +
> [PcdsFeatureFlag]
> gEfiMdePkgTokenSpaceGuid.PcdUgaConsumeSupport|TRUE
>
> @@ -26,6 +28,9 @@ [PcdsFixedAtBuild]
> gEfiMdePkgTokenSpaceGuid.PcdDebugPrintErrorLevel|0x80000000
> gEfiMdePkgTokenSpaceGuid.PcdPciExpressBaseAddress|0xE0000000
>
> +[LibraryClasses]
> + SafeIntLib|MdePkg/Library/BaseSafeIntLib/BaseSafeIntLib.inf
> +
> [Components]
> MdePkg/Library/UefiFileHandleLib/UefiFileHandleLib.inf
> MdePkg/Library/BaseCacheMaintenanceLib/BaseCacheMaintenanceLib.inf
> @@ -115,6 +120,19 @@ [Components]
>
> MdePkg/Library/StandaloneMmDriverEntryPoint/StandaloneMmDriverEntryP
> oint.inf
>
> MdePkg/Library/StandaloneMmServicesTableLib/StandaloneMmServicesTabl
> eLib.inf
>
> + #
> + # Add UEFI Target Based Unit Tests
> + #
> + MdePkg/Test/UnitTest/Library/BaseLib/BaseLibUnitTestsUefi.inf
> +
> + #
> + # Build PEIM, DXE_DRIVER, SMM_DRIVER, UEFI Shell components that test
> SafeIntLib
> + #
> + MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntLibPei.inf
> + MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntLibDxe.inf
> + MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntLibSmm.inf
> +
> MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntLibUefiShell.i
> nf
> +
> [Components.IA32, Components.X64]
> MdePkg/Library/BaseIoLibIntrinsic/BaseIoLibIntrinsic.inf
> MdePkg/Library/BaseIoLibIntrinsic/BaseIoLibIntrinsicSev.inf
> diff --git a/MdePkg/Test/MdePkgHostTest.dsc
> b/MdePkg/Test/MdePkgHostTest.dsc
> new file mode 100644
> index 0000000000..3d677ee75c
> --- /dev/null
> +++ b/MdePkg/Test/MdePkgHostTest.dsc
> @@ -0,0 +1,30 @@
> +## @file
> +# MdePkg DSC file used to build host-based unit tests.
> +#
> +# Copyright (c) 2019 - 2020, Intel Corporation. All rights reserved.<BR>
> +# Copyright (C) Microsoft Corporation.
> +# SPDX-License-Identifier: BSD-2-Clause-Patent
> +#
> +##
> +
> +[Defines]
> + PLATFORM_NAME = MdePkgHostTest
> + PLATFORM_GUID = 50652B4C-88CB-4481-96E8-37F2D0034440
> + PLATFORM_VERSION = 0.1
> + DSC_SPECIFICATION = 0x00010005
> + OUTPUT_DIRECTORY = Build/MdePkg/HostTest
> + SUPPORTED_ARCHITECTURES = IA32|X64
> + BUILD_TARGETS = NOOPT
> + SKUID_IDENTIFIER = DEFAULT
> +
> +!include UnitTestFrameworkPkg/UnitTestFrameworkPkgHost.dsc.inc
> +
> +[LibraryClasses]
> + SafeIntLib|MdePkg/Library/BaseSafeIntLib/BaseSafeIntLib.inf
> +
> +[Components]
> + #
> + # Build HOST_APPLICATION that tests the SafeIntLib
> + #
> + MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntLibHost.inf
> + MdePkg/Test/UnitTest/Library/BaseLib/BaseLibUnitTestsHost.inf
> diff --git a/MdePkg/Test/UnitTest/Library/BaseLib/Base64UnitTest.c
> b/MdePkg/Test/UnitTest/Library/BaseLib/Base64UnitTest.c
> new file mode 100644
> index 0000000000..0ad078155c
> --- /dev/null
> +++ b/MdePkg/Test/UnitTest/Library/BaseLib/Base64UnitTest.c
> @@ -0,0 +1,404 @@
> +/** @file
> + Unit tests of Base64 conversion APIs in BaseLib.
> +
> + Copyright (C) Microsoft Corporation.
> + SPDX-License-Identifier: BSD-2-Clause-Patent
> +
> +**/
> +
> +#include <Uefi.h>
> +#include <Library/BaseLib.h>
> +#include <Library/BaseMemoryLib.h>
> +#include <Library/DebugLib.h>
> +#include <Library/MemoryAllocationLib.h>
> +#include <Library/UnitTestLib.h>
> +
> +#define UNIT_TEST_APP_NAME "BaseLib Unit Test Application"
> +#define UNIT_TEST_APP_VERSION "1.0"
> +
> +/**
> + RFC 4648 https://tools.ietf.org/html/rfc4648 test vectors
> +
> + BASE64("") = ""
> + BASE64("f") = "Zg=="
> + BASE64("fo") = "Zm8="
> + BASE64("foo") = "Zm9v"
> + BASE64("foob") = "Zm9vYg=="
> + BASE64("fooba") = "Zm9vYmE="
> + BASE64("foobar") = "Zm9vYmFy"
> +
> + The test vectors are using ascii strings for the binary data
> + */
> +
> +typedef struct {
> + CHAR8 *TestInput;
> + CHAR8 *TestOutput;
> + EFI_STATUS ExpectedStatus;
> + VOID *BufferToFree;
> + UINTN ExpectedSize;
> +} BASIC_TEST_CONTEXT;
> +
> +#define B64_TEST_1 ""
> +#define BIN_TEST_1 ""
> +
> +#define B64_TEST_2 "Zg=="
> +#define BIN_TEST_2 "f"
> +
> +#define B64_TEST_3 "Zm8="
> +#define BIN_TEST_3 "fo"
> +
> +#define B64_TEST_4 "Zm9v"
> +#define BIN_TEST_4 "foo"
> +
> +#define B64_TEST_5 "Zm9vYg=="
> +#define BIN_TEST_5 "foob"
> +
> +#define B64_TEST_6 "Zm9vYmE="
> +#define BIN_TEST_6 "fooba"
> +
> +#define B64_TEST_7 "Zm9vYmFy"
> +#define BIN_TEST_7 "foobar"
> +
> +// Adds all white space - also ends the last quantum with only spaces
> afterwards
> +#define B64_TEST_8_IN " \t\v Zm9\r\nvYmFy \f "
> +#define BIN_TEST_8 "foobar"
> +
> +// Not a quantum multiple of 4
> +#define B64_ERROR_1 "Zm9vymFy="
> +
> +// Invalid characters in the string
> +#define B64_ERROR_2 "Zm$vymFy"
> +
> +// Too many '=' characters
> +#define B64_ERROR_3 "Z==="
> +
> +// Poorly placed '='
> +#define B64_ERROR_4 "Zm=vYmFy"
> +
> +#define MAX_TEST_STRING_SIZE (200)
> +
> +// ------------------------------------------------ Input----------Output-----------
> Result-------Free--Expected Output Size
> +static BASIC_TEST_CONTEXT mBasicEncodeTest1 = {BIN_TEST_1,
> B64_TEST_1, EFI_SUCCESS, NULL, sizeof(B64_TEST_1)};
> +static BASIC_TEST_CONTEXT mBasicEncodeTest2 = {BIN_TEST_2,
> B64_TEST_2, EFI_SUCCESS, NULL, sizeof(B64_TEST_2)};
> +static BASIC_TEST_CONTEXT mBasicEncodeTest3 = {BIN_TEST_3,
> B64_TEST_3, EFI_SUCCESS, NULL, sizeof(B64_TEST_3)};
> +static BASIC_TEST_CONTEXT mBasicEncodeTest4 = {BIN_TEST_4,
> B64_TEST_4, EFI_SUCCESS, NULL, sizeof(B64_TEST_4)};
> +static BASIC_TEST_CONTEXT mBasicEncodeTest5 = {BIN_TEST_5,
> B64_TEST_5, EFI_SUCCESS, NULL, sizeof(B64_TEST_5)};
> +static BASIC_TEST_CONTEXT mBasicEncodeTest6 = {BIN_TEST_6,
> B64_TEST_6, EFI_SUCCESS, NULL, sizeof(B64_TEST_6)};
> +static BASIC_TEST_CONTEXT mBasicEncodeTest7 = {BIN_TEST_7,
> B64_TEST_7, EFI_SUCCESS, NULL, sizeof(B64_TEST_7)};
> +static BASIC_TEST_CONTEXT mBasicEncodeError1 = {BIN_TEST_7,
> B64_TEST_1, EFI_BUFFER_TOO_SMALL, NULL, sizeof(B64_TEST_7)};
> +
> +static BASIC_TEST_CONTEXT mBasicDecodeTest1 = {B64_TEST_1,
> BIN_TEST_1, EFI_SUCCESS, NULL, sizeof(BIN_TEST_1)-1};
> +static BASIC_TEST_CONTEXT mBasicDecodeTest2 = {B64_TEST_2,
> BIN_TEST_2, EFI_SUCCESS, NULL, sizeof(BIN_TEST_2)-1};
> +static BASIC_TEST_CONTEXT mBasicDecodeTest3 = {B64_TEST_3,
> BIN_TEST_3, EFI_SUCCESS, NULL, sizeof(BIN_TEST_3)-1};
> +static BASIC_TEST_CONTEXT mBasicDecodeTest4 = {B64_TEST_4,
> BIN_TEST_4, EFI_SUCCESS, NULL, sizeof(BIN_TEST_4)-1};
> +static BASIC_TEST_CONTEXT mBasicDecodeTest5 = {B64_TEST_5,
> BIN_TEST_5, EFI_SUCCESS, NULL, sizeof(BIN_TEST_5)-1};
> +static BASIC_TEST_CONTEXT mBasicDecodeTest6 = {B64_TEST_6,
> BIN_TEST_6, EFI_SUCCESS, NULL, sizeof(BIN_TEST_6)-1};
> +static BASIC_TEST_CONTEXT mBasicDecodeTest7 = {B64_TEST_7,
> BIN_TEST_7, EFI_SUCCESS, NULL, sizeof(BIN_TEST_7)-1};
> +static BASIC_TEST_CONTEXT mBasicDecodeTest8 = {B64_TEST_8_IN,
> BIN_TEST_8, EFI_SUCCESS, NULL, sizeof(BIN_TEST_8)-1};
> +
> +static BASIC_TEST_CONTEXT mBasicDecodeError1 = {B64_ERROR_1,
> B64_ERROR_1, EFI_INVALID_PARAMETER, NULL, 0};
> +static BASIC_TEST_CONTEXT mBasicDecodeError2 = {B64_ERROR_2,
> B64_ERROR_2, EFI_INVALID_PARAMETER, NULL, 0};
> +static BASIC_TEST_CONTEXT mBasicDecodeError3 = {B64_ERROR_3,
> B64_ERROR_3, EFI_INVALID_PARAMETER, NULL, 0};
> +static BASIC_TEST_CONTEXT mBasicDecodeError4 = {B64_ERROR_4,
> B64_ERROR_4, EFI_INVALID_PARAMETER, NULL, 0};
> +static BASIC_TEST_CONTEXT mBasicDecodeError5 = {B64_TEST_7,
> BIN_TEST_1, EFI_BUFFER_TOO_SMALL, NULL, sizeof(BIN_TEST_7)-1};
> +
> +/**
> + Simple clean up method to make sure tests clean up even if interrupted
> and fail
> + in the middle.
> +**/
> +STATIC
> +VOID
> +EFIAPI
> +CleanUpB64TestContext (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + BASIC_TEST_CONTEXT *Btc;
> +
> + Btc = (BASIC_TEST_CONTEXT *)Context;
> + if (Btc != NULL) {
> + //free string if set
> + if (Btc->BufferToFree != NULL) {
> + FreePool (Btc->BufferToFree);
> + Btc->BufferToFree = NULL;
> + }
> + }
> +}
> +
> +/**
> + Unit test for Base64 encode APIs of BaseLib.
> +
> + @param[in] Context [Optional] An optional paramter that enables:
> + 1) test-case reuse with varied parameters and
> + 2) test-case re-entry for Target tests that need a
> + reboot. This parameter is a VOID* and it is the
> + responsibility of the test author to ensure that the
> + contents are well understood by all test cases that may
> + consume it.
> +
> + @retval UNIT_TEST_PASSED The Unit test has completed and the
> test
> + case was successful.
> + @retval UNIT_TEST_ERROR_TEST_FAILED A test case assertion has failed.
> +**/
> +STATIC
> +UNIT_TEST_STATUS
> +EFIAPI
> +RfcEncodeTest (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + BASIC_TEST_CONTEXT *Btc;
> + CHAR8 *b64String;
> + CHAR8 *binString;
> + UINTN b64StringSize;
> + EFI_STATUS Status;
> + UINT8 *BinData;
> + UINTN BinSize;
> + CHAR8 *b64WorkString;
> + UINTN ReturnSize;
> + INTN CompareStatus;
> + UINTN indx;
> +
> + Btc = (BASIC_TEST_CONTEXT *) Context;
> + binString = Btc->TestInput;
> + b64String = Btc->TestOutput;
> +
> + //
> + // Only testing the the translate functionality, so preallocate the proper
> + // string buffer.
> + //
> +
> + b64StringSize = AsciiStrnSizeS(b64String, MAX_TEST_STRING_SIZE);
> + BinSize = AsciiStrnLenS(binString, MAX_TEST_STRING_SIZE);
> + BinData = (UINT8 *) binString;
> +
> + b64WorkString = (CHAR8 *) AllocatePool(b64StringSize);
> + UT_ASSERT_NOT_NULL(b64WorkString);
> +
> + Btc->BufferToFree = b64WorkString;
> + ReturnSize = b64StringSize;
> +
> + Status = Base64Encode(BinData, BinSize, b64WorkString, &ReturnSize);
> +
> + UT_ASSERT_STATUS_EQUAL(Status, Btc->ExpectedStatus);
> +
> + UT_ASSERT_EQUAL(ReturnSize, Btc->ExpectedSize);
> +
> + if (!EFI_ERROR (Btc->ExpectedStatus)) {
> + if (ReturnSize != 0) {
> + CompareStatus = AsciiStrnCmp (b64String, b64WorkString, ReturnSize);
> + if (CompareStatus != 0) {
> + UT_LOG_ERROR ("b64 string compare error - size=%d\n", ReturnSize);
> + for (indx = 0; indx < ReturnSize; indx++) {
> + UT_LOG_ERROR (" %2.2x", 0xff & b64String[indx]);
> + }
> + UT_LOG_ERROR ("\n b64 work string:\n");
> + for (indx = 0; indx < ReturnSize; indx++) {
> + UT_LOG_ERROR (" %2.2x", 0xff & b64WorkString[indx]);
> + }
> + UT_LOG_ERROR ("\n");
> + }
> + UT_ASSERT_EQUAL (CompareStatus, 0);
> + }
> + }
> +
> + Btc->BufferToFree = NULL;
> + FreePool (b64WorkString);
> + return UNIT_TEST_PASSED;
> +}
> +
> +/**
> + Unit test for Base64 decode APIs of BaseLib.
> +
> + @param[in] Context [Optional] An optional paramter that enables:
> + 1) test-case reuse with varied parameters and
> + 2) test-case re-entry for Target tests that need a
> + reboot. This parameter is a VOID* and it is the
> + responsibility of the test author to ensure that the
> + contents are well understood by all test cases that may
> + consume it.
> +
> + @retval UNIT_TEST_PASSED The Unit test has completed and the
> test
> + case was successful.
> + @retval UNIT_TEST_ERROR_TEST_FAILED A test case assertion has failed.
> +**/
> +STATIC
> +UNIT_TEST_STATUS
> +EFIAPI
> +RfcDecodeTest(
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + BASIC_TEST_CONTEXT *Btc;
> + CHAR8 *b64String;
> + CHAR8 *binString;
> + EFI_STATUS Status;
> + UINTN b64StringLen;
> + UINTN ReturnSize;
> + UINT8 *BinData;
> + UINTN BinSize;
> + INTN CompareStatus;
> + UINTN indx;
> +
> + Btc = (BASIC_TEST_CONTEXT *)Context;
> + b64String = Btc->TestInput;
> + binString = Btc->TestOutput;
> +
> + //
> + // Only testing the the translate functionality
> + //
> +
> + b64StringLen = AsciiStrnLenS (b64String, MAX_TEST_STRING_SIZE);
> + BinSize = AsciiStrnLenS (binString, MAX_TEST_STRING_SIZE);
> +
> + BinData = AllocatePool (BinSize);
> + Btc->BufferToFree = BinData;
> +
> + ReturnSize = BinSize;
> + Status = Base64Decode (b64String, b64StringLen, BinData, &ReturnSize);
> +
> + UT_ASSERT_STATUS_EQUAL (Status, Btc->ExpectedStatus);
> +
> + // If an error is not expected, check the results
> + if (EFI_ERROR (Btc->ExpectedStatus)) {
> + if (Btc->ExpectedStatus == EFI_BUFFER_TOO_SMALL) {
> + UT_ASSERT_EQUAL (ReturnSize, Btc->ExpectedSize);
> + }
> + } else {
> + UT_ASSERT_EQUAL (ReturnSize, Btc->ExpectedSize);
> + if (ReturnSize != 0) {
> + CompareStatus = CompareMem (binString, BinData, ReturnSize);
> + if (CompareStatus != 0) {
> + UT_LOG_ERROR ("bin string compare error - size=%d\n", ReturnSize);
> + for (indx = 0; indx < ReturnSize; indx++) {
> + UT_LOG_ERROR (" %2.2x", 0xff & binString[indx]);
> + }
> + UT_LOG_ERROR ("\nBinData:\n");
> + for (indx = 0; indx < ReturnSize; indx++) {
> + UT_LOG_ERROR (" %2.2x", 0xff & BinData[indx]);
> + }
> + UT_LOG_ERROR ("\n");
> + }
> + UT_ASSERT_EQUAL (CompareStatus, 0);
> + }
> + }
> +
> + Btc->BufferToFree = NULL;
> + FreePool (BinData);
> + return UNIT_TEST_PASSED;
> +}
> +
> +/**
> + Initialze the unit test framework, suite, and unit tests for the
> + Base64 conversion APIs of BaseLib and run the unit tests.
> +
> + @retval EFI_SUCCESS All test cases were dispached.
> + @retval EFI_OUT_OF_RESOURCES There are not enough resources
> available to
> + initialize the unit tests.
> +**/
> +STATIC
> +EFI_STATUS
> +EFIAPI
> +UnitTestingEntry (
> + VOID
> + )
> +{
> + EFI_STATUS Status;
> + UNIT_TEST_FRAMEWORK_HANDLE Fw;
> + UNIT_TEST_SUITE_HANDLE b64EncodeTests;
> + UNIT_TEST_SUITE_HANDLE b64DecodeTests;
> +
> + Fw = NULL;
> +
> + DEBUG ((DEBUG_INFO, "%a v%a\n", UNIT_TEST_APP_NAME,
> UNIT_TEST_APP_VERSION));
> +
> + //
> + // Start setting up the test framework for running the tests.
> + //
> + Status = InitUnitTestFramework (&Fw, UNIT_TEST_APP_NAME,
> gEfiCallerBaseName, UNIT_TEST_APP_VERSION);
> + if (EFI_ERROR (Status)) {
> + DEBUG ((DEBUG_ERROR, "Failed in InitUnitTestFramework. Status
> = %r\n", Status));
> + goto EXIT;
> + }
> +
> + //
> + // Populate the B64 Encode Unit Test Suite.
> + //
> + Status = CreateUnitTestSuite (&b64EncodeTests, Fw, "b64 Encode binary
> to Ascii string", "BaseLib.b64Encode", NULL, NULL);
> + if (EFI_ERROR (Status)) {
> + DEBUG ((DEBUG_ERROR, "Failed in CreateUnitTestSuite for
> b64EncodeTests\n"));
> + Status = EFI_OUT_OF_RESOURCES;
> + goto EXIT;
> + }
> +
> + // --------------Suite-----------Description--------------Class Name----------
> Function--------Pre---Post-------------------Context-----------
> + AddTestCase (b64EncodeTests, "RFC 4686 Test Vector - Empty", "Test1",
> RfcEncodeTest, NULL, CleanUpB64TestContext, &mBasicEncodeTest1);
> + AddTestCase (b64EncodeTests, "RFC 4686 Test Vector - f", "Test2",
> RfcEncodeTest, NULL, CleanUpB64TestContext, &mBasicEncodeTest2);
> + AddTestCase (b64EncodeTests, "RFC 4686 Test Vector - fo", "Test3",
> RfcEncodeTest, NULL, CleanUpB64TestContext, &mBasicEncodeTest3);
> + AddTestCase (b64EncodeTests, "RFC 4686 Test Vector - foo", "Test4",
> RfcEncodeTest, NULL, CleanUpB64TestContext, &mBasicEncodeTest4);
> + AddTestCase (b64EncodeTests, "RFC 4686 Test Vector - foob", "Test5",
> RfcEncodeTest, NULL, CleanUpB64TestContext, &mBasicEncodeTest5);
> + AddTestCase (b64EncodeTests, "RFC 4686 Test Vector - fooba", "Test6",
> RfcEncodeTest, NULL, CleanUpB64TestContext, &mBasicEncodeTest6);
> + AddTestCase (b64EncodeTests, "RFC 4686 Test Vector - foobar", "Test7",
> RfcEncodeTest, NULL, CleanUpB64TestContext, &mBasicEncodeTest7);
> + AddTestCase (b64EncodeTests, "Too small of output buffer", "Error1",
> RfcEncodeTest, NULL, CleanUpB64TestContext, &mBasicEncodeError1);
> + //
> + // Populate the B64 Decode Unit Test Suite.
> + //
> + Status = CreateUnitTestSuite (&b64DecodeTests, Fw, "b64 Decode Ascii
> string to binary", "BaseLib.b64Decode", NULL, NULL);
> + if (EFI_ERROR (Status)) {
> + DEBUG ((DEBUG_ERROR, "Failed in CreateUnitTestSuite for b64Decode
> Tests\n"));
> + Status = EFI_OUT_OF_RESOURCES;
> + goto EXIT;
> + }
> +
> + AddTestCase (b64DecodeTests, "RFC 4686 Test Vector - Empty", "Test1",
> RfcDecodeTest, NULL, CleanUpB64TestContext, &mBasicDecodeTest1);
> + AddTestCase (b64DecodeTests, "RFC 4686 Test Vector - f", "Test2",
> RfcDecodeTest, NULL, CleanUpB64TestContext, &mBasicDecodeTest2);
> + AddTestCase (b64DecodeTests, "RFC 4686 Test Vector - fo", "Test3",
> RfcDecodeTest, NULL, CleanUpB64TestContext, &mBasicDecodeTest3);
> + AddTestCase (b64DecodeTests, "RFC 4686 Test Vector - foo", "Test4",
> RfcDecodeTest, NULL, CleanUpB64TestContext, &mBasicDecodeTest4);
> + AddTestCase (b64DecodeTests, "RFC 4686 Test Vector - foob", "Test5",
> RfcDecodeTest, NULL, CleanUpB64TestContext, &mBasicDecodeTest5);
> + AddTestCase (b64DecodeTests, "RFC 4686 Test Vector - fooba", "Test6",
> RfcDecodeTest, NULL, CleanUpB64TestContext, &mBasicDecodeTest6);
> + AddTestCase (b64DecodeTests, "RFC 4686 Test Vector - foobar", "Test7",
> RfcDecodeTest, NULL, CleanUpB64TestContext, &mBasicDecodeTest7);
> + AddTestCase (b64DecodeTests, "Ignore Whitespace test", "Test8",
> RfcDecodeTest, NULL, CleanUpB64TestContext, &mBasicDecodeTest8);
> +
> + AddTestCase (b64DecodeTests, "Not a quantum multiple of 4", "Error1",
> RfcDecodeTest, NULL, CleanUpB64TestContext, &mBasicDecodeError1);
> + AddTestCase (b64DecodeTests, "Invalid characters in the string", "Error2",
> RfcDecodeTest, NULL, CleanUpB64TestContext, &mBasicDecodeError2);
> + AddTestCase (b64DecodeTests, "Too many padding characters", "Error3",
> RfcDecodeTest, NULL, CleanUpB64TestContext, &mBasicDecodeError3);
> + AddTestCase (b64DecodeTests, "Incorrectly placed padding character",
> "Error4", RfcDecodeTest, NULL, CleanUpB64TestContext,
> &mBasicDecodeError4);
> + AddTestCase (b64DecodeTests, "Too small of output buffer", "Error5",
> RfcDecodeTest, NULL, CleanUpB64TestContext, &mBasicDecodeError5);
> +
> + //
> + // Execute the tests.
> + //
> + Status = RunAllTestSuites (Fw);
> +
> +EXIT:
> + if (Fw) {
> + FreeUnitTestFramework (Fw);
> + }
> +
> + return Status;
> +}
> +
> +/**
> + Standard UEFI entry point for target based unit test execution from UEFI
> Shell.
> +**/
> +EFI_STATUS
> +EFIAPI
> +BaseLibUnitTestAppEntry (
> + IN EFI_HANDLE ImageHandle,
> + IN EFI_SYSTEM_TABLE *SystemTable
> + )
> +{
> + return UnitTestingEntry ();
> +}
> +
> +/**
> + Standard POSIX C entry point for host based unit test execution.
> +**/
> +int
> +main (
> + int argc,
> + char *argv[]
> + )
> +{
> + return UnitTestingEntry ();
> +}
> diff --git a/MdePkg/Test/UnitTest/Library/BaseLib/BaseLibUnitTestsHost.inf
> b/MdePkg/Test/UnitTest/Library/BaseLib/BaseLibUnitTestsHost.inf
> new file mode 100644
> index 0000000000..b31afae633
> --- /dev/null
> +++ b/MdePkg/Test/UnitTest/Library/BaseLib/BaseLibUnitTestsHost.inf
> @@ -0,0 +1,32 @@
> +## @file
> +# Unit tests of Base64 conversion APIs in BaseLib that are run from host
> +# environment.
> +#
> +# Copyright (C) Microsoft Corporation.
> +# SPDX-License-Identifier: BSD-2-Clause-Patent
> +##
> +
> +[Defines]
> + INF_VERSION = 0x00010006
> + BASE_NAME = BaseLibUnitTestsHost
> + FILE_GUID = 1d005f4c-4dfa-41b5-ab0c-be91fe121459
> + MODULE_TYPE = HOST_APPLICATION
> + VERSION_STRING = 1.0
> +
> +#
> +# The following information is for reference only and not required by the
> build tools.
> +#
> +# VALID_ARCHITECTURES = IA32 X64
> +#
> +
> +[Sources]
> + Base64UnitTest.c
> +
> +[Packages]
> + MdePkg/MdePkg.dec
> +
> +[LibraryClasses]
> + BaseLib
> + BaseMemoryLib
> + DebugLib
> + UnitTestLib
> diff --git a/MdePkg/Test/UnitTest/Library/BaseLib/BaseLibUnitTestsUefi.inf
> b/MdePkg/Test/UnitTest/Library/BaseLib/BaseLibUnitTestsUefi.inf
> new file mode 100644
> index 0000000000..907503898a
> --- /dev/null
> +++ b/MdePkg/Test/UnitTest/Library/BaseLib/BaseLibUnitTestsUefi.inf
> @@ -0,0 +1,33 @@
> +## @file
> +# Unit tests of Base64 conversion APIs in BaseLib that are run from UEFI
> Shell.
> +#
> +# Copyright (C) Microsoft Corporation.
> +# SPDX-License-Identifier: BSD-2-Clause-Patent
> +##
> +
> +[Defines]
> + INF_VERSION = 0x00010006
> + BASE_NAME = BaseLibUnitTestsUefi
> + FILE_GUID = df5a6fed-8786-4a9d-9d02-eab39497b4a1
> + MODULE_TYPE = UEFI_APPLICATION
> + VERSION_STRING = 1.0
> + ENTRY_POINT = BaseLibUnitTestAppEntry
> +
> +#
> +# The following information is for reference only and not required by the
> build tools.
> +#
> +# VALID_ARCHITECTURES = IA32 X64
> +#
> +
> +[Sources]
> + Base64UnitTest.c
> +
> +[Packages]
> + MdePkg/MdePkg.dec
> +
> +[LibraryClasses]
> + BaseLib
> + BaseMemoryLib
> + UefiApplicationEntryPoint
> + DebugLib
> + UnitTestLib
> diff --git
> a/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/SafeIntLibUintnIntnUnitTes
> ts32.c
> b/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/SafeIntLibUintnIntnUnitTes
> ts32.c
> new file mode 100644
> index 0000000000..be5c0e15d3
> --- /dev/null
> +++
> b/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/SafeIntLibUintnIntnUnitTes
> ts32.c
> @@ -0,0 +1,540 @@
> +/** @file
> + IA32-specific functions for unit-testing INTN and UINTN functions in
> + SafeIntLib.
> +
> + Copyright (c) Microsoft Corporation.<BR>
> + Copyright (c) 2019 - 2020, Intel Corporation. All rights reserved.<BR>
> + SPDX-License-Identifier: BSD-2-Clause-Patent
> +
> +**/
> +
> +#include "TestBaseSafeIntLib.h"
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeInt32ToUintn (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + INT32 Operand;
> + UINTN Result;
> +
> + //
> + // If Operand is non-negative, then it's a cast
> + //
> + Operand = 0x5bababab;
> + Result = 0;
> + Status = SafeInt32ToUintn(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x5bababab, Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Operand = (-1537977259);
> + Status = SafeInt32ToUintn(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUint32ToIntn (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + UINT32 Operand;
> + INTN Result;
> +
> + //
> + // If Operand is <= MAX_INTN, then it's a cast
> + //
> + Operand = 0x5bababab;
> + Result = 0;
> + Status = SafeUint32ToIntn(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x5bababab, Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Operand = (0xabababab);
> + Status = SafeUint32ToIntn(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeIntnToInt32 (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + INTN Operand;
> + INT32 Result;
> +
> + //
> + // INTN is same as INT32 in IA32, so this is just a cast
> + //
> + Operand = 0x5bababab;
> + Result = 0;
> + Status = SafeIntnToInt32(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x5bababab, Result);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeIntnToUint32 (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + INTN Operand;
> + UINT32 Result;
> +
> + //
> + // If Operand is non-negative, then it's a cast
> + //
> + Operand = 0x5bababab;
> + Result = 0;
> + Status = SafeIntnToUint32(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x5bababab, Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Operand = (-1537977259);
> + Status = SafeIntnToUint32(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUintnToUint32 (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + UINTN Operand;
> + UINT32 Result;
> +
> + //
> + // UINTN is same as UINT32 in IA32, so this is just a cast
> + //
> + Operand = 0xabababab;
> + Result = 0;
> + Status = SafeUintnToUint32(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0xabababab, Result);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUintnToIntn (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + UINTN Operand;
> + INTN Result;
> +
> + //
> + // If Operand is <= MAX_INTN, then it's a cast
> + //
> + Operand = 0x5bababab;
> + Result = 0;
> + Status = SafeUintnToIntn(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x5bababab, Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Operand = (0xabababab);
> + Status = SafeUintnToIntn(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUintnToInt64 (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + UINTN Operand;
> + INT64 Result;
> +
> + //
> + // UINTN is same as UINT32 in IA32, and UINT32 is a subset of
> + // INT64, so this is just a cast
> + //
> + Operand = 0xabababab;
> + Result = 0;
> + Status = SafeUintnToInt64(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0xabababab, Result);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeInt64ToIntn (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + INT64 Operand;
> + INTN Result;
> +
> + //
> + // If Operand is between MIN_INTN and MAX_INTN2 inclusive, then it's a
> cast
> + //
> + Operand = 0x5bababab;
> + Result = 0;
> + Status = SafeInt64ToIntn(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x5bababab, Result);
> +
> + Operand = (-1537977259);
> + Status = SafeInt64ToIntn(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL((-1537977259), Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Operand = (0x5babababefefefef);
> + Status = SafeInt64ToIntn(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + Operand = (-6605562033422200815);
> + Status = SafeInt64ToIntn(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeInt64ToUintn (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + INT64 Operand;
> + UINTN Result;
> +
> + //
> + // If Operand is between 0 and MAX_UINTN inclusive, then it's a cast
> + //
> + Operand = 0xabababab;
> + Result = 0;
> + Status = SafeInt64ToUintn(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0xabababab, Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Operand = (0x5babababefefefef);
> + Status = SafeInt64ToUintn(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + Operand = (-6605562033422200815);
> + Status = SafeInt64ToUintn(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUint64ToIntn (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + UINT64 Operand;
> + INTN Result;
> +
> + //
> + // If Operand is <= MAX_INTN, then it's a cast
> + //
> + Operand = 0x5bababab;
> + Result = 0;
> + Status = SafeUint64ToIntn(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x5bababab, Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Operand = (0xababababefefefef);
> + Status = SafeUint64ToIntn(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUint64ToUintn (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + UINT64 Operand;
> + UINTN Result;
> +
> + //
> + // If Operand is <= MAX_UINTN, then it's a cast
> + //
> + Operand = 0xabababab;
> + Result = 0;
> + Status = SafeUint64ToUintn(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0xabababab, Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Operand = (0xababababefefefef);
> + Status = SafeUint64ToUintn(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUintnAdd (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + UINTN Augend;
> + UINTN Addend;
> + UINTN Result;
> +
> + //
> + // If the result of addition doesn't overflow MAX_UINTN, then it's addition
> + //
> + Augend = 0x3a3a3a3a;
> + Addend = 0x3a3a3a3a;
> + Result = 0;
> + Status = SafeUintnAdd(Augend, Addend, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x74747474, Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Augend = 0xabababab;
> + Addend = 0xbcbcbcbc;
> + Status = SafeUintnAdd(Augend, Addend, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeIntnAdd (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + INTN Augend;
> + INTN Addend;
> + INTN Result;
> +
> + //
> + // If the result of addition doesn't overflow MAX_INTN
> + // and doesn't underflow MIN_INTN, then it's addition
> + //
> + Augend = 0x3a3a3a3a;
> + Addend = 0x3a3a3a3a;
> + Result = 0;
> + Status = SafeIntnAdd(Augend, Addend, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x74747474, Result);
> +
> + Augend = (-976894522);
> + Addend = (-976894522);
> + Status = SafeIntnAdd(Augend, Addend, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL((-1953789044), Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Augend = 0x5a5a5a5a;
> + Addend = 0x5a5a5a5a;
> + Status = SafeIntnAdd(Augend, Addend, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + Augend = (-1515870810);
> + Addend = (-1515870810);
> + Status = SafeIntnAdd(Augend, Addend, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUintnSub (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + UINTN Minuend;
> + UINTN Subtrahend;
> + UINTN Result;
> +
> + //
> + // If Minuend >= Subtrahend, then it's subtraction
> + //
> + Minuend = 0x5a5a5a5a;
> + Subtrahend = 0x3b3b3b3b;
> + Result = 0;
> + Status = SafeUintnSub(Minuend, Subtrahend, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x1f1f1f1f, Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Minuend = 0x5a5a5a5a;
> + Subtrahend = 0x6d6d6d6d;
> + Status = SafeUintnSub(Minuend, Subtrahend, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeIntnSub (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + INTN Minuend;
> + INTN Subtrahend;
> + INTN Result;
> +
> + //
> + // If the result of subtractions doesn't overflow MAX_INTN or
> + // underflow MIN_INTN, then it's subtraction
> + //
> + Minuend = 0x5a5a5a5a;
> + Subtrahend = 0x3a3a3a3a;
> + Result = 0;
> + Status = SafeIntnSub(Minuend, Subtrahend, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x20202020, Result);
> +
> + Minuend = 0x3a3a3a3a;
> + Subtrahend = 0x5a5a5a5a;
> + Status = SafeIntnSub(Minuend, Subtrahend, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL((-538976288), Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Minuend = (-2054847098);
> + Subtrahend = 2054847098;
> + Status = SafeIntnSub(Minuend, Subtrahend, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + Minuend = (2054847098);
> + Subtrahend = (-2054847098);
> + Status = SafeIntnSub(Minuend, Subtrahend, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUintnMult (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + UINTN Multiplicand;
> + UINTN Multiplier;
> + UINTN Result;
> +
> + //
> + // If the result of multiplication doesn't overflow MAX_UINTN, it will
> succeed
> + //
> + Multiplicand = 0xa122a;
> + Multiplier = 0xd23;
> + Result = 0;
> + Status = SafeUintnMult(Multiplicand, Multiplier, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x844c9dbe, Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Multiplicand = 0xa122a;
> + Multiplier = 0xed23;
> + Status = SafeUintnMult(Multiplicand, Multiplier, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeIntnMult (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + INTN Multiplicand;
> + INTN Multiplier;
> + INTN Result;
> +
> + //
> + // If the result of multiplication doesn't overflow MAX_INTN and doesn't
> + // underflow MIN_UINTN, it will succeed
> + //
> + Multiplicand = 0x123456;
> + Multiplier = 0x678;
> + Result = 0;
> + Status = SafeIntnMult(Multiplicand, Multiplier, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x75c28c50, Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Multiplicand = 0x123456;
> + Multiplier = 0xabc;
> + Status = SafeIntnMult(Multiplicand, Multiplier, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> diff --git
> a/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/SafeIntLibUintnIntnUnitTes
> ts64.c
> b/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/SafeIntLibUintnIntnUnitTes
> ts64.c
> new file mode 100644
> index 0000000000..0fee298172
> --- /dev/null
> +++
> b/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/SafeIntLibUintnIntnUnitTes
> ts64.c
> @@ -0,0 +1,544 @@
> +/** @file
> + x64-specific functions for unit-testing INTN and UINTN functions in
> + SafeIntLib.
> +
> + Copyright (c) Microsoft Corporation.<BR>
> + Copyright (c) 2019 - 2020, Intel Corporation. All rights reserved.<BR>
> + SPDX-License-Identifier: BSD-2-Clause-Patent
> +
> +**/
> +
> +#include "TestBaseSafeIntLib.h"
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeInt32ToUintn (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + INT32 Operand;
> + UINTN Result;
> +
> + //
> + // If Operand is non-negative, then it's a cast
> + //
> + Operand = 0x5bababab;
> + Result = 0;
> + Status = SafeInt32ToUintn(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x5bababab, Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Operand = (-1537977259);
> + Status = SafeInt32ToUintn(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUint32ToIntn (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + UINT32 Operand;
> + INTN Result;
> +
> + //
> + // For x64, INTN is same as INT64 which is a superset of INT32
> + // This is just a cast then, and it'll never fail
> + //
> +
> + //
> + // If Operand is non-negative, then it's a cast
> + //
> + Operand = 0xabababab;
> + Result = 0;
> + Status = SafeUint32ToIntn(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0xabababab, Result);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeIntnToInt32 (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + INTN Operand;
> + INT32 Result;
> +
> + //
> + // If Operand is between MIN_INT32 and MAX_INT32 inclusive, then it's a
> cast
> + //
> + Operand = 0x5bababab;
> + Result = 0;
> + Status = SafeIntnToInt32(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x5bababab, Result);
> +
> + Operand = (-1537977259);
> + Status = SafeIntnToInt32(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL((-1537977259), Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Operand = (0x5babababefefefef);
> + Status = SafeIntnToInt32(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + Operand = (-6605562033422200815);
> + Status = SafeIntnToInt32(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeIntnToUint32 (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + INTN Operand;
> + UINT32 Result;
> +
> + //
> + // If Operand is between 0 and MAX_UINT32 inclusive, then it's a cast
> + //
> + Operand = 0xabababab;
> + Result = 0;
> + Status = SafeIntnToUint32(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0xabababab, Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Operand = (0x5babababefefefef);
> + Status = SafeIntnToUint32(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + Operand = (-6605562033422200815);
> + Status = SafeIntnToUint32(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUintnToUint32 (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + UINTN Operand;
> + UINT32 Result;
> +
> + //
> + // If Operand is <= MAX_UINT32, then it's a cast
> + //
> + Operand = 0xabababab;
> + Result = 0;
> + Status = SafeUintnToUint32(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0xabababab, Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Operand = (0xababababefefefef);
> + Status = SafeUintnToUint32(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUintnToIntn (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + UINTN Operand;
> + INTN Result;
> +
> + //
> + // If Operand is <= MAX_INTN (0x7fff_ffff_ffff_ffff), then it's a cast
> + //
> + Operand = 0x5babababefefefef;
> + Result = 0;
> + Status = SafeUintnToIntn(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x5babababefefefef, Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Operand = (0xababababefefefef);
> + Status = SafeUintnToIntn(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUintnToInt64 (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + UINTN Operand;
> + INT64 Result;
> +
> + //
> + // If Operand is <= MAX_INT64, then it's a cast
> + //
> + Operand = 0x5babababefefefef;
> + Result = 0;
> + Status = SafeUintnToInt64(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x5babababefefefef, Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Operand = (0xababababefefefef);
> + Status = SafeUintnToInt64(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeInt64ToIntn (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + INT64 Operand;
> + INTN Result;
> +
> + //
> + // INTN is same as INT64 in x64, so this is just a cast
> + //
> + Operand = 0x5babababefefefef;
> + Result = 0;
> + Status = SafeInt64ToIntn(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x5babababefefefef, Result);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeInt64ToUintn (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + INT64 Operand;
> + UINTN Result;
> +
> + //
> + // If Operand is non-negative, then it's a cast
> + //
> + Operand = 0x5babababefefefef;
> + Result = 0;
> + Status = SafeInt64ToUintn(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x5babababefefefef, Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Operand = (-6605562033422200815);
> + Status = SafeInt64ToUintn(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUint64ToIntn (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + UINT64 Operand;
> + INTN Result;
> +
> + //
> + // If Operand is <= MAX_INTN (0x7fff_ffff_ffff_ffff), then it's a cast
> + //
> + Operand = 0x5babababefefefef;
> + Result = 0;
> + Status = SafeUint64ToIntn(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x5babababefefefef, Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Operand = (0xababababefefefef);
> + Status = SafeUint64ToIntn(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUint64ToUintn (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + UINT64 Operand;
> + UINTN Result;
> +
> + //
> + // UINTN is same as UINT64 in x64, so this is just a cast
> + //
> + Operand = 0xababababefefefef;
> + Result = 0;
> + Status = SafeUint64ToUintn(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0xababababefefefef, Result);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUintnAdd (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + UINTN Augend;
> + UINTN Addend;
> + UINTN Result;
> +
> + //
> + // If the result of addition doesn't overflow MAX_UINTN, then it's addition
> + //
> + Augend = 0x3a3a3a3a12121212;
> + Addend = 0x3a3a3a3a12121212;
> + Result = 0;
> + Status = SafeUintnAdd(Augend, Addend, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x7474747424242424, Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Augend = 0xababababefefefef;
> + Addend = 0xbcbcbcbcdededede;
> + Status = SafeUintnAdd(Augend, Addend, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeIntnAdd (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + INTN Augend;
> + INTN Addend;
> + INTN Result;
> +
> + //
> + // If the result of addition doesn't overflow MAX_INTN
> + // and doesn't underflow MIN_INTN, then it's addition
> + //
> + Augend = 0x3a3a3a3a3a3a3a3a;
> + Addend = 0x3a3a3a3a3a3a3a3a;
> + Result = 0;
> + Status = SafeIntnAdd(Augend, Addend, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x7474747474747474, Result);
> +
> + Augend = (-4195730024608447034);
> + Addend = (-4195730024608447034);
> + Status = SafeIntnAdd(Augend, Addend, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL((-8391460049216894068), Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Augend = 0x5a5a5a5a5a5a5a5a;
> + Addend = 0x5a5a5a5a5a5a5a5a;
> + Status = SafeIntnAdd(Augend, Addend, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + Augend = (-6510615555426900570);
> + Addend = (-6510615555426900570);
> + Status = SafeIntnAdd(Augend, Addend, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUintnSub (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + UINTN Minuend;
> + UINTN Subtrahend;
> + UINTN Result;
> +
> + //
> + // If Minuend >= Subtrahend, then it's subtraction
> + //
> + Minuend = 0x5a5a5a5a5a5a5a5a;
> + Subtrahend = 0x3b3b3b3b3b3b3b3b;
> + Result = 0;
> + Status = SafeUintnSub(Minuend, Subtrahend, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x1f1f1f1f1f1f1f1f, Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Minuend = 0x5a5a5a5a5a5a5a5a;
> + Subtrahend = 0x6d6d6d6d6d6d6d6d;
> + Status = SafeUintnSub(Minuend, Subtrahend, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeIntnSub (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + INTN Minuend;
> + INTN Subtrahend;
> + INTN Result;
> +
> + //
> + // If the result of subtractions doesn't overflow MAX_INTN or
> + // underflow MIN_INTN, then it's subtraction
> + //
> + Minuend = 0x5a5a5a5a5a5a5a5a;
> + Subtrahend = 0x3a3a3a3a3a3a3a3a;
> + Result = 0;
> + Status = SafeIntnSub(Minuend, Subtrahend, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x2020202020202020, Result);
> +
> + Minuend = 0x3a3a3a3a3a3a3a3a;
> + Subtrahend = 0x5a5a5a5a5a5a5a5a;
> + Status = SafeIntnSub(Minuend, Subtrahend, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL((-2314885530818453536), Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Minuend = (-8825501086245354106);
> + Subtrahend = 8825501086245354106;
> + Status = SafeIntnSub(Minuend, Subtrahend, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + Minuend = (8825501086245354106);
> + Subtrahend = (-8825501086245354106);
> + Status = SafeIntnSub(Minuend, Subtrahend, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUintnMult (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + UINTN Multiplicand;
> + UINTN Multiplier;
> + UINTN Result;
> +
> + //
> + // If the result of multiplication doesn't overflow MAX_UINTN, it will
> succeed
> + //
> + Multiplicand = 0x123456789a;
> + Multiplier = 0x1234567;
> + Result = 0;
> + Status = SafeUintnMult(Multiplicand, Multiplier, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x14b66db9745a07f6, Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Multiplicand = 0x123456789a;
> + Multiplier = 0x12345678;
> + Status = SafeUintnMult(Multiplicand, Multiplier, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeIntnMult (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + INTN Multiplicand;
> + INTN Multiplier;
> + INTN Result;
> +
> + //
> + // If the result of multiplication doesn't overflow MAX_INTN and doesn't
> + // underflow MIN_UINTN, it will succeed
> + //
> + Multiplicand = 0x123456789;
> + Multiplier = 0x6789abcd;
> + Result = 0;
> + Status = SafeIntnMult(Multiplicand, Multiplier, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x75cd9045220d6bb5, Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Multiplicand = 0x123456789;
> + Multiplier = 0xa789abcd;
> + Status = SafeIntnMult(Multiplicand, Multiplier, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> diff --git
> a/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntLib.c
> b/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntLib.c
> new file mode 100644
> index 0000000000..2b1a2223a0
> --- /dev/null
> +++ b/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntLib.c
> @@ -0,0 +1,3064 @@
> +/** @file
> + UEFI OS based application for unit testing the SafeIntLib.
> +
> + Copyright (c) Microsoft Corporation.<BR>
> + Copyright (c) 2018 - 2020, Intel Corporation. All rights reserved.<BR>
> + SPDX-License-Identifier: BSD-2-Clause-Patent
> +
> +**/
> +
> +#include "TestBaseSafeIntLib.h"
> +
> +#define UNIT_TEST_NAME "Int Safe Lib Unit Test Application"
> +#define UNIT_TEST_VERSION "0.1"
> +
> +//
> +// Conversion function tests:
> +//
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeInt8ToUint8 (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + INT8 Operand;
> + UINT8 Result;
> +
> + //
> + // Positive UINT8 should result in just a cast
> + //
> + Operand = 0x5b;
> + Result = 0;
> + Status = SafeInt8ToUint8(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x5b, Result);
> +
> + //
> + // Negative number should result in an error status
> + //
> + Operand = (-56);
> + Status = SafeInt8ToUint8(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeInt8ToUint16 (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + INT8 Operand;
> + UINT16 Result;
> +
> + //
> + // Positive UINT8 should result in just a cast
> + //
> + Operand = 0x5b;
> + Result = 0;
> + Status = SafeInt8ToUint16(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x5b, Result);
> +
> + //
> + // Negative number should result in an error status
> + //
> + Operand = (-56);
> + Status = SafeInt8ToUint16(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeInt8ToUint32 (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + INT8 Operand;
> + UINT32 Result;
> +
> + //
> + // Positive UINT8 should result in just a cast
> + //
> + Operand = 0x5b;
> + Result = 0;
> + Status = SafeInt8ToUint32(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x5b, Result);
> +
> + //
> + // Negative number should result in an error status
> + //
> + Operand = (-56);
> + Status = SafeInt8ToUint32(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeInt8ToUintn (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + INT8 Operand;
> + UINTN Result;
> +
> + //
> + // Positive UINT8 should result in just a cast
> + //
> + Operand = 0x5b;
> + Result = 0;
> + Status = SafeInt8ToUintn(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x5b, Result);
> +
> + //
> + // Negative number should result in an error status
> + //
> + Operand = (-56);
> + Status = SafeInt8ToUintn(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeInt8ToUint64 (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + INT8 Operand;
> + UINT64 Result;
> +
> + //
> + // Positive UINT8 should result in just a cast
> + //
> + Operand = 0x5b;
> + Result = 0;
> + Status = SafeInt8ToUint64(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x5b, Result);
> +
> + //
> + // Negative number should result in an error status
> + //
> + Operand = (-56);
> + Status = SafeInt8ToUint64(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUint8ToInt8 (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + UINT8 Operand;
> + INT8 Result;
> +
> + //
> + // Operand <= 0x7F (MAX_INT8) should result in a cast
> + //
> + Operand = 0x5b;
> + Result = 0;
> + Status = SafeUint8ToInt8(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x5b, Result);
> +
> + //
> + // Operand larger than 0x7f should result in an error status
> + //
> + Operand = 0xaf;
> + Status = SafeUint8ToInt8(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUint8ToChar8 (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + UINT8 Operand;
> + CHAR8 Result;
> +
> + //
> + // CHAR8 is typedefed as char, which by default is signed, thus
> + // CHAR8 is same as INT8, so same tests as above:
> + //
> +
> + //
> + // Operand <= 0x7F (MAX_INT8) should result in a cast
> + //
> + Operand = 0x5b;
> + Result = 0;
> + Status = SafeUint8ToChar8(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x5b, Result);
> +
> + //
> + // Operand larger than 0x7f should result in an error status
> + //
> + Operand = 0xaf;
> + Status = SafeUint8ToChar8(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeInt16ToInt8 (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + INT16 Operand;
> + INT8 Result;
> +
> + //
> + // If Operand is between MIN_INT8 and MAX_INT8 inclusive, then it's a
> cast
> + //
> + Operand = 0x5b;
> + Result = 0;
> + Status = SafeInt16ToInt8(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x5b, Result);
> +
> + Operand = (-35);
> + Status = SafeInt16ToInt8(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL((-35), Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Operand = 0x1234;
> + Status = SafeInt16ToInt8(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + Operand = (-17835);
> + Status = SafeInt16ToInt8(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeInt16ToChar8 (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + INT16 Operand;
> + CHAR8 Result;
> +
> + //
> + // CHAR8 is typedefed as char, which may be signed or unsigned based
> + // on the compiler. Thus, for compatibility CHAR8 should be between 0 and
> MAX_INT8.
> + //
> +
> + //
> + // If Operand is between 0 and MAX_INT8 inclusive, then it's a cast
> + //
> + Operand = 0x5b;
> + Result = 0;
> + Status = SafeInt16ToChar8(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x5b, Result);
> +
> + Operand = 0;
> + Result = 0;
> + Status = SafeInt16ToChar8(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0, Result);
> +
> + Operand = MAX_INT8;
> + Result = 0;
> + Status = SafeInt16ToChar8(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(MAX_INT8, Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Operand = (-35);
> + Status = SafeInt16ToChar8(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + Operand = 0x1234;
> + Status = SafeInt16ToChar8(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + Operand = (-17835);
> + Status = SafeInt16ToChar8(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeInt16ToUint8 (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + INT16 Operand;
> + UINT8 Result;
> +
> + //
> + // If Operand is between 0 and MAX_INT8 inclusive, then it's a cast
> + //
> + Operand = 0x5b;
> + Result = 0;
> + Status = SafeInt16ToUint8(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x5b, Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Operand = 0x1234;
> + Status = SafeInt16ToUint8(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + Operand = (-17835);
> + Status = SafeInt16ToUint8(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeInt16ToUint16 (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + INT16 Operand = 0x5b5b;
> + UINT16 Result = 0;
> +
> + //
> + // If Operand is non-negative, then it's a cast
> + //
> + Status = SafeInt16ToUint16(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x5b5b, Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Operand = (-17835);
> + Status = SafeInt16ToUint16(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeInt16ToUint32 (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + INT16 Operand;
> + UINT32 Result;
> +
> + //
> + // If Operand is non-negative, then it's a cast
> + //
> + Operand = 0x5b5b;
> + Result = 0;
> + Status = SafeInt16ToUint32(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x5b5b, Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Operand = (-17835);
> + Status = SafeInt16ToUint32(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeInt16ToUintn (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + INT16 Operand;
> + UINTN Result;
> +
> + //
> + // If Operand is non-negative, then it's a cast
> + //
> + Operand = 0x5b5b;
> + Result = 0;
> + Status = SafeInt16ToUintn(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x5b5b, Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Operand = (-17835);
> + Status = SafeInt16ToUintn(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeInt16ToUint64 (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + INT16 Operand;
> + UINT64 Result;
> +
> + //
> + // If Operand is non-negative, then it's a cast
> + //
> + Operand = 0x5b5b;
> + Result = 0;
> + Status = SafeInt16ToUint64(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x5b5b, Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Operand = (-17835);
> + Status = SafeInt16ToUint64(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUint16ToInt8 (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + UINT16 Operand;
> + INT8 Result;
> +
> + //
> + // If Operand is <= MAX_INT8, it's a cast
> + //
> + Operand = 0x5b;
> + Result = 0;
> + Status = SafeUint16ToInt8(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x5b, Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Operand = (0x5b5b);
> + Status = SafeUint16ToInt8(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUint16ToChar8 (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + UINT16 Operand;
> + CHAR8 Result;
> +
> + // CHAR8 is typedefed as char, which by default is signed, thus
> + // CHAR8 is same as INT8, so same tests as above:
> +
> + //
> + // If Operand is <= MAX_INT8, it's a cast
> + //
> + Operand = 0x5b;
> + Result = 0;
> + Status = SafeUint16ToChar8(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x5b, Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Operand = (0x5b5b);
> + Status = SafeUint16ToChar8(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUint16ToUint8 (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + UINT16 Operand;
> + UINT8 Result;
> +
> + //
> + // If Operand is <= MAX_UINT8 (0xff), it's a cast
> + //
> + Operand = 0xab;
> + Result = 0;
> + Status = SafeUint16ToUint8(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0xab, Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Operand = (0x5b5b);
> + Status = SafeUint16ToUint8(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUint16ToInt16 (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + UINT16 Operand;
> + INT16 Result;
> +
> + //
> + // If Operand is <= MAX_INT16 (0x7fff), it's a cast
> + //
> + Operand = 0x5b5b;
> + Result = 0;
> + Status = SafeUint16ToInt16(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x5b5b, Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Operand = (0xabab);
> + Status = SafeUint16ToInt16(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeInt32ToInt8 (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + INT32 Operand;
> + INT8 Result;
> +
> + //
> + // If Operand is between MIN_INT8 and MAX_INT8 inclusive, then it's a
> cast
> + //
> + Operand = 0x5b;
> + Result = 0;
> + Status = SafeInt32ToInt8(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x5b, Result);
> +
> + Operand = (-57);
> + Status = SafeInt32ToInt8(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL((-57), Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Operand = (0x5bababab);
> + Status = SafeInt32ToInt8(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + Operand = (-1537977259);
> + Status = SafeInt32ToInt8(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeInt32ToChar8 (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + INT32 Operand;
> + CHAR8 Result;
> +
> + //
> + // CHAR8 is typedefed as char, which may be signed or unsigned based
> + // on the compiler. Thus, for compatibility CHAR8 should be between 0 and
> MAX_INT8.
> + //
> +
> + //
> + // If Operand is between 0 and MAX_INT8 inclusive, then it's a cast
> + //
> + Operand = 0x5b;
> + Result = 0;
> + Status = SafeInt32ToChar8(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x5b, Result);
> +
> + Operand = 0;
> + Result = 0;
> + Status = SafeInt32ToChar8(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0, Result);
> +
> + Operand = MAX_INT8;
> + Result = 0;
> + Status = SafeInt32ToChar8(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(MAX_INT8, Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Operand = (-57);
> + Status = SafeInt32ToChar8(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + Operand = (0x5bababab);
> + Status = SafeInt32ToChar8(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + Operand = (-1537977259);
> + Status = SafeInt32ToChar8(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeInt32ToUint8 (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + INT32 Operand;
> + UINT8 Result;
> +
> + //
> + // If Operand is between 0 and MAX_INT8 inclusive, then it's a cast
> + //
> + Operand = 0x5b;
> + Result = 0;
> + Status = SafeInt32ToUint8(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x5b, Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Operand = (-57);
> + Status = SafeInt32ToUint8(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + Operand = (0x5bababab);
> + Status = SafeInt32ToUint8(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + Operand = (-1537977259);
> + Status = SafeInt32ToUint8(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeInt32ToInt16 (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + INT32 Operand;
> + INT16 Result;
> +
> + //
> + // If Operand is between MIN_INT16 and MAX_INT16 inclusive, then it's a
> cast
> + //
> + Operand = 0x5b5b;
> + Result = 0;
> + Status = SafeInt32ToInt16(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x5b5b, Result);
> +
> + Operand = (-17857);
> + Status = SafeInt32ToInt16(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL((-17857), Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Operand = (0x5bababab);
> + Status = SafeInt32ToInt16(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + Operand = (-1537977259);
> + Status = SafeInt32ToInt16(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeInt32ToUint16 (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + INT32 Operand;
> + UINT16 Result;
> +
> + //
> + // If Operand is between 0 and MAX_UINT16 inclusive, then it's a cast
> + //
> + Operand = 0xabab;
> + Result = 0;
> + Status = SafeInt32ToUint16(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0xabab, Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Operand = (-17857);
> + Status = SafeInt32ToUint16(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + Operand = (0x5bababab);
> + Status = SafeInt32ToUint16(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + Operand = (-1537977259);
> + Status = SafeInt32ToUint16(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeInt32ToUint32 (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + INT32 Operand;
> + UINT32 Result;
> +
> + //
> + // If Operand is non-negative, then it's a cast
> + //
> + Operand = 0x5bababab;
> + Result = 0;
> + Status = SafeInt32ToUint32(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x5bababab, Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Operand = (-1537977259);
> + Status = SafeInt32ToUint32(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeInt32ToUint64 (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + INT32 Operand;
> + UINT64 Result;
> +
> + //
> + // If Operand is non-negative, then it's a cast
> + //
> + Operand = 0x5bababab;
> + Result = 0;
> + Status = SafeInt32ToUint64(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x5bababab, Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Operand = (-1537977259);
> + Status = SafeInt32ToUint64(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUint32ToInt8 (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + UINT32 Operand;
> + INT8 Result;
> +
> + //
> + // If Operand is <= MAX_INT8, then it's a cast
> + //
> + Operand = 0x5b;
> + Result = 0;
> + Status = SafeUint32ToInt8(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x5b, Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Operand = (0x5bababab);
> + Status = SafeUint32ToInt8(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUint32ToChar8 (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + UINT32 Operand;
> + CHAR8 Result;
> +
> + // CHAR8 is typedefed as char, which by default is signed, thus
> + // CHAR8 is same as INT8, so same tests as above:
> +
> + //
> + // If Operand is <= MAX_INT8, then it's a cast
> + //
> + Operand = 0x5b;
> + Result = 0;
> + Status = SafeUint32ToChar8(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x5b, Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Operand = (0x5bababab);
> + Status = SafeUint32ToChar8(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUint32ToUint8 (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + UINT32 Operand;
> + UINT8 Result;
> +
> + //
> + // If Operand is <= MAX_UINT8, then it's a cast
> + //
> + Operand = 0xab;
> + Result = 0;
> + Status = SafeUint32ToUint8(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0xab, Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Operand = (0xabababab);
> + Status = SafeUint32ToUint8(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUint32ToInt16 (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + UINT32 Operand;
> + INT16 Result;
> +
> + //
> + // If Operand is <= MAX_INT16, then it's a cast
> + //
> + Operand = 0x5bab;
> + Result = 0;
> + Status = SafeUint32ToInt16(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x5bab, Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Operand = (0xabababab);
> + Status = SafeUint32ToInt16(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUint32ToUint16 (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + UINT32 Operand;
> + UINT16 Result;
> +
> + //
> + // If Operand is <= MAX_UINT16, then it's a cast
> + //
> + Operand = 0xabab;
> + Result = 0;
> + Status = SafeUint32ToUint16(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0xabab, Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Operand = (0xabababab);
> + Status = SafeUint32ToUint16(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUint32ToInt32 (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + UINT32 Operand;
> + INT32 Result;
> +
> + //
> + // If Operand is <= MAX_INT32, then it's a cast
> + //
> + Operand = 0x5bababab;
> + Result = 0;
> + Status = SafeUint32ToInt32(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x5bababab, Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Operand = (0xabababab);
> + Status = SafeUint32ToInt32(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeIntnToInt8 (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + INTN Operand;
> + INT8 Result;
> +
> + //
> + // If Operand is between MIN_INT8 and MAX_INT8 inclusive, then it's a
> cast
> + //
> + Operand = 0x5b;
> + Result = 0;
> + Status = SafeIntnToInt8(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x5b, Result);
> +
> + Operand = (-53);
> + Status = SafeIntnToInt8(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL((-53), Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Operand = (0x5bababab);
> + Status = SafeIntnToInt8(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + Operand = (-1537977259);
> + Status = SafeIntnToInt8(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeIntnToChar8 (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + INTN Operand;
> + CHAR8 Result;
> +
> + //
> + // CHAR8 is typedefed as char, which may be signed or unsigned based
> + // on the compiler. Thus, for compatibility CHAR8 should be between 0 and
> MAX_INT8.
> + //
> +
> + //
> + // If Operand is between MIN_INT8 and MAX_INT8 inclusive, then it's a
> cast
> + //
> + Operand = 0x5b;
> + Result = 0;
> + Status = SafeIntnToChar8(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x5b, Result);
> +
> + Operand = 0;
> + Result = 0;
> + Status = SafeIntnToChar8(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0, Result);
> +
> + Operand = MAX_INT8;
> + Result = 0;
> + Status = SafeIntnToChar8(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(MAX_INT8, Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Operand = (-53);
> + Status = SafeIntnToChar8(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + Operand = (0x5bababab);
> + Status = SafeIntnToChar8(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + Operand = (-1537977259);
> + Status = SafeIntnToChar8(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeIntnToUint8 (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + INTN Operand;
> + UINT8 Result;
> +
> + //
> + // If Operand is between 0 and MAX_UINT8 inclusive, then it's a cast
> + //
> + Operand = 0xab;
> + Result = 0;
> + Status = SafeIntnToUint8(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0xab, Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Operand = (0x5bababab);
> + Status = SafeIntnToUint8(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + Operand = (-1537977259);
> + Status = SafeIntnToUint8(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeIntnToInt16 (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + INTN Operand;
> + INT16 Result;
> +
> + //
> + // If Operand is between MIN_INT16 and MAX_INT16 inclusive, then it's a
> cast
> + //
> + Operand = 0x5bab;
> + Result = 0;
> + Status = SafeIntnToInt16(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x5bab, Result);
> +
> + Operand = (-23467);
> + Status = SafeIntnToInt16(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL((-23467), Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Operand = (0x5bababab);
> + Status = SafeIntnToInt16(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + Operand = (-1537977259);
> + Status = SafeIntnToInt16(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeIntnToUint16 (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + INTN Operand;
> + UINT16 Result;
> +
> + //
> + // If Operand is between 0 and MAX_UINT16 inclusive, then it's a cast
> + //
> + Operand = 0xabab;
> + Result = 0;
> + Status = SafeIntnToUint16(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0xabab, Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Operand = (0x5bababab);
> + Status = SafeIntnToUint16(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + Operand = (-1537977259);
> + Status = SafeIntnToUint16(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeIntnToUintn (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + INTN Operand;
> + UINTN Result;
> +
> + //
> + // If Operand is non-negative, then it's a cast
> + //
> + Operand = 0x5bababab;
> + Result = 0;
> + Status = SafeIntnToUintn(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x5bababab, Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Operand = (-1537977259);
> + Status = SafeIntnToUintn(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeIntnToUint64 (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + INTN Operand;
> + UINT64 Result;
> +
> + //
> + // If Operand is non-negative, then it's a cast
> + //
> + Operand = 0x5bababab;
> + Result = 0;
> + Status = SafeIntnToUint64(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x5bababab, Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Operand = (-1537977259);
> + Status = SafeIntnToUint64(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUintnToInt8 (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + UINTN Operand;
> + INT8 Result;
> +
> + //
> + // If Operand is <= MAX_INT8, then it's a cast
> + //
> + Operand = 0x5b;
> + Result = 0;
> + Status = SafeUintnToInt8(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x5b, Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Operand = (0xabab);
> + Status = SafeUintnToInt8(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUintnToChar8 (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + UINTN Operand;
> + CHAR8 Result;
> +
> + // CHAR8 is typedefed as char, which by default is signed, thus
> + // CHAR8 is same as INT8, so same tests as above:
> +
> + //
> + // If Operand is <= MAX_INT8, then it's a cast
> + //
> + Operand = 0x5b;
> + Result = 0;
> + Status = SafeUintnToChar8(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x5b, Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Operand = (0xabab);
> + Status = SafeUintnToChar8(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUintnToUint8 (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + UINTN Operand;
> + UINT8 Result;
> +
> + //
> + // If Operand is <= MAX_UINT8, then it's a cast
> + //
> + Operand = 0xab;
> + Result = 0;
> + Status = SafeUintnToUint8(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0xab, Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Operand = (0xabab);
> + Status = SafeUintnToUint8(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUintnToInt16 (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + UINTN Operand;
> + INT16 Result;
> +
> + //
> + // If Operand is <= MAX_INT16, then it's a cast
> + //
> + Operand = 0x5bab;
> + Result = 0;
> + Status = SafeUintnToInt16(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x5bab, Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Operand = (0xabab);
> + Status = SafeUintnToInt16(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUintnToUint16 (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + UINTN Operand;
> + UINT16 Result;
> +
> + //
> + // If Operand is <= MAX_UINT16, then it's a cast
> + //
> + Operand = 0xabab;
> + Result = 0;
> + Status = SafeUintnToUint16(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0xabab, Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Operand = (0xabababab);
> + Status = SafeUintnToUint16(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUintnToInt32 (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + UINTN Operand;
> + INT32 Result;
> +
> + //
> + // If Operand is <= MAX_INT32, then it's a cast
> + //
> + Operand = 0x5bababab;
> + Result = 0;
> + Status = SafeUintnToInt32(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x5bababab, Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Operand = (0xabababab);
> + Status = SafeUintnToInt32(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeInt64ToInt8 (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + INT64 Operand;
> + INT8 Result;
> +
> + //
> + // If Operand is between MIN_INT8 and MAX_INT8 inclusive, then it's a
> cast
> + //
> + Operand = 0x5b;
> + Result = 0;
> + Status = SafeInt64ToInt8(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x5b, Result);
> +
> + Operand = (-37);
> + Status = SafeInt64ToInt8(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL((-37), Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Operand = (0x5babababefefefef);
> + Status = SafeInt64ToInt8(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + Operand = (-6605562033422200815);
> + Status = SafeInt64ToInt8(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeInt64ToChar8 (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + INT64 Operand;
> + CHAR8 Result;
> +
> + //
> + // CHAR8 is typedefed as char, which may be signed or unsigned based
> + // on the compiler. Thus, for compatibility CHAR8 should be between 0 and
> MAX_INT8.
> + //
> +
> + //
> + // If Operand is between MIN_INT8 and MAX_INT8 inclusive, then it's a
> cast
> + //
> + Operand = 0x5b;
> + Result = 0;
> + Status = SafeInt64ToChar8(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x5b, Result);
> +
> + Operand = 0;
> + Result = 0;
> + Status = SafeInt64ToChar8(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0, Result);
> +
> + Operand = MAX_INT8;
> + Result = 0;
> + Status = SafeInt64ToChar8(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(MAX_INT8, Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Operand = (-37);
> + Status = SafeInt64ToChar8(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + Operand = (0x5babababefefefef);
> + Status = SafeInt64ToChar8(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + Operand = (-6605562033422200815);
> + Status = SafeInt64ToChar8(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeInt64ToUint8 (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + INT64 Operand;
> + UINT8 Result;
> +
> + //
> + // If Operand is between 0 and MAX_UINT8 inclusive, then it's a cast
> + //
> + Operand = 0xab;
> + Result = 0;
> + Status = SafeInt64ToUint8(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0xab, Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Operand = (0x5babababefefefef);
> + Status = SafeInt64ToUint8(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + Operand = (-6605562033422200815);
> + Status = SafeInt64ToUint8(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeInt64ToInt16 (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + INT64 Operand;
> + INT16 Result;
> +
> + //
> + // If Operand is between MIN_INT16 and MAX_INT16 inclusive, then it's a
> cast
> + //
> + Operand = 0x5bab;
> + Result = 0;
> + Status = SafeInt64ToInt16(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x5bab, Result);
> +
> + Operand = (-23467);
> + Status = SafeInt64ToInt16(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL((-23467), Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Operand = (0x5babababefefefef);
> + Status = SafeInt64ToInt16(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + Operand = (-6605562033422200815);
> + Status = SafeInt64ToInt16(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeInt64ToUint16 (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + INT64 Operand;
> + UINT16 Result;
> +
> + //
> + // If Operand is between 0 and MAX_UINT16 inclusive, then it's a cast
> + //
> + Operand = 0xabab;
> + Result = 0;
> + Status = SafeInt64ToUint16(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0xabab, Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Operand = (0x5babababefefefef);
> + Status = SafeInt64ToUint16(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + Operand = (-6605562033422200815);
> + Status = SafeInt64ToUint16(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeInt64ToInt32 (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + INT64 Operand;
> + INT32 Result;
> +
> + //
> + // If Operand is between MIN_INT32 and MAX_INT32 inclusive, then it's a
> cast
> + //
> + Operand = 0x5bababab;
> + Result = 0;
> + Status = SafeInt64ToInt32(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x5bababab, Result);
> +
> + Operand = (-1537977259);
> + Status = SafeInt64ToInt32(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL((-1537977259), Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Operand = (0x5babababefefefef);
> + Status = SafeInt64ToInt32(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + Operand = (-6605562033422200815);
> + Status = SafeInt64ToInt32(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeInt64ToUint32 (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + INT64 Operand;
> + UINT32 Result;
> +
> + //
> + // If Operand is between 0 and MAX_UINT32 inclusive, then it's a cast
> + //
> + Operand = 0xabababab;
> + Result = 0;
> + Status = SafeInt64ToUint32(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0xabababab, Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Operand = (0x5babababefefefef);
> + Status = SafeInt64ToUint32(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + Operand = (-6605562033422200815);
> + Status = SafeInt64ToUint32(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeInt64ToUint64 (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + INT64 Operand;
> + UINT64 Result;
> +
> + //
> + // If Operand is non-negative, then it's a cast
> + //
> + Operand = 0x5babababefefefef;
> + Result = 0;
> + Status = SafeInt64ToUint64(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x5babababefefefef, Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Operand = (-6605562033422200815);
> + Status = SafeInt64ToUint64(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUint64ToInt8 (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + UINT64 Operand;
> + INT8 Result;
> +
> + //
> + // If Operand is <= MAX_INT8, then it's a cast
> + //
> + Operand = 0x5b;
> + Result = 0;
> + Status = SafeUint64ToInt8(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x5b, Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Operand = (0xababababefefefef);
> + Status = SafeUint64ToInt8(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUint64ToChar8 (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + UINT64 Operand;
> + CHAR8 Result;
> +
> + // CHAR8 is typedefed as char, which by default is signed, thus
> + // CHAR8 is same as INT8, so same tests as above:
> +
> + //
> + // If Operand is <= MAX_INT8, then it's a cast
> + //
> + Operand = 0x5b;
> + Result = 0;
> + Status = SafeUint64ToChar8(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x5b, Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Operand = (0xababababefefefef);
> + Status = SafeUint64ToChar8(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUint64ToUint8 (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + UINT64 Operand;
> + UINT8 Result;
> +
> + //
> + // If Operand is <= MAX_UINT8, then it's a cast
> + //
> + Operand = 0xab;
> + Result = 0;
> + Status = SafeUint64ToUint8(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0xab, Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Operand = (0xababababefefefef);
> + Status = SafeUint64ToUint8(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUint64ToInt16 (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + UINT64 Operand;
> + INT16 Result;
> +
> + //
> + // If Operand is <= MAX_INT16, then it's a cast
> + //
> + Operand = 0x5bab;
> + Result = 0;
> + Status = SafeUint64ToInt16(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x5bab, Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Operand = (0xababababefefefef);
> + Status = SafeUint64ToInt16(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUint64ToUint16 (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + UINT64 Operand;
> + UINT16 Result;
> +
> + //
> + // If Operand is <= MAX_UINT16, then it's a cast
> + //
> + Operand = 0xabab;
> + Result = 0;
> + Status = SafeUint64ToUint16(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0xabab, Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Operand = (0xababababefefefef);
> + Status = SafeUint64ToUint16(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUint64ToInt32 (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + UINT64 Operand;
> + INT32 Result;
> +
> + //
> + // If Operand is <= MAX_INT32, then it's a cast
> + //
> + Operand = 0x5bababab;
> + Result = 0;
> + Status = SafeUint64ToInt32(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x5bababab, Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Operand = (0xababababefefefef);
> + Status = SafeUint64ToInt32(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUint64ToUint32 (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + UINT64 Operand;
> + UINT32 Result;
> +
> + //
> + // If Operand is <= MAX_UINT32, then it's a cast
> + //
> + Operand = 0xabababab;
> + Result = 0;
> + Status = SafeUint64ToUint32(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0xabababab, Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Operand = (0xababababefefefef);
> + Status = SafeUint64ToUint32(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUint64ToInt64 (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + UINT64 Operand;
> + INT64 Result;
> +
> + //
> + // If Operand is <= MAX_INT64, then it's a cast
> + //
> + Operand = 0x5babababefefefef;
> + Result = 0;
> + Status = SafeUint64ToInt64(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x5babababefefefef, Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Operand = (0xababababefefefef);
> + Status = SafeUint64ToInt64(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +//
> +// Addition function tests:
> +//
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUint8Add (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + UINT8 Augend;
> + UINT8 Addend;
> + UINT8 Result;
> +
> + //
> + // If the result of addition doesn't overflow MAX_UINT8, then it's addition
> + //
> + Augend = 0x3a;
> + Addend = 0x3a;
> + Result = 0;
> + Status = SafeUint8Add(Augend, Addend, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x74, Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Augend = 0xab;
> + Addend = 0xbc;
> + Status = SafeUint8Add(Augend, Addend, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUint16Add (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + UINT16 Augend = 0x3a3a;
> + UINT16 Addend = 0x3a3a;
> + UINT16 Result = 0;
> +
> + //
> + // If the result of addition doesn't overflow MAX_UINT16, then it's
> addition
> + //
> + Status = SafeUint16Add(Augend, Addend, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x7474, Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Augend = 0xabab;
> + Addend = 0xbcbc;
> + Status = SafeUint16Add(Augend, Addend, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUint32Add (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + UINT32 Augend;
> + UINT32 Addend;
> + UINT32 Result;
> +
> + //
> + // If the result of addition doesn't overflow MAX_UINT32, then it's
> addition
> + //
> + Augend = 0x3a3a3a3a;
> + Addend = 0x3a3a3a3a;
> + Result = 0;
> + Status = SafeUint32Add(Augend, Addend, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x74747474, Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Augend = 0xabababab;
> + Addend = 0xbcbcbcbc;
> + Status = SafeUint32Add(Augend, Addend, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUint64Add (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + UINT64 Augend;
> + UINT64 Addend;
> + UINT64 Result;
> +
> + //
> + // If the result of addition doesn't overflow MAX_UINT64, then it's
> addition
> + //
> + Augend = 0x3a3a3a3a12121212;
> + Addend = 0x3a3a3a3a12121212;
> + Result = 0;
> + Status = SafeUint64Add(Augend, Addend, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x7474747424242424, Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Augend = 0xababababefefefef;
> + Addend = 0xbcbcbcbcdededede;
> + Status = SafeUint64Add(Augend, Addend, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeInt8Add (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + INT8 Augend;
> + INT8 Addend;
> + INT8 Result;
> +
> + //
> + // If the result of addition doesn't overflow MAX_INT8
> + // and doesn't underflow MIN_INT8, then it's addition
> + //
> + Augend = 0x3a;
> + Addend = 0x3a;
> + Result = 0;
> + Status = SafeInt8Add(Augend, Addend, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x74, Result);
> +
> + Augend = (-58);
> + Addend = (-58);
> + Status = SafeInt8Add(Augend, Addend, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL((-116), Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Augend = 0x5a;
> + Addend = 0x5a;
> + Status = SafeInt8Add(Augend, Addend, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + Augend = (-90);
> + Addend = (-90);
> + Status = SafeInt8Add(Augend, Addend, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeInt16Add (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + INT16 Augend;
> + INT16 Addend;
> + INT16 Result;
> +
> + //
> + // If the result of addition doesn't overflow MAX_INT16
> + // and doesn't underflow MIN_INT16, then it's addition
> + //
> + Augend = 0x3a3a;
> + Addend = 0x3a3a;
> + Result = 0;
> + Status = SafeInt16Add(Augend, Addend, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x7474, Result);
> +
> + Augend = (-14906);
> + Addend = (-14906);
> + Status = SafeInt16Add(Augend, Addend, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL((-29812), Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Augend = 0x5a5a;
> + Addend = 0x5a5a;
> + Status = SafeInt16Add(Augend, Addend, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + Augend = (-23130);
> + Addend = (-23130);
> + Status = SafeInt16Add(Augend, Addend, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeInt32Add (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + INT32 Augend;
> + INT32 Addend;
> + INT32 Result;
> +
> + //
> + // If the result of addition doesn't overflow MAX_INT32
> + // and doesn't underflow MIN_INT32, then it's addition
> + //
> + Augend = 0x3a3a3a3a;
> + Addend = 0x3a3a3a3a;
> + Result = 0;
> + Status = SafeInt32Add(Augend, Addend, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x74747474, Result);
> +
> + Augend = (-976894522);
> + Addend = (-976894522);
> + Status = SafeInt32Add(Augend, Addend, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL((-1953789044), Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Augend = 0x5a5a5a5a;
> + Addend = 0x5a5a5a5a;
> + Status = SafeInt32Add(Augend, Addend, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + Augend = (-1515870810);
> + Addend = (-1515870810);
> + Status = SafeInt32Add(Augend, Addend, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeInt64Add (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + INT64 Augend;
> + INT64 Addend;
> + INT64 Result;
> +
> + //
> + // If the result of addition doesn't overflow MAX_INT64
> + // and doesn't underflow MIN_INT64, then it's addition
> + //
> + Augend = 0x3a3a3a3a3a3a3a3a;
> + Addend = 0x3a3a3a3a3a3a3a3a;
> + Result = 0;
> + Status = SafeInt64Add(Augend, Addend, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x7474747474747474, Result);
> +
> + Augend = (-4195730024608447034);
> + Addend = (-4195730024608447034);
> + Status = SafeInt64Add(Augend, Addend, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL((-8391460049216894068), Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Augend = 0x5a5a5a5a5a5a5a5a;
> + Addend = 0x5a5a5a5a5a5a5a5a;
> + Status = SafeInt64Add(Augend, Addend, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + Augend = (-6510615555426900570);
> + Addend = (-6510615555426900570);
> + Status = SafeInt64Add(Augend, Addend, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +//
> +// Subtraction function tests:
> +//
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUint8Sub (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + UINT8 Minuend;
> + UINT8 Subtrahend;
> + UINT8 Result;
> +
> + //
> + // If Minuend >= Subtrahend, then it's subtraction
> + //
> + Minuend = 0x5a;
> + Subtrahend = 0x3b;
> + Result = 0;
> + Status = SafeUint8Sub(Minuend, Subtrahend, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x1f, Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Minuend = 0x5a;
> + Subtrahend = 0x6d;
> + Status = SafeUint8Sub(Minuend, Subtrahend, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUint16Sub (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + UINT16 Minuend;
> + UINT16 Subtrahend;
> + UINT16 Result;
> +
> + //
> + // If Minuend >= Subtrahend, then it's subtraction
> + //
> + Minuend = 0x5a5a;
> + Subtrahend = 0x3b3b;
> + Result = 0;
> + Status = SafeUint16Sub(Minuend, Subtrahend, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x1f1f, Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Minuend = 0x5a5a;
> + Subtrahend = 0x6d6d;
> + Status = SafeUint16Sub(Minuend, Subtrahend, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUint32Sub (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + UINT32 Minuend;
> + UINT32 Subtrahend;
> + UINT32 Result;
> +
> + //
> + // If Minuend >= Subtrahend, then it's subtraction
> + //
> + Minuend = 0x5a5a5a5a;
> + Subtrahend = 0x3b3b3b3b;
> + Result = 0;
> + Status = SafeUint32Sub(Minuend, Subtrahend, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x1f1f1f1f, Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Minuend = 0x5a5a5a5a;
> + Subtrahend = 0x6d6d6d6d;
> + Status = SafeUint32Sub(Minuend, Subtrahend, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUint64Sub (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + UINT64 Minuend;
> + UINT64 Subtrahend;
> + UINT64 Result;
> +
> + //
> + // If Minuend >= Subtrahend, then it's subtraction
> + //
> + Minuend = 0x5a5a5a5a5a5a5a5a;
> + Subtrahend = 0x3b3b3b3b3b3b3b3b;
> + Result = 0;
> + Status = SafeUint64Sub(Minuend, Subtrahend, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x1f1f1f1f1f1f1f1f, Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Minuend = 0x5a5a5a5a5a5a5a5a;
> + Subtrahend = 0x6d6d6d6d6d6d6d6d;
> + Status = SafeUint64Sub(Minuend, Subtrahend, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeInt8Sub (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + INT8 Minuend;
> + INT8 Subtrahend;
> + INT8 Result;
> +
> + //
> + // If the result of subtractions doesn't overflow MAX_INT8 or
> + // underflow MIN_INT8, then it's subtraction
> + //
> + Minuend = 0x5a;
> + Subtrahend = 0x3a;
> + Result = 0;
> + Status = SafeInt8Sub(Minuend, Subtrahend, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x20, Result);
> +
> + Minuend = 58;
> + Subtrahend = 78;
> + Status = SafeInt8Sub(Minuend, Subtrahend, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL((-20), Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Minuend = (-80);
> + Subtrahend = 80;
> + Status = SafeInt8Sub(Minuend, Subtrahend, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + Minuend = (80);
> + Subtrahend = (-80);
> + Status = SafeInt8Sub(Minuend, Subtrahend, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeInt16Sub (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + INT16 Minuend;
> + INT16 Subtrahend;
> + INT16 Result;
> +
> + //
> + // If the result of subtractions doesn't overflow MAX_INT16 or
> + // underflow MIN_INT16, then it's subtraction
> + //
> + Minuend = 0x5a5a;
> + Subtrahend = 0x3a3a;
> + Result = 0;
> + Status = SafeInt16Sub(Minuend, Subtrahend, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x2020, Result);
> +
> + Minuend = 0x3a3a;
> + Subtrahend = 0x5a5a;
> + Status = SafeInt16Sub(Minuend, Subtrahend, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL((-8224), Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Minuend = (-31354);
> + Subtrahend = 31354;
> + Status = SafeInt16Sub(Minuend, Subtrahend, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + Minuend = (31354);
> + Subtrahend = (-31354);
> + Status = SafeInt16Sub(Minuend, Subtrahend, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeInt32Sub (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + INT32 Minuend;
> + INT32 Subtrahend;
> + INT32 Result;
> +
> + //
> + // If the result of subtractions doesn't overflow MAX_INT32 or
> + // underflow MIN_INT32, then it's subtraction
> + //
> + Minuend = 0x5a5a5a5a;
> + Subtrahend = 0x3a3a3a3a;
> + Result = 0;
> + Status = SafeInt32Sub(Minuend, Subtrahend, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x20202020, Result);
> +
> + Minuend = 0x3a3a3a3a;
> + Subtrahend = 0x5a5a5a5a;
> + Status = SafeInt32Sub(Minuend, Subtrahend, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL((-538976288), Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Minuend = (-2054847098);
> + Subtrahend = 2054847098;
> + Status = SafeInt32Sub(Minuend, Subtrahend, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + Minuend = (2054847098);
> + Subtrahend = (-2054847098);
> + Status = SafeInt32Sub(Minuend, Subtrahend, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeInt64Sub (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + INT64 Minuend;
> + INT64 Subtrahend;
> + INT64 Result;
> +
> + //
> + // If the result of subtractions doesn't overflow MAX_INT64 or
> + // underflow MIN_INT64, then it's subtraction
> + //
> + Minuend = 0x5a5a5a5a5a5a5a5a;
> + Subtrahend = 0x3a3a3a3a3a3a3a3a;
> + Result = 0;
> + Status = SafeInt64Sub(Minuend, Subtrahend, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x2020202020202020, Result);
> +
> + Minuend = 0x3a3a3a3a3a3a3a3a;
> + Subtrahend = 0x5a5a5a5a5a5a5a5a;
> + Status = SafeInt64Sub(Minuend, Subtrahend, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL((-2314885530818453536), Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Minuend = (-8825501086245354106);
> + Subtrahend = 8825501086245354106;
> + Status = SafeInt64Sub(Minuend, Subtrahend, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + Minuend = (8825501086245354106);
> + Subtrahend = (-8825501086245354106);
> + Status = SafeInt64Sub(Minuend, Subtrahend, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +//
> +// Multiplication function tests:
> +//
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUint8Mult (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + UINT8 Multiplicand;
> + UINT8 Multiplier;
> + UINT8 Result;
> +
> + //
> + // If the result of multiplication doesn't overflow MAX_UINT8, it will
> succeed
> + //
> + Multiplicand = 0x12;
> + Multiplier = 0xa;
> + Result = 0;
> + Status = SafeUint8Mult(Multiplicand, Multiplier, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0xb4, Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Multiplicand = 0x12;
> + Multiplier = 0x23;
> + Status = SafeUint8Mult(Multiplicand, Multiplier, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUint16Mult (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + UINT16 Multiplicand;
> + UINT16 Multiplier;
> + UINT16 Result;
> +
> + //
> + // If the result of multiplication doesn't overflow MAX_UINT16, it will
> succeed
> + //
> + Multiplicand = 0x212;
> + Multiplier = 0x7a;
> + Result = 0;
> + Status = SafeUint16Mult(Multiplicand, Multiplier, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0xfc94, Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Multiplicand = 0x1234;
> + Multiplier = 0x213;
> + Status = SafeUint16Mult(Multiplicand, Multiplier, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUint32Mult (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + UINT32 Multiplicand;
> + UINT32 Multiplier;
> + UINT32 Result;
> +
> + //
> + // If the result of multiplication doesn't overflow MAX_UINT32, it will
> succeed
> + //
> + Multiplicand = 0xa122a;
> + Multiplier = 0xd23;
> + Result = 0;
> + Status = SafeUint32Mult(Multiplicand, Multiplier, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x844c9dbe, Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Multiplicand = 0xa122a;
> + Multiplier = 0xed23;
> + Status = SafeUint32Mult(Multiplicand, Multiplier, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUint64Mult (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + UINT64 Multiplicand;
> + UINT64 Multiplier;
> + UINT64 Result;
> +
> + //
> + // If the result of multiplication doesn't overflow MAX_UINT64, it will
> succeed
> + //
> + Multiplicand = 0x123456789a;
> + Multiplier = 0x1234567;
> + Result = 0;
> + Status = SafeUint64Mult(Multiplicand, Multiplier, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x14b66db9745a07f6, Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Multiplicand = 0x123456789a;
> + Multiplier = 0x12345678;
> + Status = SafeUint64Mult(Multiplicand, Multiplier, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeInt8Mult (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + INT8 Multiplicand;
> + INT8 Multiplier;
> + INT8 Result;
> +
> + //
> + // If the result of multiplication doesn't overflow MAX_INT8 and doesn't
> + // underflow MIN_UINT8, it will succeed
> + //
> + Multiplicand = 0x12;
> + Multiplier = 0x7;
> + Result = 0;
> + Status = SafeInt8Mult(Multiplicand, Multiplier, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x7e, Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Multiplicand = 0x12;
> + Multiplier = 0xa;
> + Status = SafeInt8Mult(Multiplicand, Multiplier, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeInt16Mult (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + INT16 Multiplicand;
> + INT16 Multiplier;
> + INT16 Result;
> +
> + //
> + // If the result of multiplication doesn't overflow MAX_INT16 and doesn't
> + // underflow MIN_UINT16, it will succeed
> + //
> + Multiplicand = 0x123;
> + Multiplier = 0x67;
> + Result = 0;
> + Status = SafeInt16Mult(Multiplicand, Multiplier, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x7515, Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Multiplicand = 0x123;
> + Multiplier = 0xab;
> + Status = SafeInt16Mult(Multiplicand, Multiplier, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeInt32Mult (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + INT32 Multiplicand;
> + INT32 Multiplier;
> + INT32 Result;
> +
> + //
> + // If the result of multiplication doesn't overflow MAX_INT32 and doesn't
> + // underflow MIN_UINT32, it will succeed
> + //
> + Multiplicand = 0x123456;
> + Multiplier = 0x678;
> + Result = 0;
> + Status = SafeInt32Mult(Multiplicand, Multiplier, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x75c28c50, Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Multiplicand = 0x123456;
> + Multiplier = 0xabc;
> + Status = SafeInt32Mult(Multiplicand, Multiplier, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeInt64Mult (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + INT64 Multiplicand;
> + INT64 Multiplier;
> + INT64 Result;
> +
> + //
> + // If the result of multiplication doesn't overflow MAX_INT64 and doesn't
> + // underflow MIN_UINT64, it will succeed
> + //
> + Multiplicand = 0x123456789;
> + Multiplier = 0x6789abcd;
> + Result = 0;
> + Status = SafeInt64Mult(Multiplicand, Multiplier, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x75cd9045220d6bb5, Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Multiplicand = 0x123456789;
> + Multiplier = 0xa789abcd;
> + Status = SafeInt64Mult(Multiplicand, Multiplier, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +/**
> +
> + Main fuction sets up the unit test environment
> +
> +**/
> +EFI_STATUS
> +EFIAPI
> +UefiTestMain (
> + VOID
> + )
> +{
> + EFI_STATUS Status;
> + UNIT_TEST_FRAMEWORK_HANDLE Framework;
> + UNIT_TEST_SUITE_HANDLE ConversionTestSuite;
> + UNIT_TEST_SUITE_HANDLE AdditionSubtractionTestSuite;
> + UNIT_TEST_SUITE_HANDLE MultiplicationTestSuite;
> +
> + Framework = NULL;
> + ConversionTestSuite = NULL;
> + AdditionSubtractionTestSuite = NULL;
> + MultiplicationTestSuite = NULL;
> +
> + DEBUG((DEBUG_INFO, "%a v%a\n", UNIT_TEST_NAME,
> UNIT_TEST_VERSION));
> +
> + //
> + // Start setting up the test framework for running the tests.
> + //
> + Status = InitUnitTestFramework (&Framework, UNIT_TEST_NAME,
> gEfiCallerBaseName, UNIT_TEST_VERSION);
> + if (EFI_ERROR(Status)) {
> + DEBUG((DEBUG_ERROR, "Failed in InitUnitTestFramework. Status = %r\n",
> Status));
> + goto EXIT;
> + }
> +
> + ///
> + // Test the conversion functions
> + //
> + Status = CreateUnitTestSuite (&ConversionTestSuite, Framework, "Int Safe
> Conversions Test Suite", "Common.SafeInt.Convert", NULL, NULL);
> + if (EFI_ERROR(Status)) {
> + DEBUG((DEBUG_ERROR, "Failed in CreateUnitTestSuite for Conversions
> Test Suite\n"));
> + Status = EFI_OUT_OF_RESOURCES;
> + goto EXIT;
> + }
> + AddTestCase(ConversionTestSuite, "Test SafeInt8ToUint8",
> "TestSafeInt8ToUint8", TestSafeInt8ToUint8, NULL, NULL, NULL);
> + AddTestCase(ConversionTestSuite, "Test SafeInt8ToUint16",
> "TestSafeInt8ToUint16", TestSafeInt8ToUint16, NULL, NULL, NULL);
> + AddTestCase(ConversionTestSuite, "Test SafeInt8ToUint32",
> "TestSafeInt8ToUint32", TestSafeInt8ToUint32, NULL, NULL, NULL);
> + AddTestCase(ConversionTestSuite, "Test SafeInt8ToUintn",
> "TestSafeInt8ToUintn", TestSafeInt8ToUintn, NULL, NULL, NULL);
> + AddTestCase(ConversionTestSuite, "Test SafeInt8ToUint64",
> "TestSafeInt8ToUint64", TestSafeInt8ToUint64, NULL, NULL, NULL);
> + AddTestCase(ConversionTestSuite, "Test SafeUint8ToInt8",
> "TestSafeUint8ToInt8", TestSafeUint8ToInt8, NULL, NULL, NULL);
> + AddTestCase(ConversionTestSuite, "Test SafeUint8ToChar8",
> "TestSafeUint8ToChar8", TestSafeUint8ToChar8, NULL, NULL, NULL);
> + AddTestCase(ConversionTestSuite, "Test SafeInt16ToInt8",
> "TestSafeInt16ToInt8", TestSafeInt16ToInt8, NULL, NULL, NULL);
> + AddTestCase(ConversionTestSuite, "Test SafeInt16ToChar8",
> "TestSafeInt16ToChar8", TestSafeInt16ToChar8, NULL, NULL, NULL);
> + AddTestCase(ConversionTestSuite, "Test SafeInt16ToUint8",
> "TestSafeInt16ToUint8", TestSafeInt16ToUint8, NULL, NULL, NULL);
> + AddTestCase(ConversionTestSuite, "Test SafeInt16ToUint16",
> "TestSafeInt16ToUint16", TestSafeInt16ToUint16, NULL, NULL, NULL);
> + AddTestCase(ConversionTestSuite, "Test SafeInt16ToUint32",
> "TestSafeInt16ToUint32", TestSafeInt16ToUint32, NULL, NULL, NULL);
> + AddTestCase(ConversionTestSuite, "Test SafeInt16ToUintn",
> "TestSafeInt16ToUintn", TestSafeInt16ToUintn, NULL, NULL, NULL);
> + AddTestCase(ConversionTestSuite, "Test SafeInt16ToUint64",
> "TestSafeInt16ToUint64", TestSafeInt16ToUint64, NULL, NULL, NULL);
> + AddTestCase(ConversionTestSuite, "Test SafeUint16ToInt8",
> "TestSafeUint16ToInt8", TestSafeUint16ToInt8, NULL, NULL, NULL);
> + AddTestCase(ConversionTestSuite, "Test SafeUint16ToChar8",
> "TestSafeUint16ToChar8", TestSafeUint16ToChar8, NULL, NULL, NULL);
> + AddTestCase(ConversionTestSuite, "Test SafeUint16ToUint8",
> "TestSafeUint16ToUint8", TestSafeUint16ToUint8, NULL, NULL, NULL);
> + AddTestCase(ConversionTestSuite, "Test SafeUint16ToInt16",
> "TestSafeUint16ToInt16", TestSafeUint16ToInt16, NULL, NULL, NULL);
> + AddTestCase(ConversionTestSuite, "Test SafeInt32ToInt8",
> "TestSafeInt32ToInt8", TestSafeInt32ToInt8, NULL, NULL, NULL);
> + AddTestCase(ConversionTestSuite, "Test SafeInt32ToChar8",
> "TestSafeInt32ToChar8", TestSafeInt32ToChar8, NULL, NULL, NULL);
> + AddTestCase(ConversionTestSuite, "Test SafeInt32ToUint8",
> "TestSafeInt32ToUint8", TestSafeInt32ToUint8, NULL, NULL, NULL);
> + AddTestCase(ConversionTestSuite, "Test SafeInt32ToInt16",
> "TestSafeInt32ToInt16", TestSafeInt32ToInt16, NULL, NULL, NULL);
> + AddTestCase(ConversionTestSuite, "Test SafeInt32ToUint16",
> "TestSafeInt32ToUint16", TestSafeInt32ToUint16, NULL, NULL, NULL);
> + AddTestCase(ConversionTestSuite, "Test SafeInt32ToUint32",
> "TestSafeInt32ToUint32", TestSafeInt32ToUint32, NULL, NULL, NULL);
> + AddTestCase(ConversionTestSuite, "Test SafeInt32ToUintn",
> "TestSafeInt32ToUintn", TestSafeInt32ToUintn, NULL, NULL, NULL);
> + AddTestCase(ConversionTestSuite, "Test SafeInt32ToUint64",
> "TestSafeInt32ToUint64", TestSafeInt32ToUint64, NULL, NULL, NULL);
> + AddTestCase(ConversionTestSuite, "Test SafeUint32ToInt8",
> "TestSafeUint32ToInt8", TestSafeUint32ToInt8, NULL, NULL, NULL);
> + AddTestCase(ConversionTestSuite, "Test SafeUint32ToChar8",
> "TestSafeUint32ToChar8", TestSafeUint32ToChar8, NULL, NULL, NULL);
> + AddTestCase(ConversionTestSuite, "Test SafeUint32ToUint8",
> "TestSafeUint32ToUint8", TestSafeUint32ToUint8, NULL, NULL, NULL);
> + AddTestCase(ConversionTestSuite, "Test SafeUint32ToInt16",
> "TestSafeUint32ToInt16", TestSafeUint32ToInt16, NULL, NULL, NULL);
> + AddTestCase(ConversionTestSuite, "Test SafeUint32ToUint16",
> "TestSafeUint32ToUint16", TestSafeUint32ToUint16, NULL, NULL, NULL);
> + AddTestCase(ConversionTestSuite, "Test SafeUint32ToInt32",
> "TestSafeUint32ToInt32", TestSafeUint32ToInt32, NULL, NULL, NULL);
> + AddTestCase(ConversionTestSuite, "Test SafeUint32ToIntn",
> "TestSafeUint32ToIntn", TestSafeUint32ToIntn, NULL, NULL, NULL);
> + AddTestCase(ConversionTestSuite, "Test SafeIntnToInt8",
> "TestSafeIntnToInt8", TestSafeIntnToInt8, NULL, NULL, NULL);
> + AddTestCase(ConversionTestSuite, "Test SafeIntnToChar8",
> "TestSafeIntnToChar8", TestSafeIntnToChar8, NULL, NULL, NULL);
> + AddTestCase(ConversionTestSuite, "Test SafeIntnToUint8",
> "TestSafeIntnToUint8", TestSafeIntnToUint8, NULL, NULL, NULL);
> + AddTestCase(ConversionTestSuite, "Test SafeIntnToInt16",
> "TestSafeIntnToInt16", TestSafeIntnToInt16, NULL, NULL, NULL);
> + AddTestCase(ConversionTestSuite, "Test SafeIntnToUint16",
> "TestSafeIntnToUint16", TestSafeIntnToUint16, NULL, NULL, NULL);
> + AddTestCase(ConversionTestSuite, "Test SafeIntnToInt32",
> "TestSafeIntnToInt32", TestSafeIntnToInt32, NULL, NULL, NULL);
> + AddTestCase(ConversionTestSuite, "Test SafeIntnToUint32",
> "TestSafeIntnToUint32", TestSafeIntnToUint32, NULL, NULL, NULL);
> + AddTestCase(ConversionTestSuite, "Test SafeIntnToUintn",
> "TestSafeIntnToUintn", TestSafeIntnToUintn, NULL, NULL, NULL);
> + AddTestCase(ConversionTestSuite, "Test SafeIntnToUint64",
> "TestSafeIntnToUint64", TestSafeIntnToUint64, NULL, NULL, NULL);
> + AddTestCase(ConversionTestSuite, "Test SafeUintnToInt8",
> "TestSafeUintnToInt8", TestSafeUintnToInt8, NULL, NULL, NULL);
> + AddTestCase(ConversionTestSuite, "Test SafeUintnToChar8",
> "TestSafeUintnToChar8", TestSafeUintnToChar8, NULL, NULL, NULL);
> + AddTestCase(ConversionTestSuite, "Test SafeUintnToUint8",
> "TestSafeUintnToUint8", TestSafeUintnToUint8, NULL, NULL, NULL);
> + AddTestCase(ConversionTestSuite, "Test SafeUintnToInt16",
> "TestSafeUintnToInt16", TestSafeUintnToInt16, NULL, NULL, NULL);
> + AddTestCase(ConversionTestSuite, "Test SafeUintnToUint16",
> "TestSafeUintnToUint16", TestSafeUintnToUint16, NULL, NULL, NULL);
> + AddTestCase(ConversionTestSuite, "Test SafeUintnToInt32",
> "TestSafeUintnToInt32", TestSafeUintnToInt32, NULL, NULL, NULL);
> + AddTestCase(ConversionTestSuite, "Test SafeUintnToUint32",
> "TestSafeUintnToUint32", TestSafeUintnToUint32, NULL, NULL, NULL);
> + AddTestCase(ConversionTestSuite, "Test SafeUintnToIntn",
> "TestSafeUintnToIntn", TestSafeUintnToIntn, NULL, NULL, NULL);
> + AddTestCase(ConversionTestSuite, "Test SafeUintnToInt64",
> "TestSafeUintnToInt64", TestSafeUintnToInt64, NULL, NULL, NULL);
> + AddTestCase(ConversionTestSuite, "Test SafeInt64ToInt8",
> "TestSafeInt64ToInt8", TestSafeInt64ToInt8, NULL, NULL, NULL);
> + AddTestCase(ConversionTestSuite, "Test SafeInt64ToChar8",
> "TestSafeInt64ToChar8", TestSafeInt64ToChar8, NULL, NULL, NULL);
> + AddTestCase(ConversionTestSuite, "Test SafeInt64ToUint8",
> "TestSafeInt64ToUint8", TestSafeInt64ToUint8, NULL, NULL, NULL);
> + AddTestCase(ConversionTestSuite, "Test SafeInt64ToInt16",
> "TestSafeInt64ToInt16", TestSafeInt64ToInt16, NULL, NULL, NULL);
> + AddTestCase(ConversionTestSuite, "Test SafeInt64ToUint16",
> "TestSafeInt64ToUint16", TestSafeInt64ToUint16, NULL, NULL, NULL);
> + AddTestCase(ConversionTestSuite, "Test SafeInt64ToInt32",
> "TestSafeInt64ToInt32", TestSafeInt64ToInt32, NULL, NULL, NULL);
> + AddTestCase(ConversionTestSuite, "Test SafeInt64ToUint32",
> "TestSafeInt64ToUint32", TestSafeInt64ToUint32, NULL, NULL, NULL);
> + AddTestCase(ConversionTestSuite, "Test SafeInt64ToIntn",
> "TestSafeInt64ToIntn", TestSafeInt64ToIntn, NULL, NULL, NULL);
> + AddTestCase(ConversionTestSuite, "Test SafeInt64ToUintn",
> "TestSafeInt64ToUintn", TestSafeInt64ToUintn, NULL, NULL, NULL);
> + AddTestCase(ConversionTestSuite, "Test SafeInt64ToUint64",
> "TestSafeInt64ToUint64", TestSafeInt64ToUint64, NULL, NULL, NULL);
> + AddTestCase(ConversionTestSuite, "Test SafeUint64ToInt8",
> "TestSafeUint64ToInt8", TestSafeUint64ToInt8, NULL, NULL, NULL);
> + AddTestCase(ConversionTestSuite, "Test SafeUint64ToChar8",
> "TestSafeUint64ToChar8", TestSafeUint64ToChar8, NULL, NULL, NULL);
> + AddTestCase(ConversionTestSuite, "Test SafeUint64ToUint8",
> "TestSafeUint64ToUint8", TestSafeUint64ToUint8, NULL, NULL, NULL);
> + AddTestCase(ConversionTestSuite, "Test SafeUint64ToInt16",
> "TestSafeUint64ToInt16", TestSafeUint64ToInt16, NULL, NULL, NULL);
> + AddTestCase(ConversionTestSuite, "Test SafeUint64ToUint16",
> "TestSafeUint64ToUint16", TestSafeUint64ToUint16, NULL, NULL, NULL);
> + AddTestCase(ConversionTestSuite, "Test SafeUint64ToInt32",
> "TestSafeUint64ToInt32", TestSafeUint64ToInt32, NULL, NULL, NULL);
> + AddTestCase(ConversionTestSuite, "Test SafeUint64ToUint32",
> "TestSafeUint64ToUint32", TestSafeUint64ToUint32, NULL, NULL, NULL);
> + AddTestCase(ConversionTestSuite, "Test SafeUint64ToIntn",
> "TestSafeUint64ToIntn", TestSafeUint64ToIntn, NULL, NULL, NULL);
> + AddTestCase(ConversionTestSuite, "Test SafeUint64ToUintn",
> "TestSafeUint64ToUintn", TestSafeUint64ToUintn, NULL, NULL, NULL);
> + AddTestCase(ConversionTestSuite, "Test SafeUint64ToInt64",
> "TestSafeUint64ToInt64", TestSafeUint64ToInt64, NULL, NULL, NULL);
> +
> + //
> + // Test the addition and subtraction functions
> + //
> + Status = CreateUnitTestSuite(&AdditionSubtractionTestSuite, Framework,
> "Int Safe Add/Subtract Test Suite", "Common.SafeInt.AddSubtract", NULL,
> NULL);
> + if (EFI_ERROR(Status)) {
> + DEBUG((DEBUG_ERROR, "Failed in CreateUnitTestSuite for Int Safe
> Add/Subtract Test Suite\n"));
> + Status = EFI_OUT_OF_RESOURCES;
> + goto EXIT;
> + }
> + AddTestCase(AdditionSubtractionTestSuite, "Test SafeUint8Add",
> "TestSafeUint8Add", TestSafeUint8Add, NULL, NULL, NULL);
> + AddTestCase(AdditionSubtractionTestSuite, "Test SafeUint16Add",
> "TestSafeUint16Add", TestSafeUint16Add, NULL, NULL, NULL);
> + AddTestCase(AdditionSubtractionTestSuite, "Test SafeUint32Add",
> "TestSafeUint32Add", TestSafeUint32Add, NULL, NULL, NULL);
> + AddTestCase(AdditionSubtractionTestSuite, "Test SafeUintnAdd",
> "TestSafeUintnAdd", TestSafeUintnAdd, NULL, NULL, NULL);
> + AddTestCase(AdditionSubtractionTestSuite, "Test SafeUint64Add",
> "TestSafeUint64Add", TestSafeUint64Add, NULL, NULL, NULL);
> + AddTestCase(AdditionSubtractionTestSuite, "Test SafeInt8Add",
> "TestSafeInt8Add", TestSafeInt8Add, NULL, NULL, NULL);
> + AddTestCase(AdditionSubtractionTestSuite, "Test SafeInt16Add",
> "TestSafeInt16Add", TestSafeInt16Add, NULL, NULL, NULL);
> + AddTestCase(AdditionSubtractionTestSuite, "Test SafeInt32Add",
> "TestSafeInt32Add", TestSafeInt32Add, NULL, NULL, NULL);
> + AddTestCase(AdditionSubtractionTestSuite, "Test SafeIntnAdd",
> "TestSafeIntnAdd", TestSafeIntnAdd, NULL, NULL, NULL);
> + AddTestCase(AdditionSubtractionTestSuite, "Test SafeInt64Add",
> "TestSafeInt64Add", TestSafeInt64Add, NULL, NULL, NULL);
> + AddTestCase(AdditionSubtractionTestSuite, "Test SafeUint8Sub",
> "TestSafeUint8Sub", TestSafeUint8Sub, NULL, NULL, NULL);
> + AddTestCase(AdditionSubtractionTestSuite, "Test SafeUint16Sub",
> "TestSafeUint16Sub", TestSafeUint16Sub, NULL, NULL, NULL);
> + AddTestCase(AdditionSubtractionTestSuite, "Test SafeUint32Sub",
> "TestSafeUint32Sub", TestSafeUint32Sub, NULL, NULL, NULL);
> + AddTestCase(AdditionSubtractionTestSuite, "Test SafeUintnSub",
> "TestSafeUintnSub", TestSafeUintnSub, NULL, NULL, NULL);
> + AddTestCase(AdditionSubtractionTestSuite, "Test SafeUint64Sub",
> "TestSafeUint64Sub", TestSafeUint64Sub, NULL, NULL, NULL);
> + AddTestCase(AdditionSubtractionTestSuite, "Test SafeInt8Sub",
> "TestSafeInt8Sub", TestSafeInt8Sub, NULL, NULL, NULL);
> + AddTestCase(AdditionSubtractionTestSuite, "Test SafeInt16Sub",
> "TestSafeInt16Sub", TestSafeInt16Sub, NULL, NULL, NULL);
> + AddTestCase(AdditionSubtractionTestSuite, "Test SafeInt32Sub",
> "TestSafeInt32Sub", TestSafeInt32Sub, NULL, NULL, NULL);
> + AddTestCase(AdditionSubtractionTestSuite, "Test SafeIntnSub",
> "TestSafeIntnSub", TestSafeIntnSub, NULL, NULL, NULL);
> + AddTestCase(AdditionSubtractionTestSuite, "Test SafeInt64Sub",
> "TestSafeInt64Sub", TestSafeInt64Sub, NULL, NULL, NULL);
> +
> + //
> + // Test the multiplication functions
> + //
> + Status = CreateUnitTestSuite(&MultiplicationTestSuite, Framework, "Int
> Safe Multiply Test Suite", "Common.SafeInt.Multiply", NULL, NULL);
> + if (EFI_ERROR(Status)) {
> + DEBUG((DEBUG_ERROR, "Failed in CreateUnitTestSuite for Int Safe
> Multiply Test Suite\n"));
> + Status = EFI_OUT_OF_RESOURCES;
> + goto EXIT;
> + }
> + AddTestCase(MultiplicationTestSuite, "Test SafeUint8Mult",
> "TestSafeUint8Mult", TestSafeUint8Mult, NULL, NULL, NULL);
> + AddTestCase(MultiplicationTestSuite, "Test SafeUint16Mult",
> "TestSafeUint16Mult", TestSafeUint16Mult, NULL, NULL, NULL);
> + AddTestCase(MultiplicationTestSuite, "Test SafeUint32Mult",
> "TestSafeUint32Mult", TestSafeUint32Mult, NULL, NULL, NULL);
> + AddTestCase(MultiplicationTestSuite, "Test SafeUintnMult",
> "TestSafeUintnMult", TestSafeUintnMult, NULL, NULL, NULL);
> + AddTestCase(MultiplicationTestSuite, "Test SafeUint64Mult",
> "TestSafeUint64Mult", TestSafeUint64Mult, NULL, NULL, NULL);
> + AddTestCase(MultiplicationTestSuite, "Test SafeInt8Mult",
> "TestSafeInt8Mult", TestSafeInt8Mult, NULL, NULL, NULL);
> + AddTestCase(MultiplicationTestSuite, "Test SafeInt16Mult",
> "TestSafeInt16Mult", TestSafeInt16Mult, NULL, NULL, NULL);
> + AddTestCase(MultiplicationTestSuite, "Test SafeInt32Mult",
> "TestSafeInt32Mult", TestSafeInt32Mult, NULL, NULL, NULL);
> + AddTestCase(MultiplicationTestSuite, "Test SafeIntnMult",
> "TestSafeIntnMult", TestSafeIntnMult, NULL, NULL, NULL);
> + AddTestCase(MultiplicationTestSuite, "Test SafeInt64Mult",
> "TestSafeInt64Mult", TestSafeInt64Mult, NULL, NULL, NULL);
> +
> + //
> + // Execute the tests.
> + //
> + Status = RunAllTestSuites(Framework);
> +
> +EXIT:
> + if (Framework != NULL) {
> + FreeUnitTestFramework(Framework);
> + }
> +
> + return Status;
> +}
> +
> +EFI_STATUS
> +EFIAPI
> +PeiEntryPoint (
> + IN EFI_PEI_FILE_HANDLE FileHandle,
> + IN CONST EFI_PEI_SERVICES **PeiServices
> + )
> +{
> + return UefiTestMain ();
> +}
> +
> +EFI_STATUS
> +EFIAPI
> +DxeEntryPoint (
> + IN EFI_HANDLE ImageHandle,
> + IN EFI_SYSTEM_TABLE *SystemTable
> + )
> +{
> + return UefiTestMain ();
> +}
> +
> +int
> +main (
> + int argc,
> + char *argv[]
> + )
> +{
> + return UefiTestMain ();
> +}
> diff --git
> a/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntLib.h
> b/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntLib.h
> new file mode 100644
> index 0000000000..7957c99a85
> --- /dev/null
> +++ b/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntLib.h
> @@ -0,0 +1,123 @@
> +/** @file
> + UEFI OS based application for unit testing the SafeIntLib.
> +
> + Copyright (c) Microsoft Corporation.<BR>
> + Copyright (c) 2018 - 2020, Intel Corporation. All rights reserved.<BR>
> + SPDX-License-Identifier: BSD-2-Clause-Patent
> +
> +**/
> +
> +#ifndef _TEST_BASE_SAFE_INT_LIB_H_
> +#define _TEST_BASE_SAFE_INT_LIB_H_
> +
> +#include <PiPei.h>
> +#include <Uefi.h>
> +#include <Library/UefiLib.h>
> +#include <Library/DebugLib.h>
> +#include <Library/MemoryAllocationLib.h>
> +#include <Library/UnitTestLib.h>
> +#include <Library/SafeIntLib.h>
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeInt32ToUintn(
> + IN UNIT_TEST_CONTEXT Context
> + );
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUint32ToIntn(
> + IN UNIT_TEST_CONTEXT Context
> + );
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeIntnToInt32(
> + IN UNIT_TEST_CONTEXT Context
> + );
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeIntnToUint32(
> + IN UNIT_TEST_CONTEXT Context
> + );
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUintnToUint32(
> + IN UNIT_TEST_CONTEXT Context
> + );
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUintnToIntn(
> + IN UNIT_TEST_CONTEXT Context
> + );
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUintnToInt64(
> + IN UNIT_TEST_CONTEXT Context
> + );
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeInt64ToIntn(
> + IN UNIT_TEST_CONTEXT Context
> + );
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeInt64ToUintn(
> + IN UNIT_TEST_CONTEXT Context
> + );
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUint64ToIntn(
> + IN UNIT_TEST_CONTEXT Context
> + );
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUint64ToUintn(
> + IN UNIT_TEST_CONTEXT Context
> + );
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUintnAdd(
> + IN UNIT_TEST_CONTEXT Context
> + );
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeIntnAdd(
> + IN UNIT_TEST_CONTEXT Context
> + );
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUintnSub(
> + IN UNIT_TEST_CONTEXT Context
> + );
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeIntnSub(
> + IN UNIT_TEST_CONTEXT Context
> + );
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUintnMult(
> + IN UNIT_TEST_CONTEXT Context
> + );
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeIntnMult(
> + IN UNIT_TEST_CONTEXT Context
> + );
> +
> +#endif
> diff --git
> a/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntLib.uni
> b/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntLib.uni
> new file mode 100644
> index 0000000000..956835c30d
> --- /dev/null
> +++ b/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntLib.uni
> @@ -0,0 +1,13 @@
> +// /** @file
> +// Application that Unit Tests the SafeIntLib
> +//
> +// Copyright (c) 2020, Intel Corporation. All rights reserved.<BR>
> +//
> +// SPDX-License-Identifier: BSD-2-Clause-Patent
> +//
> +// **/
> +
> +#string STR_MODULE_ABSTRACT #language en-US "Application that
> Unit Tests the SafeIntLib"
> +
> +#string STR_MODULE_DESCRIPTION #language en-US "Application
> that Unit Tests the SafeIntLib."
> +
> diff --git
> a/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntLibDxe.inf
> b/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntLibDxe.inf
> new file mode 100644
> index 0000000000..de67b04bd5
> --- /dev/null
> +++
> b/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntLibDxe.inf
> @@ -0,0 +1,45 @@
> +## @file
> +# DXE Driver that Unit Tests the SafeIntLib
> +#
> +# Copyright (c) Microsoft Corporation.<BR>
> +# Copyright (c) 2019 - 2020, Intel Corporation. All rights reserved.<BR>
> +# SPDX-License-Identifier: BSD-2-Clause-Patent
> +##
> +
> +[Defines]
> + INF_VERSION = 0x00010005
> + BASE_NAME = TestBaseSafeIntLibDxe
> + MODULE_UNI_FILE = TestBaseSafeIntLib.uni
> + FILE_GUID = 9729DB60-FB9D-4625-9EE1-93B21EC246B8
> + MODULE_TYPE = DXE_DRIVER
> + VERSION_STRING = 1.0
> + ENTRY_POINT = DxeEntryPoint
> +
> +#
> +# The following information is for reference only and not required by the
> build tools.
> +#
> +# VALID_ARCHITECTURES = IA32 X64
> +#
> +
> +[Sources]
> + TestBaseSafeIntLib.c
> + TestBaseSafeIntLib.h
> +
> +[Sources.Ia32, Sources.ARM]
> + SafeIntLibUintnIntnUnitTests32.c
> +
> +[Sources.X64, Sources.AARCH64]
> + SafeIntLibUintnIntnUnitTests64.c
> +
> +[Packages]
> + MdePkg/MdePkg.dec
> +
> +[LibraryClasses]
> + UefiDriverEntryPoint
> + BaseLib
> + DebugLib
> + SafeIntLib
> + UnitTestLib
> +
> +[Depex]
> + TRUE
> diff --git
> a/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntLibHost.inf
> b/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntLibHost.inf
> new file mode 100644
> index 0000000000..35c93fdeac
> --- /dev/null
> +++
> b/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntLibHost.inf
> @@ -0,0 +1,40 @@
> +## @file
> +# Host OS based Application that Unit Tests the SafeIntLib
> +#
> +# Copyright (c) Microsoft Corporation.<BR>
> +# Copyright (c) 2019 - 2020, Intel Corporation. All rights reserved.<BR>
> +# SPDX-License-Identifier: BSD-2-Clause-Patent
> +##
> +
> +[Defines]
> + INF_VERSION = 0x00010005
> + BASE_NAME = TestBaseSafeIntLibHost
> + MODULE_UNI_FILE = TestBaseSafeIntLib.uni
> + FILE_GUID = 95487689-9E30-41AD-B773-3650C94BCBE2
> + MODULE_TYPE = HOST_APPLICATION
> + VERSION_STRING = 1.0
> +
> +#
> +# The following information is for reference only and not required by the
> build tools.
> +#
> +# VALID_ARCHITECTURES = IA32 X64
> +#
> +
> +[Sources]
> + TestBaseSafeIntLib.c
> + TestBaseSafeIntLib.h
> +
> +[Sources.Ia32, Sources.ARM]
> + SafeIntLibUintnIntnUnitTests32.c
> +
> +[Sources.X64, Sources.AARCH64]
> + SafeIntLibUintnIntnUnitTests64.c
> +
> +[Packages]
> + MdePkg/MdePkg.dec
> +
> +[LibraryClasses]
> + BaseLib
> + DebugLib
> + SafeIntLib
> + UnitTestLib
> diff --git
> a/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntLibPei.inf
> b/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntLibPei.inf
> new file mode 100644
> index 0000000000..c8ba4f44ef
> --- /dev/null
> +++
> b/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntLibPei.inf
> @@ -0,0 +1,45 @@
> +## @file
> +# PEIM that Unit Tests the SafeIntLib
> +#
> +# Copyright (c) Microsoft Corporation.<BR>
> +# Copyright (c) 2019 - 2020, Intel Corporation. All rights reserved.<BR>
> +# SPDX-License-Identifier: BSD-2-Clause-Patent
> +##
> +
> +[Defines]
> + INF_VERSION = 0x00010005
> + BASE_NAME = TestBaseSafeIntLibPei
> + MODULE_UNI_FILE = TestBaseSafeIntLib.uni
> + FILE_GUID = 7D910602-ED53-45E6-826E-8266705B9734
> + MODULE_TYPE = PEIM
> + VERSION_STRING = 1.0
> + ENTRY_POINT = PeiEntryPoint
> +
> +#
> +# The following information is for reference only and not required by the
> build tools.
> +#
> +# VALID_ARCHITECTURES = IA32 X64
> +#
> +
> +[Sources]
> + TestBaseSafeIntLib.c
> + TestBaseSafeIntLib.h
> +
> +[Sources.Ia32, Sources.ARM]
> + SafeIntLibUintnIntnUnitTests32.c
> +
> +[Sources.X64, Sources.AARCH64]
> + SafeIntLibUintnIntnUnitTests64.c
> +
> +[Packages]
> + MdePkg/MdePkg.dec
> +
> +[LibraryClasses]
> + PeimEntryPoint
> + BaseLib
> + DebugLib
> + SafeIntLib
> + UnitTestLib
> +
> +[Depex]
> + TRUE
> diff --git
> a/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntLibSmm.inf
> b/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntLibSmm.inf
> new file mode 100644
> index 0000000000..df7288501d
> --- /dev/null
> +++
> b/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntLibSmm.inf
> @@ -0,0 +1,45 @@
> +## @file
> +# SMM Driver that Unit Tests the SafeIntLib
> +#
> +# Copyright (c) Microsoft Corporation.<BR>
> +# Copyright (c) 2019 - 2020, Intel Corporation. All rights reserved.<BR>
> +# SPDX-License-Identifier: BSD-2-Clause-Patent
> +##
> +
> +[Defines]
> + INF_VERSION = 0x00010005
> + BASE_NAME = TestBaseSafeIntLibSmm
> + MODULE_UNI_FILE = TestBaseSafeIntLib.uni
> + FILE_GUID = 2F2A1907-B1B4-4E33-8B83-62A60AB4F0D4
> + MODULE_TYPE = DXE_SMM_DRIVER
> + VERSION_STRING = 1.0
> + ENTRY_POINT = DxeEntryPoint
> +
> +#
> +# The following information is for reference only and not required by the
> build tools.
> +#
> +# VALID_ARCHITECTURES = IA32 X64
> +#
> +
> +[Sources]
> + TestBaseSafeIntLib.c
> + TestBaseSafeIntLib.h
> +
> +[Sources.Ia32, Sources.ARM]
> + SafeIntLibUintnIntnUnitTests32.c
> +
> +[Sources.X64, Sources.AARCH64]
> + SafeIntLibUintnIntnUnitTests64.c
> +
> +[Packages]
> + MdePkg/MdePkg.dec
> +
> +[LibraryClasses]
> + UefiDriverEntryPoint
> + BaseLib
> + DebugLib
> + SafeIntLib
> + UnitTestLib
> +
> +[Depex]
> + TRUE
> diff --git
> a/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntLibUefiShel
> l.inf
> b/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntLibUefiShel
> l.inf
> new file mode 100644
> index 0000000000..5a13c1c845
> --- /dev/null
> +++
> b/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntLibUefiShel
> l.inf
> @@ -0,0 +1,42 @@
> +## @file
> +# UEFI Shell based Application that Unit Tests the SafeIntLib
> +#
> +# Copyright (c) Microsoft Corporation.<BR>
> +# Copyright (c) 2019 - 2020, Intel Corporation. All rights reserved.<BR>
> +# SPDX-License-Identifier: BSD-2-Clause-Patent
> +##
> +
> +[Defines]
> + INF_VERSION = 0x00010005
> + BASE_NAME = TestBaseSafeIntLibUefiShell
> + MODULE_UNI_FILE = TestBaseSafeIntLib.uni
> + FILE_GUID = 1F91B73E-5B6A-4317-80E8-E7C36A3C7AF4
> + MODULE_TYPE = UEFI_APPLICATION
> + VERSION_STRING = 1.0
> + ENTRY_POINT = DxeEntryPoint
> +
> +#
> +# The following information is for reference only and not required by the
> build tools.
> +#
> +# VALID_ARCHITECTURES = IA32 X64
> +#
> +
> +[Sources]
> + TestBaseSafeIntLib.c
> + TestBaseSafeIntLib.h
> +
> +[Sources.Ia32, Sources.ARM]
> + SafeIntLibUintnIntnUnitTests32.c
> +
> +[Sources.X64, Sources.AARCH64]
> + SafeIntLibUintnIntnUnitTests64.c
> +
> +[Packages]
> + MdePkg/MdePkg.dec
> +
> +[LibraryClasses]
> + UefiApplicationEntryPoint
> + BaseLib
> + DebugLib
> + SafeIntLib
> + UnitTestLib
> --
> 2.21.0.windows.1
>
>
>
-=-=-=-=-=-=-=-=-=-=-=-
Groups.io Links: You receive all messages sent to this group.
View/Reply Online (#53936): https://edk2.groups.io/g/devel/message/53936
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]
-=-=-=-=-=-=-=-=-=-=-=-
Mike:
Is there the ready UEFI shell environment to run target based tests? Is Emulator used?
Thanks
Liming
> -----Original Message-----
> From: Kinney, Michael D <michael.d.kinney@intel.com>
> Sent: Friday, January 24, 2020 10:10 AM
> To: devel@edk2.groups.io
> Cc: Sean Brogan <sean.brogan@microsoft.com>; Bret Barkelew <Bret.Barkelew@microsoft.com>; Gao, Liming <liming.gao@intel.com>
> Subject: [Patch 08/11] MdePkg/Test: Add SafeIntLib and BaseLib Base64 unit tests
>
> * Add unit tests for SafeIntLib class
> * Add unit tests for BaseLib Base64 conversion APIs.
> * Add Test/MdePkgHostTest.dsc -to build host based unit
> tests
> * Update MdePkg.dsc to build target based tests for
> SafeIntLib and BaseLib
> * Update MdePkg.ci.yaml to build and run host based
> tests for SafeIntLib and BaseLib
>
> Cc: Sean Brogan <sean.brogan@microsoft.com>
> Cc: Bret Barkelew <Bret.Barkelew@microsoft.com>
> Cc: Liming Gao <liming.gao@intel.com>
> Signed-off-by: Michael D Kinney <michael.d.kinney@intel.com>
> ---
> MdePkg/MdePkg.ci.yaml | 19 +-
> MdePkg/MdePkg.dsc | 18 +
> MdePkg/Test/MdePkgHostTest.dsc | 30 +
> .../UnitTest/Library/BaseLib/Base64UnitTest.c | 404 +++
> .../Library/BaseLib/BaseLibUnitTestsHost.inf | 32 +
> .../Library/BaseLib/BaseLibUnitTestsUefi.inf | 33 +
> .../SafeIntLibUintnIntnUnitTests32.c | 540 +++
> .../SafeIntLibUintnIntnUnitTests64.c | 544 +++
> .../BaseSafeIntLib/TestBaseSafeIntLib.c | 3064 +++++++++++++++++
> .../BaseSafeIntLib/TestBaseSafeIntLib.h | 123 +
> .../BaseSafeIntLib/TestBaseSafeIntLib.uni | 13 +
> .../BaseSafeIntLib/TestBaseSafeIntLibDxe.inf | 45 +
> .../BaseSafeIntLib/TestBaseSafeIntLibHost.inf | 40 +
> .../BaseSafeIntLib/TestBaseSafeIntLibPei.inf | 45 +
> .../BaseSafeIntLib/TestBaseSafeIntLibSmm.inf | 45 +
> .../TestBaseSafeIntLibUefiShell.inf | 42 +
> 16 files changed, 5034 insertions(+), 3 deletions(-)
> create mode 100644 MdePkg/Test/MdePkgHostTest.dsc
> create mode 100644 MdePkg/Test/UnitTest/Library/BaseLib/Base64UnitTest.c
> create mode 100644 MdePkg/Test/UnitTest/Library/BaseLib/BaseLibUnitTestsHost.inf
> create mode 100644 MdePkg/Test/UnitTest/Library/BaseLib/BaseLibUnitTestsUefi.inf
> create mode 100644 MdePkg/Test/UnitTest/Library/BaseSafeIntLib/SafeIntLibUintnIntnUnitTests32.c
> create mode 100644 MdePkg/Test/UnitTest/Library/BaseSafeIntLib/SafeIntLibUintnIntnUnitTests64.c
> create mode 100644 MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntLib.c
> create mode 100644 MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntLib.h
> create mode 100644 MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntLib.uni
> create mode 100644 MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntLibDxe.inf
> create mode 100644 MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntLibHost.inf
> create mode 100644 MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntLibPei.inf
> create mode 100644 MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntLibSmm.inf
> create mode 100644 MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntLibUefiShell.inf
>
> diff --git a/MdePkg/MdePkg.ci.yaml b/MdePkg/MdePkg.ci.yaml
> index 65c4ec3bec..88e490fcb6 100644
> --- a/MdePkg/MdePkg.ci.yaml
> +++ b/MdePkg/MdePkg.ci.yaml
> @@ -10,8 +10,13 @@
> "DscPath": "MdePkg.dsc"
> },
>
> + ## options defined ci/Plugin/HostUnitTestCompilerPlugin
> + "HostUnitTestCompilerPlugin": {
> + "DscPath": "Test/MdePkgHostTest.dsc"
> + },
> +
> ## options defined ci/Plugin/CharEncodingCheck
> -"CharEncodingCheck": {
> + "CharEncodingCheck": {
> "IgnoreFiles": []
> },
>
> @@ -21,7 +26,9 @@
> "MdePkg/MdePkg.dec"
> ],
> # For host based unit tests
> - "AcceptableDependencies-HOST_APPLICATION":[],
> + "AcceptableDependencies-HOST_APPLICATION":[
> + "UnitTestFrameworkPkg/UnitTestFrameworkPkg.dec"
> + ],
> # For UEFI shell based apps
> "AcceptableDependencies-UEFI_APPLICATION":[],
> "IgnoreInf": []
> @@ -29,10 +36,16 @@
>
> ## options defined ci/Plugin/DscCompleteCheck
> "DscCompleteCheck": {
> - "IgnoreInf": [],
> + "IgnoreInf": [""],
> "DscPath": "MdePkg.dsc"
> },
>
> + ## options defined ci/Plugin/HostUnitTestDscCompleteCheck
> + "HostUnitTestDscCompleteCheck": {
> + "IgnoreInf": [""],
> + "DscPath": "Test/MdePkgHostTest.dsc"
> + },
> +
> ## options defined ci/Plugin/GuidCheck
> "GuidCheck": {
> "IgnoreGuidName": [
> diff --git a/MdePkg/MdePkg.dsc b/MdePkg/MdePkg.dsc
> index 0aeafaaacc..87af740853 100644
> --- a/MdePkg/MdePkg.dsc
> +++ b/MdePkg/MdePkg.dsc
> @@ -18,6 +18,8 @@ [Defines]
> BUILD_TARGETS = DEBUG|RELEASE|NOOPT
> SKUID_IDENTIFIER = DEFAULT
>
> +!include UnitTestFrameworkPkg/UnitTestFrameworkPkgTarget.dsc.inc
> +
> [PcdsFeatureFlag]
> gEfiMdePkgTokenSpaceGuid.PcdUgaConsumeSupport|TRUE
>
> @@ -26,6 +28,9 @@ [PcdsFixedAtBuild]
> gEfiMdePkgTokenSpaceGuid.PcdDebugPrintErrorLevel|0x80000000
> gEfiMdePkgTokenSpaceGuid.PcdPciExpressBaseAddress|0xE0000000
>
> +[LibraryClasses]
> + SafeIntLib|MdePkg/Library/BaseSafeIntLib/BaseSafeIntLib.inf
> +
> [Components]
> MdePkg/Library/UefiFileHandleLib/UefiFileHandleLib.inf
> MdePkg/Library/BaseCacheMaintenanceLib/BaseCacheMaintenanceLib.inf
> @@ -115,6 +120,19 @@ [Components]
> MdePkg/Library/StandaloneMmDriverEntryPoint/StandaloneMmDriverEntryPoint.inf
> MdePkg/Library/StandaloneMmServicesTableLib/StandaloneMmServicesTableLib.inf
>
> + #
> + # Add UEFI Target Based Unit Tests
> + #
> + MdePkg/Test/UnitTest/Library/BaseLib/BaseLibUnitTestsUefi.inf
> +
> + #
> + # Build PEIM, DXE_DRIVER, SMM_DRIVER, UEFI Shell components that test SafeIntLib
> + #
> + MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntLibPei.inf
> + MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntLibDxe.inf
> + MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntLibSmm.inf
> + MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntLibUefiShell.inf
> +
> [Components.IA32, Components.X64]
> MdePkg/Library/BaseIoLibIntrinsic/BaseIoLibIntrinsic.inf
> MdePkg/Library/BaseIoLibIntrinsic/BaseIoLibIntrinsicSev.inf
> diff --git a/MdePkg/Test/MdePkgHostTest.dsc b/MdePkg/Test/MdePkgHostTest.dsc
> new file mode 100644
> index 0000000000..3d677ee75c
> --- /dev/null
> +++ b/MdePkg/Test/MdePkgHostTest.dsc
> @@ -0,0 +1,30 @@
> +## @file
> +# MdePkg DSC file used to build host-based unit tests.
> +#
> +# Copyright (c) 2019 - 2020, Intel Corporation. All rights reserved.<BR>
> +# Copyright (C) Microsoft Corporation.
> +# SPDX-License-Identifier: BSD-2-Clause-Patent
> +#
> +##
> +
> +[Defines]
> + PLATFORM_NAME = MdePkgHostTest
> + PLATFORM_GUID = 50652B4C-88CB-4481-96E8-37F2D0034440
> + PLATFORM_VERSION = 0.1
> + DSC_SPECIFICATION = 0x00010005
> + OUTPUT_DIRECTORY = Build/MdePkg/HostTest
> + SUPPORTED_ARCHITECTURES = IA32|X64
> + BUILD_TARGETS = NOOPT
> + SKUID_IDENTIFIER = DEFAULT
> +
> +!include UnitTestFrameworkPkg/UnitTestFrameworkPkgHost.dsc.inc
> +
> +[LibraryClasses]
> + SafeIntLib|MdePkg/Library/BaseSafeIntLib/BaseSafeIntLib.inf
> +
> +[Components]
> + #
> + # Build HOST_APPLICATION that tests the SafeIntLib
> + #
> + MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntLibHost.inf
> + MdePkg/Test/UnitTest/Library/BaseLib/BaseLibUnitTestsHost.inf
> diff --git a/MdePkg/Test/UnitTest/Library/BaseLib/Base64UnitTest.c b/MdePkg/Test/UnitTest/Library/BaseLib/Base64UnitTest.c
> new file mode 100644
> index 0000000000..0ad078155c
> --- /dev/null
> +++ b/MdePkg/Test/UnitTest/Library/BaseLib/Base64UnitTest.c
> @@ -0,0 +1,404 @@
> +/** @file
> + Unit tests of Base64 conversion APIs in BaseLib.
> +
> + Copyright (C) Microsoft Corporation.
> + SPDX-License-Identifier: BSD-2-Clause-Patent
> +
> +**/
> +
> +#include <Uefi.h>
> +#include <Library/BaseLib.h>
> +#include <Library/BaseMemoryLib.h>
> +#include <Library/DebugLib.h>
> +#include <Library/MemoryAllocationLib.h>
> +#include <Library/UnitTestLib.h>
> +
> +#define UNIT_TEST_APP_NAME "BaseLib Unit Test Application"
> +#define UNIT_TEST_APP_VERSION "1.0"
> +
> +/**
> + RFC 4648 https://tools.ietf.org/html/rfc4648 test vectors
> +
> + BASE64("") = ""
> + BASE64("f") = "Zg=="
> + BASE64("fo") = "Zm8="
> + BASE64("foo") = "Zm9v"
> + BASE64("foob") = "Zm9vYg=="
> + BASE64("fooba") = "Zm9vYmE="
> + BASE64("foobar") = "Zm9vYmFy"
> +
> + The test vectors are using ascii strings for the binary data
> + */
> +
> +typedef struct {
> + CHAR8 *TestInput;
> + CHAR8 *TestOutput;
> + EFI_STATUS ExpectedStatus;
> + VOID *BufferToFree;
> + UINTN ExpectedSize;
> +} BASIC_TEST_CONTEXT;
> +
> +#define B64_TEST_1 ""
> +#define BIN_TEST_1 ""
> +
> +#define B64_TEST_2 "Zg=="
> +#define BIN_TEST_2 "f"
> +
> +#define B64_TEST_3 "Zm8="
> +#define BIN_TEST_3 "fo"
> +
> +#define B64_TEST_4 "Zm9v"
> +#define BIN_TEST_4 "foo"
> +
> +#define B64_TEST_5 "Zm9vYg=="
> +#define BIN_TEST_5 "foob"
> +
> +#define B64_TEST_6 "Zm9vYmE="
> +#define BIN_TEST_6 "fooba"
> +
> +#define B64_TEST_7 "Zm9vYmFy"
> +#define BIN_TEST_7 "foobar"
> +
> +// Adds all white space - also ends the last quantum with only spaces afterwards
> +#define B64_TEST_8_IN " \t\v Zm9\r\nvYmFy \f "
> +#define BIN_TEST_8 "foobar"
> +
> +// Not a quantum multiple of 4
> +#define B64_ERROR_1 "Zm9vymFy="
> +
> +// Invalid characters in the string
> +#define B64_ERROR_2 "Zm$vymFy"
> +
> +// Too many '=' characters
> +#define B64_ERROR_3 "Z==="
> +
> +// Poorly placed '='
> +#define B64_ERROR_4 "Zm=vYmFy"
> +
> +#define MAX_TEST_STRING_SIZE (200)
> +
> +// ------------------------------------------------ Input----------Output-----------Result-------Free--Expected Output Size
> +static BASIC_TEST_CONTEXT mBasicEncodeTest1 = {BIN_TEST_1, B64_TEST_1, EFI_SUCCESS, NULL, sizeof(B64_TEST_1)};
> +static BASIC_TEST_CONTEXT mBasicEncodeTest2 = {BIN_TEST_2, B64_TEST_2, EFI_SUCCESS, NULL, sizeof(B64_TEST_2)};
> +static BASIC_TEST_CONTEXT mBasicEncodeTest3 = {BIN_TEST_3, B64_TEST_3, EFI_SUCCESS, NULL, sizeof(B64_TEST_3)};
> +static BASIC_TEST_CONTEXT mBasicEncodeTest4 = {BIN_TEST_4, B64_TEST_4, EFI_SUCCESS, NULL, sizeof(B64_TEST_4)};
> +static BASIC_TEST_CONTEXT mBasicEncodeTest5 = {BIN_TEST_5, B64_TEST_5, EFI_SUCCESS, NULL, sizeof(B64_TEST_5)};
> +static BASIC_TEST_CONTEXT mBasicEncodeTest6 = {BIN_TEST_6, B64_TEST_6, EFI_SUCCESS, NULL, sizeof(B64_TEST_6)};
> +static BASIC_TEST_CONTEXT mBasicEncodeTest7 = {BIN_TEST_7, B64_TEST_7, EFI_SUCCESS, NULL, sizeof(B64_TEST_7)};
> +static BASIC_TEST_CONTEXT mBasicEncodeError1 = {BIN_TEST_7, B64_TEST_1, EFI_BUFFER_TOO_SMALL, NULL,
> sizeof(B64_TEST_7)};
> +
> +static BASIC_TEST_CONTEXT mBasicDecodeTest1 = {B64_TEST_1, BIN_TEST_1, EFI_SUCCESS, NULL, sizeof(BIN_TEST_1)-1};
> +static BASIC_TEST_CONTEXT mBasicDecodeTest2 = {B64_TEST_2, BIN_TEST_2, EFI_SUCCESS, NULL, sizeof(BIN_TEST_2)-1};
> +static BASIC_TEST_CONTEXT mBasicDecodeTest3 = {B64_TEST_3, BIN_TEST_3, EFI_SUCCESS, NULL, sizeof(BIN_TEST_3)-1};
> +static BASIC_TEST_CONTEXT mBasicDecodeTest4 = {B64_TEST_4, BIN_TEST_4, EFI_SUCCESS, NULL, sizeof(BIN_TEST_4)-1};
> +static BASIC_TEST_CONTEXT mBasicDecodeTest5 = {B64_TEST_5, BIN_TEST_5, EFI_SUCCESS, NULL, sizeof(BIN_TEST_5)-1};
> +static BASIC_TEST_CONTEXT mBasicDecodeTest6 = {B64_TEST_6, BIN_TEST_6, EFI_SUCCESS, NULL, sizeof(BIN_TEST_6)-1};
> +static BASIC_TEST_CONTEXT mBasicDecodeTest7 = {B64_TEST_7, BIN_TEST_7, EFI_SUCCESS, NULL, sizeof(BIN_TEST_7)-1};
> +static BASIC_TEST_CONTEXT mBasicDecodeTest8 = {B64_TEST_8_IN, BIN_TEST_8, EFI_SUCCESS, NULL, sizeof(BIN_TEST_8)-1};
> +
> +static BASIC_TEST_CONTEXT mBasicDecodeError1 = {B64_ERROR_1, B64_ERROR_1, EFI_INVALID_PARAMETER, NULL, 0};
> +static BASIC_TEST_CONTEXT mBasicDecodeError2 = {B64_ERROR_2, B64_ERROR_2, EFI_INVALID_PARAMETER, NULL, 0};
> +static BASIC_TEST_CONTEXT mBasicDecodeError3 = {B64_ERROR_3, B64_ERROR_3, EFI_INVALID_PARAMETER, NULL, 0};
> +static BASIC_TEST_CONTEXT mBasicDecodeError4 = {B64_ERROR_4, B64_ERROR_4, EFI_INVALID_PARAMETER, NULL, 0};
> +static BASIC_TEST_CONTEXT mBasicDecodeError5 = {B64_TEST_7, BIN_TEST_1, EFI_BUFFER_TOO_SMALL, NULL,
> sizeof(BIN_TEST_7)-1};
> +
> +/**
> + Simple clean up method to make sure tests clean up even if interrupted and fail
> + in the middle.
> +**/
> +STATIC
> +VOID
> +EFIAPI
> +CleanUpB64TestContext (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + BASIC_TEST_CONTEXT *Btc;
> +
> + Btc = (BASIC_TEST_CONTEXT *)Context;
> + if (Btc != NULL) {
> + //free string if set
> + if (Btc->BufferToFree != NULL) {
> + FreePool (Btc->BufferToFree);
> + Btc->BufferToFree = NULL;
> + }
> + }
> +}
> +
> +/**
> + Unit test for Base64 encode APIs of BaseLib.
> +
> + @param[in] Context [Optional] An optional paramter that enables:
> + 1) test-case reuse with varied parameters and
> + 2) test-case re-entry for Target tests that need a
> + reboot. This parameter is a VOID* and it is the
> + responsibility of the test author to ensure that the
> + contents are well understood by all test cases that may
> + consume it.
> +
> + @retval UNIT_TEST_PASSED The Unit test has completed and the test
> + case was successful.
> + @retval UNIT_TEST_ERROR_TEST_FAILED A test case assertion has failed.
> +**/
> +STATIC
> +UNIT_TEST_STATUS
> +EFIAPI
> +RfcEncodeTest (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + BASIC_TEST_CONTEXT *Btc;
> + CHAR8 *b64String;
> + CHAR8 *binString;
> + UINTN b64StringSize;
> + EFI_STATUS Status;
> + UINT8 *BinData;
> + UINTN BinSize;
> + CHAR8 *b64WorkString;
> + UINTN ReturnSize;
> + INTN CompareStatus;
> + UINTN indx;
> +
> + Btc = (BASIC_TEST_CONTEXT *) Context;
> + binString = Btc->TestInput;
> + b64String = Btc->TestOutput;
> +
> + //
> + // Only testing the the translate functionality, so preallocate the proper
> + // string buffer.
> + //
> +
> + b64StringSize = AsciiStrnSizeS(b64String, MAX_TEST_STRING_SIZE);
> + BinSize = AsciiStrnLenS(binString, MAX_TEST_STRING_SIZE);
> + BinData = (UINT8 *) binString;
> +
> + b64WorkString = (CHAR8 *) AllocatePool(b64StringSize);
> + UT_ASSERT_NOT_NULL(b64WorkString);
> +
> + Btc->BufferToFree = b64WorkString;
> + ReturnSize = b64StringSize;
> +
> + Status = Base64Encode(BinData, BinSize, b64WorkString, &ReturnSize);
> +
> + UT_ASSERT_STATUS_EQUAL(Status, Btc->ExpectedStatus);
> +
> + UT_ASSERT_EQUAL(ReturnSize, Btc->ExpectedSize);
> +
> + if (!EFI_ERROR (Btc->ExpectedStatus)) {
> + if (ReturnSize != 0) {
> + CompareStatus = AsciiStrnCmp (b64String, b64WorkString, ReturnSize);
> + if (CompareStatus != 0) {
> + UT_LOG_ERROR ("b64 string compare error - size=%d\n", ReturnSize);
> + for (indx = 0; indx < ReturnSize; indx++) {
> + UT_LOG_ERROR (" %2.2x", 0xff & b64String[indx]);
> + }
> + UT_LOG_ERROR ("\n b64 work string:\n");
> + for (indx = 0; indx < ReturnSize; indx++) {
> + UT_LOG_ERROR (" %2.2x", 0xff & b64WorkString[indx]);
> + }
> + UT_LOG_ERROR ("\n");
> + }
> + UT_ASSERT_EQUAL (CompareStatus, 0);
> + }
> + }
> +
> + Btc->BufferToFree = NULL;
> + FreePool (b64WorkString);
> + return UNIT_TEST_PASSED;
> +}
> +
> +/**
> + Unit test for Base64 decode APIs of BaseLib.
> +
> + @param[in] Context [Optional] An optional paramter that enables:
> + 1) test-case reuse with varied parameters and
> + 2) test-case re-entry for Target tests that need a
> + reboot. This parameter is a VOID* and it is the
> + responsibility of the test author to ensure that the
> + contents are well understood by all test cases that may
> + consume it.
> +
> + @retval UNIT_TEST_PASSED The Unit test has completed and the test
> + case was successful.
> + @retval UNIT_TEST_ERROR_TEST_FAILED A test case assertion has failed.
> +**/
> +STATIC
> +UNIT_TEST_STATUS
> +EFIAPI
> +RfcDecodeTest(
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + BASIC_TEST_CONTEXT *Btc;
> + CHAR8 *b64String;
> + CHAR8 *binString;
> + EFI_STATUS Status;
> + UINTN b64StringLen;
> + UINTN ReturnSize;
> + UINT8 *BinData;
> + UINTN BinSize;
> + INTN CompareStatus;
> + UINTN indx;
> +
> + Btc = (BASIC_TEST_CONTEXT *)Context;
> + b64String = Btc->TestInput;
> + binString = Btc->TestOutput;
> +
> + //
> + // Only testing the the translate functionality
> + //
> +
> + b64StringLen = AsciiStrnLenS (b64String, MAX_TEST_STRING_SIZE);
> + BinSize = AsciiStrnLenS (binString, MAX_TEST_STRING_SIZE);
> +
> + BinData = AllocatePool (BinSize);
> + Btc->BufferToFree = BinData;
> +
> + ReturnSize = BinSize;
> + Status = Base64Decode (b64String, b64StringLen, BinData, &ReturnSize);
> +
> + UT_ASSERT_STATUS_EQUAL (Status, Btc->ExpectedStatus);
> +
> + // If an error is not expected, check the results
> + if (EFI_ERROR (Btc->ExpectedStatus)) {
> + if (Btc->ExpectedStatus == EFI_BUFFER_TOO_SMALL) {
> + UT_ASSERT_EQUAL (ReturnSize, Btc->ExpectedSize);
> + }
> + } else {
> + UT_ASSERT_EQUAL (ReturnSize, Btc->ExpectedSize);
> + if (ReturnSize != 0) {
> + CompareStatus = CompareMem (binString, BinData, ReturnSize);
> + if (CompareStatus != 0) {
> + UT_LOG_ERROR ("bin string compare error - size=%d\n", ReturnSize);
> + for (indx = 0; indx < ReturnSize; indx++) {
> + UT_LOG_ERROR (" %2.2x", 0xff & binString[indx]);
> + }
> + UT_LOG_ERROR ("\nBinData:\n");
> + for (indx = 0; indx < ReturnSize; indx++) {
> + UT_LOG_ERROR (" %2.2x", 0xff & BinData[indx]);
> + }
> + UT_LOG_ERROR ("\n");
> + }
> + UT_ASSERT_EQUAL (CompareStatus, 0);
> + }
> + }
> +
> + Btc->BufferToFree = NULL;
> + FreePool (BinData);
> + return UNIT_TEST_PASSED;
> +}
> +
> +/**
> + Initialze the unit test framework, suite, and unit tests for the
> + Base64 conversion APIs of BaseLib and run the unit tests.
> +
> + @retval EFI_SUCCESS All test cases were dispached.
> + @retval EFI_OUT_OF_RESOURCES There are not enough resources available to
> + initialize the unit tests.
> +**/
> +STATIC
> +EFI_STATUS
> +EFIAPI
> +UnitTestingEntry (
> + VOID
> + )
> +{
> + EFI_STATUS Status;
> + UNIT_TEST_FRAMEWORK_HANDLE Fw;
> + UNIT_TEST_SUITE_HANDLE b64EncodeTests;
> + UNIT_TEST_SUITE_HANDLE b64DecodeTests;
> +
> + Fw = NULL;
> +
> + DEBUG ((DEBUG_INFO, "%a v%a\n", UNIT_TEST_APP_NAME, UNIT_TEST_APP_VERSION));
> +
> + //
> + // Start setting up the test framework for running the tests.
> + //
> + Status = InitUnitTestFramework (&Fw, UNIT_TEST_APP_NAME, gEfiCallerBaseName, UNIT_TEST_APP_VERSION);
> + if (EFI_ERROR (Status)) {
> + DEBUG ((DEBUG_ERROR, "Failed in InitUnitTestFramework. Status = %r\n", Status));
> + goto EXIT;
> + }
> +
> + //
> + // Populate the B64 Encode Unit Test Suite.
> + //
> + Status = CreateUnitTestSuite (&b64EncodeTests, Fw, "b64 Encode binary to Ascii string", "BaseLib.b64Encode", NULL, NULL);
> + if (EFI_ERROR (Status)) {
> + DEBUG ((DEBUG_ERROR, "Failed in CreateUnitTestSuite for b64EncodeTests\n"));
> + Status = EFI_OUT_OF_RESOURCES;
> + goto EXIT;
> + }
> +
> + // --------------Suite-----------Description--------------Class Name----------Function--------Pre---Post-------------------Context-----------
> + AddTestCase (b64EncodeTests, "RFC 4686 Test Vector - Empty", "Test1", RfcEncodeTest, NULL, CleanUpB64TestContext,
> &mBasicEncodeTest1);
> + AddTestCase (b64EncodeTests, "RFC 4686 Test Vector - f", "Test2", RfcEncodeTest, NULL, CleanUpB64TestContext,
> &mBasicEncodeTest2);
> + AddTestCase (b64EncodeTests, "RFC 4686 Test Vector - fo", "Test3", RfcEncodeTest, NULL, CleanUpB64TestContext,
> &mBasicEncodeTest3);
> + AddTestCase (b64EncodeTests, "RFC 4686 Test Vector - foo", "Test4", RfcEncodeTest, NULL, CleanUpB64TestContext,
> &mBasicEncodeTest4);
> + AddTestCase (b64EncodeTests, "RFC 4686 Test Vector - foob", "Test5", RfcEncodeTest, NULL, CleanUpB64TestContext,
> &mBasicEncodeTest5);
> + AddTestCase (b64EncodeTests, "RFC 4686 Test Vector - fooba", "Test6", RfcEncodeTest, NULL, CleanUpB64TestContext,
> &mBasicEncodeTest6);
> + AddTestCase (b64EncodeTests, "RFC 4686 Test Vector - foobar", "Test7", RfcEncodeTest, NULL, CleanUpB64TestContext,
> &mBasicEncodeTest7);
> + AddTestCase (b64EncodeTests, "Too small of output buffer", "Error1", RfcEncodeTest, NULL, CleanUpB64TestContext,
> &mBasicEncodeError1);
> + //
> + // Populate the B64 Decode Unit Test Suite.
> + //
> + Status = CreateUnitTestSuite (&b64DecodeTests, Fw, "b64 Decode Ascii string to binary", "BaseLib.b64Decode", NULL, NULL);
> + if (EFI_ERROR (Status)) {
> + DEBUG ((DEBUG_ERROR, "Failed in CreateUnitTestSuite for b64Decode Tests\n"));
> + Status = EFI_OUT_OF_RESOURCES;
> + goto EXIT;
> + }
> +
> + AddTestCase (b64DecodeTests, "RFC 4686 Test Vector - Empty", "Test1", RfcDecodeTest, NULL, CleanUpB64TestContext,
> &mBasicDecodeTest1);
> + AddTestCase (b64DecodeTests, "RFC 4686 Test Vector - f", "Test2", RfcDecodeTest, NULL, CleanUpB64TestContext,
> &mBasicDecodeTest2);
> + AddTestCase (b64DecodeTests, "RFC 4686 Test Vector - fo", "Test3", RfcDecodeTest, NULL, CleanUpB64TestContext,
> &mBasicDecodeTest3);
> + AddTestCase (b64DecodeTests, "RFC 4686 Test Vector - foo", "Test4", RfcDecodeTest, NULL, CleanUpB64TestContext,
> &mBasicDecodeTest4);
> + AddTestCase (b64DecodeTests, "RFC 4686 Test Vector - foob", "Test5", RfcDecodeTest, NULL, CleanUpB64TestContext,
> &mBasicDecodeTest5);
> + AddTestCase (b64DecodeTests, "RFC 4686 Test Vector - fooba", "Test6", RfcDecodeTest, NULL, CleanUpB64TestContext,
> &mBasicDecodeTest6);
> + AddTestCase (b64DecodeTests, "RFC 4686 Test Vector - foobar", "Test7", RfcDecodeTest, NULL, CleanUpB64TestContext,
> &mBasicDecodeTest7);
> + AddTestCase (b64DecodeTests, "Ignore Whitespace test", "Test8", RfcDecodeTest, NULL, CleanUpB64TestContext,
> &mBasicDecodeTest8);
> +
> + AddTestCase (b64DecodeTests, "Not a quantum multiple of 4", "Error1", RfcDecodeTest, NULL, CleanUpB64TestContext,
> &mBasicDecodeError1);
> + AddTestCase (b64DecodeTests, "Invalid characters in the string", "Error2", RfcDecodeTest, NULL, CleanUpB64TestContext,
> &mBasicDecodeError2);
> + AddTestCase (b64DecodeTests, "Too many padding characters", "Error3", RfcDecodeTest, NULL, CleanUpB64TestContext,
> &mBasicDecodeError3);
> + AddTestCase (b64DecodeTests, "Incorrectly placed padding character", "Error4", RfcDecodeTest, NULL, CleanUpB64TestContext,
> &mBasicDecodeError4);
> + AddTestCase (b64DecodeTests, "Too small of output buffer", "Error5", RfcDecodeTest, NULL, CleanUpB64TestContext,
> &mBasicDecodeError5);
> +
> + //
> + // Execute the tests.
> + //
> + Status = RunAllTestSuites (Fw);
> +
> +EXIT:
> + if (Fw) {
> + FreeUnitTestFramework (Fw);
> + }
> +
> + return Status;
> +}
> +
> +/**
> + Standard UEFI entry point for target based unit test execution from UEFI Shell.
> +**/
> +EFI_STATUS
> +EFIAPI
> +BaseLibUnitTestAppEntry (
> + IN EFI_HANDLE ImageHandle,
> + IN EFI_SYSTEM_TABLE *SystemTable
> + )
> +{
> + return UnitTestingEntry ();
> +}
> +
> +/**
> + Standard POSIX C entry point for host based unit test execution.
> +**/
> +int
> +main (
> + int argc,
> + char *argv[]
> + )
> +{
> + return UnitTestingEntry ();
> +}
> diff --git a/MdePkg/Test/UnitTest/Library/BaseLib/BaseLibUnitTestsHost.inf
> b/MdePkg/Test/UnitTest/Library/BaseLib/BaseLibUnitTestsHost.inf
> new file mode 100644
> index 0000000000..b31afae633
> --- /dev/null
> +++ b/MdePkg/Test/UnitTest/Library/BaseLib/BaseLibUnitTestsHost.inf
> @@ -0,0 +1,32 @@
> +## @file
> +# Unit tests of Base64 conversion APIs in BaseLib that are run from host
> +# environment.
> +#
> +# Copyright (C) Microsoft Corporation.
> +# SPDX-License-Identifier: BSD-2-Clause-Patent
> +##
> +
> +[Defines]
> + INF_VERSION = 0x00010006
> + BASE_NAME = BaseLibUnitTestsHost
> + FILE_GUID = 1d005f4c-4dfa-41b5-ab0c-be91fe121459
> + MODULE_TYPE = HOST_APPLICATION
> + VERSION_STRING = 1.0
> +
> +#
> +# The following information is for reference only and not required by the build tools.
> +#
> +# VALID_ARCHITECTURES = IA32 X64
> +#
> +
> +[Sources]
> + Base64UnitTest.c
> +
> +[Packages]
> + MdePkg/MdePkg.dec
> +
> +[LibraryClasses]
> + BaseLib
> + BaseMemoryLib
> + DebugLib
> + UnitTestLib
> diff --git a/MdePkg/Test/UnitTest/Library/BaseLib/BaseLibUnitTestsUefi.inf
> b/MdePkg/Test/UnitTest/Library/BaseLib/BaseLibUnitTestsUefi.inf
> new file mode 100644
> index 0000000000..907503898a
> --- /dev/null
> +++ b/MdePkg/Test/UnitTest/Library/BaseLib/BaseLibUnitTestsUefi.inf
> @@ -0,0 +1,33 @@
> +## @file
> +# Unit tests of Base64 conversion APIs in BaseLib that are run from UEFI Shell.
> +#
> +# Copyright (C) Microsoft Corporation.
> +# SPDX-License-Identifier: BSD-2-Clause-Patent
> +##
> +
> +[Defines]
> + INF_VERSION = 0x00010006
> + BASE_NAME = BaseLibUnitTestsUefi
> + FILE_GUID = df5a6fed-8786-4a9d-9d02-eab39497b4a1
> + MODULE_TYPE = UEFI_APPLICATION
> + VERSION_STRING = 1.0
> + ENTRY_POINT = BaseLibUnitTestAppEntry
> +
> +#
> +# The following information is for reference only and not required by the build tools.
> +#
> +# VALID_ARCHITECTURES = IA32 X64
> +#
> +
> +[Sources]
> + Base64UnitTest.c
> +
> +[Packages]
> + MdePkg/MdePkg.dec
> +
> +[LibraryClasses]
> + BaseLib
> + BaseMemoryLib
> + UefiApplicationEntryPoint
> + DebugLib
> + UnitTestLib
> diff --git a/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/SafeIntLibUintnIntnUnitTests32.c
> b/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/SafeIntLibUintnIntnUnitTests32.c
> new file mode 100644
> index 0000000000..be5c0e15d3
> --- /dev/null
> +++ b/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/SafeIntLibUintnIntnUnitTests32.c
> @@ -0,0 +1,540 @@
> +/** @file
> + IA32-specific functions for unit-testing INTN and UINTN functions in
> + SafeIntLib.
> +
> + Copyright (c) Microsoft Corporation.<BR>
> + Copyright (c) 2019 - 2020, Intel Corporation. All rights reserved.<BR>
> + SPDX-License-Identifier: BSD-2-Clause-Patent
> +
> +**/
> +
> +#include "TestBaseSafeIntLib.h"
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeInt32ToUintn (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + INT32 Operand;
> + UINTN Result;
> +
> + //
> + // If Operand is non-negative, then it's a cast
> + //
> + Operand = 0x5bababab;
> + Result = 0;
> + Status = SafeInt32ToUintn(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x5bababab, Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Operand = (-1537977259);
> + Status = SafeInt32ToUintn(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUint32ToIntn (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + UINT32 Operand;
> + INTN Result;
> +
> + //
> + // If Operand is <= MAX_INTN, then it's a cast
> + //
> + Operand = 0x5bababab;
> + Result = 0;
> + Status = SafeUint32ToIntn(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x5bababab, Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Operand = (0xabababab);
> + Status = SafeUint32ToIntn(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeIntnToInt32 (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + INTN Operand;
> + INT32 Result;
> +
> + //
> + // INTN is same as INT32 in IA32, so this is just a cast
> + //
> + Operand = 0x5bababab;
> + Result = 0;
> + Status = SafeIntnToInt32(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x5bababab, Result);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeIntnToUint32 (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + INTN Operand;
> + UINT32 Result;
> +
> + //
> + // If Operand is non-negative, then it's a cast
> + //
> + Operand = 0x5bababab;
> + Result = 0;
> + Status = SafeIntnToUint32(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x5bababab, Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Operand = (-1537977259);
> + Status = SafeIntnToUint32(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUintnToUint32 (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + UINTN Operand;
> + UINT32 Result;
> +
> + //
> + // UINTN is same as UINT32 in IA32, so this is just a cast
> + //
> + Operand = 0xabababab;
> + Result = 0;
> + Status = SafeUintnToUint32(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0xabababab, Result);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUintnToIntn (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + UINTN Operand;
> + INTN Result;
> +
> + //
> + // If Operand is <= MAX_INTN, then it's a cast
> + //
> + Operand = 0x5bababab;
> + Result = 0;
> + Status = SafeUintnToIntn(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x5bababab, Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Operand = (0xabababab);
> + Status = SafeUintnToIntn(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUintnToInt64 (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + UINTN Operand;
> + INT64 Result;
> +
> + //
> + // UINTN is same as UINT32 in IA32, and UINT32 is a subset of
> + // INT64, so this is just a cast
> + //
> + Operand = 0xabababab;
> + Result = 0;
> + Status = SafeUintnToInt64(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0xabababab, Result);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeInt64ToIntn (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + INT64 Operand;
> + INTN Result;
> +
> + //
> + // If Operand is between MIN_INTN and MAX_INTN2 inclusive, then it's a cast
> + //
> + Operand = 0x5bababab;
> + Result = 0;
> + Status = SafeInt64ToIntn(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x5bababab, Result);
> +
> + Operand = (-1537977259);
> + Status = SafeInt64ToIntn(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL((-1537977259), Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Operand = (0x5babababefefefef);
> + Status = SafeInt64ToIntn(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + Operand = (-6605562033422200815);
> + Status = SafeInt64ToIntn(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeInt64ToUintn (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + INT64 Operand;
> + UINTN Result;
> +
> + //
> + // If Operand is between 0 and MAX_UINTN inclusive, then it's a cast
> + //
> + Operand = 0xabababab;
> + Result = 0;
> + Status = SafeInt64ToUintn(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0xabababab, Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Operand = (0x5babababefefefef);
> + Status = SafeInt64ToUintn(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + Operand = (-6605562033422200815);
> + Status = SafeInt64ToUintn(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUint64ToIntn (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + UINT64 Operand;
> + INTN Result;
> +
> + //
> + // If Operand is <= MAX_INTN, then it's a cast
> + //
> + Operand = 0x5bababab;
> + Result = 0;
> + Status = SafeUint64ToIntn(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x5bababab, Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Operand = (0xababababefefefef);
> + Status = SafeUint64ToIntn(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUint64ToUintn (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + UINT64 Operand;
> + UINTN Result;
> +
> + //
> + // If Operand is <= MAX_UINTN, then it's a cast
> + //
> + Operand = 0xabababab;
> + Result = 0;
> + Status = SafeUint64ToUintn(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0xabababab, Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Operand = (0xababababefefefef);
> + Status = SafeUint64ToUintn(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUintnAdd (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + UINTN Augend;
> + UINTN Addend;
> + UINTN Result;
> +
> + //
> + // If the result of addition doesn't overflow MAX_UINTN, then it's addition
> + //
> + Augend = 0x3a3a3a3a;
> + Addend = 0x3a3a3a3a;
> + Result = 0;
> + Status = SafeUintnAdd(Augend, Addend, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x74747474, Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Augend = 0xabababab;
> + Addend = 0xbcbcbcbc;
> + Status = SafeUintnAdd(Augend, Addend, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeIntnAdd (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + INTN Augend;
> + INTN Addend;
> + INTN Result;
> +
> + //
> + // If the result of addition doesn't overflow MAX_INTN
> + // and doesn't underflow MIN_INTN, then it's addition
> + //
> + Augend = 0x3a3a3a3a;
> + Addend = 0x3a3a3a3a;
> + Result = 0;
> + Status = SafeIntnAdd(Augend, Addend, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x74747474, Result);
> +
> + Augend = (-976894522);
> + Addend = (-976894522);
> + Status = SafeIntnAdd(Augend, Addend, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL((-1953789044), Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Augend = 0x5a5a5a5a;
> + Addend = 0x5a5a5a5a;
> + Status = SafeIntnAdd(Augend, Addend, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + Augend = (-1515870810);
> + Addend = (-1515870810);
> + Status = SafeIntnAdd(Augend, Addend, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUintnSub (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + UINTN Minuend;
> + UINTN Subtrahend;
> + UINTN Result;
> +
> + //
> + // If Minuend >= Subtrahend, then it's subtraction
> + //
> + Minuend = 0x5a5a5a5a;
> + Subtrahend = 0x3b3b3b3b;
> + Result = 0;
> + Status = SafeUintnSub(Minuend, Subtrahend, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x1f1f1f1f, Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Minuend = 0x5a5a5a5a;
> + Subtrahend = 0x6d6d6d6d;
> + Status = SafeUintnSub(Minuend, Subtrahend, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeIntnSub (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + INTN Minuend;
> + INTN Subtrahend;
> + INTN Result;
> +
> + //
> + // If the result of subtractions doesn't overflow MAX_INTN or
> + // underflow MIN_INTN, then it's subtraction
> + //
> + Minuend = 0x5a5a5a5a;
> + Subtrahend = 0x3a3a3a3a;
> + Result = 0;
> + Status = SafeIntnSub(Minuend, Subtrahend, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x20202020, Result);
> +
> + Minuend = 0x3a3a3a3a;
> + Subtrahend = 0x5a5a5a5a;
> + Status = SafeIntnSub(Minuend, Subtrahend, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL((-538976288), Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Minuend = (-2054847098);
> + Subtrahend = 2054847098;
> + Status = SafeIntnSub(Minuend, Subtrahend, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + Minuend = (2054847098);
> + Subtrahend = (-2054847098);
> + Status = SafeIntnSub(Minuend, Subtrahend, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUintnMult (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + UINTN Multiplicand;
> + UINTN Multiplier;
> + UINTN Result;
> +
> + //
> + // If the result of multiplication doesn't overflow MAX_UINTN, it will succeed
> + //
> + Multiplicand = 0xa122a;
> + Multiplier = 0xd23;
> + Result = 0;
> + Status = SafeUintnMult(Multiplicand, Multiplier, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x844c9dbe, Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Multiplicand = 0xa122a;
> + Multiplier = 0xed23;
> + Status = SafeUintnMult(Multiplicand, Multiplier, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeIntnMult (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + INTN Multiplicand;
> + INTN Multiplier;
> + INTN Result;
> +
> + //
> + // If the result of multiplication doesn't overflow MAX_INTN and doesn't
> + // underflow MIN_UINTN, it will succeed
> + //
> + Multiplicand = 0x123456;
> + Multiplier = 0x678;
> + Result = 0;
> + Status = SafeIntnMult(Multiplicand, Multiplier, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x75c28c50, Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Multiplicand = 0x123456;
> + Multiplier = 0xabc;
> + Status = SafeIntnMult(Multiplicand, Multiplier, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> diff --git a/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/SafeIntLibUintnIntnUnitTests64.c
> b/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/SafeIntLibUintnIntnUnitTests64.c
> new file mode 100644
> index 0000000000..0fee298172
> --- /dev/null
> +++ b/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/SafeIntLibUintnIntnUnitTests64.c
> @@ -0,0 +1,544 @@
> +/** @file
> + x64-specific functions for unit-testing INTN and UINTN functions in
> + SafeIntLib.
> +
> + Copyright (c) Microsoft Corporation.<BR>
> + Copyright (c) 2019 - 2020, Intel Corporation. All rights reserved.<BR>
> + SPDX-License-Identifier: BSD-2-Clause-Patent
> +
> +**/
> +
> +#include "TestBaseSafeIntLib.h"
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeInt32ToUintn (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + INT32 Operand;
> + UINTN Result;
> +
> + //
> + // If Operand is non-negative, then it's a cast
> + //
> + Operand = 0x5bababab;
> + Result = 0;
> + Status = SafeInt32ToUintn(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x5bababab, Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Operand = (-1537977259);
> + Status = SafeInt32ToUintn(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUint32ToIntn (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + UINT32 Operand;
> + INTN Result;
> +
> + //
> + // For x64, INTN is same as INT64 which is a superset of INT32
> + // This is just a cast then, and it'll never fail
> + //
> +
> + //
> + // If Operand is non-negative, then it's a cast
> + //
> + Operand = 0xabababab;
> + Result = 0;
> + Status = SafeUint32ToIntn(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0xabababab, Result);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeIntnToInt32 (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + INTN Operand;
> + INT32 Result;
> +
> + //
> + // If Operand is between MIN_INT32 and MAX_INT32 inclusive, then it's a cast
> + //
> + Operand = 0x5bababab;
> + Result = 0;
> + Status = SafeIntnToInt32(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x5bababab, Result);
> +
> + Operand = (-1537977259);
> + Status = SafeIntnToInt32(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL((-1537977259), Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Operand = (0x5babababefefefef);
> + Status = SafeIntnToInt32(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + Operand = (-6605562033422200815);
> + Status = SafeIntnToInt32(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeIntnToUint32 (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + INTN Operand;
> + UINT32 Result;
> +
> + //
> + // If Operand is between 0 and MAX_UINT32 inclusive, then it's a cast
> + //
> + Operand = 0xabababab;
> + Result = 0;
> + Status = SafeIntnToUint32(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0xabababab, Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Operand = (0x5babababefefefef);
> + Status = SafeIntnToUint32(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + Operand = (-6605562033422200815);
> + Status = SafeIntnToUint32(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUintnToUint32 (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + UINTN Operand;
> + UINT32 Result;
> +
> + //
> + // If Operand is <= MAX_UINT32, then it's a cast
> + //
> + Operand = 0xabababab;
> + Result = 0;
> + Status = SafeUintnToUint32(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0xabababab, Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Operand = (0xababababefefefef);
> + Status = SafeUintnToUint32(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUintnToIntn (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + UINTN Operand;
> + INTN Result;
> +
> + //
> + // If Operand is <= MAX_INTN (0x7fff_ffff_ffff_ffff), then it's a cast
> + //
> + Operand = 0x5babababefefefef;
> + Result = 0;
> + Status = SafeUintnToIntn(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x5babababefefefef, Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Operand = (0xababababefefefef);
> + Status = SafeUintnToIntn(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUintnToInt64 (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + UINTN Operand;
> + INT64 Result;
> +
> + //
> + // If Operand is <= MAX_INT64, then it's a cast
> + //
> + Operand = 0x5babababefefefef;
> + Result = 0;
> + Status = SafeUintnToInt64(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x5babababefefefef, Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Operand = (0xababababefefefef);
> + Status = SafeUintnToInt64(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeInt64ToIntn (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + INT64 Operand;
> + INTN Result;
> +
> + //
> + // INTN is same as INT64 in x64, so this is just a cast
> + //
> + Operand = 0x5babababefefefef;
> + Result = 0;
> + Status = SafeInt64ToIntn(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x5babababefefefef, Result);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeInt64ToUintn (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + INT64 Operand;
> + UINTN Result;
> +
> + //
> + // If Operand is non-negative, then it's a cast
> + //
> + Operand = 0x5babababefefefef;
> + Result = 0;
> + Status = SafeInt64ToUintn(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x5babababefefefef, Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Operand = (-6605562033422200815);
> + Status = SafeInt64ToUintn(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUint64ToIntn (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + UINT64 Operand;
> + INTN Result;
> +
> + //
> + // If Operand is <= MAX_INTN (0x7fff_ffff_ffff_ffff), then it's a cast
> + //
> + Operand = 0x5babababefefefef;
> + Result = 0;
> + Status = SafeUint64ToIntn(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x5babababefefefef, Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Operand = (0xababababefefefef);
> + Status = SafeUint64ToIntn(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUint64ToUintn (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + UINT64 Operand;
> + UINTN Result;
> +
> + //
> + // UINTN is same as UINT64 in x64, so this is just a cast
> + //
> + Operand = 0xababababefefefef;
> + Result = 0;
> + Status = SafeUint64ToUintn(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0xababababefefefef, Result);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUintnAdd (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + UINTN Augend;
> + UINTN Addend;
> + UINTN Result;
> +
> + //
> + // If the result of addition doesn't overflow MAX_UINTN, then it's addition
> + //
> + Augend = 0x3a3a3a3a12121212;
> + Addend = 0x3a3a3a3a12121212;
> + Result = 0;
> + Status = SafeUintnAdd(Augend, Addend, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x7474747424242424, Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Augend = 0xababababefefefef;
> + Addend = 0xbcbcbcbcdededede;
> + Status = SafeUintnAdd(Augend, Addend, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeIntnAdd (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + INTN Augend;
> + INTN Addend;
> + INTN Result;
> +
> + //
> + // If the result of addition doesn't overflow MAX_INTN
> + // and doesn't underflow MIN_INTN, then it's addition
> + //
> + Augend = 0x3a3a3a3a3a3a3a3a;
> + Addend = 0x3a3a3a3a3a3a3a3a;
> + Result = 0;
> + Status = SafeIntnAdd(Augend, Addend, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x7474747474747474, Result);
> +
> + Augend = (-4195730024608447034);
> + Addend = (-4195730024608447034);
> + Status = SafeIntnAdd(Augend, Addend, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL((-8391460049216894068), Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Augend = 0x5a5a5a5a5a5a5a5a;
> + Addend = 0x5a5a5a5a5a5a5a5a;
> + Status = SafeIntnAdd(Augend, Addend, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + Augend = (-6510615555426900570);
> + Addend = (-6510615555426900570);
> + Status = SafeIntnAdd(Augend, Addend, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUintnSub (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + UINTN Minuend;
> + UINTN Subtrahend;
> + UINTN Result;
> +
> + //
> + // If Minuend >= Subtrahend, then it's subtraction
> + //
> + Minuend = 0x5a5a5a5a5a5a5a5a;
> + Subtrahend = 0x3b3b3b3b3b3b3b3b;
> + Result = 0;
> + Status = SafeUintnSub(Minuend, Subtrahend, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x1f1f1f1f1f1f1f1f, Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Minuend = 0x5a5a5a5a5a5a5a5a;
> + Subtrahend = 0x6d6d6d6d6d6d6d6d;
> + Status = SafeUintnSub(Minuend, Subtrahend, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeIntnSub (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + INTN Minuend;
> + INTN Subtrahend;
> + INTN Result;
> +
> + //
> + // If the result of subtractions doesn't overflow MAX_INTN or
> + // underflow MIN_INTN, then it's subtraction
> + //
> + Minuend = 0x5a5a5a5a5a5a5a5a;
> + Subtrahend = 0x3a3a3a3a3a3a3a3a;
> + Result = 0;
> + Status = SafeIntnSub(Minuend, Subtrahend, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x2020202020202020, Result);
> +
> + Minuend = 0x3a3a3a3a3a3a3a3a;
> + Subtrahend = 0x5a5a5a5a5a5a5a5a;
> + Status = SafeIntnSub(Minuend, Subtrahend, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL((-2314885530818453536), Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Minuend = (-8825501086245354106);
> + Subtrahend = 8825501086245354106;
> + Status = SafeIntnSub(Minuend, Subtrahend, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + Minuend = (8825501086245354106);
> + Subtrahend = (-8825501086245354106);
> + Status = SafeIntnSub(Minuend, Subtrahend, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUintnMult (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + UINTN Multiplicand;
> + UINTN Multiplier;
> + UINTN Result;
> +
> + //
> + // If the result of multiplication doesn't overflow MAX_UINTN, it will succeed
> + //
> + Multiplicand = 0x123456789a;
> + Multiplier = 0x1234567;
> + Result = 0;
> + Status = SafeUintnMult(Multiplicand, Multiplier, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x14b66db9745a07f6, Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Multiplicand = 0x123456789a;
> + Multiplier = 0x12345678;
> + Status = SafeUintnMult(Multiplicand, Multiplier, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeIntnMult (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + INTN Multiplicand;
> + INTN Multiplier;
> + INTN Result;
> +
> + //
> + // If the result of multiplication doesn't overflow MAX_INTN and doesn't
> + // underflow MIN_UINTN, it will succeed
> + //
> + Multiplicand = 0x123456789;
> + Multiplier = 0x6789abcd;
> + Result = 0;
> + Status = SafeIntnMult(Multiplicand, Multiplier, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x75cd9045220d6bb5, Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Multiplicand = 0x123456789;
> + Multiplier = 0xa789abcd;
> + Status = SafeIntnMult(Multiplicand, Multiplier, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> diff --git a/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntLib.c
> b/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntLib.c
> new file mode 100644
> index 0000000000..2b1a2223a0
> --- /dev/null
> +++ b/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntLib.c
> @@ -0,0 +1,3064 @@
> +/** @file
> + UEFI OS based application for unit testing the SafeIntLib.
> +
> + Copyright (c) Microsoft Corporation.<BR>
> + Copyright (c) 2018 - 2020, Intel Corporation. All rights reserved.<BR>
> + SPDX-License-Identifier: BSD-2-Clause-Patent
> +
> +**/
> +
> +#include "TestBaseSafeIntLib.h"
> +
> +#define UNIT_TEST_NAME "Int Safe Lib Unit Test Application"
> +#define UNIT_TEST_VERSION "0.1"
> +
> +//
> +// Conversion function tests:
> +//
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeInt8ToUint8 (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + INT8 Operand;
> + UINT8 Result;
> +
> + //
> + // Positive UINT8 should result in just a cast
> + //
> + Operand = 0x5b;
> + Result = 0;
> + Status = SafeInt8ToUint8(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x5b, Result);
> +
> + //
> + // Negative number should result in an error status
> + //
> + Operand = (-56);
> + Status = SafeInt8ToUint8(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeInt8ToUint16 (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + INT8 Operand;
> + UINT16 Result;
> +
> + //
> + // Positive UINT8 should result in just a cast
> + //
> + Operand = 0x5b;
> + Result = 0;
> + Status = SafeInt8ToUint16(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x5b, Result);
> +
> + //
> + // Negative number should result in an error status
> + //
> + Operand = (-56);
> + Status = SafeInt8ToUint16(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeInt8ToUint32 (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + INT8 Operand;
> + UINT32 Result;
> +
> + //
> + // Positive UINT8 should result in just a cast
> + //
> + Operand = 0x5b;
> + Result = 0;
> + Status = SafeInt8ToUint32(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x5b, Result);
> +
> + //
> + // Negative number should result in an error status
> + //
> + Operand = (-56);
> + Status = SafeInt8ToUint32(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeInt8ToUintn (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + INT8 Operand;
> + UINTN Result;
> +
> + //
> + // Positive UINT8 should result in just a cast
> + //
> + Operand = 0x5b;
> + Result = 0;
> + Status = SafeInt8ToUintn(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x5b, Result);
> +
> + //
> + // Negative number should result in an error status
> + //
> + Operand = (-56);
> + Status = SafeInt8ToUintn(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeInt8ToUint64 (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + INT8 Operand;
> + UINT64 Result;
> +
> + //
> + // Positive UINT8 should result in just a cast
> + //
> + Operand = 0x5b;
> + Result = 0;
> + Status = SafeInt8ToUint64(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x5b, Result);
> +
> + //
> + // Negative number should result in an error status
> + //
> + Operand = (-56);
> + Status = SafeInt8ToUint64(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUint8ToInt8 (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + UINT8 Operand;
> + INT8 Result;
> +
> + //
> + // Operand <= 0x7F (MAX_INT8) should result in a cast
> + //
> + Operand = 0x5b;
> + Result = 0;
> + Status = SafeUint8ToInt8(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x5b, Result);
> +
> + //
> + // Operand larger than 0x7f should result in an error status
> + //
> + Operand = 0xaf;
> + Status = SafeUint8ToInt8(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUint8ToChar8 (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + UINT8 Operand;
> + CHAR8 Result;
> +
> + //
> + // CHAR8 is typedefed as char, which by default is signed, thus
> + // CHAR8 is same as INT8, so same tests as above:
> + //
> +
> + //
> + // Operand <= 0x7F (MAX_INT8) should result in a cast
> + //
> + Operand = 0x5b;
> + Result = 0;
> + Status = SafeUint8ToChar8(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x5b, Result);
> +
> + //
> + // Operand larger than 0x7f should result in an error status
> + //
> + Operand = 0xaf;
> + Status = SafeUint8ToChar8(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeInt16ToInt8 (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + INT16 Operand;
> + INT8 Result;
> +
> + //
> + // If Operand is between MIN_INT8 and MAX_INT8 inclusive, then it's a cast
> + //
> + Operand = 0x5b;
> + Result = 0;
> + Status = SafeInt16ToInt8(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x5b, Result);
> +
> + Operand = (-35);
> + Status = SafeInt16ToInt8(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL((-35), Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Operand = 0x1234;
> + Status = SafeInt16ToInt8(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + Operand = (-17835);
> + Status = SafeInt16ToInt8(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeInt16ToChar8 (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + INT16 Operand;
> + CHAR8 Result;
> +
> + //
> + // CHAR8 is typedefed as char, which may be signed or unsigned based
> + // on the compiler. Thus, for compatibility CHAR8 should be between 0 and MAX_INT8.
> + //
> +
> + //
> + // If Operand is between 0 and MAX_INT8 inclusive, then it's a cast
> + //
> + Operand = 0x5b;
> + Result = 0;
> + Status = SafeInt16ToChar8(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x5b, Result);
> +
> + Operand = 0;
> + Result = 0;
> + Status = SafeInt16ToChar8(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0, Result);
> +
> + Operand = MAX_INT8;
> + Result = 0;
> + Status = SafeInt16ToChar8(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(MAX_INT8, Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Operand = (-35);
> + Status = SafeInt16ToChar8(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + Operand = 0x1234;
> + Status = SafeInt16ToChar8(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + Operand = (-17835);
> + Status = SafeInt16ToChar8(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeInt16ToUint8 (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + INT16 Operand;
> + UINT8 Result;
> +
> + //
> + // If Operand is between 0 and MAX_INT8 inclusive, then it's a cast
> + //
> + Operand = 0x5b;
> + Result = 0;
> + Status = SafeInt16ToUint8(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x5b, Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Operand = 0x1234;
> + Status = SafeInt16ToUint8(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + Operand = (-17835);
> + Status = SafeInt16ToUint8(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeInt16ToUint16 (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + INT16 Operand = 0x5b5b;
> + UINT16 Result = 0;
> +
> + //
> + // If Operand is non-negative, then it's a cast
> + //
> + Status = SafeInt16ToUint16(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x5b5b, Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Operand = (-17835);
> + Status = SafeInt16ToUint16(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeInt16ToUint32 (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + INT16 Operand;
> + UINT32 Result;
> +
> + //
> + // If Operand is non-negative, then it's a cast
> + //
> + Operand = 0x5b5b;
> + Result = 0;
> + Status = SafeInt16ToUint32(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x5b5b, Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Operand = (-17835);
> + Status = SafeInt16ToUint32(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeInt16ToUintn (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + INT16 Operand;
> + UINTN Result;
> +
> + //
> + // If Operand is non-negative, then it's a cast
> + //
> + Operand = 0x5b5b;
> + Result = 0;
> + Status = SafeInt16ToUintn(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x5b5b, Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Operand = (-17835);
> + Status = SafeInt16ToUintn(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeInt16ToUint64 (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + INT16 Operand;
> + UINT64 Result;
> +
> + //
> + // If Operand is non-negative, then it's a cast
> + //
> + Operand = 0x5b5b;
> + Result = 0;
> + Status = SafeInt16ToUint64(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x5b5b, Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Operand = (-17835);
> + Status = SafeInt16ToUint64(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUint16ToInt8 (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + UINT16 Operand;
> + INT8 Result;
> +
> + //
> + // If Operand is <= MAX_INT8, it's a cast
> + //
> + Operand = 0x5b;
> + Result = 0;
> + Status = SafeUint16ToInt8(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x5b, Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Operand = (0x5b5b);
> + Status = SafeUint16ToInt8(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUint16ToChar8 (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + UINT16 Operand;
> + CHAR8 Result;
> +
> + // CHAR8 is typedefed as char, which by default is signed, thus
> + // CHAR8 is same as INT8, so same tests as above:
> +
> + //
> + // If Operand is <= MAX_INT8, it's a cast
> + //
> + Operand = 0x5b;
> + Result = 0;
> + Status = SafeUint16ToChar8(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x5b, Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Operand = (0x5b5b);
> + Status = SafeUint16ToChar8(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUint16ToUint8 (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + UINT16 Operand;
> + UINT8 Result;
> +
> + //
> + // If Operand is <= MAX_UINT8 (0xff), it's a cast
> + //
> + Operand = 0xab;
> + Result = 0;
> + Status = SafeUint16ToUint8(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0xab, Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Operand = (0x5b5b);
> + Status = SafeUint16ToUint8(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUint16ToInt16 (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + UINT16 Operand;
> + INT16 Result;
> +
> + //
> + // If Operand is <= MAX_INT16 (0x7fff), it's a cast
> + //
> + Operand = 0x5b5b;
> + Result = 0;
> + Status = SafeUint16ToInt16(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x5b5b, Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Operand = (0xabab);
> + Status = SafeUint16ToInt16(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeInt32ToInt8 (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + INT32 Operand;
> + INT8 Result;
> +
> + //
> + // If Operand is between MIN_INT8 and MAX_INT8 inclusive, then it's a cast
> + //
> + Operand = 0x5b;
> + Result = 0;
> + Status = SafeInt32ToInt8(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x5b, Result);
> +
> + Operand = (-57);
> + Status = SafeInt32ToInt8(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL((-57), Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Operand = (0x5bababab);
> + Status = SafeInt32ToInt8(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + Operand = (-1537977259);
> + Status = SafeInt32ToInt8(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeInt32ToChar8 (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + INT32 Operand;
> + CHAR8 Result;
> +
> + //
> + // CHAR8 is typedefed as char, which may be signed or unsigned based
> + // on the compiler. Thus, for compatibility CHAR8 should be between 0 and MAX_INT8.
> + //
> +
> + //
> + // If Operand is between 0 and MAX_INT8 inclusive, then it's a cast
> + //
> + Operand = 0x5b;
> + Result = 0;
> + Status = SafeInt32ToChar8(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x5b, Result);
> +
> + Operand = 0;
> + Result = 0;
> + Status = SafeInt32ToChar8(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0, Result);
> +
> + Operand = MAX_INT8;
> + Result = 0;
> + Status = SafeInt32ToChar8(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(MAX_INT8, Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Operand = (-57);
> + Status = SafeInt32ToChar8(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + Operand = (0x5bababab);
> + Status = SafeInt32ToChar8(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + Operand = (-1537977259);
> + Status = SafeInt32ToChar8(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeInt32ToUint8 (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + INT32 Operand;
> + UINT8 Result;
> +
> + //
> + // If Operand is between 0 and MAX_INT8 inclusive, then it's a cast
> + //
> + Operand = 0x5b;
> + Result = 0;
> + Status = SafeInt32ToUint8(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x5b, Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Operand = (-57);
> + Status = SafeInt32ToUint8(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + Operand = (0x5bababab);
> + Status = SafeInt32ToUint8(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + Operand = (-1537977259);
> + Status = SafeInt32ToUint8(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeInt32ToInt16 (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + INT32 Operand;
> + INT16 Result;
> +
> + //
> + // If Operand is between MIN_INT16 and MAX_INT16 inclusive, then it's a cast
> + //
> + Operand = 0x5b5b;
> + Result = 0;
> + Status = SafeInt32ToInt16(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x5b5b, Result);
> +
> + Operand = (-17857);
> + Status = SafeInt32ToInt16(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL((-17857), Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Operand = (0x5bababab);
> + Status = SafeInt32ToInt16(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + Operand = (-1537977259);
> + Status = SafeInt32ToInt16(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeInt32ToUint16 (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + INT32 Operand;
> + UINT16 Result;
> +
> + //
> + // If Operand is between 0 and MAX_UINT16 inclusive, then it's a cast
> + //
> + Operand = 0xabab;
> + Result = 0;
> + Status = SafeInt32ToUint16(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0xabab, Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Operand = (-17857);
> + Status = SafeInt32ToUint16(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + Operand = (0x5bababab);
> + Status = SafeInt32ToUint16(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + Operand = (-1537977259);
> + Status = SafeInt32ToUint16(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeInt32ToUint32 (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + INT32 Operand;
> + UINT32 Result;
> +
> + //
> + // If Operand is non-negative, then it's a cast
> + //
> + Operand = 0x5bababab;
> + Result = 0;
> + Status = SafeInt32ToUint32(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x5bababab, Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Operand = (-1537977259);
> + Status = SafeInt32ToUint32(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeInt32ToUint64 (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + INT32 Operand;
> + UINT64 Result;
> +
> + //
> + // If Operand is non-negative, then it's a cast
> + //
> + Operand = 0x5bababab;
> + Result = 0;
> + Status = SafeInt32ToUint64(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x5bababab, Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Operand = (-1537977259);
> + Status = SafeInt32ToUint64(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUint32ToInt8 (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + UINT32 Operand;
> + INT8 Result;
> +
> + //
> + // If Operand is <= MAX_INT8, then it's a cast
> + //
> + Operand = 0x5b;
> + Result = 0;
> + Status = SafeUint32ToInt8(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x5b, Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Operand = (0x5bababab);
> + Status = SafeUint32ToInt8(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUint32ToChar8 (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + UINT32 Operand;
> + CHAR8 Result;
> +
> + // CHAR8 is typedefed as char, which by default is signed, thus
> + // CHAR8 is same as INT8, so same tests as above:
> +
> + //
> + // If Operand is <= MAX_INT8, then it's a cast
> + //
> + Operand = 0x5b;
> + Result = 0;
> + Status = SafeUint32ToChar8(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x5b, Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Operand = (0x5bababab);
> + Status = SafeUint32ToChar8(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUint32ToUint8 (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + UINT32 Operand;
> + UINT8 Result;
> +
> + //
> + // If Operand is <= MAX_UINT8, then it's a cast
> + //
> + Operand = 0xab;
> + Result = 0;
> + Status = SafeUint32ToUint8(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0xab, Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Operand = (0xabababab);
> + Status = SafeUint32ToUint8(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUint32ToInt16 (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + UINT32 Operand;
> + INT16 Result;
> +
> + //
> + // If Operand is <= MAX_INT16, then it's a cast
> + //
> + Operand = 0x5bab;
> + Result = 0;
> + Status = SafeUint32ToInt16(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x5bab, Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Operand = (0xabababab);
> + Status = SafeUint32ToInt16(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUint32ToUint16 (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + UINT32 Operand;
> + UINT16 Result;
> +
> + //
> + // If Operand is <= MAX_UINT16, then it's a cast
> + //
> + Operand = 0xabab;
> + Result = 0;
> + Status = SafeUint32ToUint16(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0xabab, Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Operand = (0xabababab);
> + Status = SafeUint32ToUint16(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUint32ToInt32 (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + UINT32 Operand;
> + INT32 Result;
> +
> + //
> + // If Operand is <= MAX_INT32, then it's a cast
> + //
> + Operand = 0x5bababab;
> + Result = 0;
> + Status = SafeUint32ToInt32(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x5bababab, Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Operand = (0xabababab);
> + Status = SafeUint32ToInt32(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeIntnToInt8 (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + INTN Operand;
> + INT8 Result;
> +
> + //
> + // If Operand is between MIN_INT8 and MAX_INT8 inclusive, then it's a cast
> + //
> + Operand = 0x5b;
> + Result = 0;
> + Status = SafeIntnToInt8(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x5b, Result);
> +
> + Operand = (-53);
> + Status = SafeIntnToInt8(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL((-53), Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Operand = (0x5bababab);
> + Status = SafeIntnToInt8(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + Operand = (-1537977259);
> + Status = SafeIntnToInt8(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeIntnToChar8 (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + INTN Operand;
> + CHAR8 Result;
> +
> + //
> + // CHAR8 is typedefed as char, which may be signed or unsigned based
> + // on the compiler. Thus, for compatibility CHAR8 should be between 0 and MAX_INT8.
> + //
> +
> + //
> + // If Operand is between MIN_INT8 and MAX_INT8 inclusive, then it's a cast
> + //
> + Operand = 0x5b;
> + Result = 0;
> + Status = SafeIntnToChar8(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x5b, Result);
> +
> + Operand = 0;
> + Result = 0;
> + Status = SafeIntnToChar8(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0, Result);
> +
> + Operand = MAX_INT8;
> + Result = 0;
> + Status = SafeIntnToChar8(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(MAX_INT8, Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Operand = (-53);
> + Status = SafeIntnToChar8(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + Operand = (0x5bababab);
> + Status = SafeIntnToChar8(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + Operand = (-1537977259);
> + Status = SafeIntnToChar8(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeIntnToUint8 (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + INTN Operand;
> + UINT8 Result;
> +
> + //
> + // If Operand is between 0 and MAX_UINT8 inclusive, then it's a cast
> + //
> + Operand = 0xab;
> + Result = 0;
> + Status = SafeIntnToUint8(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0xab, Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Operand = (0x5bababab);
> + Status = SafeIntnToUint8(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + Operand = (-1537977259);
> + Status = SafeIntnToUint8(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeIntnToInt16 (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + INTN Operand;
> + INT16 Result;
> +
> + //
> + // If Operand is between MIN_INT16 and MAX_INT16 inclusive, then it's a cast
> + //
> + Operand = 0x5bab;
> + Result = 0;
> + Status = SafeIntnToInt16(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x5bab, Result);
> +
> + Operand = (-23467);
> + Status = SafeIntnToInt16(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL((-23467), Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Operand = (0x5bababab);
> + Status = SafeIntnToInt16(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + Operand = (-1537977259);
> + Status = SafeIntnToInt16(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeIntnToUint16 (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + INTN Operand;
> + UINT16 Result;
> +
> + //
> + // If Operand is between 0 and MAX_UINT16 inclusive, then it's a cast
> + //
> + Operand = 0xabab;
> + Result = 0;
> + Status = SafeIntnToUint16(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0xabab, Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Operand = (0x5bababab);
> + Status = SafeIntnToUint16(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + Operand = (-1537977259);
> + Status = SafeIntnToUint16(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeIntnToUintn (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + INTN Operand;
> + UINTN Result;
> +
> + //
> + // If Operand is non-negative, then it's a cast
> + //
> + Operand = 0x5bababab;
> + Result = 0;
> + Status = SafeIntnToUintn(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x5bababab, Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Operand = (-1537977259);
> + Status = SafeIntnToUintn(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeIntnToUint64 (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + INTN Operand;
> + UINT64 Result;
> +
> + //
> + // If Operand is non-negative, then it's a cast
> + //
> + Operand = 0x5bababab;
> + Result = 0;
> + Status = SafeIntnToUint64(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x5bababab, Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Operand = (-1537977259);
> + Status = SafeIntnToUint64(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUintnToInt8 (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + UINTN Operand;
> + INT8 Result;
> +
> + //
> + // If Operand is <= MAX_INT8, then it's a cast
> + //
> + Operand = 0x5b;
> + Result = 0;
> + Status = SafeUintnToInt8(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x5b, Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Operand = (0xabab);
> + Status = SafeUintnToInt8(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUintnToChar8 (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + UINTN Operand;
> + CHAR8 Result;
> +
> + // CHAR8 is typedefed as char, which by default is signed, thus
> + // CHAR8 is same as INT8, so same tests as above:
> +
> + //
> + // If Operand is <= MAX_INT8, then it's a cast
> + //
> + Operand = 0x5b;
> + Result = 0;
> + Status = SafeUintnToChar8(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x5b, Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Operand = (0xabab);
> + Status = SafeUintnToChar8(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUintnToUint8 (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + UINTN Operand;
> + UINT8 Result;
> +
> + //
> + // If Operand is <= MAX_UINT8, then it's a cast
> + //
> + Operand = 0xab;
> + Result = 0;
> + Status = SafeUintnToUint8(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0xab, Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Operand = (0xabab);
> + Status = SafeUintnToUint8(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUintnToInt16 (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + UINTN Operand;
> + INT16 Result;
> +
> + //
> + // If Operand is <= MAX_INT16, then it's a cast
> + //
> + Operand = 0x5bab;
> + Result = 0;
> + Status = SafeUintnToInt16(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x5bab, Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Operand = (0xabab);
> + Status = SafeUintnToInt16(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUintnToUint16 (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + UINTN Operand;
> + UINT16 Result;
> +
> + //
> + // If Operand is <= MAX_UINT16, then it's a cast
> + //
> + Operand = 0xabab;
> + Result = 0;
> + Status = SafeUintnToUint16(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0xabab, Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Operand = (0xabababab);
> + Status = SafeUintnToUint16(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUintnToInt32 (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + UINTN Operand;
> + INT32 Result;
> +
> + //
> + // If Operand is <= MAX_INT32, then it's a cast
> + //
> + Operand = 0x5bababab;
> + Result = 0;
> + Status = SafeUintnToInt32(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x5bababab, Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Operand = (0xabababab);
> + Status = SafeUintnToInt32(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeInt64ToInt8 (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + INT64 Operand;
> + INT8 Result;
> +
> + //
> + // If Operand is between MIN_INT8 and MAX_INT8 inclusive, then it's a cast
> + //
> + Operand = 0x5b;
> + Result = 0;
> + Status = SafeInt64ToInt8(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x5b, Result);
> +
> + Operand = (-37);
> + Status = SafeInt64ToInt8(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL((-37), Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Operand = (0x5babababefefefef);
> + Status = SafeInt64ToInt8(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + Operand = (-6605562033422200815);
> + Status = SafeInt64ToInt8(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeInt64ToChar8 (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + INT64 Operand;
> + CHAR8 Result;
> +
> + //
> + // CHAR8 is typedefed as char, which may be signed or unsigned based
> + // on the compiler. Thus, for compatibility CHAR8 should be between 0 and MAX_INT8.
> + //
> +
> + //
> + // If Operand is between MIN_INT8 and MAX_INT8 inclusive, then it's a cast
> + //
> + Operand = 0x5b;
> + Result = 0;
> + Status = SafeInt64ToChar8(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x5b, Result);
> +
> + Operand = 0;
> + Result = 0;
> + Status = SafeInt64ToChar8(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0, Result);
> +
> + Operand = MAX_INT8;
> + Result = 0;
> + Status = SafeInt64ToChar8(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(MAX_INT8, Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Operand = (-37);
> + Status = SafeInt64ToChar8(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + Operand = (0x5babababefefefef);
> + Status = SafeInt64ToChar8(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + Operand = (-6605562033422200815);
> + Status = SafeInt64ToChar8(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeInt64ToUint8 (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + INT64 Operand;
> + UINT8 Result;
> +
> + //
> + // If Operand is between 0 and MAX_UINT8 inclusive, then it's a cast
> + //
> + Operand = 0xab;
> + Result = 0;
> + Status = SafeInt64ToUint8(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0xab, Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Operand = (0x5babababefefefef);
> + Status = SafeInt64ToUint8(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + Operand = (-6605562033422200815);
> + Status = SafeInt64ToUint8(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeInt64ToInt16 (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + INT64 Operand;
> + INT16 Result;
> +
> + //
> + // If Operand is between MIN_INT16 and MAX_INT16 inclusive, then it's a cast
> + //
> + Operand = 0x5bab;
> + Result = 0;
> + Status = SafeInt64ToInt16(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x5bab, Result);
> +
> + Operand = (-23467);
> + Status = SafeInt64ToInt16(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL((-23467), Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Operand = (0x5babababefefefef);
> + Status = SafeInt64ToInt16(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + Operand = (-6605562033422200815);
> + Status = SafeInt64ToInt16(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeInt64ToUint16 (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + INT64 Operand;
> + UINT16 Result;
> +
> + //
> + // If Operand is between 0 and MAX_UINT16 inclusive, then it's a cast
> + //
> + Operand = 0xabab;
> + Result = 0;
> + Status = SafeInt64ToUint16(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0xabab, Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Operand = (0x5babababefefefef);
> + Status = SafeInt64ToUint16(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + Operand = (-6605562033422200815);
> + Status = SafeInt64ToUint16(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeInt64ToInt32 (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + INT64 Operand;
> + INT32 Result;
> +
> + //
> + // If Operand is between MIN_INT32 and MAX_INT32 inclusive, then it's a cast
> + //
> + Operand = 0x5bababab;
> + Result = 0;
> + Status = SafeInt64ToInt32(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x5bababab, Result);
> +
> + Operand = (-1537977259);
> + Status = SafeInt64ToInt32(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL((-1537977259), Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Operand = (0x5babababefefefef);
> + Status = SafeInt64ToInt32(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + Operand = (-6605562033422200815);
> + Status = SafeInt64ToInt32(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeInt64ToUint32 (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + INT64 Operand;
> + UINT32 Result;
> +
> + //
> + // If Operand is between 0 and MAX_UINT32 inclusive, then it's a cast
> + //
> + Operand = 0xabababab;
> + Result = 0;
> + Status = SafeInt64ToUint32(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0xabababab, Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Operand = (0x5babababefefefef);
> + Status = SafeInt64ToUint32(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + Operand = (-6605562033422200815);
> + Status = SafeInt64ToUint32(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeInt64ToUint64 (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + INT64 Operand;
> + UINT64 Result;
> +
> + //
> + // If Operand is non-negative, then it's a cast
> + //
> + Operand = 0x5babababefefefef;
> + Result = 0;
> + Status = SafeInt64ToUint64(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x5babababefefefef, Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Operand = (-6605562033422200815);
> + Status = SafeInt64ToUint64(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUint64ToInt8 (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + UINT64 Operand;
> + INT8 Result;
> +
> + //
> + // If Operand is <= MAX_INT8, then it's a cast
> + //
> + Operand = 0x5b;
> + Result = 0;
> + Status = SafeUint64ToInt8(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x5b, Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Operand = (0xababababefefefef);
> + Status = SafeUint64ToInt8(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUint64ToChar8 (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + UINT64 Operand;
> + CHAR8 Result;
> +
> + // CHAR8 is typedefed as char, which by default is signed, thus
> + // CHAR8 is same as INT8, so same tests as above:
> +
> + //
> + // If Operand is <= MAX_INT8, then it's a cast
> + //
> + Operand = 0x5b;
> + Result = 0;
> + Status = SafeUint64ToChar8(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x5b, Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Operand = (0xababababefefefef);
> + Status = SafeUint64ToChar8(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUint64ToUint8 (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + UINT64 Operand;
> + UINT8 Result;
> +
> + //
> + // If Operand is <= MAX_UINT8, then it's a cast
> + //
> + Operand = 0xab;
> + Result = 0;
> + Status = SafeUint64ToUint8(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0xab, Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Operand = (0xababababefefefef);
> + Status = SafeUint64ToUint8(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUint64ToInt16 (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + UINT64 Operand;
> + INT16 Result;
> +
> + //
> + // If Operand is <= MAX_INT16, then it's a cast
> + //
> + Operand = 0x5bab;
> + Result = 0;
> + Status = SafeUint64ToInt16(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x5bab, Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Operand = (0xababababefefefef);
> + Status = SafeUint64ToInt16(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUint64ToUint16 (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + UINT64 Operand;
> + UINT16 Result;
> +
> + //
> + // If Operand is <= MAX_UINT16, then it's a cast
> + //
> + Operand = 0xabab;
> + Result = 0;
> + Status = SafeUint64ToUint16(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0xabab, Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Operand = (0xababababefefefef);
> + Status = SafeUint64ToUint16(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUint64ToInt32 (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + UINT64 Operand;
> + INT32 Result;
> +
> + //
> + // If Operand is <= MAX_INT32, then it's a cast
> + //
> + Operand = 0x5bababab;
> + Result = 0;
> + Status = SafeUint64ToInt32(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x5bababab, Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Operand = (0xababababefefefef);
> + Status = SafeUint64ToInt32(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUint64ToUint32 (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + UINT64 Operand;
> + UINT32 Result;
> +
> + //
> + // If Operand is <= MAX_UINT32, then it's a cast
> + //
> + Operand = 0xabababab;
> + Result = 0;
> + Status = SafeUint64ToUint32(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0xabababab, Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Operand = (0xababababefefefef);
> + Status = SafeUint64ToUint32(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUint64ToInt64 (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + UINT64 Operand;
> + INT64 Result;
> +
> + //
> + // If Operand is <= MAX_INT64, then it's a cast
> + //
> + Operand = 0x5babababefefefef;
> + Result = 0;
> + Status = SafeUint64ToInt64(Operand, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x5babababefefefef, Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Operand = (0xababababefefefef);
> + Status = SafeUint64ToInt64(Operand, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +//
> +// Addition function tests:
> +//
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUint8Add (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + UINT8 Augend;
> + UINT8 Addend;
> + UINT8 Result;
> +
> + //
> + // If the result of addition doesn't overflow MAX_UINT8, then it's addition
> + //
> + Augend = 0x3a;
> + Addend = 0x3a;
> + Result = 0;
> + Status = SafeUint8Add(Augend, Addend, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x74, Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Augend = 0xab;
> + Addend = 0xbc;
> + Status = SafeUint8Add(Augend, Addend, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUint16Add (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + UINT16 Augend = 0x3a3a;
> + UINT16 Addend = 0x3a3a;
> + UINT16 Result = 0;
> +
> + //
> + // If the result of addition doesn't overflow MAX_UINT16, then it's addition
> + //
> + Status = SafeUint16Add(Augend, Addend, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x7474, Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Augend = 0xabab;
> + Addend = 0xbcbc;
> + Status = SafeUint16Add(Augend, Addend, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUint32Add (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + UINT32 Augend;
> + UINT32 Addend;
> + UINT32 Result;
> +
> + //
> + // If the result of addition doesn't overflow MAX_UINT32, then it's addition
> + //
> + Augend = 0x3a3a3a3a;
> + Addend = 0x3a3a3a3a;
> + Result = 0;
> + Status = SafeUint32Add(Augend, Addend, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x74747474, Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Augend = 0xabababab;
> + Addend = 0xbcbcbcbc;
> + Status = SafeUint32Add(Augend, Addend, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUint64Add (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + UINT64 Augend;
> + UINT64 Addend;
> + UINT64 Result;
> +
> + //
> + // If the result of addition doesn't overflow MAX_UINT64, then it's addition
> + //
> + Augend = 0x3a3a3a3a12121212;
> + Addend = 0x3a3a3a3a12121212;
> + Result = 0;
> + Status = SafeUint64Add(Augend, Addend, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x7474747424242424, Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Augend = 0xababababefefefef;
> + Addend = 0xbcbcbcbcdededede;
> + Status = SafeUint64Add(Augend, Addend, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeInt8Add (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + INT8 Augend;
> + INT8 Addend;
> + INT8 Result;
> +
> + //
> + // If the result of addition doesn't overflow MAX_INT8
> + // and doesn't underflow MIN_INT8, then it's addition
> + //
> + Augend = 0x3a;
> + Addend = 0x3a;
> + Result = 0;
> + Status = SafeInt8Add(Augend, Addend, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x74, Result);
> +
> + Augend = (-58);
> + Addend = (-58);
> + Status = SafeInt8Add(Augend, Addend, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL((-116), Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Augend = 0x5a;
> + Addend = 0x5a;
> + Status = SafeInt8Add(Augend, Addend, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + Augend = (-90);
> + Addend = (-90);
> + Status = SafeInt8Add(Augend, Addend, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeInt16Add (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + INT16 Augend;
> + INT16 Addend;
> + INT16 Result;
> +
> + //
> + // If the result of addition doesn't overflow MAX_INT16
> + // and doesn't underflow MIN_INT16, then it's addition
> + //
> + Augend = 0x3a3a;
> + Addend = 0x3a3a;
> + Result = 0;
> + Status = SafeInt16Add(Augend, Addend, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x7474, Result);
> +
> + Augend = (-14906);
> + Addend = (-14906);
> + Status = SafeInt16Add(Augend, Addend, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL((-29812), Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Augend = 0x5a5a;
> + Addend = 0x5a5a;
> + Status = SafeInt16Add(Augend, Addend, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + Augend = (-23130);
> + Addend = (-23130);
> + Status = SafeInt16Add(Augend, Addend, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeInt32Add (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + INT32 Augend;
> + INT32 Addend;
> + INT32 Result;
> +
> + //
> + // If the result of addition doesn't overflow MAX_INT32
> + // and doesn't underflow MIN_INT32, then it's addition
> + //
> + Augend = 0x3a3a3a3a;
> + Addend = 0x3a3a3a3a;
> + Result = 0;
> + Status = SafeInt32Add(Augend, Addend, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x74747474, Result);
> +
> + Augend = (-976894522);
> + Addend = (-976894522);
> + Status = SafeInt32Add(Augend, Addend, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL((-1953789044), Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Augend = 0x5a5a5a5a;
> + Addend = 0x5a5a5a5a;
> + Status = SafeInt32Add(Augend, Addend, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + Augend = (-1515870810);
> + Addend = (-1515870810);
> + Status = SafeInt32Add(Augend, Addend, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeInt64Add (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + INT64 Augend;
> + INT64 Addend;
> + INT64 Result;
> +
> + //
> + // If the result of addition doesn't overflow MAX_INT64
> + // and doesn't underflow MIN_INT64, then it's addition
> + //
> + Augend = 0x3a3a3a3a3a3a3a3a;
> + Addend = 0x3a3a3a3a3a3a3a3a;
> + Result = 0;
> + Status = SafeInt64Add(Augend, Addend, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x7474747474747474, Result);
> +
> + Augend = (-4195730024608447034);
> + Addend = (-4195730024608447034);
> + Status = SafeInt64Add(Augend, Addend, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL((-8391460049216894068), Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Augend = 0x5a5a5a5a5a5a5a5a;
> + Addend = 0x5a5a5a5a5a5a5a5a;
> + Status = SafeInt64Add(Augend, Addend, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + Augend = (-6510615555426900570);
> + Addend = (-6510615555426900570);
> + Status = SafeInt64Add(Augend, Addend, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +//
> +// Subtraction function tests:
> +//
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUint8Sub (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + UINT8 Minuend;
> + UINT8 Subtrahend;
> + UINT8 Result;
> +
> + //
> + // If Minuend >= Subtrahend, then it's subtraction
> + //
> + Minuend = 0x5a;
> + Subtrahend = 0x3b;
> + Result = 0;
> + Status = SafeUint8Sub(Minuend, Subtrahend, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x1f, Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Minuend = 0x5a;
> + Subtrahend = 0x6d;
> + Status = SafeUint8Sub(Minuend, Subtrahend, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUint16Sub (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + UINT16 Minuend;
> + UINT16 Subtrahend;
> + UINT16 Result;
> +
> + //
> + // If Minuend >= Subtrahend, then it's subtraction
> + //
> + Minuend = 0x5a5a;
> + Subtrahend = 0x3b3b;
> + Result = 0;
> + Status = SafeUint16Sub(Minuend, Subtrahend, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x1f1f, Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Minuend = 0x5a5a;
> + Subtrahend = 0x6d6d;
> + Status = SafeUint16Sub(Minuend, Subtrahend, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUint32Sub (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + UINT32 Minuend;
> + UINT32 Subtrahend;
> + UINT32 Result;
> +
> + //
> + // If Minuend >= Subtrahend, then it's subtraction
> + //
> + Minuend = 0x5a5a5a5a;
> + Subtrahend = 0x3b3b3b3b;
> + Result = 0;
> + Status = SafeUint32Sub(Minuend, Subtrahend, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x1f1f1f1f, Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Minuend = 0x5a5a5a5a;
> + Subtrahend = 0x6d6d6d6d;
> + Status = SafeUint32Sub(Minuend, Subtrahend, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUint64Sub (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + UINT64 Minuend;
> + UINT64 Subtrahend;
> + UINT64 Result;
> +
> + //
> + // If Minuend >= Subtrahend, then it's subtraction
> + //
> + Minuend = 0x5a5a5a5a5a5a5a5a;
> + Subtrahend = 0x3b3b3b3b3b3b3b3b;
> + Result = 0;
> + Status = SafeUint64Sub(Minuend, Subtrahend, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x1f1f1f1f1f1f1f1f, Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Minuend = 0x5a5a5a5a5a5a5a5a;
> + Subtrahend = 0x6d6d6d6d6d6d6d6d;
> + Status = SafeUint64Sub(Minuend, Subtrahend, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeInt8Sub (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + INT8 Minuend;
> + INT8 Subtrahend;
> + INT8 Result;
> +
> + //
> + // If the result of subtractions doesn't overflow MAX_INT8 or
> + // underflow MIN_INT8, then it's subtraction
> + //
> + Minuend = 0x5a;
> + Subtrahend = 0x3a;
> + Result = 0;
> + Status = SafeInt8Sub(Minuend, Subtrahend, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x20, Result);
> +
> + Minuend = 58;
> + Subtrahend = 78;
> + Status = SafeInt8Sub(Minuend, Subtrahend, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL((-20), Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Minuend = (-80);
> + Subtrahend = 80;
> + Status = SafeInt8Sub(Minuend, Subtrahend, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + Minuend = (80);
> + Subtrahend = (-80);
> + Status = SafeInt8Sub(Minuend, Subtrahend, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeInt16Sub (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + INT16 Minuend;
> + INT16 Subtrahend;
> + INT16 Result;
> +
> + //
> + // If the result of subtractions doesn't overflow MAX_INT16 or
> + // underflow MIN_INT16, then it's subtraction
> + //
> + Minuend = 0x5a5a;
> + Subtrahend = 0x3a3a;
> + Result = 0;
> + Status = SafeInt16Sub(Minuend, Subtrahend, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x2020, Result);
> +
> + Minuend = 0x3a3a;
> + Subtrahend = 0x5a5a;
> + Status = SafeInt16Sub(Minuend, Subtrahend, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL((-8224), Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Minuend = (-31354);
> + Subtrahend = 31354;
> + Status = SafeInt16Sub(Minuend, Subtrahend, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + Minuend = (31354);
> + Subtrahend = (-31354);
> + Status = SafeInt16Sub(Minuend, Subtrahend, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeInt32Sub (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + INT32 Minuend;
> + INT32 Subtrahend;
> + INT32 Result;
> +
> + //
> + // If the result of subtractions doesn't overflow MAX_INT32 or
> + // underflow MIN_INT32, then it's subtraction
> + //
> + Minuend = 0x5a5a5a5a;
> + Subtrahend = 0x3a3a3a3a;
> + Result = 0;
> + Status = SafeInt32Sub(Minuend, Subtrahend, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x20202020, Result);
> +
> + Minuend = 0x3a3a3a3a;
> + Subtrahend = 0x5a5a5a5a;
> + Status = SafeInt32Sub(Minuend, Subtrahend, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL((-538976288), Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Minuend = (-2054847098);
> + Subtrahend = 2054847098;
> + Status = SafeInt32Sub(Minuend, Subtrahend, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + Minuend = (2054847098);
> + Subtrahend = (-2054847098);
> + Status = SafeInt32Sub(Minuend, Subtrahend, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeInt64Sub (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + INT64 Minuend;
> + INT64 Subtrahend;
> + INT64 Result;
> +
> + //
> + // If the result of subtractions doesn't overflow MAX_INT64 or
> + // underflow MIN_INT64, then it's subtraction
> + //
> + Minuend = 0x5a5a5a5a5a5a5a5a;
> + Subtrahend = 0x3a3a3a3a3a3a3a3a;
> + Result = 0;
> + Status = SafeInt64Sub(Minuend, Subtrahend, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x2020202020202020, Result);
> +
> + Minuend = 0x3a3a3a3a3a3a3a3a;
> + Subtrahend = 0x5a5a5a5a5a5a5a5a;
> + Status = SafeInt64Sub(Minuend, Subtrahend, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL((-2314885530818453536), Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Minuend = (-8825501086245354106);
> + Subtrahend = 8825501086245354106;
> + Status = SafeInt64Sub(Minuend, Subtrahend, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + Minuend = (8825501086245354106);
> + Subtrahend = (-8825501086245354106);
> + Status = SafeInt64Sub(Minuend, Subtrahend, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +//
> +// Multiplication function tests:
> +//
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUint8Mult (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + UINT8 Multiplicand;
> + UINT8 Multiplier;
> + UINT8 Result;
> +
> + //
> + // If the result of multiplication doesn't overflow MAX_UINT8, it will succeed
> + //
> + Multiplicand = 0x12;
> + Multiplier = 0xa;
> + Result = 0;
> + Status = SafeUint8Mult(Multiplicand, Multiplier, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0xb4, Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Multiplicand = 0x12;
> + Multiplier = 0x23;
> + Status = SafeUint8Mult(Multiplicand, Multiplier, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUint16Mult (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + UINT16 Multiplicand;
> + UINT16 Multiplier;
> + UINT16 Result;
> +
> + //
> + // If the result of multiplication doesn't overflow MAX_UINT16, it will succeed
> + //
> + Multiplicand = 0x212;
> + Multiplier = 0x7a;
> + Result = 0;
> + Status = SafeUint16Mult(Multiplicand, Multiplier, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0xfc94, Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Multiplicand = 0x1234;
> + Multiplier = 0x213;
> + Status = SafeUint16Mult(Multiplicand, Multiplier, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUint32Mult (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + UINT32 Multiplicand;
> + UINT32 Multiplier;
> + UINT32 Result;
> +
> + //
> + // If the result of multiplication doesn't overflow MAX_UINT32, it will succeed
> + //
> + Multiplicand = 0xa122a;
> + Multiplier = 0xd23;
> + Result = 0;
> + Status = SafeUint32Mult(Multiplicand, Multiplier, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x844c9dbe, Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Multiplicand = 0xa122a;
> + Multiplier = 0xed23;
> + Status = SafeUint32Mult(Multiplicand, Multiplier, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUint64Mult (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + UINT64 Multiplicand;
> + UINT64 Multiplier;
> + UINT64 Result;
> +
> + //
> + // If the result of multiplication doesn't overflow MAX_UINT64, it will succeed
> + //
> + Multiplicand = 0x123456789a;
> + Multiplier = 0x1234567;
> + Result = 0;
> + Status = SafeUint64Mult(Multiplicand, Multiplier, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x14b66db9745a07f6, Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Multiplicand = 0x123456789a;
> + Multiplier = 0x12345678;
> + Status = SafeUint64Mult(Multiplicand, Multiplier, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeInt8Mult (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + INT8 Multiplicand;
> + INT8 Multiplier;
> + INT8 Result;
> +
> + //
> + // If the result of multiplication doesn't overflow MAX_INT8 and doesn't
> + // underflow MIN_UINT8, it will succeed
> + //
> + Multiplicand = 0x12;
> + Multiplier = 0x7;
> + Result = 0;
> + Status = SafeInt8Mult(Multiplicand, Multiplier, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x7e, Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Multiplicand = 0x12;
> + Multiplier = 0xa;
> + Status = SafeInt8Mult(Multiplicand, Multiplier, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeInt16Mult (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + INT16 Multiplicand;
> + INT16 Multiplier;
> + INT16 Result;
> +
> + //
> + // If the result of multiplication doesn't overflow MAX_INT16 and doesn't
> + // underflow MIN_UINT16, it will succeed
> + //
> + Multiplicand = 0x123;
> + Multiplier = 0x67;
> + Result = 0;
> + Status = SafeInt16Mult(Multiplicand, Multiplier, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x7515, Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Multiplicand = 0x123;
> + Multiplier = 0xab;
> + Status = SafeInt16Mult(Multiplicand, Multiplier, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeInt32Mult (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + INT32 Multiplicand;
> + INT32 Multiplier;
> + INT32 Result;
> +
> + //
> + // If the result of multiplication doesn't overflow MAX_INT32 and doesn't
> + // underflow MIN_UINT32, it will succeed
> + //
> + Multiplicand = 0x123456;
> + Multiplier = 0x678;
> + Result = 0;
> + Status = SafeInt32Mult(Multiplicand, Multiplier, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x75c28c50, Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Multiplicand = 0x123456;
> + Multiplier = 0xabc;
> + Status = SafeInt32Mult(Multiplicand, Multiplier, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeInt64Mult (
> + IN UNIT_TEST_CONTEXT Context
> + )
> +{
> + EFI_STATUS Status;
> + INT64 Multiplicand;
> + INT64 Multiplier;
> + INT64 Result;
> +
> + //
> + // If the result of multiplication doesn't overflow MAX_INT64 and doesn't
> + // underflow MIN_UINT64, it will succeed
> + //
> + Multiplicand = 0x123456789;
> + Multiplier = 0x6789abcd;
> + Result = 0;
> + Status = SafeInt64Mult(Multiplicand, Multiplier, &Result);
> + UT_ASSERT_NOT_EFI_ERROR(Status);
> + UT_ASSERT_EQUAL(0x75cd9045220d6bb5, Result);
> +
> + //
> + // Otherwise should result in an error status
> + //
> + Multiplicand = 0x123456789;
> + Multiplier = 0xa789abcd;
> + Status = SafeInt64Mult(Multiplicand, Multiplier, &Result);
> + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> +
> + return UNIT_TEST_PASSED;
> +}
> +
> +/**
> +
> + Main fuction sets up the unit test environment
> +
> +**/
> +EFI_STATUS
> +EFIAPI
> +UefiTestMain (
> + VOID
> + )
> +{
> + EFI_STATUS Status;
> + UNIT_TEST_FRAMEWORK_HANDLE Framework;
> + UNIT_TEST_SUITE_HANDLE ConversionTestSuite;
> + UNIT_TEST_SUITE_HANDLE AdditionSubtractionTestSuite;
> + UNIT_TEST_SUITE_HANDLE MultiplicationTestSuite;
> +
> + Framework = NULL;
> + ConversionTestSuite = NULL;
> + AdditionSubtractionTestSuite = NULL;
> + MultiplicationTestSuite = NULL;
> +
> + DEBUG((DEBUG_INFO, "%a v%a\n", UNIT_TEST_NAME, UNIT_TEST_VERSION));
> +
> + //
> + // Start setting up the test framework for running the tests.
> + //
> + Status = InitUnitTestFramework (&Framework, UNIT_TEST_NAME, gEfiCallerBaseName, UNIT_TEST_VERSION);
> + if (EFI_ERROR(Status)) {
> + DEBUG((DEBUG_ERROR, "Failed in InitUnitTestFramework. Status = %r\n", Status));
> + goto EXIT;
> + }
> +
> + ///
> + // Test the conversion functions
> + //
> + Status = CreateUnitTestSuite (&ConversionTestSuite, Framework, "Int Safe Conversions Test Suite", "Common.SafeInt.Convert", NULL,
> NULL);
> + if (EFI_ERROR(Status)) {
> + DEBUG((DEBUG_ERROR, "Failed in CreateUnitTestSuite for Conversions Test Suite\n"));
> + Status = EFI_OUT_OF_RESOURCES;
> + goto EXIT;
> + }
> + AddTestCase(ConversionTestSuite, "Test SafeInt8ToUint8", "TestSafeInt8ToUint8", TestSafeInt8ToUint8, NULL, NULL, NULL);
> + AddTestCase(ConversionTestSuite, "Test SafeInt8ToUint16", "TestSafeInt8ToUint16", TestSafeInt8ToUint16, NULL, NULL, NULL);
> + AddTestCase(ConversionTestSuite, "Test SafeInt8ToUint32", "TestSafeInt8ToUint32", TestSafeInt8ToUint32, NULL, NULL, NULL);
> + AddTestCase(ConversionTestSuite, "Test SafeInt8ToUintn", "TestSafeInt8ToUintn", TestSafeInt8ToUintn, NULL, NULL, NULL);
> + AddTestCase(ConversionTestSuite, "Test SafeInt8ToUint64", "TestSafeInt8ToUint64", TestSafeInt8ToUint64, NULL, NULL, NULL);
> + AddTestCase(ConversionTestSuite, "Test SafeUint8ToInt8", "TestSafeUint8ToInt8", TestSafeUint8ToInt8, NULL, NULL, NULL);
> + AddTestCase(ConversionTestSuite, "Test SafeUint8ToChar8", "TestSafeUint8ToChar8", TestSafeUint8ToChar8, NULL, NULL, NULL);
> + AddTestCase(ConversionTestSuite, "Test SafeInt16ToInt8", "TestSafeInt16ToInt8", TestSafeInt16ToInt8, NULL, NULL, NULL);
> + AddTestCase(ConversionTestSuite, "Test SafeInt16ToChar8", "TestSafeInt16ToChar8", TestSafeInt16ToChar8, NULL, NULL, NULL);
> + AddTestCase(ConversionTestSuite, "Test SafeInt16ToUint8", "TestSafeInt16ToUint8", TestSafeInt16ToUint8, NULL, NULL, NULL);
> + AddTestCase(ConversionTestSuite, "Test SafeInt16ToUint16", "TestSafeInt16ToUint16", TestSafeInt16ToUint16, NULL, NULL, NULL);
> + AddTestCase(ConversionTestSuite, "Test SafeInt16ToUint32", "TestSafeInt16ToUint32", TestSafeInt16ToUint32, NULL, NULL, NULL);
> + AddTestCase(ConversionTestSuite, "Test SafeInt16ToUintn", "TestSafeInt16ToUintn", TestSafeInt16ToUintn, NULL, NULL, NULL);
> + AddTestCase(ConversionTestSuite, "Test SafeInt16ToUint64", "TestSafeInt16ToUint64", TestSafeInt16ToUint64, NULL, NULL, NULL);
> + AddTestCase(ConversionTestSuite, "Test SafeUint16ToInt8", "TestSafeUint16ToInt8", TestSafeUint16ToInt8, NULL, NULL, NULL);
> + AddTestCase(ConversionTestSuite, "Test SafeUint16ToChar8", "TestSafeUint16ToChar8", TestSafeUint16ToChar8, NULL, NULL, NULL);
> + AddTestCase(ConversionTestSuite, "Test SafeUint16ToUint8", "TestSafeUint16ToUint8", TestSafeUint16ToUint8, NULL, NULL, NULL);
> + AddTestCase(ConversionTestSuite, "Test SafeUint16ToInt16", "TestSafeUint16ToInt16", TestSafeUint16ToInt16, NULL, NULL, NULL);
> + AddTestCase(ConversionTestSuite, "Test SafeInt32ToInt8", "TestSafeInt32ToInt8", TestSafeInt32ToInt8, NULL, NULL, NULL);
> + AddTestCase(ConversionTestSuite, "Test SafeInt32ToChar8", "TestSafeInt32ToChar8", TestSafeInt32ToChar8, NULL, NULL, NULL);
> + AddTestCase(ConversionTestSuite, "Test SafeInt32ToUint8", "TestSafeInt32ToUint8", TestSafeInt32ToUint8, NULL, NULL, NULL);
> + AddTestCase(ConversionTestSuite, "Test SafeInt32ToInt16", "TestSafeInt32ToInt16", TestSafeInt32ToInt16, NULL, NULL, NULL);
> + AddTestCase(ConversionTestSuite, "Test SafeInt32ToUint16", "TestSafeInt32ToUint16", TestSafeInt32ToUint16, NULL, NULL, NULL);
> + AddTestCase(ConversionTestSuite, "Test SafeInt32ToUint32", "TestSafeInt32ToUint32", TestSafeInt32ToUint32, NULL, NULL, NULL);
> + AddTestCase(ConversionTestSuite, "Test SafeInt32ToUintn", "TestSafeInt32ToUintn", TestSafeInt32ToUintn, NULL, NULL, NULL);
> + AddTestCase(ConversionTestSuite, "Test SafeInt32ToUint64", "TestSafeInt32ToUint64", TestSafeInt32ToUint64, NULL, NULL, NULL);
> + AddTestCase(ConversionTestSuite, "Test SafeUint32ToInt8", "TestSafeUint32ToInt8", TestSafeUint32ToInt8, NULL, NULL, NULL);
> + AddTestCase(ConversionTestSuite, "Test SafeUint32ToChar8", "TestSafeUint32ToChar8", TestSafeUint32ToChar8, NULL, NULL, NULL);
> + AddTestCase(ConversionTestSuite, "Test SafeUint32ToUint8", "TestSafeUint32ToUint8", TestSafeUint32ToUint8, NULL, NULL, NULL);
> + AddTestCase(ConversionTestSuite, "Test SafeUint32ToInt16", "TestSafeUint32ToInt16", TestSafeUint32ToInt16, NULL, NULL, NULL);
> + AddTestCase(ConversionTestSuite, "Test SafeUint32ToUint16", "TestSafeUint32ToUint16", TestSafeUint32ToUint16, NULL, NULL,
> NULL);
> + AddTestCase(ConversionTestSuite, "Test SafeUint32ToInt32", "TestSafeUint32ToInt32", TestSafeUint32ToInt32, NULL, NULL, NULL);
> + AddTestCase(ConversionTestSuite, "Test SafeUint32ToIntn", "TestSafeUint32ToIntn", TestSafeUint32ToIntn, NULL, NULL, NULL);
> + AddTestCase(ConversionTestSuite, "Test SafeIntnToInt8", "TestSafeIntnToInt8", TestSafeIntnToInt8, NULL, NULL, NULL);
> + AddTestCase(ConversionTestSuite, "Test SafeIntnToChar8", "TestSafeIntnToChar8", TestSafeIntnToChar8, NULL, NULL, NULL);
> + AddTestCase(ConversionTestSuite, "Test SafeIntnToUint8", "TestSafeIntnToUint8", TestSafeIntnToUint8, NULL, NULL, NULL);
> + AddTestCase(ConversionTestSuite, "Test SafeIntnToInt16", "TestSafeIntnToInt16", TestSafeIntnToInt16, NULL, NULL, NULL);
> + AddTestCase(ConversionTestSuite, "Test SafeIntnToUint16", "TestSafeIntnToUint16", TestSafeIntnToUint16, NULL, NULL, NULL);
> + AddTestCase(ConversionTestSuite, "Test SafeIntnToInt32", "TestSafeIntnToInt32", TestSafeIntnToInt32, NULL, NULL, NULL);
> + AddTestCase(ConversionTestSuite, "Test SafeIntnToUint32", "TestSafeIntnToUint32", TestSafeIntnToUint32, NULL, NULL, NULL);
> + AddTestCase(ConversionTestSuite, "Test SafeIntnToUintn", "TestSafeIntnToUintn", TestSafeIntnToUintn, NULL, NULL, NULL);
> + AddTestCase(ConversionTestSuite, "Test SafeIntnToUint64", "TestSafeIntnToUint64", TestSafeIntnToUint64, NULL, NULL, NULL);
> + AddTestCase(ConversionTestSuite, "Test SafeUintnToInt8", "TestSafeUintnToInt8", TestSafeUintnToInt8, NULL, NULL, NULL);
> + AddTestCase(ConversionTestSuite, "Test SafeUintnToChar8", "TestSafeUintnToChar8", TestSafeUintnToChar8, NULL, NULL, NULL);
> + AddTestCase(ConversionTestSuite, "Test SafeUintnToUint8", "TestSafeUintnToUint8", TestSafeUintnToUint8, NULL, NULL, NULL);
> + AddTestCase(ConversionTestSuite, "Test SafeUintnToInt16", "TestSafeUintnToInt16", TestSafeUintnToInt16, NULL, NULL, NULL);
> + AddTestCase(ConversionTestSuite, "Test SafeUintnToUint16", "TestSafeUintnToUint16", TestSafeUintnToUint16, NULL, NULL, NULL);
> + AddTestCase(ConversionTestSuite, "Test SafeUintnToInt32", "TestSafeUintnToInt32", TestSafeUintnToInt32, NULL, NULL, NULL);
> + AddTestCase(ConversionTestSuite, "Test SafeUintnToUint32", "TestSafeUintnToUint32", TestSafeUintnToUint32, NULL, NULL, NULL);
> + AddTestCase(ConversionTestSuite, "Test SafeUintnToIntn", "TestSafeUintnToIntn", TestSafeUintnToIntn, NULL, NULL, NULL);
> + AddTestCase(ConversionTestSuite, "Test SafeUintnToInt64", "TestSafeUintnToInt64", TestSafeUintnToInt64, NULL, NULL, NULL);
> + AddTestCase(ConversionTestSuite, "Test SafeInt64ToInt8", "TestSafeInt64ToInt8", TestSafeInt64ToInt8, NULL, NULL, NULL);
> + AddTestCase(ConversionTestSuite, "Test SafeInt64ToChar8", "TestSafeInt64ToChar8", TestSafeInt64ToChar8, NULL, NULL, NULL);
> + AddTestCase(ConversionTestSuite, "Test SafeInt64ToUint8", "TestSafeInt64ToUint8", TestSafeInt64ToUint8, NULL, NULL, NULL);
> + AddTestCase(ConversionTestSuite, "Test SafeInt64ToInt16", "TestSafeInt64ToInt16", TestSafeInt64ToInt16, NULL, NULL, NULL);
> + AddTestCase(ConversionTestSuite, "Test SafeInt64ToUint16", "TestSafeInt64ToUint16", TestSafeInt64ToUint16, NULL, NULL, NULL);
> + AddTestCase(ConversionTestSuite, "Test SafeInt64ToInt32", "TestSafeInt64ToInt32", TestSafeInt64ToInt32, NULL, NULL, NULL);
> + AddTestCase(ConversionTestSuite, "Test SafeInt64ToUint32", "TestSafeInt64ToUint32", TestSafeInt64ToUint32, NULL, NULL, NULL);
> + AddTestCase(ConversionTestSuite, "Test SafeInt64ToIntn", "TestSafeInt64ToIntn", TestSafeInt64ToIntn, NULL, NULL, NULL);
> + AddTestCase(ConversionTestSuite, "Test SafeInt64ToUintn", "TestSafeInt64ToUintn", TestSafeInt64ToUintn, NULL, NULL, NULL);
> + AddTestCase(ConversionTestSuite, "Test SafeInt64ToUint64", "TestSafeInt64ToUint64", TestSafeInt64ToUint64, NULL, NULL, NULL);
> + AddTestCase(ConversionTestSuite, "Test SafeUint64ToInt8", "TestSafeUint64ToInt8", TestSafeUint64ToInt8, NULL, NULL, NULL);
> + AddTestCase(ConversionTestSuite, "Test SafeUint64ToChar8", "TestSafeUint64ToChar8", TestSafeUint64ToChar8, NULL, NULL, NULL);
> + AddTestCase(ConversionTestSuite, "Test SafeUint64ToUint8", "TestSafeUint64ToUint8", TestSafeUint64ToUint8, NULL, NULL, NULL);
> + AddTestCase(ConversionTestSuite, "Test SafeUint64ToInt16", "TestSafeUint64ToInt16", TestSafeUint64ToInt16, NULL, NULL, NULL);
> + AddTestCase(ConversionTestSuite, "Test SafeUint64ToUint16", "TestSafeUint64ToUint16", TestSafeUint64ToUint16, NULL, NULL,
> NULL);
> + AddTestCase(ConversionTestSuite, "Test SafeUint64ToInt32", "TestSafeUint64ToInt32", TestSafeUint64ToInt32, NULL, NULL, NULL);
> + AddTestCase(ConversionTestSuite, "Test SafeUint64ToUint32", "TestSafeUint64ToUint32", TestSafeUint64ToUint32, NULL, NULL,
> NULL);
> + AddTestCase(ConversionTestSuite, "Test SafeUint64ToIntn", "TestSafeUint64ToIntn", TestSafeUint64ToIntn, NULL, NULL, NULL);
> + AddTestCase(ConversionTestSuite, "Test SafeUint64ToUintn", "TestSafeUint64ToUintn", TestSafeUint64ToUintn, NULL, NULL, NULL);
> + AddTestCase(ConversionTestSuite, "Test SafeUint64ToInt64", "TestSafeUint64ToInt64", TestSafeUint64ToInt64, NULL, NULL, NULL);
> +
> + //
> + // Test the addition and subtraction functions
> + //
> + Status = CreateUnitTestSuite(&AdditionSubtractionTestSuite, Framework, "Int Safe Add/Subtract Test Suite",
> "Common.SafeInt.AddSubtract", NULL, NULL);
> + if (EFI_ERROR(Status)) {
> + DEBUG((DEBUG_ERROR, "Failed in CreateUnitTestSuite for Int Safe Add/Subtract Test Suite\n"));
> + Status = EFI_OUT_OF_RESOURCES;
> + goto EXIT;
> + }
> + AddTestCase(AdditionSubtractionTestSuite, "Test SafeUint8Add", "TestSafeUint8Add", TestSafeUint8Add, NULL, NULL, NULL);
> + AddTestCase(AdditionSubtractionTestSuite, "Test SafeUint16Add", "TestSafeUint16Add", TestSafeUint16Add, NULL, NULL, NULL);
> + AddTestCase(AdditionSubtractionTestSuite, "Test SafeUint32Add", "TestSafeUint32Add", TestSafeUint32Add, NULL, NULL, NULL);
> + AddTestCase(AdditionSubtractionTestSuite, "Test SafeUintnAdd", "TestSafeUintnAdd", TestSafeUintnAdd, NULL, NULL, NULL);
> + AddTestCase(AdditionSubtractionTestSuite, "Test SafeUint64Add", "TestSafeUint64Add", TestSafeUint64Add, NULL, NULL, NULL);
> + AddTestCase(AdditionSubtractionTestSuite, "Test SafeInt8Add", "TestSafeInt8Add", TestSafeInt8Add, NULL, NULL, NULL);
> + AddTestCase(AdditionSubtractionTestSuite, "Test SafeInt16Add", "TestSafeInt16Add", TestSafeInt16Add, NULL, NULL, NULL);
> + AddTestCase(AdditionSubtractionTestSuite, "Test SafeInt32Add", "TestSafeInt32Add", TestSafeInt32Add, NULL, NULL, NULL);
> + AddTestCase(AdditionSubtractionTestSuite, "Test SafeIntnAdd", "TestSafeIntnAdd", TestSafeIntnAdd, NULL, NULL, NULL);
> + AddTestCase(AdditionSubtractionTestSuite, "Test SafeInt64Add", "TestSafeInt64Add", TestSafeInt64Add, NULL, NULL, NULL);
> + AddTestCase(AdditionSubtractionTestSuite, "Test SafeUint8Sub", "TestSafeUint8Sub", TestSafeUint8Sub, NULL, NULL, NULL);
> + AddTestCase(AdditionSubtractionTestSuite, "Test SafeUint16Sub", "TestSafeUint16Sub", TestSafeUint16Sub, NULL, NULL, NULL);
> + AddTestCase(AdditionSubtractionTestSuite, "Test SafeUint32Sub", "TestSafeUint32Sub", TestSafeUint32Sub, NULL, NULL, NULL);
> + AddTestCase(AdditionSubtractionTestSuite, "Test SafeUintnSub", "TestSafeUintnSub", TestSafeUintnSub, NULL, NULL, NULL);
> + AddTestCase(AdditionSubtractionTestSuite, "Test SafeUint64Sub", "TestSafeUint64Sub", TestSafeUint64Sub, NULL, NULL, NULL);
> + AddTestCase(AdditionSubtractionTestSuite, "Test SafeInt8Sub", "TestSafeInt8Sub", TestSafeInt8Sub, NULL, NULL, NULL);
> + AddTestCase(AdditionSubtractionTestSuite, "Test SafeInt16Sub", "TestSafeInt16Sub", TestSafeInt16Sub, NULL, NULL, NULL);
> + AddTestCase(AdditionSubtractionTestSuite, "Test SafeInt32Sub", "TestSafeInt32Sub", TestSafeInt32Sub, NULL, NULL, NULL);
> + AddTestCase(AdditionSubtractionTestSuite, "Test SafeIntnSub", "TestSafeIntnSub", TestSafeIntnSub, NULL, NULL, NULL);
> + AddTestCase(AdditionSubtractionTestSuite, "Test SafeInt64Sub", "TestSafeInt64Sub", TestSafeInt64Sub, NULL, NULL, NULL);
> +
> + //
> + // Test the multiplication functions
> + //
> + Status = CreateUnitTestSuite(&MultiplicationTestSuite, Framework, "Int Safe Multiply Test Suite", "Common.SafeInt.Multiply", NULL,
> NULL);
> + if (EFI_ERROR(Status)) {
> + DEBUG((DEBUG_ERROR, "Failed in CreateUnitTestSuite for Int Safe Multiply Test Suite\n"));
> + Status = EFI_OUT_OF_RESOURCES;
> + goto EXIT;
> + }
> + AddTestCase(MultiplicationTestSuite, "Test SafeUint8Mult", "TestSafeUint8Mult", TestSafeUint8Mult, NULL, NULL, NULL);
> + AddTestCase(MultiplicationTestSuite, "Test SafeUint16Mult", "TestSafeUint16Mult", TestSafeUint16Mult, NULL, NULL, NULL);
> + AddTestCase(MultiplicationTestSuite, "Test SafeUint32Mult", "TestSafeUint32Mult", TestSafeUint32Mult, NULL, NULL, NULL);
> + AddTestCase(MultiplicationTestSuite, "Test SafeUintnMult", "TestSafeUintnMult", TestSafeUintnMult, NULL, NULL, NULL);
> + AddTestCase(MultiplicationTestSuite, "Test SafeUint64Mult", "TestSafeUint64Mult", TestSafeUint64Mult, NULL, NULL, NULL);
> + AddTestCase(MultiplicationTestSuite, "Test SafeInt8Mult", "TestSafeInt8Mult", TestSafeInt8Mult, NULL, NULL, NULL);
> + AddTestCase(MultiplicationTestSuite, "Test SafeInt16Mult", "TestSafeInt16Mult", TestSafeInt16Mult, NULL, NULL, NULL);
> + AddTestCase(MultiplicationTestSuite, "Test SafeInt32Mult", "TestSafeInt32Mult", TestSafeInt32Mult, NULL, NULL, NULL);
> + AddTestCase(MultiplicationTestSuite, "Test SafeIntnMult", "TestSafeIntnMult", TestSafeIntnMult, NULL, NULL, NULL);
> + AddTestCase(MultiplicationTestSuite, "Test SafeInt64Mult", "TestSafeInt64Mult", TestSafeInt64Mult, NULL, NULL, NULL);
> +
> + //
> + // Execute the tests.
> + //
> + Status = RunAllTestSuites(Framework);
> +
> +EXIT:
> + if (Framework != NULL) {
> + FreeUnitTestFramework(Framework);
> + }
> +
> + return Status;
> +}
> +
> +EFI_STATUS
> +EFIAPI
> +PeiEntryPoint (
> + IN EFI_PEI_FILE_HANDLE FileHandle,
> + IN CONST EFI_PEI_SERVICES **PeiServices
> + )
> +{
> + return UefiTestMain ();
> +}
> +
> +EFI_STATUS
> +EFIAPI
> +DxeEntryPoint (
> + IN EFI_HANDLE ImageHandle,
> + IN EFI_SYSTEM_TABLE *SystemTable
> + )
> +{
> + return UefiTestMain ();
> +}
> +
> +int
> +main (
> + int argc,
> + char *argv[]
> + )
> +{
> + return UefiTestMain ();
> +}
> diff --git a/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntLib.h
> b/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntLib.h
> new file mode 100644
> index 0000000000..7957c99a85
> --- /dev/null
> +++ b/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntLib.h
> @@ -0,0 +1,123 @@
> +/** @file
> + UEFI OS based application for unit testing the SafeIntLib.
> +
> + Copyright (c) Microsoft Corporation.<BR>
> + Copyright (c) 2018 - 2020, Intel Corporation. All rights reserved.<BR>
> + SPDX-License-Identifier: BSD-2-Clause-Patent
> +
> +**/
> +
> +#ifndef _TEST_BASE_SAFE_INT_LIB_H_
> +#define _TEST_BASE_SAFE_INT_LIB_H_
> +
> +#include <PiPei.h>
> +#include <Uefi.h>
> +#include <Library/UefiLib.h>
> +#include <Library/DebugLib.h>
> +#include <Library/MemoryAllocationLib.h>
> +#include <Library/UnitTestLib.h>
> +#include <Library/SafeIntLib.h>
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeInt32ToUintn(
> + IN UNIT_TEST_CONTEXT Context
> + );
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUint32ToIntn(
> + IN UNIT_TEST_CONTEXT Context
> + );
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeIntnToInt32(
> + IN UNIT_TEST_CONTEXT Context
> + );
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeIntnToUint32(
> + IN UNIT_TEST_CONTEXT Context
> + );
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUintnToUint32(
> + IN UNIT_TEST_CONTEXT Context
> + );
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUintnToIntn(
> + IN UNIT_TEST_CONTEXT Context
> + );
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUintnToInt64(
> + IN UNIT_TEST_CONTEXT Context
> + );
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeInt64ToIntn(
> + IN UNIT_TEST_CONTEXT Context
> + );
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeInt64ToUintn(
> + IN UNIT_TEST_CONTEXT Context
> + );
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUint64ToIntn(
> + IN UNIT_TEST_CONTEXT Context
> + );
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUint64ToUintn(
> + IN UNIT_TEST_CONTEXT Context
> + );
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUintnAdd(
> + IN UNIT_TEST_CONTEXT Context
> + );
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeIntnAdd(
> + IN UNIT_TEST_CONTEXT Context
> + );
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUintnSub(
> + IN UNIT_TEST_CONTEXT Context
> + );
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeIntnSub(
> + IN UNIT_TEST_CONTEXT Context
> + );
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeUintnMult(
> + IN UNIT_TEST_CONTEXT Context
> + );
> +
> +UNIT_TEST_STATUS
> +EFIAPI
> +TestSafeIntnMult(
> + IN UNIT_TEST_CONTEXT Context
> + );
> +
> +#endif
> diff --git a/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntLib.uni
> b/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntLib.uni
> new file mode 100644
> index 0000000000..956835c30d
> --- /dev/null
> +++ b/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntLib.uni
> @@ -0,0 +1,13 @@
> +// /** @file
> +// Application that Unit Tests the SafeIntLib
> +//
> +// Copyright (c) 2020, Intel Corporation. All rights reserved.<BR>
> +//
> +// SPDX-License-Identifier: BSD-2-Clause-Patent
> +//
> +// **/
> +
> +#string STR_MODULE_ABSTRACT #language en-US "Application that Unit Tests the SafeIntLib"
> +
> +#string STR_MODULE_DESCRIPTION #language en-US "Application that Unit Tests the SafeIntLib."
> +
> diff --git a/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntLibDxe.inf
> b/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntLibDxe.inf
> new file mode 100644
> index 0000000000..de67b04bd5
> --- /dev/null
> +++ b/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntLibDxe.inf
> @@ -0,0 +1,45 @@
> +## @file
> +# DXE Driver that Unit Tests the SafeIntLib
> +#
> +# Copyright (c) Microsoft Corporation.<BR>
> +# Copyright (c) 2019 - 2020, Intel Corporation. All rights reserved.<BR>
> +# SPDX-License-Identifier: BSD-2-Clause-Patent
> +##
> +
> +[Defines]
> + INF_VERSION = 0x00010005
> + BASE_NAME = TestBaseSafeIntLibDxe
> + MODULE_UNI_FILE = TestBaseSafeIntLib.uni
> + FILE_GUID = 9729DB60-FB9D-4625-9EE1-93B21EC246B8
> + MODULE_TYPE = DXE_DRIVER
> + VERSION_STRING = 1.0
> + ENTRY_POINT = DxeEntryPoint
> +
> +#
> +# The following information is for reference only and not required by the build tools.
> +#
> +# VALID_ARCHITECTURES = IA32 X64
> +#
> +
> +[Sources]
> + TestBaseSafeIntLib.c
> + TestBaseSafeIntLib.h
> +
> +[Sources.Ia32, Sources.ARM]
> + SafeIntLibUintnIntnUnitTests32.c
> +
> +[Sources.X64, Sources.AARCH64]
> + SafeIntLibUintnIntnUnitTests64.c
> +
> +[Packages]
> + MdePkg/MdePkg.dec
> +
> +[LibraryClasses]
> + UefiDriverEntryPoint
> + BaseLib
> + DebugLib
> + SafeIntLib
> + UnitTestLib
> +
> +[Depex]
> + TRUE
> diff --git a/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntLibHost.inf
> b/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntLibHost.inf
> new file mode 100644
> index 0000000000..35c93fdeac
> --- /dev/null
> +++ b/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntLibHost.inf
> @@ -0,0 +1,40 @@
> +## @file
> +# Host OS based Application that Unit Tests the SafeIntLib
> +#
> +# Copyright (c) Microsoft Corporation.<BR>
> +# Copyright (c) 2019 - 2020, Intel Corporation. All rights reserved.<BR>
> +# SPDX-License-Identifier: BSD-2-Clause-Patent
> +##
> +
> +[Defines]
> + INF_VERSION = 0x00010005
> + BASE_NAME = TestBaseSafeIntLibHost
> + MODULE_UNI_FILE = TestBaseSafeIntLib.uni
> + FILE_GUID = 95487689-9E30-41AD-B773-3650C94BCBE2
> + MODULE_TYPE = HOST_APPLICATION
> + VERSION_STRING = 1.0
> +
> +#
> +# The following information is for reference only and not required by the build tools.
> +#
> +# VALID_ARCHITECTURES = IA32 X64
> +#
> +
> +[Sources]
> + TestBaseSafeIntLib.c
> + TestBaseSafeIntLib.h
> +
> +[Sources.Ia32, Sources.ARM]
> + SafeIntLibUintnIntnUnitTests32.c
> +
> +[Sources.X64, Sources.AARCH64]
> + SafeIntLibUintnIntnUnitTests64.c
> +
> +[Packages]
> + MdePkg/MdePkg.dec
> +
> +[LibraryClasses]
> + BaseLib
> + DebugLib
> + SafeIntLib
> + UnitTestLib
> diff --git a/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntLibPei.inf
> b/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntLibPei.inf
> new file mode 100644
> index 0000000000..c8ba4f44ef
> --- /dev/null
> +++ b/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntLibPei.inf
> @@ -0,0 +1,45 @@
> +## @file
> +# PEIM that Unit Tests the SafeIntLib
> +#
> +# Copyright (c) Microsoft Corporation.<BR>
> +# Copyright (c) 2019 - 2020, Intel Corporation. All rights reserved.<BR>
> +# SPDX-License-Identifier: BSD-2-Clause-Patent
> +##
> +
> +[Defines]
> + INF_VERSION = 0x00010005
> + BASE_NAME = TestBaseSafeIntLibPei
> + MODULE_UNI_FILE = TestBaseSafeIntLib.uni
> + FILE_GUID = 7D910602-ED53-45E6-826E-8266705B9734
> + MODULE_TYPE = PEIM
> + VERSION_STRING = 1.0
> + ENTRY_POINT = PeiEntryPoint
> +
> +#
> +# The following information is for reference only and not required by the build tools.
> +#
> +# VALID_ARCHITECTURES = IA32 X64
> +#
> +
> +[Sources]
> + TestBaseSafeIntLib.c
> + TestBaseSafeIntLib.h
> +
> +[Sources.Ia32, Sources.ARM]
> + SafeIntLibUintnIntnUnitTests32.c
> +
> +[Sources.X64, Sources.AARCH64]
> + SafeIntLibUintnIntnUnitTests64.c
> +
> +[Packages]
> + MdePkg/MdePkg.dec
> +
> +[LibraryClasses]
> + PeimEntryPoint
> + BaseLib
> + DebugLib
> + SafeIntLib
> + UnitTestLib
> +
> +[Depex]
> + TRUE
> diff --git a/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntLibSmm.inf
> b/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntLibSmm.inf
> new file mode 100644
> index 0000000000..df7288501d
> --- /dev/null
> +++ b/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntLibSmm.inf
> @@ -0,0 +1,45 @@
> +## @file
> +# SMM Driver that Unit Tests the SafeIntLib
> +#
> +# Copyright (c) Microsoft Corporation.<BR>
> +# Copyright (c) 2019 - 2020, Intel Corporation. All rights reserved.<BR>
> +# SPDX-License-Identifier: BSD-2-Clause-Patent
> +##
> +
> +[Defines]
> + INF_VERSION = 0x00010005
> + BASE_NAME = TestBaseSafeIntLibSmm
> + MODULE_UNI_FILE = TestBaseSafeIntLib.uni
> + FILE_GUID = 2F2A1907-B1B4-4E33-8B83-62A60AB4F0D4
> + MODULE_TYPE = DXE_SMM_DRIVER
> + VERSION_STRING = 1.0
> + ENTRY_POINT = DxeEntryPoint
> +
> +#
> +# The following information is for reference only and not required by the build tools.
> +#
> +# VALID_ARCHITECTURES = IA32 X64
> +#
> +
> +[Sources]
> + TestBaseSafeIntLib.c
> + TestBaseSafeIntLib.h
> +
> +[Sources.Ia32, Sources.ARM]
> + SafeIntLibUintnIntnUnitTests32.c
> +
> +[Sources.X64, Sources.AARCH64]
> + SafeIntLibUintnIntnUnitTests64.c
> +
> +[Packages]
> + MdePkg/MdePkg.dec
> +
> +[LibraryClasses]
> + UefiDriverEntryPoint
> + BaseLib
> + DebugLib
> + SafeIntLib
> + UnitTestLib
> +
> +[Depex]
> + TRUE
> diff --git a/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntLibUefiShell.inf
> b/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntLibUefiShell.inf
> new file mode 100644
> index 0000000000..5a13c1c845
> --- /dev/null
> +++ b/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntLibUefiShell.inf
> @@ -0,0 +1,42 @@
> +## @file
> +# UEFI Shell based Application that Unit Tests the SafeIntLib
> +#
> +# Copyright (c) Microsoft Corporation.<BR>
> +# Copyright (c) 2019 - 2020, Intel Corporation. All rights reserved.<BR>
> +# SPDX-License-Identifier: BSD-2-Clause-Patent
> +##
> +
> +[Defines]
> + INF_VERSION = 0x00010005
> + BASE_NAME = TestBaseSafeIntLibUefiShell
> + MODULE_UNI_FILE = TestBaseSafeIntLib.uni
> + FILE_GUID = 1F91B73E-5B6A-4317-80E8-E7C36A3C7AF4
> + MODULE_TYPE = UEFI_APPLICATION
> + VERSION_STRING = 1.0
> + ENTRY_POINT = DxeEntryPoint
> +
> +#
> +# The following information is for reference only and not required by the build tools.
> +#
> +# VALID_ARCHITECTURES = IA32 X64
> +#
> +
> +[Sources]
> + TestBaseSafeIntLib.c
> + TestBaseSafeIntLib.h
> +
> +[Sources.Ia32, Sources.ARM]
> + SafeIntLibUintnIntnUnitTests32.c
> +
> +[Sources.X64, Sources.AARCH64]
> + SafeIntLibUintnIntnUnitTests64.c
> +
> +[Packages]
> + MdePkg/MdePkg.dec
> +
> +[LibraryClasses]
> + UefiApplicationEntryPoint
> + BaseLib
> + DebugLib
> + SafeIntLib
> + UnitTestLib
> --
> 2.21.0.windows.1
-=-=-=-=-=-=-=-=-=-=-=-
Groups.io Links: You receive all messages sent to this group.
View/Reply Online (#54026): https://edk2.groups.io/g/devel/message/54026
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]
-=-=-=-=-=-=-=-=-=-=-=-
Hi Liming,
Unit tests can be run as a host application.
If they do not use cmocka, it may be possible to run from the
UEFI Shell, depending on the attributes of the API under test.
If a unit test is specific to the PEI, SMM, or early DXE phase,
Then it cannot be run from the UEFI Shell. If a unit test is
for an API of type BASE or late DXE or UEFI, it can run from the
UEFI Shell.
There are samples in the UnitTestFrameworkPkg that show a single
sample can be built for host and all target environments.
The SafeIntLib and BaseLib examples could be built and run from the
UEFI Shell. This patch series only has a single DSC file to
build and run them from a host env, but a 2nd DSC could be added
to build them for the UEFI Shell. If a unit test can be run from
the host and get full coverage, then that is an easier environment
to do the testing. Unit tests that meet this criteria do not need
to be built for the target envs. This is why the SafeIntLib and
BaseLib unit tests provided in this series do not include the
DSC file for target environments.
Thanks,
Mike
> -----Original Message-----
> From: Gao, Liming <liming.gao@intel.com>
> Sent: Thursday, February 6, 2020 11:57 PM
> To: Kinney, Michael D <michael.d.kinney@intel.com>;
> devel@edk2.groups.io
> Cc: Sean Brogan <sean.brogan@microsoft.com>; Bret
> Barkelew <Bret.Barkelew@microsoft.com>
> Subject: RE: [Patch 08/11] MdePkg/Test: Add SafeIntLib
> and BaseLib Base64 unit tests
>
> Mike:
> Is there the ready UEFI shell environment to run
> target based tests? Is Emulator used?
>
> Thanks
> Liming
> > -----Original Message-----
> > From: Kinney, Michael D <michael.d.kinney@intel.com>
> > Sent: Friday, January 24, 2020 10:10 AM
> > To: devel@edk2.groups.io
> > Cc: Sean Brogan <sean.brogan@microsoft.com>; Bret
> Barkelew <Bret.Barkelew@microsoft.com>; Gao, Liming
> <liming.gao@intel.com>
> > Subject: [Patch 08/11] MdePkg/Test: Add SafeIntLib
> and BaseLib Base64 unit tests
> >
> > * Add unit tests for SafeIntLib class
> > * Add unit tests for BaseLib Base64 conversion APIs.
> > * Add Test/MdePkgHostTest.dsc -to build host based
> unit
> > tests
> > * Update MdePkg.dsc to build target based tests for
> > SafeIntLib and BaseLib
> > * Update MdePkg.ci.yaml to build and run host based
> > tests for SafeIntLib and BaseLib
> >
> > Cc: Sean Brogan <sean.brogan@microsoft.com>
> > Cc: Bret Barkelew <Bret.Barkelew@microsoft.com>
> > Cc: Liming Gao <liming.gao@intel.com>
> > Signed-off-by: Michael D Kinney
> <michael.d.kinney@intel.com>
> > ---
> > MdePkg/MdePkg.ci.yaml | 19
> +-
> > MdePkg/MdePkg.dsc | 18
> +
> > MdePkg/Test/MdePkgHostTest.dsc | 30
> +
> > .../UnitTest/Library/BaseLib/Base64UnitTest.c | 404
> +++
> > .../Library/BaseLib/BaseLibUnitTestsHost.inf | 32
> +
> > .../Library/BaseLib/BaseLibUnitTestsUefi.inf | 33
> +
> > .../SafeIntLibUintnIntnUnitTests32.c | 540
> +++
> > .../SafeIntLibUintnIntnUnitTests64.c | 544
> +++
> > .../BaseSafeIntLib/TestBaseSafeIntLib.c | 3064
> +++++++++++++++++
> > .../BaseSafeIntLib/TestBaseSafeIntLib.h | 123
> +
> > .../BaseSafeIntLib/TestBaseSafeIntLib.uni | 13
> +
> > .../BaseSafeIntLib/TestBaseSafeIntLibDxe.inf | 45
> +
> > .../BaseSafeIntLib/TestBaseSafeIntLibHost.inf | 40
> +
> > .../BaseSafeIntLib/TestBaseSafeIntLibPei.inf | 45
> +
> > .../BaseSafeIntLib/TestBaseSafeIntLibSmm.inf | 45
> +
> > .../TestBaseSafeIntLibUefiShell.inf | 42
> +
> > 16 files changed, 5034 insertions(+), 3 deletions(-)
> > create mode 100644 MdePkg/Test/MdePkgHostTest.dsc
> > create mode 100644
> MdePkg/Test/UnitTest/Library/BaseLib/Base64UnitTest.c
> > create mode 100644
> MdePkg/Test/UnitTest/Library/BaseLib/BaseLibUnitTestsHo
> st.inf
> > create mode 100644
> MdePkg/Test/UnitTest/Library/BaseLib/BaseLibUnitTestsUe
> fi.inf
> > create mode 100644
> MdePkg/Test/UnitTest/Library/BaseSafeIntLib/SafeIntLibU
> intnIntnUnitTests32.c
> > create mode 100644
> MdePkg/Test/UnitTest/Library/BaseSafeIntLib/SafeIntLibU
> intnIntnUnitTests64.c
> > create mode 100644
> MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSaf
> eIntLib.c
> > create mode 100644
> MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSaf
> eIntLib.h
> > create mode 100644
> MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSaf
> eIntLib.uni
> > create mode 100644
> MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSaf
> eIntLibDxe.inf
> > create mode 100644
> MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSaf
> eIntLibHost.inf
> > create mode 100644
> MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSaf
> eIntLibPei.inf
> > create mode 100644
> MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSaf
> eIntLibSmm.inf
> > create mode 100644
> MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSaf
> eIntLibUefiShell.inf
> >
> > diff --git a/MdePkg/MdePkg.ci.yaml
> b/MdePkg/MdePkg.ci.yaml
> > index 65c4ec3bec..88e490fcb6 100644
> > --- a/MdePkg/MdePkg.ci.yaml
> > +++ b/MdePkg/MdePkg.ci.yaml
> > @@ -10,8 +10,13 @@
> > "DscPath": "MdePkg.dsc"
> > },
> >
> > + ## options defined
> ci/Plugin/HostUnitTestCompilerPlugin
> > + "HostUnitTestCompilerPlugin": {
> > + "DscPath": "Test/MdePkgHostTest.dsc"
> > + },
> > +
> > ## options defined ci/Plugin/CharEncodingCheck
> > -"CharEncodingCheck": {
> > + "CharEncodingCheck": {
> > "IgnoreFiles": []
> > },
> >
> > @@ -21,7 +26,9 @@
> > "MdePkg/MdePkg.dec"
> > ],
> > # For host based unit tests
> > - "AcceptableDependencies-
> HOST_APPLICATION":[],
> > + "AcceptableDependencies-HOST_APPLICATION":[
> > +
> "UnitTestFrameworkPkg/UnitTestFrameworkPkg.dec"
> > + ],
> > # For UEFI shell based apps
> > "AcceptableDependencies-
> UEFI_APPLICATION":[],
> > "IgnoreInf": []
> > @@ -29,10 +36,16 @@
> >
> > ## options defined ci/Plugin/DscCompleteCheck
> > "DscCompleteCheck": {
> > - "IgnoreInf": [],
> > + "IgnoreInf": [""],
> > "DscPath": "MdePkg.dsc"
> > },
> >
> > + ## options defined
> ci/Plugin/HostUnitTestDscCompleteCheck
> > + "HostUnitTestDscCompleteCheck": {
> > + "IgnoreInf": [""],
> > + "DscPath": "Test/MdePkgHostTest.dsc"
> > + },
> > +
> > ## options defined ci/Plugin/GuidCheck
> > "GuidCheck": {
> > "IgnoreGuidName": [
> > diff --git a/MdePkg/MdePkg.dsc b/MdePkg/MdePkg.dsc
> > index 0aeafaaacc..87af740853 100644
> > --- a/MdePkg/MdePkg.dsc
> > +++ b/MdePkg/MdePkg.dsc
> > @@ -18,6 +18,8 @@ [Defines]
> > BUILD_TARGETS =
> DEBUG|RELEASE|NOOPT
> > SKUID_IDENTIFIER = DEFAULT
> >
> > +!include
> UnitTestFrameworkPkg/UnitTestFrameworkPkgTarget.dsc.inc
> > +
> > [PcdsFeatureFlag]
> > gEfiMdePkgTokenSpaceGuid.PcdUgaConsumeSupport|TRUE
> >
> > @@ -26,6 +28,9 @@ [PcdsFixedAtBuild]
> >
> gEfiMdePkgTokenSpaceGuid.PcdDebugPrintErrorLevel|0x8000
> 0000
> >
> gEfiMdePkgTokenSpaceGuid.PcdPciExpressBaseAddress|0xE00
> 00000
> >
> > +[LibraryClasses]
> > +
> SafeIntLib|MdePkg/Library/BaseSafeIntLib/BaseSafeIntLib
> .inf
> > +
> > [Components]
> >
> MdePkg/Library/UefiFileHandleLib/UefiFileHandleLib.inf
> >
> MdePkg/Library/BaseCacheMaintenanceLib/BaseCacheMainten
> anceLib.inf
> > @@ -115,6 +120,19 @@ [Components]
> >
> MdePkg/Library/StandaloneMmDriverEntryPoint/StandaloneM
> mDriverEntryPoint.inf
> >
> MdePkg/Library/StandaloneMmServicesTableLib/StandaloneM
> mServicesTableLib.inf
> >
> > + #
> > + # Add UEFI Target Based Unit Tests
> > + #
> > +
> MdePkg/Test/UnitTest/Library/BaseLib/BaseLibUnitTestsUe
> fi.inf
> > +
> > + #
> > + # Build PEIM, DXE_DRIVER, SMM_DRIVER, UEFI Shell
> components that test SafeIntLib
> > + #
> > +
> MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSaf
> eIntLibPei.inf
> > +
> MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSaf
> eIntLibDxe.inf
> > +
> MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSaf
> eIntLibSmm.inf
> > +
> MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSaf
> eIntLibUefiShell.inf
> > +
> > [Components.IA32, Components.X64]
> >
> MdePkg/Library/BaseIoLibIntrinsic/BaseIoLibIntrinsic.in
> f
> >
> MdePkg/Library/BaseIoLibIntrinsic/BaseIoLibIntrinsicSev
> .inf
> > diff --git a/MdePkg/Test/MdePkgHostTest.dsc
> b/MdePkg/Test/MdePkgHostTest.dsc
> > new file mode 100644
> > index 0000000000..3d677ee75c
> > --- /dev/null
> > +++ b/MdePkg/Test/MdePkgHostTest.dsc
> > @@ -0,0 +1,30 @@
> > +## @file
> > +# MdePkg DSC file used to build host-based unit
> tests.
> > +#
> > +# Copyright (c) 2019 - 2020, Intel Corporation. All
> rights reserved.<BR>
> > +# Copyright (C) Microsoft Corporation.
> > +# SPDX-License-Identifier: BSD-2-Clause-Patent
> > +#
> > +##
> > +
> > +[Defines]
> > + PLATFORM_NAME = MdePkgHostTest
> > + PLATFORM_GUID = 50652B4C-88CB-4481-96E8-
> 37F2D0034440
> > + PLATFORM_VERSION = 0.1
> > + DSC_SPECIFICATION = 0x00010005
> > + OUTPUT_DIRECTORY = Build/MdePkg/HostTest
> > + SUPPORTED_ARCHITECTURES = IA32|X64
> > + BUILD_TARGETS = NOOPT
> > + SKUID_IDENTIFIER = DEFAULT
> > +
> > +!include
> UnitTestFrameworkPkg/UnitTestFrameworkPkgHost.dsc.inc
> > +
> > +[LibraryClasses]
> > +
> SafeIntLib|MdePkg/Library/BaseSafeIntLib/BaseSafeIntLib
> .inf
> > +
> > +[Components]
> > + #
> > + # Build HOST_APPLICATION that tests the SafeIntLib
> > + #
> > +
> MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSaf
> eIntLibHost.inf
> > +
> MdePkg/Test/UnitTest/Library/BaseLib/BaseLibUnitTestsHo
> st.inf
> > diff --git
> a/MdePkg/Test/UnitTest/Library/BaseLib/Base64UnitTest.c
> b/MdePkg/Test/UnitTest/Library/BaseLib/Base64UnitTest.c
> > new file mode 100644
> > index 0000000000..0ad078155c
> > --- /dev/null
> > +++
> b/MdePkg/Test/UnitTest/Library/BaseLib/Base64UnitTest.c
> > @@ -0,0 +1,404 @@
> > +/** @file
> > + Unit tests of Base64 conversion APIs in BaseLib.
> > +
> > + Copyright (C) Microsoft Corporation.
> > + SPDX-License-Identifier: BSD-2-Clause-Patent
> > +
> > +**/
> > +
> > +#include <Uefi.h>
> > +#include <Library/BaseLib.h>
> > +#include <Library/BaseMemoryLib.h>
> > +#include <Library/DebugLib.h>
> > +#include <Library/MemoryAllocationLib.h>
> > +#include <Library/UnitTestLib.h>
> > +
> > +#define UNIT_TEST_APP_NAME "BaseLib Unit Test
> Application"
> > +#define UNIT_TEST_APP_VERSION "1.0"
> > +
> > +/**
> > + RFC 4648 https://tools.ietf.org/html/rfc4648 test
> vectors
> > +
> > + BASE64("") = ""
> > + BASE64("f") = "Zg=="
> > + BASE64("fo") = "Zm8="
> > + BASE64("foo") = "Zm9v"
> > + BASE64("foob") = "Zm9vYg=="
> > + BASE64("fooba") = "Zm9vYmE="
> > + BASE64("foobar") = "Zm9vYmFy"
> > +
> > + The test vectors are using ascii strings for the
> binary data
> > + */
> > +
> > +typedef struct {
> > + CHAR8 *TestInput;
> > + CHAR8 *TestOutput;
> > + EFI_STATUS ExpectedStatus;
> > + VOID *BufferToFree;
> > + UINTN ExpectedSize;
> > +} BASIC_TEST_CONTEXT;
> > +
> > +#define B64_TEST_1 ""
> > +#define BIN_TEST_1 ""
> > +
> > +#define B64_TEST_2 "Zg=="
> > +#define BIN_TEST_2 "f"
> > +
> > +#define B64_TEST_3 "Zm8="
> > +#define BIN_TEST_3 "fo"
> > +
> > +#define B64_TEST_4 "Zm9v"
> > +#define BIN_TEST_4 "foo"
> > +
> > +#define B64_TEST_5 "Zm9vYg=="
> > +#define BIN_TEST_5 "foob"
> > +
> > +#define B64_TEST_6 "Zm9vYmE="
> > +#define BIN_TEST_6 "fooba"
> > +
> > +#define B64_TEST_7 "Zm9vYmFy"
> > +#define BIN_TEST_7 "foobar"
> > +
> > +// Adds all white space - also ends the last quantum
> with only spaces afterwards
> > +#define B64_TEST_8_IN " \t\v Zm9\r\nvYmFy \f "
> > +#define BIN_TEST_8 "foobar"
> > +
> > +// Not a quantum multiple of 4
> > +#define B64_ERROR_1 "Zm9vymFy="
> > +
> > +// Invalid characters in the string
> > +#define B64_ERROR_2 "Zm$vymFy"
> > +
> > +// Too many '=' characters
> > +#define B64_ERROR_3 "Z==="
> > +
> > +// Poorly placed '='
> > +#define B64_ERROR_4 "Zm=vYmFy"
> > +
> > +#define MAX_TEST_STRING_SIZE (200)
> > +
> > +// ------------------------------------------------
> Input----------Output-----------Result-------Free--
> Expected Output Size
> > +static BASIC_TEST_CONTEXT mBasicEncodeTest1 =
> {BIN_TEST_1, B64_TEST_1, EFI_SUCCESS, NULL,
> sizeof(B64_TEST_1)};
> > +static BASIC_TEST_CONTEXT mBasicEncodeTest2 =
> {BIN_TEST_2, B64_TEST_2, EFI_SUCCESS, NULL,
> sizeof(B64_TEST_2)};
> > +static BASIC_TEST_CONTEXT mBasicEncodeTest3 =
> {BIN_TEST_3, B64_TEST_3, EFI_SUCCESS, NULL,
> sizeof(B64_TEST_3)};
> > +static BASIC_TEST_CONTEXT mBasicEncodeTest4 =
> {BIN_TEST_4, B64_TEST_4, EFI_SUCCESS, NULL,
> sizeof(B64_TEST_4)};
> > +static BASIC_TEST_CONTEXT mBasicEncodeTest5 =
> {BIN_TEST_5, B64_TEST_5, EFI_SUCCESS, NULL,
> sizeof(B64_TEST_5)};
> > +static BASIC_TEST_CONTEXT mBasicEncodeTest6 =
> {BIN_TEST_6, B64_TEST_6, EFI_SUCCESS, NULL,
> sizeof(B64_TEST_6)};
> > +static BASIC_TEST_CONTEXT mBasicEncodeTest7 =
> {BIN_TEST_7, B64_TEST_7, EFI_SUCCESS, NULL,
> sizeof(B64_TEST_7)};
> > +static BASIC_TEST_CONTEXT mBasicEncodeError1 =
> {BIN_TEST_7, B64_TEST_1, EFI_BUFFER_TOO_SMALL,
> NULL,
> > sizeof(B64_TEST_7)};
> > +
> > +static BASIC_TEST_CONTEXT mBasicDecodeTest1 =
> {B64_TEST_1, BIN_TEST_1, EFI_SUCCESS, NULL,
> sizeof(BIN_TEST_1)-1};
> > +static BASIC_TEST_CONTEXT mBasicDecodeTest2 =
> {B64_TEST_2, BIN_TEST_2, EFI_SUCCESS, NULL,
> sizeof(BIN_TEST_2)-1};
> > +static BASIC_TEST_CONTEXT mBasicDecodeTest3 =
> {B64_TEST_3, BIN_TEST_3, EFI_SUCCESS, NULL,
> sizeof(BIN_TEST_3)-1};
> > +static BASIC_TEST_CONTEXT mBasicDecodeTest4 =
> {B64_TEST_4, BIN_TEST_4, EFI_SUCCESS, NULL,
> sizeof(BIN_TEST_4)-1};
> > +static BASIC_TEST_CONTEXT mBasicDecodeTest5 =
> {B64_TEST_5, BIN_TEST_5, EFI_SUCCESS, NULL,
> sizeof(BIN_TEST_5)-1};
> > +static BASIC_TEST_CONTEXT mBasicDecodeTest6 =
> {B64_TEST_6, BIN_TEST_6, EFI_SUCCESS, NULL,
> sizeof(BIN_TEST_6)-1};
> > +static BASIC_TEST_CONTEXT mBasicDecodeTest7 =
> {B64_TEST_7, BIN_TEST_7, EFI_SUCCESS, NULL,
> sizeof(BIN_TEST_7)-1};
> > +static BASIC_TEST_CONTEXT mBasicDecodeTest8 =
> {B64_TEST_8_IN, BIN_TEST_8, EFI_SUCCESS, NULL,
> sizeof(BIN_TEST_8)-1};
> > +
> > +static BASIC_TEST_CONTEXT mBasicDecodeError1 =
> {B64_ERROR_1, B64_ERROR_1,
> EFI_INVALID_PARAMETER, NULL, 0};
> > +static BASIC_TEST_CONTEXT mBasicDecodeError2 =
> {B64_ERROR_2, B64_ERROR_2,
> EFI_INVALID_PARAMETER, NULL, 0};
> > +static BASIC_TEST_CONTEXT mBasicDecodeError3 =
> {B64_ERROR_3, B64_ERROR_3,
> EFI_INVALID_PARAMETER, NULL, 0};
> > +static BASIC_TEST_CONTEXT mBasicDecodeError4 =
> {B64_ERROR_4, B64_ERROR_4,
> EFI_INVALID_PARAMETER, NULL, 0};
> > +static BASIC_TEST_CONTEXT mBasicDecodeError5 =
> {B64_TEST_7, BIN_TEST_1, EFI_BUFFER_TOO_SMALL,
> NULL,
> > sizeof(BIN_TEST_7)-1};
> > +
> > +/**
> > + Simple clean up method to make sure tests clean up
> even if interrupted and fail
> > + in the middle.
> > +**/
> > +STATIC
> > +VOID
> > +EFIAPI
> > +CleanUpB64TestContext (
> > + IN UNIT_TEST_CONTEXT Context
> > + )
> > +{
> > + BASIC_TEST_CONTEXT *Btc;
> > +
> > + Btc = (BASIC_TEST_CONTEXT *)Context;
> > + if (Btc != NULL) {
> > + //free string if set
> > + if (Btc->BufferToFree != NULL) {
> > + FreePool (Btc->BufferToFree);
> > + Btc->BufferToFree = NULL;
> > + }
> > + }
> > +}
> > +
> > +/**
> > + Unit test for Base64 encode APIs of BaseLib.
> > +
> > + @param[in] Context [Optional] An optional
> paramter that enables:
> > + 1) test-case reuse with
> varied parameters and
> > + 2) test-case re-entry for
> Target tests that need a
> > + reboot. This parameter is
> a VOID* and it is the
> > + responsibility of the test
> author to ensure that the
> > + contents are well
> understood by all test cases that may
> > + consume it.
> > +
> > + @retval UNIT_TEST_PASSED The Unit
> test has completed and the test
> > + case was
> successful.
> > + @retval UNIT_TEST_ERROR_TEST_FAILED A test case
> assertion has failed.
> > +**/
> > +STATIC
> > +UNIT_TEST_STATUS
> > +EFIAPI
> > +RfcEncodeTest (
> > + IN UNIT_TEST_CONTEXT Context
> > + )
> > +{
> > + BASIC_TEST_CONTEXT *Btc;
> > + CHAR8 *b64String;
> > + CHAR8 *binString;
> > + UINTN b64StringSize;
> > + EFI_STATUS Status;
> > + UINT8 *BinData;
> > + UINTN BinSize;
> > + CHAR8 *b64WorkString;
> > + UINTN ReturnSize;
> > + INTN CompareStatus;
> > + UINTN indx;
> > +
> > + Btc = (BASIC_TEST_CONTEXT *) Context;
> > + binString = Btc->TestInput;
> > + b64String = Btc->TestOutput;
> > +
> > + //
> > + // Only testing the the translate functionality,
> so preallocate the proper
> > + // string buffer.
> > + //
> > +
> > + b64StringSize = AsciiStrnSizeS(b64String,
> MAX_TEST_STRING_SIZE);
> > + BinSize = AsciiStrnLenS(binString,
> MAX_TEST_STRING_SIZE);
> > + BinData = (UINT8 *) binString;
> > +
> > + b64WorkString = (CHAR8 *)
> AllocatePool(b64StringSize);
> > + UT_ASSERT_NOT_NULL(b64WorkString);
> > +
> > + Btc->BufferToFree = b64WorkString;
> > + ReturnSize = b64StringSize;
> > +
> > + Status = Base64Encode(BinData, BinSize,
> b64WorkString, &ReturnSize);
> > +
> > + UT_ASSERT_STATUS_EQUAL(Status, Btc-
> >ExpectedStatus);
> > +
> > + UT_ASSERT_EQUAL(ReturnSize, Btc->ExpectedSize);
> > +
> > + if (!EFI_ERROR (Btc->ExpectedStatus)) {
> > + if (ReturnSize != 0) {
> > + CompareStatus = AsciiStrnCmp (b64String,
> b64WorkString, ReturnSize);
> > + if (CompareStatus != 0) {
> > + UT_LOG_ERROR ("b64 string compare error -
> size=%d\n", ReturnSize);
> > + for (indx = 0; indx < ReturnSize; indx++) {
> > + UT_LOG_ERROR (" %2.2x", 0xff &
> b64String[indx]);
> > + }
> > + UT_LOG_ERROR ("\n b64 work string:\n");
> > + for (indx = 0; indx < ReturnSize; indx++) {
> > + UT_LOG_ERROR (" %2.2x", 0xff &
> b64WorkString[indx]);
> > + }
> > + UT_LOG_ERROR ("\n");
> > + }
> > + UT_ASSERT_EQUAL (CompareStatus, 0);
> > + }
> > + }
> > +
> > + Btc->BufferToFree = NULL;
> > + FreePool (b64WorkString);
> > + return UNIT_TEST_PASSED;
> > +}
> > +
> > +/**
> > + Unit test for Base64 decode APIs of BaseLib.
> > +
> > + @param[in] Context [Optional] An optional
> paramter that enables:
> > + 1) test-case reuse with
> varied parameters and
> > + 2) test-case re-entry for
> Target tests that need a
> > + reboot. This parameter is
> a VOID* and it is the
> > + responsibility of the test
> author to ensure that the
> > + contents are well
> understood by all test cases that may
> > + consume it.
> > +
> > + @retval UNIT_TEST_PASSED The Unit
> test has completed and the test
> > + case was
> successful.
> > + @retval UNIT_TEST_ERROR_TEST_FAILED A test case
> assertion has failed.
> > +**/
> > +STATIC
> > +UNIT_TEST_STATUS
> > +EFIAPI
> > +RfcDecodeTest(
> > + IN UNIT_TEST_CONTEXT Context
> > + )
> > +{
> > + BASIC_TEST_CONTEXT *Btc;
> > + CHAR8 *b64String;
> > + CHAR8 *binString;
> > + EFI_STATUS Status;
> > + UINTN b64StringLen;
> > + UINTN ReturnSize;
> > + UINT8 *BinData;
> > + UINTN BinSize;
> > + INTN CompareStatus;
> > + UINTN indx;
> > +
> > + Btc = (BASIC_TEST_CONTEXT *)Context;
> > + b64String = Btc->TestInput;
> > + binString = Btc->TestOutput;
> > +
> > + //
> > + // Only testing the the translate functionality
> > + //
> > +
> > + b64StringLen = AsciiStrnLenS (b64String,
> MAX_TEST_STRING_SIZE);
> > + BinSize = AsciiStrnLenS (binString,
> MAX_TEST_STRING_SIZE);
> > +
> > + BinData = AllocatePool (BinSize);
> > + Btc->BufferToFree = BinData;
> > +
> > + ReturnSize = BinSize;
> > + Status = Base64Decode (b64String, b64StringLen,
> BinData, &ReturnSize);
> > +
> > + UT_ASSERT_STATUS_EQUAL (Status, Btc-
> >ExpectedStatus);
> > +
> > + // If an error is not expected, check the results
> > + if (EFI_ERROR (Btc->ExpectedStatus)) {
> > + if (Btc->ExpectedStatus == EFI_BUFFER_TOO_SMALL)
> {
> > + UT_ASSERT_EQUAL (ReturnSize, Btc-
> >ExpectedSize);
> > + }
> > + } else {
> > + UT_ASSERT_EQUAL (ReturnSize, Btc->ExpectedSize);
> > + if (ReturnSize != 0) {
> > + CompareStatus = CompareMem (binString,
> BinData, ReturnSize);
> > + if (CompareStatus != 0) {
> > + UT_LOG_ERROR ("bin string compare error -
> size=%d\n", ReturnSize);
> > + for (indx = 0; indx < ReturnSize; indx++) {
> > + UT_LOG_ERROR (" %2.2x", 0xff &
> binString[indx]);
> > + }
> > + UT_LOG_ERROR ("\nBinData:\n");
> > + for (indx = 0; indx < ReturnSize; indx++) {
> > + UT_LOG_ERROR (" %2.2x", 0xff &
> BinData[indx]);
> > + }
> > + UT_LOG_ERROR ("\n");
> > + }
> > + UT_ASSERT_EQUAL (CompareStatus, 0);
> > + }
> > + }
> > +
> > + Btc->BufferToFree = NULL;
> > + FreePool (BinData);
> > + return UNIT_TEST_PASSED;
> > +}
> > +
> > +/**
> > + Initialze the unit test framework, suite, and unit
> tests for the
> > + Base64 conversion APIs of BaseLib and run the unit
> tests.
> > +
> > + @retval EFI_SUCCESS All test cases were
> dispached.
> > + @retval EFI_OUT_OF_RESOURCES There are not
> enough resources available to
> > + initialize the unit
> tests.
> > +**/
> > +STATIC
> > +EFI_STATUS
> > +EFIAPI
> > +UnitTestingEntry (
> > + VOID
> > + )
> > +{
> > + EFI_STATUS Status;
> > + UNIT_TEST_FRAMEWORK_HANDLE Fw;
> > + UNIT_TEST_SUITE_HANDLE b64EncodeTests;
> > + UNIT_TEST_SUITE_HANDLE b64DecodeTests;
> > +
> > + Fw = NULL;
> > +
> > + DEBUG ((DEBUG_INFO, "%a v%a\n",
> UNIT_TEST_APP_NAME, UNIT_TEST_APP_VERSION));
> > +
> > + //
> > + // Start setting up the test framework for running
> the tests.
> > + //
> > + Status = InitUnitTestFramework (&Fw,
> UNIT_TEST_APP_NAME, gEfiCallerBaseName,
> UNIT_TEST_APP_VERSION);
> > + if (EFI_ERROR (Status)) {
> > + DEBUG ((DEBUG_ERROR, "Failed in
> InitUnitTestFramework. Status = %r\n", Status));
> > + goto EXIT;
> > + }
> > +
> > + //
> > + // Populate the B64 Encode Unit Test Suite.
> > + //
> > + Status = CreateUnitTestSuite (&b64EncodeTests, Fw,
> "b64 Encode binary to Ascii string",
> "BaseLib.b64Encode", NULL, NULL);
> > + if (EFI_ERROR (Status)) {
> > + DEBUG ((DEBUG_ERROR, "Failed in
> CreateUnitTestSuite for b64EncodeTests\n"));
> > + Status = EFI_OUT_OF_RESOURCES;
> > + goto EXIT;
> > + }
> > +
> > + // --------------Suite-----------Description------
> --------Class Name----------Function--------Pre---Post-
> ------------------Context-----------
> > + AddTestCase (b64EncodeTests, "RFC 4686 Test Vector
> - Empty", "Test1", RfcEncodeTest, NULL,
> CleanUpB64TestContext,
> > &mBasicEncodeTest1);
> > + AddTestCase (b64EncodeTests, "RFC 4686 Test Vector
> - f", "Test2", RfcEncodeTest, NULL,
> CleanUpB64TestContext,
> > &mBasicEncodeTest2);
> > + AddTestCase (b64EncodeTests, "RFC 4686 Test Vector
> - fo", "Test3", RfcEncodeTest, NULL,
> CleanUpB64TestContext,
> > &mBasicEncodeTest3);
> > + AddTestCase (b64EncodeTests, "RFC 4686 Test Vector
> - foo", "Test4", RfcEncodeTest, NULL,
> CleanUpB64TestContext,
> > &mBasicEncodeTest4);
> > + AddTestCase (b64EncodeTests, "RFC 4686 Test Vector
> - foob", "Test5", RfcEncodeTest, NULL,
> CleanUpB64TestContext,
> > &mBasicEncodeTest5);
> > + AddTestCase (b64EncodeTests, "RFC 4686 Test Vector
> - fooba", "Test6", RfcEncodeTest, NULL,
> CleanUpB64TestContext,
> > &mBasicEncodeTest6);
> > + AddTestCase (b64EncodeTests, "RFC 4686 Test Vector
> - foobar", "Test7", RfcEncodeTest, NULL,
> CleanUpB64TestContext,
> > &mBasicEncodeTest7);
> > + AddTestCase (b64EncodeTests, "Too small of output
> buffer", "Error1", RfcEncodeTest, NULL,
> CleanUpB64TestContext,
> > &mBasicEncodeError1);
> > + //
> > + // Populate the B64 Decode Unit Test Suite.
> > + //
> > + Status = CreateUnitTestSuite (&b64DecodeTests, Fw,
> "b64 Decode Ascii string to binary",
> "BaseLib.b64Decode", NULL, NULL);
> > + if (EFI_ERROR (Status)) {
> > + DEBUG ((DEBUG_ERROR, "Failed in
> CreateUnitTestSuite for b64Decode Tests\n"));
> > + Status = EFI_OUT_OF_RESOURCES;
> > + goto EXIT;
> > + }
> > +
> > + AddTestCase (b64DecodeTests, "RFC 4686 Test Vector
> - Empty", "Test1", RfcDecodeTest, NULL,
> CleanUpB64TestContext,
> > &mBasicDecodeTest1);
> > + AddTestCase (b64DecodeTests, "RFC 4686 Test Vector
> - f", "Test2", RfcDecodeTest, NULL,
> CleanUpB64TestContext,
> > &mBasicDecodeTest2);
> > + AddTestCase (b64DecodeTests, "RFC 4686 Test Vector
> - fo", "Test3", RfcDecodeTest, NULL,
> CleanUpB64TestContext,
> > &mBasicDecodeTest3);
> > + AddTestCase (b64DecodeTests, "RFC 4686 Test Vector
> - foo", "Test4", RfcDecodeTest, NULL,
> CleanUpB64TestContext,
> > &mBasicDecodeTest4);
> > + AddTestCase (b64DecodeTests, "RFC 4686 Test Vector
> - foob", "Test5", RfcDecodeTest, NULL,
> CleanUpB64TestContext,
> > &mBasicDecodeTest5);
> > + AddTestCase (b64DecodeTests, "RFC 4686 Test Vector
> - fooba", "Test6", RfcDecodeTest, NULL,
> CleanUpB64TestContext,
> > &mBasicDecodeTest6);
> > + AddTestCase (b64DecodeTests, "RFC 4686 Test Vector
> - foobar", "Test7", RfcDecodeTest, NULL,
> CleanUpB64TestContext,
> > &mBasicDecodeTest7);
> > + AddTestCase (b64DecodeTests, "Ignore Whitespace
> test", "Test8", RfcDecodeTest, NULL,
> CleanUpB64TestContext,
> > &mBasicDecodeTest8);
> > +
> > + AddTestCase (b64DecodeTests, "Not a quantum
> multiple of 4", "Error1", RfcDecodeTest, NULL,
> CleanUpB64TestContext,
> > &mBasicDecodeError1);
> > + AddTestCase (b64DecodeTests, "Invalid characters
> in the string", "Error2", RfcDecodeTest, NULL,
> CleanUpB64TestContext,
> > &mBasicDecodeError2);
> > + AddTestCase (b64DecodeTests, "Too many padding
> characters", "Error3", RfcDecodeTest, NULL,
> CleanUpB64TestContext,
> > &mBasicDecodeError3);
> > + AddTestCase (b64DecodeTests, "Incorrectly placed
> padding character", "Error4", RfcDecodeTest, NULL,
> CleanUpB64TestContext,
> > &mBasicDecodeError4);
> > + AddTestCase (b64DecodeTests, "Too small of output
> buffer", "Error5", RfcDecodeTest, NULL,
> CleanUpB64TestContext,
> > &mBasicDecodeError5);
> > +
> > + //
> > + // Execute the tests.
> > + //
> > + Status = RunAllTestSuites (Fw);
> > +
> > +EXIT:
> > + if (Fw) {
> > + FreeUnitTestFramework (Fw);
> > + }
> > +
> > + return Status;
> > +}
> > +
> > +/**
> > + Standard UEFI entry point for target based unit
> test execution from UEFI Shell.
> > +**/
> > +EFI_STATUS
> > +EFIAPI
> > +BaseLibUnitTestAppEntry (
> > + IN EFI_HANDLE ImageHandle,
> > + IN EFI_SYSTEM_TABLE *SystemTable
> > + )
> > +{
> > + return UnitTestingEntry ();
> > +}
> > +
> > +/**
> > + Standard POSIX C entry point for host based unit
> test execution.
> > +**/
> > +int
> > +main (
> > + int argc,
> > + char *argv[]
> > + )
> > +{
> > + return UnitTestingEntry ();
> > +}
> > diff --git
> a/MdePkg/Test/UnitTest/Library/BaseLib/BaseLibUnitTests
> Host.inf
> >
> b/MdePkg/Test/UnitTest/Library/BaseLib/BaseLibUnitTests
> Host.inf
> > new file mode 100644
> > index 0000000000..b31afae633
> > --- /dev/null
> > +++
> b/MdePkg/Test/UnitTest/Library/BaseLib/BaseLibUnitTests
> Host.inf
> > @@ -0,0 +1,32 @@
> > +## @file
> > +# Unit tests of Base64 conversion APIs in BaseLib
> that are run from host
> > +# environment.
> > +#
> > +# Copyright (C) Microsoft Corporation.
> > +# SPDX-License-Identifier: BSD-2-Clause-Patent
> > +##
> > +
> > +[Defines]
> > + INF_VERSION = 0x00010006
> > + BASE_NAME =
> BaseLibUnitTestsHost
> > + FILE_GUID = 1d005f4c-4dfa-
> 41b5-ab0c-be91fe121459
> > + MODULE_TYPE = HOST_APPLICATION
> > + VERSION_STRING = 1.0
> > +
> > +#
> > +# The following information is for reference only
> and not required by the build tools.
> > +#
> > +# VALID_ARCHITECTURES = IA32 X64
> > +#
> > +
> > +[Sources]
> > + Base64UnitTest.c
> > +
> > +[Packages]
> > + MdePkg/MdePkg.dec
> > +
> > +[LibraryClasses]
> > + BaseLib
> > + BaseMemoryLib
> > + DebugLib
> > + UnitTestLib
> > diff --git
> a/MdePkg/Test/UnitTest/Library/BaseLib/BaseLibUnitTests
> Uefi.inf
> >
> b/MdePkg/Test/UnitTest/Library/BaseLib/BaseLibUnitTests
> Uefi.inf
> > new file mode 100644
> > index 0000000000..907503898a
> > --- /dev/null
> > +++
> b/MdePkg/Test/UnitTest/Library/BaseLib/BaseLibUnitTests
> Uefi.inf
> > @@ -0,0 +1,33 @@
> > +## @file
> > +# Unit tests of Base64 conversion APIs in BaseLib
> that are run from UEFI Shell.
> > +#
> > +# Copyright (C) Microsoft Corporation.
> > +# SPDX-License-Identifier: BSD-2-Clause-Patent
> > +##
> > +
> > +[Defines]
> > + INF_VERSION = 0x00010006
> > + BASE_NAME =
> BaseLibUnitTestsUefi
> > + FILE_GUID = df5a6fed-8786-
> 4a9d-9d02-eab39497b4a1
> > + MODULE_TYPE = UEFI_APPLICATION
> > + VERSION_STRING = 1.0
> > + ENTRY_POINT =
> BaseLibUnitTestAppEntry
> > +
> > +#
> > +# The following information is for reference only
> and not required by the build tools.
> > +#
> > +# VALID_ARCHITECTURES = IA32 X64
> > +#
> > +
> > +[Sources]
> > + Base64UnitTest.c
> > +
> > +[Packages]
> > + MdePkg/MdePkg.dec
> > +
> > +[LibraryClasses]
> > + BaseLib
> > + BaseMemoryLib
> > + UefiApplicationEntryPoint
> > + DebugLib
> > + UnitTestLib
> > diff --git
> a/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/SafeIntLi
> bUintnIntnUnitTests32.c
> >
> b/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/SafeIntLi
> bUintnIntnUnitTests32.c
> > new file mode 100644
> > index 0000000000..be5c0e15d3
> > --- /dev/null
> > +++
> b/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/SafeIntLi
> bUintnIntnUnitTests32.c
> > @@ -0,0 +1,540 @@
> > +/** @file
> > + IA32-specific functions for unit-testing INTN and
> UINTN functions in
> > + SafeIntLib.
> > +
> > + Copyright (c) Microsoft Corporation.<BR>
> > + Copyright (c) 2019 - 2020, Intel Corporation. All
> rights reserved.<BR>
> > + SPDX-License-Identifier: BSD-2-Clause-Patent
> > +
> > +**/
> > +
> > +#include "TestBaseSafeIntLib.h"
> > +
> > +UNIT_TEST_STATUS
> > +EFIAPI
> > +TestSafeInt32ToUintn (
> > + IN UNIT_TEST_CONTEXT Context
> > + )
> > +{
> > + EFI_STATUS Status;
> > + INT32 Operand;
> > + UINTN Result;
> > +
> > + //
> > + // If Operand is non-negative, then it's a cast
> > + //
> > + Operand = 0x5bababab;
> > + Result = 0;
> > + Status = SafeInt32ToUintn(Operand, &Result);
> > + UT_ASSERT_NOT_EFI_ERROR(Status);
> > + UT_ASSERT_EQUAL(0x5bababab, Result);
> > +
> > + //
> > + // Otherwise should result in an error status
> > + //
> > + Operand = (-1537977259);
> > + Status = SafeInt32ToUintn(Operand, &Result);
> > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> > +
> > + return UNIT_TEST_PASSED;
> > +}
> > +
> > +UNIT_TEST_STATUS
> > +EFIAPI
> > +TestSafeUint32ToIntn (
> > + IN UNIT_TEST_CONTEXT Context
> > + )
> > +{
> > + EFI_STATUS Status;
> > + UINT32 Operand;
> > + INTN Result;
> > +
> > + //
> > + // If Operand is <= MAX_INTN, then it's a cast
> > + //
> > + Operand = 0x5bababab;
> > + Result = 0;
> > + Status = SafeUint32ToIntn(Operand, &Result);
> > + UT_ASSERT_NOT_EFI_ERROR(Status);
> > + UT_ASSERT_EQUAL(0x5bababab, Result);
> > +
> > + //
> > + // Otherwise should result in an error status
> > + //
> > + Operand = (0xabababab);
> > + Status = SafeUint32ToIntn(Operand, &Result);
> > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> > +
> > + return UNIT_TEST_PASSED;
> > +}
> > +
> > +UNIT_TEST_STATUS
> > +EFIAPI
> > +TestSafeIntnToInt32 (
> > + IN UNIT_TEST_CONTEXT Context
> > + )
> > +{
> > + EFI_STATUS Status;
> > + INTN Operand;
> > + INT32 Result;
> > +
> > + //
> > + // INTN is same as INT32 in IA32, so this is just
> a cast
> > + //
> > + Operand = 0x5bababab;
> > + Result = 0;
> > + Status = SafeIntnToInt32(Operand, &Result);
> > + UT_ASSERT_NOT_EFI_ERROR(Status);
> > + UT_ASSERT_EQUAL(0x5bababab, Result);
> > +
> > + return UNIT_TEST_PASSED;
> > +}
> > +
> > +UNIT_TEST_STATUS
> > +EFIAPI
> > +TestSafeIntnToUint32 (
> > + IN UNIT_TEST_CONTEXT Context
> > + )
> > +{
> > + EFI_STATUS Status;
> > + INTN Operand;
> > + UINT32 Result;
> > +
> > + //
> > + // If Operand is non-negative, then it's a cast
> > + //
> > + Operand = 0x5bababab;
> > + Result = 0;
> > + Status = SafeIntnToUint32(Operand, &Result);
> > + UT_ASSERT_NOT_EFI_ERROR(Status);
> > + UT_ASSERT_EQUAL(0x5bababab, Result);
> > +
> > + //
> > + // Otherwise should result in an error status
> > + //
> > + Operand = (-1537977259);
> > + Status = SafeIntnToUint32(Operand, &Result);
> > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> > +
> > + return UNIT_TEST_PASSED;
> > +}
> > +
> > +UNIT_TEST_STATUS
> > +EFIAPI
> > +TestSafeUintnToUint32 (
> > + IN UNIT_TEST_CONTEXT Context
> > + )
> > +{
> > + EFI_STATUS Status;
> > + UINTN Operand;
> > + UINT32 Result;
> > +
> > + //
> > + // UINTN is same as UINT32 in IA32, so this is
> just a cast
> > + //
> > + Operand = 0xabababab;
> > + Result = 0;
> > + Status = SafeUintnToUint32(Operand, &Result);
> > + UT_ASSERT_NOT_EFI_ERROR(Status);
> > + UT_ASSERT_EQUAL(0xabababab, Result);
> > +
> > + return UNIT_TEST_PASSED;
> > +}
> > +
> > +UNIT_TEST_STATUS
> > +EFIAPI
> > +TestSafeUintnToIntn (
> > + IN UNIT_TEST_CONTEXT Context
> > + )
> > +{
> > + EFI_STATUS Status;
> > + UINTN Operand;
> > + INTN Result;
> > +
> > + //
> > + // If Operand is <= MAX_INTN, then it's a cast
> > + //
> > + Operand = 0x5bababab;
> > + Result = 0;
> > + Status = SafeUintnToIntn(Operand, &Result);
> > + UT_ASSERT_NOT_EFI_ERROR(Status);
> > + UT_ASSERT_EQUAL(0x5bababab, Result);
> > +
> > + //
> > + // Otherwise should result in an error status
> > + //
> > + Operand = (0xabababab);
> > + Status = SafeUintnToIntn(Operand, &Result);
> > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> > +
> > + return UNIT_TEST_PASSED;
> > +}
> > +
> > +UNIT_TEST_STATUS
> > +EFIAPI
> > +TestSafeUintnToInt64 (
> > + IN UNIT_TEST_CONTEXT Context
> > + )
> > +{
> > + EFI_STATUS Status;
> > + UINTN Operand;
> > + INT64 Result;
> > +
> > + //
> > + // UINTN is same as UINT32 in IA32, and UINT32 is
> a subset of
> > + // INT64, so this is just a cast
> > + //
> > + Operand = 0xabababab;
> > + Result = 0;
> > + Status = SafeUintnToInt64(Operand, &Result);
> > + UT_ASSERT_NOT_EFI_ERROR(Status);
> > + UT_ASSERT_EQUAL(0xabababab, Result);
> > +
> > + return UNIT_TEST_PASSED;
> > +}
> > +
> > +UNIT_TEST_STATUS
> > +EFIAPI
> > +TestSafeInt64ToIntn (
> > + IN UNIT_TEST_CONTEXT Context
> > + )
> > +{
> > + EFI_STATUS Status;
> > + INT64 Operand;
> > + INTN Result;
> > +
> > + //
> > + // If Operand is between MIN_INTN and MAX_INTN2
> inclusive, then it's a cast
> > + //
> > + Operand = 0x5bababab;
> > + Result = 0;
> > + Status = SafeInt64ToIntn(Operand, &Result);
> > + UT_ASSERT_NOT_EFI_ERROR(Status);
> > + UT_ASSERT_EQUAL(0x5bababab, Result);
> > +
> > + Operand = (-1537977259);
> > + Status = SafeInt64ToIntn(Operand, &Result);
> > + UT_ASSERT_NOT_EFI_ERROR(Status);
> > + UT_ASSERT_EQUAL((-1537977259), Result);
> > +
> > + //
> > + // Otherwise should result in an error status
> > + //
> > + Operand = (0x5babababefefefef);
> > + Status = SafeInt64ToIntn(Operand, &Result);
> > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> > +
> > + Operand = (-6605562033422200815);
> > + Status = SafeInt64ToIntn(Operand, &Result);
> > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> > +
> > + return UNIT_TEST_PASSED;
> > +}
> > +
> > +UNIT_TEST_STATUS
> > +EFIAPI
> > +TestSafeInt64ToUintn (
> > + IN UNIT_TEST_CONTEXT Context
> > + )
> > +{
> > + EFI_STATUS Status;
> > + INT64 Operand;
> > + UINTN Result;
> > +
> > + //
> > + // If Operand is between 0 and MAX_UINTN
> inclusive, then it's a cast
> > + //
> > + Operand = 0xabababab;
> > + Result = 0;
> > + Status = SafeInt64ToUintn(Operand, &Result);
> > + UT_ASSERT_NOT_EFI_ERROR(Status);
> > + UT_ASSERT_EQUAL(0xabababab, Result);
> > +
> > + //
> > + // Otherwise should result in an error status
> > + //
> > + Operand = (0x5babababefefefef);
> > + Status = SafeInt64ToUintn(Operand, &Result);
> > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> > +
> > + Operand = (-6605562033422200815);
> > + Status = SafeInt64ToUintn(Operand, &Result);
> > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> > +
> > + return UNIT_TEST_PASSED;
> > +}
> > +
> > +UNIT_TEST_STATUS
> > +EFIAPI
> > +TestSafeUint64ToIntn (
> > + IN UNIT_TEST_CONTEXT Context
> > + )
> > +{
> > + EFI_STATUS Status;
> > + UINT64 Operand;
> > + INTN Result;
> > +
> > + //
> > + // If Operand is <= MAX_INTN, then it's a cast
> > + //
> > + Operand = 0x5bababab;
> > + Result = 0;
> > + Status = SafeUint64ToIntn(Operand, &Result);
> > + UT_ASSERT_NOT_EFI_ERROR(Status);
> > + UT_ASSERT_EQUAL(0x5bababab, Result);
> > +
> > + //
> > + // Otherwise should result in an error status
> > + //
> > + Operand = (0xababababefefefef);
> > + Status = SafeUint64ToIntn(Operand, &Result);
> > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> > +
> > + return UNIT_TEST_PASSED;
> > +}
> > +
> > +UNIT_TEST_STATUS
> > +EFIAPI
> > +TestSafeUint64ToUintn (
> > + IN UNIT_TEST_CONTEXT Context
> > + )
> > +{
> > + EFI_STATUS Status;
> > + UINT64 Operand;
> > + UINTN Result;
> > +
> > + //
> > + // If Operand is <= MAX_UINTN, then it's a cast
> > + //
> > + Operand = 0xabababab;
> > + Result = 0;
> > + Status = SafeUint64ToUintn(Operand, &Result);
> > + UT_ASSERT_NOT_EFI_ERROR(Status);
> > + UT_ASSERT_EQUAL(0xabababab, Result);
> > +
> > + //
> > + // Otherwise should result in an error status
> > + //
> > + Operand = (0xababababefefefef);
> > + Status = SafeUint64ToUintn(Operand, &Result);
> > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> > +
> > + return UNIT_TEST_PASSED;
> > +}
> > +
> > +UNIT_TEST_STATUS
> > +EFIAPI
> > +TestSafeUintnAdd (
> > + IN UNIT_TEST_CONTEXT Context
> > + )
> > +{
> > + EFI_STATUS Status;
> > + UINTN Augend;
> > + UINTN Addend;
> > + UINTN Result;
> > +
> > + //
> > + // If the result of addition doesn't overflow
> MAX_UINTN, then it's addition
> > + //
> > + Augend = 0x3a3a3a3a;
> > + Addend = 0x3a3a3a3a;
> > + Result = 0;
> > + Status = SafeUintnAdd(Augend, Addend, &Result);
> > + UT_ASSERT_NOT_EFI_ERROR(Status);
> > + UT_ASSERT_EQUAL(0x74747474, Result);
> > +
> > + //
> > + // Otherwise should result in an error status
> > + //
> > + Augend = 0xabababab;
> > + Addend = 0xbcbcbcbc;
> > + Status = SafeUintnAdd(Augend, Addend, &Result);
> > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> > +
> > + return UNIT_TEST_PASSED;
> > +}
> > +
> > +UNIT_TEST_STATUS
> > +EFIAPI
> > +TestSafeIntnAdd (
> > + IN UNIT_TEST_CONTEXT Context
> > + )
> > +{
> > + EFI_STATUS Status;
> > + INTN Augend;
> > + INTN Addend;
> > + INTN Result;
> > +
> > + //
> > + // If the result of addition doesn't overflow
> MAX_INTN
> > + // and doesn't underflow MIN_INTN, then it's
> addition
> > + //
> > + Augend = 0x3a3a3a3a;
> > + Addend = 0x3a3a3a3a;
> > + Result = 0;
> > + Status = SafeIntnAdd(Augend, Addend, &Result);
> > + UT_ASSERT_NOT_EFI_ERROR(Status);
> > + UT_ASSERT_EQUAL(0x74747474, Result);
> > +
> > + Augend = (-976894522);
> > + Addend = (-976894522);
> > + Status = SafeIntnAdd(Augend, Addend, &Result);
> > + UT_ASSERT_NOT_EFI_ERROR(Status);
> > + UT_ASSERT_EQUAL((-1953789044), Result);
> > +
> > + //
> > + // Otherwise should result in an error status
> > + //
> > + Augend = 0x5a5a5a5a;
> > + Addend = 0x5a5a5a5a;
> > + Status = SafeIntnAdd(Augend, Addend, &Result);
> > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> > +
> > + Augend = (-1515870810);
> > + Addend = (-1515870810);
> > + Status = SafeIntnAdd(Augend, Addend, &Result);
> > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> > +
> > + return UNIT_TEST_PASSED;
> > +}
> > +
> > +UNIT_TEST_STATUS
> > +EFIAPI
> > +TestSafeUintnSub (
> > + IN UNIT_TEST_CONTEXT Context
> > + )
> > +{
> > + EFI_STATUS Status;
> > + UINTN Minuend;
> > + UINTN Subtrahend;
> > + UINTN Result;
> > +
> > + //
> > + // If Minuend >= Subtrahend, then it's subtraction
> > + //
> > + Minuend = 0x5a5a5a5a;
> > + Subtrahend = 0x3b3b3b3b;
> > + Result = 0;
> > + Status = SafeUintnSub(Minuend, Subtrahend,
> &Result);
> > + UT_ASSERT_NOT_EFI_ERROR(Status);
> > + UT_ASSERT_EQUAL(0x1f1f1f1f, Result);
> > +
> > + //
> > + // Otherwise should result in an error status
> > + //
> > + Minuend = 0x5a5a5a5a;
> > + Subtrahend = 0x6d6d6d6d;
> > + Status = SafeUintnSub(Minuend, Subtrahend,
> &Result);
> > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> > +
> > + return UNIT_TEST_PASSED;
> > +}
> > +
> > +UNIT_TEST_STATUS
> > +EFIAPI
> > +TestSafeIntnSub (
> > + IN UNIT_TEST_CONTEXT Context
> > + )
> > +{
> > + EFI_STATUS Status;
> > + INTN Minuend;
> > + INTN Subtrahend;
> > + INTN Result;
> > +
> > + //
> > + // If the result of subtractions doesn't overflow
> MAX_INTN or
> > + // underflow MIN_INTN, then it's subtraction
> > + //
> > + Minuend = 0x5a5a5a5a;
> > + Subtrahend = 0x3a3a3a3a;
> > + Result = 0;
> > + Status = SafeIntnSub(Minuend, Subtrahend,
> &Result);
> > + UT_ASSERT_NOT_EFI_ERROR(Status);
> > + UT_ASSERT_EQUAL(0x20202020, Result);
> > +
> > + Minuend = 0x3a3a3a3a;
> > + Subtrahend = 0x5a5a5a5a;
> > + Status = SafeIntnSub(Minuend, Subtrahend,
> &Result);
> > + UT_ASSERT_NOT_EFI_ERROR(Status);
> > + UT_ASSERT_EQUAL((-538976288), Result);
> > +
> > + //
> > + // Otherwise should result in an error status
> > + //
> > + Minuend = (-2054847098);
> > + Subtrahend = 2054847098;
> > + Status = SafeIntnSub(Minuend, Subtrahend,
> &Result);
> > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> > +
> > + Minuend = (2054847098);
> > + Subtrahend = (-2054847098);
> > + Status = SafeIntnSub(Minuend, Subtrahend,
> &Result);
> > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> > +
> > + return UNIT_TEST_PASSED;
> > +}
> > +
> > +UNIT_TEST_STATUS
> > +EFIAPI
> > +TestSafeUintnMult (
> > + IN UNIT_TEST_CONTEXT Context
> > + )
> > +{
> > + EFI_STATUS Status;
> > + UINTN Multiplicand;
> > + UINTN Multiplier;
> > + UINTN Result;
> > +
> > + //
> > + // If the result of multiplication doesn't
> overflow MAX_UINTN, it will succeed
> > + //
> > + Multiplicand = 0xa122a;
> > + Multiplier = 0xd23;
> > + Result = 0;
> > + Status = SafeUintnMult(Multiplicand, Multiplier,
> &Result);
> > + UT_ASSERT_NOT_EFI_ERROR(Status);
> > + UT_ASSERT_EQUAL(0x844c9dbe, Result);
> > +
> > + //
> > + // Otherwise should result in an error status
> > + //
> > + Multiplicand = 0xa122a;
> > + Multiplier = 0xed23;
> > + Status = SafeUintnMult(Multiplicand, Multiplier,
> &Result);
> > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> > +
> > + return UNIT_TEST_PASSED;
> > +}
> > +
> > +UNIT_TEST_STATUS
> > +EFIAPI
> > +TestSafeIntnMult (
> > + IN UNIT_TEST_CONTEXT Context
> > + )
> > +{
> > + EFI_STATUS Status;
> > + INTN Multiplicand;
> > + INTN Multiplier;
> > + INTN Result;
> > +
> > + //
> > + // If the result of multiplication doesn't
> overflow MAX_INTN and doesn't
> > + // underflow MIN_UINTN, it will succeed
> > + //
> > + Multiplicand = 0x123456;
> > + Multiplier = 0x678;
> > + Result = 0;
> > + Status = SafeIntnMult(Multiplicand, Multiplier,
> &Result);
> > + UT_ASSERT_NOT_EFI_ERROR(Status);
> > + UT_ASSERT_EQUAL(0x75c28c50, Result);
> > +
> > + //
> > + // Otherwise should result in an error status
> > + //
> > + Multiplicand = 0x123456;
> > + Multiplier = 0xabc;
> > + Status = SafeIntnMult(Multiplicand, Multiplier,
> &Result);
> > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> > +
> > + return UNIT_TEST_PASSED;
> > +}
> > diff --git
> a/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/SafeIntLi
> bUintnIntnUnitTests64.c
> >
> b/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/SafeIntLi
> bUintnIntnUnitTests64.c
> > new file mode 100644
> > index 0000000000..0fee298172
> > --- /dev/null
> > +++
> b/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/SafeIntLi
> bUintnIntnUnitTests64.c
> > @@ -0,0 +1,544 @@
> > +/** @file
> > + x64-specific functions for unit-testing INTN and
> UINTN functions in
> > + SafeIntLib.
> > +
> > + Copyright (c) Microsoft Corporation.<BR>
> > + Copyright (c) 2019 - 2020, Intel Corporation. All
> rights reserved.<BR>
> > + SPDX-License-Identifier: BSD-2-Clause-Patent
> > +
> > +**/
> > +
> > +#include "TestBaseSafeIntLib.h"
> > +
> > +UNIT_TEST_STATUS
> > +EFIAPI
> > +TestSafeInt32ToUintn (
> > + IN UNIT_TEST_CONTEXT Context
> > + )
> > +{
> > + EFI_STATUS Status;
> > + INT32 Operand;
> > + UINTN Result;
> > +
> > + //
> > + // If Operand is non-negative, then it's a cast
> > + //
> > + Operand = 0x5bababab;
> > + Result = 0;
> > + Status = SafeInt32ToUintn(Operand, &Result);
> > + UT_ASSERT_NOT_EFI_ERROR(Status);
> > + UT_ASSERT_EQUAL(0x5bababab, Result);
> > +
> > + //
> > + // Otherwise should result in an error status
> > + //
> > + Operand = (-1537977259);
> > + Status = SafeInt32ToUintn(Operand, &Result);
> > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> > +
> > + return UNIT_TEST_PASSED;
> > +}
> > +
> > +UNIT_TEST_STATUS
> > +EFIAPI
> > +TestSafeUint32ToIntn (
> > + IN UNIT_TEST_CONTEXT Context
> > + )
> > +{
> > + EFI_STATUS Status;
> > + UINT32 Operand;
> > + INTN Result;
> > +
> > + //
> > + // For x64, INTN is same as INT64 which is a
> superset of INT32
> > + // This is just a cast then, and it'll never fail
> > + //
> > +
> > + //
> > + // If Operand is non-negative, then it's a cast
> > + //
> > + Operand = 0xabababab;
> > + Result = 0;
> > + Status = SafeUint32ToIntn(Operand, &Result);
> > + UT_ASSERT_NOT_EFI_ERROR(Status);
> > + UT_ASSERT_EQUAL(0xabababab, Result);
> > +
> > + return UNIT_TEST_PASSED;
> > +}
> > +
> > +UNIT_TEST_STATUS
> > +EFIAPI
> > +TestSafeIntnToInt32 (
> > + IN UNIT_TEST_CONTEXT Context
> > + )
> > +{
> > + EFI_STATUS Status;
> > + INTN Operand;
> > + INT32 Result;
> > +
> > + //
> > + // If Operand is between MIN_INT32 and MAX_INT32
> inclusive, then it's a cast
> > + //
> > + Operand = 0x5bababab;
> > + Result = 0;
> > + Status = SafeIntnToInt32(Operand, &Result);
> > + UT_ASSERT_NOT_EFI_ERROR(Status);
> > + UT_ASSERT_EQUAL(0x5bababab, Result);
> > +
> > + Operand = (-1537977259);
> > + Status = SafeIntnToInt32(Operand, &Result);
> > + UT_ASSERT_NOT_EFI_ERROR(Status);
> > + UT_ASSERT_EQUAL((-1537977259), Result);
> > +
> > + //
> > + // Otherwise should result in an error status
> > + //
> > + Operand = (0x5babababefefefef);
> > + Status = SafeIntnToInt32(Operand, &Result);
> > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> > +
> > + Operand = (-6605562033422200815);
> > + Status = SafeIntnToInt32(Operand, &Result);
> > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> > +
> > + return UNIT_TEST_PASSED;
> > +}
> > +
> > +UNIT_TEST_STATUS
> > +EFIAPI
> > +TestSafeIntnToUint32 (
> > + IN UNIT_TEST_CONTEXT Context
> > + )
> > +{
> > + EFI_STATUS Status;
> > + INTN Operand;
> > + UINT32 Result;
> > +
> > + //
> > + // If Operand is between 0 and MAX_UINT32
> inclusive, then it's a cast
> > + //
> > + Operand = 0xabababab;
> > + Result = 0;
> > + Status = SafeIntnToUint32(Operand, &Result);
> > + UT_ASSERT_NOT_EFI_ERROR(Status);
> > + UT_ASSERT_EQUAL(0xabababab, Result);
> > +
> > + //
> > + // Otherwise should result in an error status
> > + //
> > + Operand = (0x5babababefefefef);
> > + Status = SafeIntnToUint32(Operand, &Result);
> > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> > +
> > + Operand = (-6605562033422200815);
> > + Status = SafeIntnToUint32(Operand, &Result);
> > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> > +
> > + return UNIT_TEST_PASSED;
> > +}
> > +
> > +UNIT_TEST_STATUS
> > +EFIAPI
> > +TestSafeUintnToUint32 (
> > + IN UNIT_TEST_CONTEXT Context
> > + )
> > +{
> > + EFI_STATUS Status;
> > + UINTN Operand;
> > + UINT32 Result;
> > +
> > + //
> > + // If Operand is <= MAX_UINT32, then it's a cast
> > + //
> > + Operand = 0xabababab;
> > + Result = 0;
> > + Status = SafeUintnToUint32(Operand, &Result);
> > + UT_ASSERT_NOT_EFI_ERROR(Status);
> > + UT_ASSERT_EQUAL(0xabababab, Result);
> > +
> > + //
> > + // Otherwise should result in an error status
> > + //
> > + Operand = (0xababababefefefef);
> > + Status = SafeUintnToUint32(Operand, &Result);
> > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> > +
> > + return UNIT_TEST_PASSED;
> > +}
> > +
> > +UNIT_TEST_STATUS
> > +EFIAPI
> > +TestSafeUintnToIntn (
> > + IN UNIT_TEST_CONTEXT Context
> > + )
> > +{
> > + EFI_STATUS Status;
> > + UINTN Operand;
> > + INTN Result;
> > +
> > + //
> > + // If Operand is <= MAX_INTN
> (0x7fff_ffff_ffff_ffff), then it's a cast
> > + //
> > + Operand = 0x5babababefefefef;
> > + Result = 0;
> > + Status = SafeUintnToIntn(Operand, &Result);
> > + UT_ASSERT_NOT_EFI_ERROR(Status);
> > + UT_ASSERT_EQUAL(0x5babababefefefef, Result);
> > +
> > + //
> > + // Otherwise should result in an error status
> > + //
> > + Operand = (0xababababefefefef);
> > + Status = SafeUintnToIntn(Operand, &Result);
> > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> > +
> > + return UNIT_TEST_PASSED;
> > +}
> > +
> > +UNIT_TEST_STATUS
> > +EFIAPI
> > +TestSafeUintnToInt64 (
> > + IN UNIT_TEST_CONTEXT Context
> > + )
> > +{
> > + EFI_STATUS Status;
> > + UINTN Operand;
> > + INT64 Result;
> > +
> > + //
> > + // If Operand is <= MAX_INT64, then it's a cast
> > + //
> > + Operand = 0x5babababefefefef;
> > + Result = 0;
> > + Status = SafeUintnToInt64(Operand, &Result);
> > + UT_ASSERT_NOT_EFI_ERROR(Status);
> > + UT_ASSERT_EQUAL(0x5babababefefefef, Result);
> > +
> > + //
> > + // Otherwise should result in an error status
> > + //
> > + Operand = (0xababababefefefef);
> > + Status = SafeUintnToInt64(Operand, &Result);
> > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> > +
> > + return UNIT_TEST_PASSED;
> > +}
> > +
> > +UNIT_TEST_STATUS
> > +EFIAPI
> > +TestSafeInt64ToIntn (
> > + IN UNIT_TEST_CONTEXT Context
> > + )
> > +{
> > + EFI_STATUS Status;
> > + INT64 Operand;
> > + INTN Result;
> > +
> > + //
> > + // INTN is same as INT64 in x64, so this is just a
> cast
> > + //
> > + Operand = 0x5babababefefefef;
> > + Result = 0;
> > + Status = SafeInt64ToIntn(Operand, &Result);
> > + UT_ASSERT_NOT_EFI_ERROR(Status);
> > + UT_ASSERT_EQUAL(0x5babababefefefef, Result);
> > +
> > + return UNIT_TEST_PASSED;
> > +}
> > +
> > +UNIT_TEST_STATUS
> > +EFIAPI
> > +TestSafeInt64ToUintn (
> > + IN UNIT_TEST_CONTEXT Context
> > + )
> > +{
> > + EFI_STATUS Status;
> > + INT64 Operand;
> > + UINTN Result;
> > +
> > + //
> > + // If Operand is non-negative, then it's a cast
> > + //
> > + Operand = 0x5babababefefefef;
> > + Result = 0;
> > + Status = SafeInt64ToUintn(Operand, &Result);
> > + UT_ASSERT_NOT_EFI_ERROR(Status);
> > + UT_ASSERT_EQUAL(0x5babababefefefef, Result);
> > +
> > + //
> > + // Otherwise should result in an error status
> > + //
> > + Operand = (-6605562033422200815);
> > + Status = SafeInt64ToUintn(Operand, &Result);
> > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> > +
> > + return UNIT_TEST_PASSED;
> > +}
> > +
> > +UNIT_TEST_STATUS
> > +EFIAPI
> > +TestSafeUint64ToIntn (
> > + IN UNIT_TEST_CONTEXT Context
> > + )
> > +{
> > + EFI_STATUS Status;
> > + UINT64 Operand;
> > + INTN Result;
> > +
> > + //
> > + // If Operand is <= MAX_INTN
> (0x7fff_ffff_ffff_ffff), then it's a cast
> > + //
> > + Operand = 0x5babababefefefef;
> > + Result = 0;
> > + Status = SafeUint64ToIntn(Operand, &Result);
> > + UT_ASSERT_NOT_EFI_ERROR(Status);
> > + UT_ASSERT_EQUAL(0x5babababefefefef, Result);
> > +
> > + //
> > + // Otherwise should result in an error status
> > + //
> > + Operand = (0xababababefefefef);
> > + Status = SafeUint64ToIntn(Operand, &Result);
> > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> > +
> > + return UNIT_TEST_PASSED;
> > +}
> > +
> > +UNIT_TEST_STATUS
> > +EFIAPI
> > +TestSafeUint64ToUintn (
> > + IN UNIT_TEST_CONTEXT Context
> > + )
> > +{
> > + EFI_STATUS Status;
> > + UINT64 Operand;
> > + UINTN Result;
> > +
> > + //
> > + // UINTN is same as UINT64 in x64, so this is just
> a cast
> > + //
> > + Operand = 0xababababefefefef;
> > + Result = 0;
> > + Status = SafeUint64ToUintn(Operand, &Result);
> > + UT_ASSERT_NOT_EFI_ERROR(Status);
> > + UT_ASSERT_EQUAL(0xababababefefefef, Result);
> > +
> > + return UNIT_TEST_PASSED;
> > +}
> > +
> > +UNIT_TEST_STATUS
> > +EFIAPI
> > +TestSafeUintnAdd (
> > + IN UNIT_TEST_CONTEXT Context
> > + )
> > +{
> > + EFI_STATUS Status;
> > + UINTN Augend;
> > + UINTN Addend;
> > + UINTN Result;
> > +
> > + //
> > + // If the result of addition doesn't overflow
> MAX_UINTN, then it's addition
> > + //
> > + Augend = 0x3a3a3a3a12121212;
> > + Addend = 0x3a3a3a3a12121212;
> > + Result = 0;
> > + Status = SafeUintnAdd(Augend, Addend, &Result);
> > + UT_ASSERT_NOT_EFI_ERROR(Status);
> > + UT_ASSERT_EQUAL(0x7474747424242424, Result);
> > +
> > + //
> > + // Otherwise should result in an error status
> > + //
> > + Augend = 0xababababefefefef;
> > + Addend = 0xbcbcbcbcdededede;
> > + Status = SafeUintnAdd(Augend, Addend, &Result);
> > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> > +
> > + return UNIT_TEST_PASSED;
> > +}
> > +
> > +UNIT_TEST_STATUS
> > +EFIAPI
> > +TestSafeIntnAdd (
> > + IN UNIT_TEST_CONTEXT Context
> > + )
> > +{
> > + EFI_STATUS Status;
> > + INTN Augend;
> > + INTN Addend;
> > + INTN Result;
> > +
> > + //
> > + // If the result of addition doesn't overflow
> MAX_INTN
> > + // and doesn't underflow MIN_INTN, then it's
> addition
> > + //
> > + Augend = 0x3a3a3a3a3a3a3a3a;
> > + Addend = 0x3a3a3a3a3a3a3a3a;
> > + Result = 0;
> > + Status = SafeIntnAdd(Augend, Addend, &Result);
> > + UT_ASSERT_NOT_EFI_ERROR(Status);
> > + UT_ASSERT_EQUAL(0x7474747474747474, Result);
> > +
> > + Augend = (-4195730024608447034);
> > + Addend = (-4195730024608447034);
> > + Status = SafeIntnAdd(Augend, Addend, &Result);
> > + UT_ASSERT_NOT_EFI_ERROR(Status);
> > + UT_ASSERT_EQUAL((-8391460049216894068), Result);
> > +
> > + //
> > + // Otherwise should result in an error status
> > + //
> > + Augend = 0x5a5a5a5a5a5a5a5a;
> > + Addend = 0x5a5a5a5a5a5a5a5a;
> > + Status = SafeIntnAdd(Augend, Addend, &Result);
> > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> > +
> > + Augend = (-6510615555426900570);
> > + Addend = (-6510615555426900570);
> > + Status = SafeIntnAdd(Augend, Addend, &Result);
> > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> > +
> > + return UNIT_TEST_PASSED;
> > +}
> > +
> > +UNIT_TEST_STATUS
> > +EFIAPI
> > +TestSafeUintnSub (
> > + IN UNIT_TEST_CONTEXT Context
> > + )
> > +{
> > + EFI_STATUS Status;
> > + UINTN Minuend;
> > + UINTN Subtrahend;
> > + UINTN Result;
> > +
> > + //
> > + // If Minuend >= Subtrahend, then it's subtraction
> > + //
> > + Minuend = 0x5a5a5a5a5a5a5a5a;
> > + Subtrahend = 0x3b3b3b3b3b3b3b3b;
> > + Result = 0;
> > + Status = SafeUintnSub(Minuend, Subtrahend,
> &Result);
> > + UT_ASSERT_NOT_EFI_ERROR(Status);
> > + UT_ASSERT_EQUAL(0x1f1f1f1f1f1f1f1f, Result);
> > +
> > + //
> > + // Otherwise should result in an error status
> > + //
> > + Minuend = 0x5a5a5a5a5a5a5a5a;
> > + Subtrahend = 0x6d6d6d6d6d6d6d6d;
> > + Status = SafeUintnSub(Minuend, Subtrahend,
> &Result);
> > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> > +
> > + return UNIT_TEST_PASSED;
> > +}
> > +
> > +UNIT_TEST_STATUS
> > +EFIAPI
> > +TestSafeIntnSub (
> > + IN UNIT_TEST_CONTEXT Context
> > + )
> > +{
> > + EFI_STATUS Status;
> > + INTN Minuend;
> > + INTN Subtrahend;
> > + INTN Result;
> > +
> > + //
> > + // If the result of subtractions doesn't overflow
> MAX_INTN or
> > + // underflow MIN_INTN, then it's subtraction
> > + //
> > + Minuend = 0x5a5a5a5a5a5a5a5a;
> > + Subtrahend = 0x3a3a3a3a3a3a3a3a;
> > + Result = 0;
> > + Status = SafeIntnSub(Minuend, Subtrahend,
> &Result);
> > + UT_ASSERT_NOT_EFI_ERROR(Status);
> > + UT_ASSERT_EQUAL(0x2020202020202020, Result);
> > +
> > + Minuend = 0x3a3a3a3a3a3a3a3a;
> > + Subtrahend = 0x5a5a5a5a5a5a5a5a;
> > + Status = SafeIntnSub(Minuend, Subtrahend,
> &Result);
> > + UT_ASSERT_NOT_EFI_ERROR(Status);
> > + UT_ASSERT_EQUAL((-2314885530818453536), Result);
> > +
> > + //
> > + // Otherwise should result in an error status
> > + //
> > + Minuend = (-8825501086245354106);
> > + Subtrahend = 8825501086245354106;
> > + Status = SafeIntnSub(Minuend, Subtrahend,
> &Result);
> > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> > +
> > + Minuend = (8825501086245354106);
> > + Subtrahend = (-8825501086245354106);
> > + Status = SafeIntnSub(Minuend, Subtrahend,
> &Result);
> > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> > +
> > + return UNIT_TEST_PASSED;
> > +}
> > +
> > +UNIT_TEST_STATUS
> > +EFIAPI
> > +TestSafeUintnMult (
> > + IN UNIT_TEST_CONTEXT Context
> > + )
> > +{
> > + EFI_STATUS Status;
> > + UINTN Multiplicand;
> > + UINTN Multiplier;
> > + UINTN Result;
> > +
> > + //
> > + // If the result of multiplication doesn't
> overflow MAX_UINTN, it will succeed
> > + //
> > + Multiplicand = 0x123456789a;
> > + Multiplier = 0x1234567;
> > + Result = 0;
> > + Status = SafeUintnMult(Multiplicand, Multiplier,
> &Result);
> > + UT_ASSERT_NOT_EFI_ERROR(Status);
> > + UT_ASSERT_EQUAL(0x14b66db9745a07f6, Result);
> > +
> > + //
> > + // Otherwise should result in an error status
> > + //
> > + Multiplicand = 0x123456789a;
> > + Multiplier = 0x12345678;
> > + Status = SafeUintnMult(Multiplicand, Multiplier,
> &Result);
> > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> > +
> > + return UNIT_TEST_PASSED;
> > +}
> > +
> > +UNIT_TEST_STATUS
> > +EFIAPI
> > +TestSafeIntnMult (
> > + IN UNIT_TEST_CONTEXT Context
> > + )
> > +{
> > + EFI_STATUS Status;
> > + INTN Multiplicand;
> > + INTN Multiplier;
> > + INTN Result;
> > +
> > + //
> > + // If the result of multiplication doesn't
> overflow MAX_INTN and doesn't
> > + // underflow MIN_UINTN, it will succeed
> > + //
> > + Multiplicand = 0x123456789;
> > + Multiplier = 0x6789abcd;
> > + Result = 0;
> > + Status = SafeIntnMult(Multiplicand, Multiplier,
> &Result);
> > + UT_ASSERT_NOT_EFI_ERROR(Status);
> > + UT_ASSERT_EQUAL(0x75cd9045220d6bb5, Result);
> > +
> > + //
> > + // Otherwise should result in an error status
> > + //
> > + Multiplicand = 0x123456789;
> > + Multiplier = 0xa789abcd;
> > + Status = SafeIntnMult(Multiplicand, Multiplier,
> &Result);
> > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> > +
> > + return UNIT_TEST_PASSED;
> > +}
> > diff --git
> a/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseS
> afeIntLib.c
> >
> b/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseS
> afeIntLib.c
> > new file mode 100644
> > index 0000000000..2b1a2223a0
> > --- /dev/null
> > +++
> b/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseS
> afeIntLib.c
> > @@ -0,0 +1,3064 @@
> > +/** @file
> > + UEFI OS based application for unit testing the
> SafeIntLib.
> > +
> > + Copyright (c) Microsoft Corporation.<BR>
> > + Copyright (c) 2018 - 2020, Intel Corporation. All
> rights reserved.<BR>
> > + SPDX-License-Identifier: BSD-2-Clause-Patent
> > +
> > +**/
> > +
> > +#include "TestBaseSafeIntLib.h"
> > +
> > +#define UNIT_TEST_NAME "Int Safe Lib Unit
> Test Application"
> > +#define UNIT_TEST_VERSION "0.1"
> > +
> > +//
> > +// Conversion function tests:
> > +//
> > +UNIT_TEST_STATUS
> > +EFIAPI
> > +TestSafeInt8ToUint8 (
> > + IN UNIT_TEST_CONTEXT Context
> > + )
> > +{
> > + EFI_STATUS Status;
> > + INT8 Operand;
> > + UINT8 Result;
> > +
> > + //
> > + // Positive UINT8 should result in just a cast
> > + //
> > + Operand = 0x5b;
> > + Result = 0;
> > + Status = SafeInt8ToUint8(Operand, &Result);
> > + UT_ASSERT_NOT_EFI_ERROR(Status);
> > + UT_ASSERT_EQUAL(0x5b, Result);
> > +
> > + //
> > + // Negative number should result in an error
> status
> > + //
> > + Operand = (-56);
> > + Status = SafeInt8ToUint8(Operand, &Result);
> > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> > +
> > + return UNIT_TEST_PASSED;
> > +}
> > +
> > +UNIT_TEST_STATUS
> > +EFIAPI
> > +TestSafeInt8ToUint16 (
> > + IN UNIT_TEST_CONTEXT Context
> > + )
> > +{
> > + EFI_STATUS Status;
> > + INT8 Operand;
> > + UINT16 Result;
> > +
> > + //
> > + // Positive UINT8 should result in just a cast
> > + //
> > + Operand = 0x5b;
> > + Result = 0;
> > + Status = SafeInt8ToUint16(Operand, &Result);
> > + UT_ASSERT_NOT_EFI_ERROR(Status);
> > + UT_ASSERT_EQUAL(0x5b, Result);
> > +
> > + //
> > + // Negative number should result in an error
> status
> > + //
> > + Operand = (-56);
> > + Status = SafeInt8ToUint16(Operand, &Result);
> > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> > +
> > + return UNIT_TEST_PASSED;
> > +}
> > +
> > +UNIT_TEST_STATUS
> > +EFIAPI
> > +TestSafeInt8ToUint32 (
> > + IN UNIT_TEST_CONTEXT Context
> > + )
> > +{
> > + EFI_STATUS Status;
> > + INT8 Operand;
> > + UINT32 Result;
> > +
> > + //
> > + // Positive UINT8 should result in just a cast
> > + //
> > + Operand = 0x5b;
> > + Result = 0;
> > + Status = SafeInt8ToUint32(Operand, &Result);
> > + UT_ASSERT_NOT_EFI_ERROR(Status);
> > + UT_ASSERT_EQUAL(0x5b, Result);
> > +
> > + //
> > + // Negative number should result in an error
> status
> > + //
> > + Operand = (-56);
> > + Status = SafeInt8ToUint32(Operand, &Result);
> > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> > +
> > + return UNIT_TEST_PASSED;
> > +}
> > +
> > +UNIT_TEST_STATUS
> > +EFIAPI
> > +TestSafeInt8ToUintn (
> > + IN UNIT_TEST_CONTEXT Context
> > + )
> > +{
> > + EFI_STATUS Status;
> > + INT8 Operand;
> > + UINTN Result;
> > +
> > + //
> > + // Positive UINT8 should result in just a cast
> > + //
> > + Operand = 0x5b;
> > + Result = 0;
> > + Status = SafeInt8ToUintn(Operand, &Result);
> > + UT_ASSERT_NOT_EFI_ERROR(Status);
> > + UT_ASSERT_EQUAL(0x5b, Result);
> > +
> > + //
> > + // Negative number should result in an error
> status
> > + //
> > + Operand = (-56);
> > + Status = SafeInt8ToUintn(Operand, &Result);
> > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> > +
> > + return UNIT_TEST_PASSED;
> > +}
> > +
> > +UNIT_TEST_STATUS
> > +EFIAPI
> > +TestSafeInt8ToUint64 (
> > + IN UNIT_TEST_CONTEXT Context
> > + )
> > +{
> > + EFI_STATUS Status;
> > + INT8 Operand;
> > + UINT64 Result;
> > +
> > + //
> > + // Positive UINT8 should result in just a cast
> > + //
> > + Operand = 0x5b;
> > + Result = 0;
> > + Status = SafeInt8ToUint64(Operand, &Result);
> > + UT_ASSERT_NOT_EFI_ERROR(Status);
> > + UT_ASSERT_EQUAL(0x5b, Result);
> > +
> > + //
> > + // Negative number should result in an error
> status
> > + //
> > + Operand = (-56);
> > + Status = SafeInt8ToUint64(Operand, &Result);
> > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> > +
> > + return UNIT_TEST_PASSED;
> > +}
> > +
> > +UNIT_TEST_STATUS
> > +EFIAPI
> > +TestSafeUint8ToInt8 (
> > + IN UNIT_TEST_CONTEXT Context
> > + )
> > +{
> > + EFI_STATUS Status;
> > + UINT8 Operand;
> > + INT8 Result;
> > +
> > + //
> > + // Operand <= 0x7F (MAX_INT8) should result in a
> cast
> > + //
> > + Operand = 0x5b;
> > + Result = 0;
> > + Status = SafeUint8ToInt8(Operand, &Result);
> > + UT_ASSERT_NOT_EFI_ERROR(Status);
> > + UT_ASSERT_EQUAL(0x5b, Result);
> > +
> > + //
> > + // Operand larger than 0x7f should result in an
> error status
> > + //
> > + Operand = 0xaf;
> > + Status = SafeUint8ToInt8(Operand, &Result);
> > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> > +
> > + return UNIT_TEST_PASSED;
> > +}
> > +
> > +UNIT_TEST_STATUS
> > +EFIAPI
> > +TestSafeUint8ToChar8 (
> > + IN UNIT_TEST_CONTEXT Context
> > + )
> > +{
> > + EFI_STATUS Status;
> > + UINT8 Operand;
> > + CHAR8 Result;
> > +
> > + //
> > + // CHAR8 is typedefed as char, which by default is
> signed, thus
> > + // CHAR8 is same as INT8, so same tests as above:
> > + //
> > +
> > + //
> > + // Operand <= 0x7F (MAX_INT8) should result in a
> cast
> > + //
> > + Operand = 0x5b;
> > + Result = 0;
> > + Status = SafeUint8ToChar8(Operand, &Result);
> > + UT_ASSERT_NOT_EFI_ERROR(Status);
> > + UT_ASSERT_EQUAL(0x5b, Result);
> > +
> > + //
> > + // Operand larger than 0x7f should result in an
> error status
> > + //
> > + Operand = 0xaf;
> > + Status = SafeUint8ToChar8(Operand, &Result);
> > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> > +
> > + return UNIT_TEST_PASSED;
> > +}
> > +
> > +UNIT_TEST_STATUS
> > +EFIAPI
> > +TestSafeInt16ToInt8 (
> > + IN UNIT_TEST_CONTEXT Context
> > + )
> > +{
> > + EFI_STATUS Status;
> > + INT16 Operand;
> > + INT8 Result;
> > +
> > + //
> > + // If Operand is between MIN_INT8 and MAX_INT8
> inclusive, then it's a cast
> > + //
> > + Operand = 0x5b;
> > + Result = 0;
> > + Status = SafeInt16ToInt8(Operand, &Result);
> > + UT_ASSERT_NOT_EFI_ERROR(Status);
> > + UT_ASSERT_EQUAL(0x5b, Result);
> > +
> > + Operand = (-35);
> > + Status = SafeInt16ToInt8(Operand, &Result);
> > + UT_ASSERT_NOT_EFI_ERROR(Status);
> > + UT_ASSERT_EQUAL((-35), Result);
> > +
> > + //
> > + // Otherwise should result in an error status
> > + //
> > + Operand = 0x1234;
> > + Status = SafeInt16ToInt8(Operand, &Result);
> > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> > +
> > + Operand = (-17835);
> > + Status = SafeInt16ToInt8(Operand, &Result);
> > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> > +
> > + return UNIT_TEST_PASSED;
> > +}
> > +
> > +UNIT_TEST_STATUS
> > +EFIAPI
> > +TestSafeInt16ToChar8 (
> > + IN UNIT_TEST_CONTEXT Context
> > + )
> > +{
> > + EFI_STATUS Status;
> > + INT16 Operand;
> > + CHAR8 Result;
> > +
> > + //
> > + // CHAR8 is typedefed as char, which may be signed
> or unsigned based
> > + // on the compiler. Thus, for compatibility CHAR8
> should be between 0 and MAX_INT8.
> > + //
> > +
> > + //
> > + // If Operand is between 0 and MAX_INT8 inclusive,
> then it's a cast
> > + //
> > + Operand = 0x5b;
> > + Result = 0;
> > + Status = SafeInt16ToChar8(Operand, &Result);
> > + UT_ASSERT_NOT_EFI_ERROR(Status);
> > + UT_ASSERT_EQUAL(0x5b, Result);
> > +
> > + Operand = 0;
> > + Result = 0;
> > + Status = SafeInt16ToChar8(Operand, &Result);
> > + UT_ASSERT_NOT_EFI_ERROR(Status);
> > + UT_ASSERT_EQUAL(0, Result);
> > +
> > + Operand = MAX_INT8;
> > + Result = 0;
> > + Status = SafeInt16ToChar8(Operand, &Result);
> > + UT_ASSERT_NOT_EFI_ERROR(Status);
> > + UT_ASSERT_EQUAL(MAX_INT8, Result);
> > +
> > + //
> > + // Otherwise should result in an error status
> > + //
> > + Operand = (-35);
> > + Status = SafeInt16ToChar8(Operand, &Result);
> > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> > +
> > + Operand = 0x1234;
> > + Status = SafeInt16ToChar8(Operand, &Result);
> > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> > +
> > + Operand = (-17835);
> > + Status = SafeInt16ToChar8(Operand, &Result);
> > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> > +
> > + return UNIT_TEST_PASSED;
> > +}
> > +
> > +UNIT_TEST_STATUS
> > +EFIAPI
> > +TestSafeInt16ToUint8 (
> > + IN UNIT_TEST_CONTEXT Context
> > + )
> > +{
> > + EFI_STATUS Status;
> > + INT16 Operand;
> > + UINT8 Result;
> > +
> > + //
> > + // If Operand is between 0 and MAX_INT8 inclusive,
> then it's a cast
> > + //
> > + Operand = 0x5b;
> > + Result = 0;
> > + Status = SafeInt16ToUint8(Operand, &Result);
> > + UT_ASSERT_NOT_EFI_ERROR(Status);
> > + UT_ASSERT_EQUAL(0x5b, Result);
> > +
> > + //
> > + // Otherwise should result in an error status
> > + //
> > + Operand = 0x1234;
> > + Status = SafeInt16ToUint8(Operand, &Result);
> > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> > +
> > + Operand = (-17835);
> > + Status = SafeInt16ToUint8(Operand, &Result);
> > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> > +
> > + return UNIT_TEST_PASSED;
> > +}
> > +
> > +UNIT_TEST_STATUS
> > +EFIAPI
> > +TestSafeInt16ToUint16 (
> > + IN UNIT_TEST_CONTEXT Context
> > + )
> > +{
> > + EFI_STATUS Status;
> > + INT16 Operand = 0x5b5b;
> > + UINT16 Result = 0;
> > +
> > + //
> > + // If Operand is non-negative, then it's a cast
> > + //
> > + Status = SafeInt16ToUint16(Operand, &Result);
> > + UT_ASSERT_NOT_EFI_ERROR(Status);
> > + UT_ASSERT_EQUAL(0x5b5b, Result);
> > +
> > + //
> > + // Otherwise should result in an error status
> > + //
> > + Operand = (-17835);
> > + Status = SafeInt16ToUint16(Operand, &Result);
> > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> > +
> > + return UNIT_TEST_PASSED;
> > +}
> > +
> > +UNIT_TEST_STATUS
> > +EFIAPI
> > +TestSafeInt16ToUint32 (
> > + IN UNIT_TEST_CONTEXT Context
> > + )
> > +{
> > + EFI_STATUS Status;
> > + INT16 Operand;
> > + UINT32 Result;
> > +
> > + //
> > + // If Operand is non-negative, then it's a cast
> > + //
> > + Operand = 0x5b5b;
> > + Result = 0;
> > + Status = SafeInt16ToUint32(Operand, &Result);
> > + UT_ASSERT_NOT_EFI_ERROR(Status);
> > + UT_ASSERT_EQUAL(0x5b5b, Result);
> > +
> > + //
> > + // Otherwise should result in an error status
> > + //
> > + Operand = (-17835);
> > + Status = SafeInt16ToUint32(Operand, &Result);
> > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> > +
> > + return UNIT_TEST_PASSED;
> > +}
> > +
> > +UNIT_TEST_STATUS
> > +EFIAPI
> > +TestSafeInt16ToUintn (
> > + IN UNIT_TEST_CONTEXT Context
> > + )
> > +{
> > + EFI_STATUS Status;
> > + INT16 Operand;
> > + UINTN Result;
> > +
> > + //
> > + // If Operand is non-negative, then it's a cast
> > + //
> > + Operand = 0x5b5b;
> > + Result = 0;
> > + Status = SafeInt16ToUintn(Operand, &Result);
> > + UT_ASSERT_NOT_EFI_ERROR(Status);
> > + UT_ASSERT_EQUAL(0x5b5b, Result);
> > +
> > + //
> > + // Otherwise should result in an error status
> > + //
> > + Operand = (-17835);
> > + Status = SafeInt16ToUintn(Operand, &Result);
> > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> > +
> > + return UNIT_TEST_PASSED;
> > +}
> > +
> > +UNIT_TEST_STATUS
> > +EFIAPI
> > +TestSafeInt16ToUint64 (
> > + IN UNIT_TEST_CONTEXT Context
> > + )
> > +{
> > + EFI_STATUS Status;
> > + INT16 Operand;
> > + UINT64 Result;
> > +
> > + //
> > + // If Operand is non-negative, then it's a cast
> > + //
> > + Operand = 0x5b5b;
> > + Result = 0;
> > + Status = SafeInt16ToUint64(Operand, &Result);
> > + UT_ASSERT_NOT_EFI_ERROR(Status);
> > + UT_ASSERT_EQUAL(0x5b5b, Result);
> > +
> > + //
> > + // Otherwise should result in an error status
> > + //
> > + Operand = (-17835);
> > + Status = SafeInt16ToUint64(Operand, &Result);
> > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> > +
> > + return UNIT_TEST_PASSED;
> > +}
> > +
> > +UNIT_TEST_STATUS
> > +EFIAPI
> > +TestSafeUint16ToInt8 (
> > + IN UNIT_TEST_CONTEXT Context
> > + )
> > +{
> > + EFI_STATUS Status;
> > + UINT16 Operand;
> > + INT8 Result;
> > +
> > + //
> > + // If Operand is <= MAX_INT8, it's a cast
> > + //
> > + Operand = 0x5b;
> > + Result = 0;
> > + Status = SafeUint16ToInt8(Operand, &Result);
> > + UT_ASSERT_NOT_EFI_ERROR(Status);
> > + UT_ASSERT_EQUAL(0x5b, Result);
> > +
> > + //
> > + // Otherwise should result in an error status
> > + //
> > + Operand = (0x5b5b);
> > + Status = SafeUint16ToInt8(Operand, &Result);
> > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> > +
> > + return UNIT_TEST_PASSED;
> > +}
> > +
> > +UNIT_TEST_STATUS
> > +EFIAPI
> > +TestSafeUint16ToChar8 (
> > + IN UNIT_TEST_CONTEXT Context
> > + )
> > +{
> > + EFI_STATUS Status;
> > + UINT16 Operand;
> > + CHAR8 Result;
> > +
> > + // CHAR8 is typedefed as char, which by default is
> signed, thus
> > + // CHAR8 is same as INT8, so same tests as above:
> > +
> > + //
> > + // If Operand is <= MAX_INT8, it's a cast
> > + //
> > + Operand = 0x5b;
> > + Result = 0;
> > + Status = SafeUint16ToChar8(Operand, &Result);
> > + UT_ASSERT_NOT_EFI_ERROR(Status);
> > + UT_ASSERT_EQUAL(0x5b, Result);
> > +
> > + //
> > + // Otherwise should result in an error status
> > + //
> > + Operand = (0x5b5b);
> > + Status = SafeUint16ToChar8(Operand, &Result);
> > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> > +
> > + return UNIT_TEST_PASSED;
> > +}
> > +
> > +UNIT_TEST_STATUS
> > +EFIAPI
> > +TestSafeUint16ToUint8 (
> > + IN UNIT_TEST_CONTEXT Context
> > + )
> > +{
> > + EFI_STATUS Status;
> > + UINT16 Operand;
> > + UINT8 Result;
> > +
> > + //
> > + // If Operand is <= MAX_UINT8 (0xff), it's a cast
> > + //
> > + Operand = 0xab;
> > + Result = 0;
> > + Status = SafeUint16ToUint8(Operand, &Result);
> > + UT_ASSERT_NOT_EFI_ERROR(Status);
> > + UT_ASSERT_EQUAL(0xab, Result);
> > +
> > + //
> > + // Otherwise should result in an error status
> > + //
> > + Operand = (0x5b5b);
> > + Status = SafeUint16ToUint8(Operand, &Result);
> > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> > +
> > + return UNIT_TEST_PASSED;
> > +}
> > +
> > +UNIT_TEST_STATUS
> > +EFIAPI
> > +TestSafeUint16ToInt16 (
> > + IN UNIT_TEST_CONTEXT Context
> > + )
> > +{
> > + EFI_STATUS Status;
> > + UINT16 Operand;
> > + INT16 Result;
> > +
> > + //
> > + // If Operand is <= MAX_INT16 (0x7fff), it's a
> cast
> > + //
> > + Operand = 0x5b5b;
> > + Result = 0;
> > + Status = SafeUint16ToInt16(Operand, &Result);
> > + UT_ASSERT_NOT_EFI_ERROR(Status);
> > + UT_ASSERT_EQUAL(0x5b5b, Result);
> > +
> > + //
> > + // Otherwise should result in an error status
> > + //
> > + Operand = (0xabab);
> > + Status = SafeUint16ToInt16(Operand, &Result);
> > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> > +
> > + return UNIT_TEST_PASSED;
> > +}
> > +
> > +UNIT_TEST_STATUS
> > +EFIAPI
> > +TestSafeInt32ToInt8 (
> > + IN UNIT_TEST_CONTEXT Context
> > + )
> > +{
> > + EFI_STATUS Status;
> > + INT32 Operand;
> > + INT8 Result;
> > +
> > + //
> > + // If Operand is between MIN_INT8 and MAX_INT8
> inclusive, then it's a cast
> > + //
> > + Operand = 0x5b;
> > + Result = 0;
> > + Status = SafeInt32ToInt8(Operand, &Result);
> > + UT_ASSERT_NOT_EFI_ERROR(Status);
> > + UT_ASSERT_EQUAL(0x5b, Result);
> > +
> > + Operand = (-57);
> > + Status = SafeInt32ToInt8(Operand, &Result);
> > + UT_ASSERT_NOT_EFI_ERROR(Status);
> > + UT_ASSERT_EQUAL((-57), Result);
> > +
> > + //
> > + // Otherwise should result in an error status
> > + //
> > + Operand = (0x5bababab);
> > + Status = SafeInt32ToInt8(Operand, &Result);
> > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> > +
> > + Operand = (-1537977259);
> > + Status = SafeInt32ToInt8(Operand, &Result);
> > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> > +
> > + return UNIT_TEST_PASSED;
> > +}
> > +
> > +UNIT_TEST_STATUS
> > +EFIAPI
> > +TestSafeInt32ToChar8 (
> > + IN UNIT_TEST_CONTEXT Context
> > + )
> > +{
> > + EFI_STATUS Status;
> > + INT32 Operand;
> > + CHAR8 Result;
> > +
> > + //
> > + // CHAR8 is typedefed as char, which may be signed
> or unsigned based
> > + // on the compiler. Thus, for compatibility CHAR8
> should be between 0 and MAX_INT8.
> > + //
> > +
> > + //
> > + // If Operand is between 0 and MAX_INT8 inclusive,
> then it's a cast
> > + //
> > + Operand = 0x5b;
> > + Result = 0;
> > + Status = SafeInt32ToChar8(Operand, &Result);
> > + UT_ASSERT_NOT_EFI_ERROR(Status);
> > + UT_ASSERT_EQUAL(0x5b, Result);
> > +
> > + Operand = 0;
> > + Result = 0;
> > + Status = SafeInt32ToChar8(Operand, &Result);
> > + UT_ASSERT_NOT_EFI_ERROR(Status);
> > + UT_ASSERT_EQUAL(0, Result);
> > +
> > + Operand = MAX_INT8;
> > + Result = 0;
> > + Status = SafeInt32ToChar8(Operand, &Result);
> > + UT_ASSERT_NOT_EFI_ERROR(Status);
> > + UT_ASSERT_EQUAL(MAX_INT8, Result);
> > +
> > + //
> > + // Otherwise should result in an error status
> > + //
> > + Operand = (-57);
> > + Status = SafeInt32ToChar8(Operand, &Result);
> > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> > +
> > + Operand = (0x5bababab);
> > + Status = SafeInt32ToChar8(Operand, &Result);
> > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> > +
> > + Operand = (-1537977259);
> > + Status = SafeInt32ToChar8(Operand, &Result);
> > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> > +
> > + return UNIT_TEST_PASSED;
> > +}
> > +
> > +UNIT_TEST_STATUS
> > +EFIAPI
> > +TestSafeInt32ToUint8 (
> > + IN UNIT_TEST_CONTEXT Context
> > + )
> > +{
> > + EFI_STATUS Status;
> > + INT32 Operand;
> > + UINT8 Result;
> > +
> > + //
> > + // If Operand is between 0 and MAX_INT8 inclusive,
> then it's a cast
> > + //
> > + Operand = 0x5b;
> > + Result = 0;
> > + Status = SafeInt32ToUint8(Operand, &Result);
> > + UT_ASSERT_NOT_EFI_ERROR(Status);
> > + UT_ASSERT_EQUAL(0x5b, Result);
> > +
> > + //
> > + // Otherwise should result in an error status
> > + //
> > + Operand = (-57);
> > + Status = SafeInt32ToUint8(Operand, &Result);
> > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> > +
> > + Operand = (0x5bababab);
> > + Status = SafeInt32ToUint8(Operand, &Result);
> > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> > +
> > + Operand = (-1537977259);
> > + Status = SafeInt32ToUint8(Operand, &Result);
> > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> > +
> > + return UNIT_TEST_PASSED;
> > +}
> > +
> > +UNIT_TEST_STATUS
> > +EFIAPI
> > +TestSafeInt32ToInt16 (
> > + IN UNIT_TEST_CONTEXT Context
> > + )
> > +{
> > + EFI_STATUS Status;
> > + INT32 Operand;
> > + INT16 Result;
> > +
> > + //
> > + // If Operand is between MIN_INT16 and MAX_INT16
> inclusive, then it's a cast
> > + //
> > + Operand = 0x5b5b;
> > + Result = 0;
> > + Status = SafeInt32ToInt16(Operand, &Result);
> > + UT_ASSERT_NOT_EFI_ERROR(Status);
> > + UT_ASSERT_EQUAL(0x5b5b, Result);
> > +
> > + Operand = (-17857);
> > + Status = SafeInt32ToInt16(Operand, &Result);
> > + UT_ASSERT_NOT_EFI_ERROR(Status);
> > + UT_ASSERT_EQUAL((-17857), Result);
> > +
> > + //
> > + // Otherwise should result in an error status
> > + //
> > + Operand = (0x5bababab);
> > + Status = SafeInt32ToInt16(Operand, &Result);
> > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> > +
> > + Operand = (-1537977259);
> > + Status = SafeInt32ToInt16(Operand, &Result);
> > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> > +
> > + return UNIT_TEST_PASSED;
> > +}
> > +
> > +UNIT_TEST_STATUS
> > +EFIAPI
> > +TestSafeInt32ToUint16 (
> > + IN UNIT_TEST_CONTEXT Context
> > + )
> > +{
> > + EFI_STATUS Status;
> > + INT32 Operand;
> > + UINT16 Result;
> > +
> > + //
> > + // If Operand is between 0 and MAX_UINT16
> inclusive, then it's a cast
> > + //
> > + Operand = 0xabab;
> > + Result = 0;
> > + Status = SafeInt32ToUint16(Operand, &Result);
> > + UT_ASSERT_NOT_EFI_ERROR(Status);
> > + UT_ASSERT_EQUAL(0xabab, Result);
> > +
> > + //
> > + // Otherwise should result in an error status
> > + //
> > + Operand = (-17857);
> > + Status = SafeInt32ToUint16(Operand, &Result);
> > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> > +
> > + Operand = (0x5bababab);
> > + Status = SafeInt32ToUint16(Operand, &Result);
> > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> > +
> > + Operand = (-1537977259);
> > + Status = SafeInt32ToUint16(Operand, &Result);
> > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> > +
> > + return UNIT_TEST_PASSED;
> > +}
> > +
> > +UNIT_TEST_STATUS
> > +EFIAPI
> > +TestSafeInt32ToUint32 (
> > + IN UNIT_TEST_CONTEXT Context
> > + )
> > +{
> > + EFI_STATUS Status;
> > + INT32 Operand;
> > + UINT32 Result;
> > +
> > + //
> > + // If Operand is non-negative, then it's a cast
> > + //
> > + Operand = 0x5bababab;
> > + Result = 0;
> > + Status = SafeInt32ToUint32(Operand, &Result);
> > + UT_ASSERT_NOT_EFI_ERROR(Status);
> > + UT_ASSERT_EQUAL(0x5bababab, Result);
> > +
> > + //
> > + // Otherwise should result in an error status
> > + //
> > + Operand = (-1537977259);
> > + Status = SafeInt32ToUint32(Operand, &Result);
> > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> > +
> > + return UNIT_TEST_PASSED;
> > +}
> > +
> > +UNIT_TEST_STATUS
> > +EFIAPI
> > +TestSafeInt32ToUint64 (
> > + IN UNIT_TEST_CONTEXT Context
> > + )
> > +{
> > + EFI_STATUS Status;
> > + INT32 Operand;
> > + UINT64 Result;
> > +
> > + //
> > + // If Operand is non-negative, then it's a cast
> > + //
> > + Operand = 0x5bababab;
> > + Result = 0;
> > + Status = SafeInt32ToUint64(Operand, &Result);
> > + UT_ASSERT_NOT_EFI_ERROR(Status);
> > + UT_ASSERT_EQUAL(0x5bababab, Result);
> > +
> > + //
> > + // Otherwise should result in an error status
> > + //
> > + Operand = (-1537977259);
> > + Status = SafeInt32ToUint64(Operand, &Result);
> > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> > +
> > + return UNIT_TEST_PASSED;
> > +}
> > +
> > +UNIT_TEST_STATUS
> > +EFIAPI
> > +TestSafeUint32ToInt8 (
> > + IN UNIT_TEST_CONTEXT Context
> > + )
> > +{
> > + EFI_STATUS Status;
> > + UINT32 Operand;
> > + INT8 Result;
> > +
> > + //
> > + // If Operand is <= MAX_INT8, then it's a cast
> > + //
> > + Operand = 0x5b;
> > + Result = 0;
> > + Status = SafeUint32ToInt8(Operand, &Result);
> > + UT_ASSERT_NOT_EFI_ERROR(Status);
> > + UT_ASSERT_EQUAL(0x5b, Result);
> > +
> > + //
> > + // Otherwise should result in an error status
> > + //
> > + Operand = (0x5bababab);
> > + Status = SafeUint32ToInt8(Operand, &Result);
> > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> > +
> > + return UNIT_TEST_PASSED;
> > +}
> > +
> > +UNIT_TEST_STATUS
> > +EFIAPI
> > +TestSafeUint32ToChar8 (
> > + IN UNIT_TEST_CONTEXT Context
> > + )
> > +{
> > + EFI_STATUS Status;
> > + UINT32 Operand;
> > + CHAR8 Result;
> > +
> > + // CHAR8 is typedefed as char, which by default is
> signed, thus
> > + // CHAR8 is same as INT8, so same tests as above:
> > +
> > + //
> > + // If Operand is <= MAX_INT8, then it's a cast
> > + //
> > + Operand = 0x5b;
> > + Result = 0;
> > + Status = SafeUint32ToChar8(Operand, &Result);
> > + UT_ASSERT_NOT_EFI_ERROR(Status);
> > + UT_ASSERT_EQUAL(0x5b, Result);
> > +
> > + //
> > + // Otherwise should result in an error status
> > + //
> > + Operand = (0x5bababab);
> > + Status = SafeUint32ToChar8(Operand, &Result);
> > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> > +
> > + return UNIT_TEST_PASSED;
> > +}
> > +
> > +UNIT_TEST_STATUS
> > +EFIAPI
> > +TestSafeUint32ToUint8 (
> > + IN UNIT_TEST_CONTEXT Context
> > + )
> > +{
> > + EFI_STATUS Status;
> > + UINT32 Operand;
> > + UINT8 Result;
> > +
> > + //
> > + // If Operand is <= MAX_UINT8, then it's a cast
> > + //
> > + Operand = 0xab;
> > + Result = 0;
> > + Status = SafeUint32ToUint8(Operand, &Result);
> > + UT_ASSERT_NOT_EFI_ERROR(Status);
> > + UT_ASSERT_EQUAL(0xab, Result);
> > +
> > + //
> > + // Otherwise should result in an error status
> > + //
> > + Operand = (0xabababab);
> > + Status = SafeUint32ToUint8(Operand, &Result);
> > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> > +
> > + return UNIT_TEST_PASSED;
> > +}
> > +
> > +UNIT_TEST_STATUS
> > +EFIAPI
> > +TestSafeUint32ToInt16 (
> > + IN UNIT_TEST_CONTEXT Context
> > + )
> > +{
> > + EFI_STATUS Status;
> > + UINT32 Operand;
> > + INT16 Result;
> > +
> > + //
> > + // If Operand is <= MAX_INT16, then it's a cast
> > + //
> > + Operand = 0x5bab;
> > + Result = 0;
> > + Status = SafeUint32ToInt16(Operand, &Result);
> > + UT_ASSERT_NOT_EFI_ERROR(Status);
> > + UT_ASSERT_EQUAL(0x5bab, Result);
> > +
> > + //
> > + // Otherwise should result in an error status
> > + //
> > + Operand = (0xabababab);
> > + Status = SafeUint32ToInt16(Operand, &Result);
> > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> > +
> > + return UNIT_TEST_PASSED;
> > +}
> > +
> > +UNIT_TEST_STATUS
> > +EFIAPI
> > +TestSafeUint32ToUint16 (
> > + IN UNIT_TEST_CONTEXT Context
> > + )
> > +{
> > + EFI_STATUS Status;
> > + UINT32 Operand;
> > + UINT16 Result;
> > +
> > + //
> > + // If Operand is <= MAX_UINT16, then it's a cast
> > + //
> > + Operand = 0xabab;
> > + Result = 0;
> > + Status = SafeUint32ToUint16(Operand, &Result);
> > + UT_ASSERT_NOT_EFI_ERROR(Status);
> > + UT_ASSERT_EQUAL(0xabab, Result);
> > +
> > + //
> > + // Otherwise should result in an error status
> > + //
> > + Operand = (0xabababab);
> > + Status = SafeUint32ToUint16(Operand, &Result);
> > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> > +
> > + return UNIT_TEST_PASSED;
> > +}
> > +
> > +UNIT_TEST_STATUS
> > +EFIAPI
> > +TestSafeUint32ToInt32 (
> > + IN UNIT_TEST_CONTEXT Context
> > + )
> > +{
> > + EFI_STATUS Status;
> > + UINT32 Operand;
> > + INT32 Result;
> > +
> > + //
> > + // If Operand is <= MAX_INT32, then it's a cast
> > + //
> > + Operand = 0x5bababab;
> > + Result = 0;
> > + Status = SafeUint32ToInt32(Operand, &Result);
> > + UT_ASSERT_NOT_EFI_ERROR(Status);
> > + UT_ASSERT_EQUAL(0x5bababab, Result);
> > +
> > + //
> > + // Otherwise should result in an error status
> > + //
> > + Operand = (0xabababab);
> > + Status = SafeUint32ToInt32(Operand, &Result);
> > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> > +
> > + return UNIT_TEST_PASSED;
> > +}
> > +
> > +UNIT_TEST_STATUS
> > +EFIAPI
> > +TestSafeIntnToInt8 (
> > + IN UNIT_TEST_CONTEXT Context
> > + )
> > +{
> > + EFI_STATUS Status;
> > + INTN Operand;
> > + INT8 Result;
> > +
> > + //
> > + // If Operand is between MIN_INT8 and MAX_INT8
> inclusive, then it's a cast
> > + //
> > + Operand = 0x5b;
> > + Result = 0;
> > + Status = SafeIntnToInt8(Operand, &Result);
> > + UT_ASSERT_NOT_EFI_ERROR(Status);
> > + UT_ASSERT_EQUAL(0x5b, Result);
> > +
> > + Operand = (-53);
> > + Status = SafeIntnToInt8(Operand, &Result);
> > + UT_ASSERT_NOT_EFI_ERROR(Status);
> > + UT_ASSERT_EQUAL((-53), Result);
> > +
> > + //
> > + // Otherwise should result in an error status
> > + //
> > + Operand = (0x5bababab);
> > + Status = SafeIntnToInt8(Operand, &Result);
> > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> > +
> > + Operand = (-1537977259);
> > + Status = SafeIntnToInt8(Operand, &Result);
> > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> > +
> > + return UNIT_TEST_PASSED;
> > +}
> > +
> > +UNIT_TEST_STATUS
> > +EFIAPI
> > +TestSafeIntnToChar8 (
> > + IN UNIT_TEST_CONTEXT Context
> > + )
> > +{
> > + EFI_STATUS Status;
> > + INTN Operand;
> > + CHAR8 Result;
> > +
> > + //
> > + // CHAR8 is typedefed as char, which may be signed
> or unsigned based
> > + // on the compiler. Thus, for compatibility CHAR8
> should be between 0 and MAX_INT8.
> > + //
> > +
> > + //
> > + // If Operand is between MIN_INT8 and MAX_INT8
> inclusive, then it's a cast
> > + //
> > + Operand = 0x5b;
> > + Result = 0;
> > + Status = SafeIntnToChar8(Operand, &Result);
> > + UT_ASSERT_NOT_EFI_ERROR(Status);
> > + UT_ASSERT_EQUAL(0x5b, Result);
> > +
> > + Operand = 0;
> > + Result = 0;
> > + Status = SafeIntnToChar8(Operand, &Result);
> > + UT_ASSERT_NOT_EFI_ERROR(Status);
> > + UT_ASSERT_EQUAL(0, Result);
> > +
> > + Operand = MAX_INT8;
> > + Result = 0;
> > + Status = SafeIntnToChar8(Operand, &Result);
> > + UT_ASSERT_NOT_EFI_ERROR(Status);
> > + UT_ASSERT_EQUAL(MAX_INT8, Result);
> > +
> > + //
> > + // Otherwise should result in an error status
> > + //
> > + Operand = (-53);
> > + Status = SafeIntnToChar8(Operand, &Result);
> > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> > +
> > + Operand = (0x5bababab);
> > + Status = SafeIntnToChar8(Operand, &Result);
> > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> > +
> > + Operand = (-1537977259);
> > + Status = SafeIntnToChar8(Operand, &Result);
> > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> > +
> > + return UNIT_TEST_PASSED;
> > +}
> > +
> > +UNIT_TEST_STATUS
> > +EFIAPI
> > +TestSafeIntnToUint8 (
> > + IN UNIT_TEST_CONTEXT Context
> > + )
> > +{
> > + EFI_STATUS Status;
> > + INTN Operand;
> > + UINT8 Result;
> > +
> > + //
> > + // If Operand is between 0 and MAX_UINT8
> inclusive, then it's a cast
> > + //
> > + Operand = 0xab;
> > + Result = 0;
> > + Status = SafeIntnToUint8(Operand, &Result);
> > + UT_ASSERT_NOT_EFI_ERROR(Status);
> > + UT_ASSERT_EQUAL(0xab, Result);
> > +
> > + //
> > + // Otherwise should result in an error status
> > + //
> > + Operand = (0x5bababab);
> > + Status = SafeIntnToUint8(Operand, &Result);
> > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> > +
> > + Operand = (-1537977259);
> > + Status = SafeIntnToUint8(Operand, &Result);
> > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> > +
> > + return UNIT_TEST_PASSED;
> > +}
> > +
> > +UNIT_TEST_STATUS
> > +EFIAPI
> > +TestSafeIntnToInt16 (
> > + IN UNIT_TEST_CONTEXT Context
> > + )
> > +{
> > + EFI_STATUS Status;
> > + INTN Operand;
> > + INT16 Result;
> > +
> > + //
> > + // If Operand is between MIN_INT16 and MAX_INT16
> inclusive, then it's a cast
> > + //
> > + Operand = 0x5bab;
> > + Result = 0;
> > + Status = SafeIntnToInt16(Operand, &Result);
> > + UT_ASSERT_NOT_EFI_ERROR(Status);
> > + UT_ASSERT_EQUAL(0x5bab, Result);
> > +
> > + Operand = (-23467);
> > + Status = SafeIntnToInt16(Operand, &Result);
> > + UT_ASSERT_NOT_EFI_ERROR(Status);
> > + UT_ASSERT_EQUAL((-23467), Result);
> > +
> > + //
> > + // Otherwise should result in an error status
> > + //
> > + Operand = (0x5bababab);
> > + Status = SafeIntnToInt16(Operand, &Result);
> > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> > +
> > + Operand = (-1537977259);
> > + Status = SafeIntnToInt16(Operand, &Result);
> > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> > +
> > + return UNIT_TEST_PASSED;
> > +}
> > +
> > +UNIT_TEST_STATUS
> > +EFIAPI
> > +TestSafeIntnToUint16 (
> > + IN UNIT_TEST_CONTEXT Context
> > + )
> > +{
> > + EFI_STATUS Status;
> > + INTN Operand;
> > + UINT16 Result;
> > +
> > + //
> > + // If Operand is between 0 and MAX_UINT16
> inclusive, then it's a cast
> > + //
> > + Operand = 0xabab;
> > + Result = 0;
> > + Status = SafeIntnToUint16(Operand, &Result);
> > + UT_ASSERT_NOT_EFI_ERROR(Status);
> > + UT_ASSERT_EQUAL(0xabab, Result);
> > +
> > + //
> > + // Otherwise should result in an error status
> > + //
> > + Operand = (0x5bababab);
> > + Status = SafeIntnToUint16(Operand, &Result);
> > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> > +
> > + Operand = (-1537977259);
> > + Status = SafeIntnToUint16(Operand, &Result);
> > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> > +
> > + return UNIT_TEST_PASSED;
> > +}
> > +
> > +UNIT_TEST_STATUS
> > +EFIAPI
> > +TestSafeIntnToUintn (
> > + IN UNIT_TEST_CONTEXT Context
> > + )
> > +{
> > + EFI_STATUS Status;
> > + INTN Operand;
> > + UINTN Result;
> > +
> > + //
> > + // If Operand is non-negative, then it's a cast
> > + //
> > + Operand = 0x5bababab;
> > + Result = 0;
> > + Status = SafeIntnToUintn(Operand, &Result);
> > + UT_ASSERT_NOT_EFI_ERROR(Status);
> > + UT_ASSERT_EQUAL(0x5bababab, Result);
> > +
> > + //
> > + // Otherwise should result in an error status
> > + //
> > + Operand = (-1537977259);
> > + Status = SafeIntnToUintn(Operand, &Result);
> > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> > +
> > + return UNIT_TEST_PASSED;
> > +}
> > +
> > +UNIT_TEST_STATUS
> > +EFIAPI
> > +TestSafeIntnToUint64 (
> > + IN UNIT_TEST_CONTEXT Context
> > + )
> > +{
> > + EFI_STATUS Status;
> > + INTN Operand;
> > + UINT64 Result;
> > +
> > + //
> > + // If Operand is non-negative, then it's a cast
> > + //
> > + Operand = 0x5bababab;
> > + Result = 0;
> > + Status = SafeIntnToUint64(Operand, &Result);
> > + UT_ASSERT_NOT_EFI_ERROR(Status);
> > + UT_ASSERT_EQUAL(0x5bababab, Result);
> > +
> > + //
> > + // Otherwise should result in an error status
> > + //
> > + Operand = (-1537977259);
> > + Status = SafeIntnToUint64(Operand, &Result);
> > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> > +
> > + return UNIT_TEST_PASSED;
> > +}
> > +
> > +UNIT_TEST_STATUS
> > +EFIAPI
> > +TestSafeUintnToInt8 (
> > + IN UNIT_TEST_CONTEXT Context
> > + )
> > +{
> > + EFI_STATUS Status;
> > + UINTN Operand;
> > + INT8 Result;
> > +
> > + //
> > + // If Operand is <= MAX_INT8, then it's a cast
> > + //
> > + Operand = 0x5b;
> > + Result = 0;
> > + Status = SafeUintnToInt8(Operand, &Result);
> > + UT_ASSERT_NOT_EFI_ERROR(Status);
> > + UT_ASSERT_EQUAL(0x5b, Result);
> > +
> > + //
> > + // Otherwise should result in an error status
> > + //
> > + Operand = (0xabab);
> > + Status = SafeUintnToInt8(Operand, &Result);
> > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> > +
> > + return UNIT_TEST_PASSED;
> > +}
> > +
> > +UNIT_TEST_STATUS
> > +EFIAPI
> > +TestSafeUintnToChar8 (
> > + IN UNIT_TEST_CONTEXT Context
> > + )
> > +{
> > + EFI_STATUS Status;
> > + UINTN Operand;
> > + CHAR8 Result;
> > +
> > + // CHAR8 is typedefed as char, which by default is
> signed, thus
> > + // CHAR8 is same as INT8, so same tests as above:
> > +
> > + //
> > + // If Operand is <= MAX_INT8, then it's a cast
> > + //
> > + Operand = 0x5b;
> > + Result = 0;
> > + Status = SafeUintnToChar8(Operand, &Result);
> > + UT_ASSERT_NOT_EFI_ERROR(Status);
> > + UT_ASSERT_EQUAL(0x5b, Result);
> > +
> > + //
> > + // Otherwise should result in an error status
> > + //
> > + Operand = (0xabab);
> > + Status = SafeUintnToChar8(Operand, &Result);
> > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> > +
> > + return UNIT_TEST_PASSED;
> > +}
> > +
> > +UNIT_TEST_STATUS
> > +EFIAPI
> > +TestSafeUintnToUint8 (
> > + IN UNIT_TEST_CONTEXT Context
> > + )
> > +{
> > + EFI_STATUS Status;
> > + UINTN Operand;
> > + UINT8 Result;
> > +
> > + //
> > + // If Operand is <= MAX_UINT8, then it's a cast
> > + //
> > + Operand = 0xab;
> > + Result = 0;
> > + Status = SafeUintnToUint8(Operand, &Result);
> > + UT_ASSERT_NOT_EFI_ERROR(Status);
> > + UT_ASSERT_EQUAL(0xab, Result);
> > +
> > + //
> > + // Otherwise should result in an error status
> > + //
> > + Operand = (0xabab);
> > + Status = SafeUintnToUint8(Operand, &Result);
> > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> > +
> > + return UNIT_TEST_PASSED;
> > +}
> > +
> > +UNIT_TEST_STATUS
> > +EFIAPI
> > +TestSafeUintnToInt16 (
> > + IN UNIT_TEST_CONTEXT Context
> > + )
> > +{
> > + EFI_STATUS Status;
> > + UINTN Operand;
> > + INT16 Result;
> > +
> > + //
> > + // If Operand is <= MAX_INT16, then it's a cast
> > + //
> > + Operand = 0x5bab;
> > + Result = 0;
> > + Status = SafeUintnToInt16(Operand, &Result);
> > + UT_ASSERT_NOT_EFI_ERROR(Status);
> > + UT_ASSERT_EQUAL(0x5bab, Result);
> > +
> > + //
> > + // Otherwise should result in an error status
> > + //
> > + Operand = (0xabab);
> > + Status = SafeUintnToInt16(Operand, &Result);
> > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> > +
> > + return UNIT_TEST_PASSED;
> > +}
> > +
> > +UNIT_TEST_STATUS
> > +EFIAPI
> > +TestSafeUintnToUint16 (
> > + IN UNIT_TEST_CONTEXT Context
> > + )
> > +{
> > + EFI_STATUS Status;
> > + UINTN Operand;
> > + UINT16 Result;
> > +
> > + //
> > + // If Operand is <= MAX_UINT16, then it's a cast
> > + //
> > + Operand = 0xabab;
> > + Result = 0;
> > + Status = SafeUintnToUint16(Operand, &Result);
> > + UT_ASSERT_NOT_EFI_ERROR(Status);
> > + UT_ASSERT_EQUAL(0xabab, Result);
> > +
> > + //
> > + // Otherwise should result in an error status
> > + //
> > + Operand = (0xabababab);
> > + Status = SafeUintnToUint16(Operand, &Result);
> > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> > +
> > + return UNIT_TEST_PASSED;
> > +}
> > +
> > +UNIT_TEST_STATUS
> > +EFIAPI
> > +TestSafeUintnToInt32 (
> > + IN UNIT_TEST_CONTEXT Context
> > + )
> > +{
> > + EFI_STATUS Status;
> > + UINTN Operand;
> > + INT32 Result;
> > +
> > + //
> > + // If Operand is <= MAX_INT32, then it's a cast
> > + //
> > + Operand = 0x5bababab;
> > + Result = 0;
> > + Status = SafeUintnToInt32(Operand, &Result);
> > + UT_ASSERT_NOT_EFI_ERROR(Status);
> > + UT_ASSERT_EQUAL(0x5bababab, Result);
> > +
> > + //
> > + // Otherwise should result in an error status
> > + //
> > + Operand = (0xabababab);
> > + Status = SafeUintnToInt32(Operand, &Result);
> > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> > +
> > + return UNIT_TEST_PASSED;
> > +}
> > +
> > +UNIT_TEST_STATUS
> > +EFIAPI
> > +TestSafeInt64ToInt8 (
> > + IN UNIT_TEST_CONTEXT Context
> > + )
> > +{
> > + EFI_STATUS Status;
> > + INT64 Operand;
> > + INT8 Result;
> > +
> > + //
> > + // If Operand is between MIN_INT8 and MAX_INT8
> inclusive, then it's a cast
> > + //
> > + Operand = 0x5b;
> > + Result = 0;
> > + Status = SafeInt64ToInt8(Operand, &Result);
> > + UT_ASSERT_NOT_EFI_ERROR(Status);
> > + UT_ASSERT_EQUAL(0x5b, Result);
> > +
> > + Operand = (-37);
> > + Status = SafeInt64ToInt8(Operand, &Result);
> > + UT_ASSERT_NOT_EFI_ERROR(Status);
> > + UT_ASSERT_EQUAL((-37), Result);
> > +
> > + //
> > + // Otherwise should result in an error status
> > + //
> > + Operand = (0x5babababefefefef);
> > + Status = SafeInt64ToInt8(Operand, &Result);
> > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> > +
> > + Operand = (-6605562033422200815);
> > + Status = SafeInt64ToInt8(Operand, &Result);
> > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> > +
> > + return UNIT_TEST_PASSED;
> > +}
> > +
> > +UNIT_TEST_STATUS
> > +EFIAPI
> > +TestSafeInt64ToChar8 (
> > + IN UNIT_TEST_CONTEXT Context
> > + )
> > +{
> > + EFI_STATUS Status;
> > + INT64 Operand;
> > + CHAR8 Result;
> > +
> > + //
> > + // CHAR8 is typedefed as char, which may be signed
> or unsigned based
> > + // on the compiler. Thus, for compatibility CHAR8
> should be between 0 and MAX_INT8.
> > + //
> > +
> > + //
> > + // If Operand is between MIN_INT8 and MAX_INT8
> inclusive, then it's a cast
> > + //
> > + Operand = 0x5b;
> > + Result = 0;
> > + Status = SafeInt64ToChar8(Operand, &Result);
> > + UT_ASSERT_NOT_EFI_ERROR(Status);
> > + UT_ASSERT_EQUAL(0x5b, Result);
> > +
> > + Operand = 0;
> > + Result = 0;
> > + Status = SafeInt64ToChar8(Operand, &Result);
> > + UT_ASSERT_NOT_EFI_ERROR(Status);
> > + UT_ASSERT_EQUAL(0, Result);
> > +
> > + Operand = MAX_INT8;
> > + Result = 0;
> > + Status = SafeInt64ToChar8(Operand, &Result);
> > + UT_ASSERT_NOT_EFI_ERROR(Status);
> > + UT_ASSERT_EQUAL(MAX_INT8, Result);
> > +
> > + //
> > + // Otherwise should result in an error status
> > + //
> > + Operand = (-37);
> > + Status = SafeInt64ToChar8(Operand, &Result);
> > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> > +
> > + Operand = (0x5babababefefefef);
> > + Status = SafeInt64ToChar8(Operand, &Result);
> > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> > +
> > + Operand = (-6605562033422200815);
> > + Status = SafeInt64ToChar8(Operand, &Result);
> > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> > +
> > + return UNIT_TEST_PASSED;
> > +}
> > +
> > +UNIT_TEST_STATUS
> > +EFIAPI
> > +TestSafeInt64ToUint8 (
> > + IN UNIT_TEST_CONTEXT Context
> > + )
> > +{
> > + EFI_STATUS Status;
> > + INT64 Operand;
> > + UINT8 Result;
> > +
> > + //
> > + // If Operand is between 0 and MAX_UINT8
> inclusive, then it's a cast
> > + //
> > + Operand = 0xab;
> > + Result = 0;
> > + Status = SafeInt64ToUint8(Operand, &Result);
> > + UT_ASSERT_NOT_EFI_ERROR(Status);
> > + UT_ASSERT_EQUAL(0xab, Result);
> > +
> > + //
> > + // Otherwise should result in an error status
> > + //
> > + Operand = (0x5babababefefefef);
> > + Status = SafeInt64ToUint8(Operand, &Result);
> > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> > +
> > + Operand = (-6605562033422200815);
> > + Status = SafeInt64ToUint8(Operand, &Result);
> > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> > +
> > + return UNIT_TEST_PASSED;
> > +}
> > +
> > +UNIT_TEST_STATUS
> > +EFIAPI
> > +TestSafeInt64ToInt16 (
> > + IN UNIT_TEST_CONTEXT Context
> > + )
> > +{
> > + EFI_STATUS Status;
> > + INT64 Operand;
> > + INT16 Result;
> > +
> > + //
> > + // If Operand is between MIN_INT16 and MAX_INT16
> inclusive, then it's a cast
> > + //
> > + Operand = 0x5bab;
> > + Result = 0;
> > + Status = SafeInt64ToInt16(Operand, &Result);
> > + UT_ASSERT_NOT_EFI_ERROR(Status);
> > + UT_ASSERT_EQUAL(0x5bab, Result);
> > +
> > + Operand = (-23467);
> > + Status = SafeInt64ToInt16(Operand, &Result);
> > + UT_ASSERT_NOT_EFI_ERROR(Status);
> > + UT_ASSERT_EQUAL((-23467), Result);
> > +
> > + //
> > + // Otherwise should result in an error status
> > + //
> > + Operand = (0x5babababefefefef);
> > + Status = SafeInt64ToInt16(Operand, &Result);
> > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> > +
> > + Operand = (-6605562033422200815);
> > + Status = SafeInt64ToInt16(Operand, &Result);
> > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> > +
> > + return UNIT_TEST_PASSED;
> > +}
> > +
> > +UNIT_TEST_STATUS
> > +EFIAPI
> > +TestSafeInt64ToUint16 (
> > + IN UNIT_TEST_CONTEXT Context
> > + )
> > +{
> > + EFI_STATUS Status;
> > + INT64 Operand;
> > + UINT16 Result;
> > +
> > + //
> > + // If Operand is between 0 and MAX_UINT16
> inclusive, then it's a cast
> > + //
> > + Operand = 0xabab;
> > + Result = 0;
> > + Status = SafeInt64ToUint16(Operand, &Result);
> > + UT_ASSERT_NOT_EFI_ERROR(Status);
> > + UT_ASSERT_EQUAL(0xabab, Result);
> > +
> > + //
> > + // Otherwise should result in an error status
> > + //
> > + Operand = (0x5babababefefefef);
> > + Status = SafeInt64ToUint16(Operand, &Result);
> > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> > +
> > + Operand = (-6605562033422200815);
> > + Status = SafeInt64ToUint16(Operand, &Result);
> > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> > +
> > + return UNIT_TEST_PASSED;
> > +}
> > +
> > +UNIT_TEST_STATUS
> > +EFIAPI
> > +TestSafeInt64ToInt32 (
> > + IN UNIT_TEST_CONTEXT Context
> > + )
> > +{
> > + EFI_STATUS Status;
> > + INT64 Operand;
> > + INT32 Result;
> > +
> > + //
> > + // If Operand is between MIN_INT32 and MAX_INT32
> inclusive, then it's a cast
> > + //
> > + Operand = 0x5bababab;
> > + Result = 0;
> > + Status = SafeInt64ToInt32(Operand, &Result);
> > + UT_ASSERT_NOT_EFI_ERROR(Status);
> > + UT_ASSERT_EQUAL(0x5bababab, Result);
> > +
> > + Operand = (-1537977259);
> > + Status = SafeInt64ToInt32(Operand, &Result);
> > + UT_ASSERT_NOT_EFI_ERROR(Status);
> > + UT_ASSERT_EQUAL((-1537977259), Result);
> > +
> > + //
> > + // Otherwise should result in an error status
> > + //
> > + Operand = (0x5babababefefefef);
> > + Status = SafeInt64ToInt32(Operand, &Result);
> > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> > +
> > + Operand = (-6605562033422200815);
> > + Status = SafeInt64ToInt32(Operand, &Result);
> > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> > +
> > + return UNIT_TEST_PASSED;
> > +}
> > +
> > +UNIT_TEST_STATUS
> > +EFIAPI
> > +TestSafeInt64ToUint32 (
> > + IN UNIT_TEST_CONTEXT Context
> > + )
> > +{
> > + EFI_STATUS Status;
> > + INT64 Operand;
> > + UINT32 Result;
> > +
> > + //
> > + // If Operand is between 0 and MAX_UINT32
> inclusive, then it's a cast
> > + //
> > + Operand = 0xabababab;
> > + Result = 0;
> > + Status = SafeInt64ToUint32(Operand, &Result);
> > + UT_ASSERT_NOT_EFI_ERROR(Status);
> > + UT_ASSERT_EQUAL(0xabababab, Result);
> > +
> > + //
> > + // Otherwise should result in an error status
> > + //
> > + Operand = (0x5babababefefefef);
> > + Status = SafeInt64ToUint32(Operand, &Result);
> > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> > +
> > + Operand = (-6605562033422200815);
> > + Status = SafeInt64ToUint32(Operand, &Result);
> > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> > +
> > + return UNIT_TEST_PASSED;
> > +}
> > +
> > +UNIT_TEST_STATUS
> > +EFIAPI
> > +TestSafeInt64ToUint64 (
> > + IN UNIT_TEST_CONTEXT Context
> > + )
> > +{
> > + EFI_STATUS Status;
> > + INT64 Operand;
> > + UINT64 Result;
> > +
> > + //
> > + // If Operand is non-negative, then it's a cast
> > + //
> > + Operand = 0x5babababefefefef;
> > + Result = 0;
> > + Status = SafeInt64ToUint64(Operand, &Result);
> > + UT_ASSERT_NOT_EFI_ERROR(Status);
> > + UT_ASSERT_EQUAL(0x5babababefefefef, Result);
> > +
> > + //
> > + // Otherwise should result in an error status
> > + //
> > + Operand = (-6605562033422200815);
> > + Status = SafeInt64ToUint64(Operand, &Result);
> > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> > +
> > + return UNIT_TEST_PASSED;
> > +}
> > +
> > +UNIT_TEST_STATUS
> > +EFIAPI
> > +TestSafeUint64ToInt8 (
> > + IN UNIT_TEST_CONTEXT Context
> > + )
> > +{
> > + EFI_STATUS Status;
> > + UINT64 Operand;
> > + INT8 Result;
> > +
> > + //
> > + // If Operand is <= MAX_INT8, then it's a cast
> > + //
> > + Operand = 0x5b;
> > + Result = 0;
> > + Status = SafeUint64ToInt8(Operand, &Result);
> > + UT_ASSERT_NOT_EFI_ERROR(Status);
> > + UT_ASSERT_EQUAL(0x5b, Result);
> > +
> > + //
> > + // Otherwise should result in an error status
> > + //
> > + Operand = (0xababababefefefef);
> > + Status = SafeUint64ToInt8(Operand, &Result);
> > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> > +
> > + return UNIT_TEST_PASSED;
> > +}
> > +
> > +UNIT_TEST_STATUS
> > +EFIAPI
> > +TestSafeUint64ToChar8 (
> > + IN UNIT_TEST_CONTEXT Context
> > + )
> > +{
> > + EFI_STATUS Status;
> > + UINT64 Operand;
> > + CHAR8 Result;
> > +
> > + // CHAR8 is typedefed as char, which by default is
> signed, thus
> > + // CHAR8 is same as INT8, so same tests as above:
> > +
> > + //
> > + // If Operand is <= MAX_INT8, then it's a cast
> > + //
> > + Operand = 0x5b;
> > + Result = 0;
> > + Status = SafeUint64ToChar8(Operand, &Result);
> > + UT_ASSERT_NOT_EFI_ERROR(Status);
> > + UT_ASSERT_EQUAL(0x5b, Result);
> > +
> > + //
> > + // Otherwise should result in an error status
> > + //
> > + Operand = (0xababababefefefef);
> > + Status = SafeUint64ToChar8(Operand, &Result);
> > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> > +
> > + return UNIT_TEST_PASSED;
> > +}
> > +
> > +UNIT_TEST_STATUS
> > +EFIAPI
> > +TestSafeUint64ToUint8 (
> > + IN UNIT_TEST_CONTEXT Context
> > + )
> > +{
> > + EFI_STATUS Status;
> > + UINT64 Operand;
> > + UINT8 Result;
> > +
> > + //
> > + // If Operand is <= MAX_UINT8, then it's a cast
> > + //
> > + Operand = 0xab;
> > + Result = 0;
> > + Status = SafeUint64ToUint8(Operand, &Result);
> > + UT_ASSERT_NOT_EFI_ERROR(Status);
> > + UT_ASSERT_EQUAL(0xab, Result);
> > +
> > + //
> > + // Otherwise should result in an error status
> > + //
> > + Operand = (0xababababefefefef);
> > + Status = SafeUint64ToUint8(Operand, &Result);
> > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> > +
> > + return UNIT_TEST_PASSED;
> > +}
> > +
> > +UNIT_TEST_STATUS
> > +EFIAPI
> > +TestSafeUint64ToInt16 (
> > + IN UNIT_TEST_CONTEXT Context
> > + )
> > +{
> > + EFI_STATUS Status;
> > + UINT64 Operand;
> > + INT16 Result;
> > +
> > + //
> > + // If Operand is <= MAX_INT16, then it's a cast
> > + //
> > + Operand = 0x5bab;
> > + Result = 0;
> > + Status = SafeUint64ToInt16(Operand, &Result);
> > + UT_ASSERT_NOT_EFI_ERROR(Status);
> > + UT_ASSERT_EQUAL(0x5bab, Result);
> > +
> > + //
> > + // Otherwise should result in an error status
> > + //
> > + Operand = (0xababababefefefef);
> > + Status = SafeUint64ToInt16(Operand, &Result);
> > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> > +
> > + return UNIT_TEST_PASSED;
> > +}
> > +
> > +UNIT_TEST_STATUS
> > +EFIAPI
> > +TestSafeUint64ToUint16 (
> > + IN UNIT_TEST_CONTEXT Context
> > + )
> > +{
> > + EFI_STATUS Status;
> > + UINT64 Operand;
> > + UINT16 Result;
> > +
> > + //
> > + // If Operand is <= MAX_UINT16, then it's a cast
> > + //
> > + Operand = 0xabab;
> > + Result = 0;
> > + Status = SafeUint64ToUint16(Operand, &Result);
> > + UT_ASSERT_NOT_EFI_ERROR(Status);
> > + UT_ASSERT_EQUAL(0xabab, Result);
> > +
> > + //
> > + // Otherwise should result in an error status
> > + //
> > + Operand = (0xababababefefefef);
> > + Status = SafeUint64ToUint16(Operand, &Result);
> > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> > +
> > + return UNIT_TEST_PASSED;
> > +}
> > +
> > +UNIT_TEST_STATUS
> > +EFIAPI
> > +TestSafeUint64ToInt32 (
> > + IN UNIT_TEST_CONTEXT Context
> > + )
> > +{
> > + EFI_STATUS Status;
> > + UINT64 Operand;
> > + INT32 Result;
> > +
> > + //
> > + // If Operand is <= MAX_INT32, then it's a cast
> > + //
> > + Operand = 0x5bababab;
> > + Result = 0;
> > + Status = SafeUint64ToInt32(Operand, &Result);
> > + UT_ASSERT_NOT_EFI_ERROR(Status);
> > + UT_ASSERT_EQUAL(0x5bababab, Result);
> > +
> > + //
> > + // Otherwise should result in an error status
> > + //
> > + Operand = (0xababababefefefef);
> > + Status = SafeUint64ToInt32(Operand, &Result);
> > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> > +
> > + return UNIT_TEST_PASSED;
> > +}
> > +
> > +UNIT_TEST_STATUS
> > +EFIAPI
> > +TestSafeUint64ToUint32 (
> > + IN UNIT_TEST_CONTEXT Context
> > + )
> > +{
> > + EFI_STATUS Status;
> > + UINT64 Operand;
> > + UINT32 Result;
> > +
> > + //
> > + // If Operand is <= MAX_UINT32, then it's a cast
> > + //
> > + Operand = 0xabababab;
> > + Result = 0;
> > + Status = SafeUint64ToUint32(Operand, &Result);
> > + UT_ASSERT_NOT_EFI_ERROR(Status);
> > + UT_ASSERT_EQUAL(0xabababab, Result);
> > +
> > + //
> > + // Otherwise should result in an error status
> > + //
> > + Operand = (0xababababefefefef);
> > + Status = SafeUint64ToUint32(Operand, &Result);
> > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> > +
> > + return UNIT_TEST_PASSED;
> > +}
> > +
> > +UNIT_TEST_STATUS
> > +EFIAPI
> > +TestSafeUint64ToInt64 (
> > + IN UNIT_TEST_CONTEXT Context
> > + )
> > +{
> > + EFI_STATUS Status;
> > + UINT64 Operand;
> > + INT64 Result;
> > +
> > + //
> > + // If Operand is <= MAX_INT64, then it's a cast
> > + //
> > + Operand = 0x5babababefefefef;
> > + Result = 0;
> > + Status = SafeUint64ToInt64(Operand, &Result);
> > + UT_ASSERT_NOT_EFI_ERROR(Status);
> > + UT_ASSERT_EQUAL(0x5babababefefefef, Result);
> > +
> > + //
> > + // Otherwise should result in an error status
> > + //
> > + Operand = (0xababababefefefef);
> > + Status = SafeUint64ToInt64(Operand, &Result);
> > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> > +
> > + return UNIT_TEST_PASSED;
> > +}
> > +
> > +//
> > +// Addition function tests:
> > +//
> > +UNIT_TEST_STATUS
> > +EFIAPI
> > +TestSafeUint8Add (
> > + IN UNIT_TEST_CONTEXT Context
> > + )
> > +{
> > + EFI_STATUS Status;
> > + UINT8 Augend;
> > + UINT8 Addend;
> > + UINT8 Result;
> > +
> > + //
> > + // If the result of addition doesn't overflow
> MAX_UINT8, then it's addition
> > + //
> > + Augend = 0x3a;
> > + Addend = 0x3a;
> > + Result = 0;
> > + Status = SafeUint8Add(Augend, Addend, &Result);
> > + UT_ASSERT_NOT_EFI_ERROR(Status);
> > + UT_ASSERT_EQUAL(0x74, Result);
> > +
> > + //
> > + // Otherwise should result in an error status
> > + //
> > + Augend = 0xab;
> > + Addend = 0xbc;
> > + Status = SafeUint8Add(Augend, Addend, &Result);
> > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> > +
> > + return UNIT_TEST_PASSED;
> > +}
> > +
> > +UNIT_TEST_STATUS
> > +EFIAPI
> > +TestSafeUint16Add (
> > + IN UNIT_TEST_CONTEXT Context
> > + )
> > +{
> > + EFI_STATUS Status;
> > + UINT16 Augend = 0x3a3a;
> > + UINT16 Addend = 0x3a3a;
> > + UINT16 Result = 0;
> > +
> > + //
> > + // If the result of addition doesn't overflow
> MAX_UINT16, then it's addition
> > + //
> > + Status = SafeUint16Add(Augend, Addend, &Result);
> > + UT_ASSERT_NOT_EFI_ERROR(Status);
> > + UT_ASSERT_EQUAL(0x7474, Result);
> > +
> > + //
> > + // Otherwise should result in an error status
> > + //
> > + Augend = 0xabab;
> > + Addend = 0xbcbc;
> > + Status = SafeUint16Add(Augend, Addend, &Result);
> > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> > +
> > + return UNIT_TEST_PASSED;
> > +}
> > +
> > +UNIT_TEST_STATUS
> > +EFIAPI
> > +TestSafeUint32Add (
> > + IN UNIT_TEST_CONTEXT Context
> > + )
> > +{
> > + EFI_STATUS Status;
> > + UINT32 Augend;
> > + UINT32 Addend;
> > + UINT32 Result;
> > +
> > + //
> > + // If the result of addition doesn't overflow
> MAX_UINT32, then it's addition
> > + //
> > + Augend = 0x3a3a3a3a;
> > + Addend = 0x3a3a3a3a;
> > + Result = 0;
> > + Status = SafeUint32Add(Augend, Addend, &Result);
> > + UT_ASSERT_NOT_EFI_ERROR(Status);
> > + UT_ASSERT_EQUAL(0x74747474, Result);
> > +
> > + //
> > + // Otherwise should result in an error status
> > + //
> > + Augend = 0xabababab;
> > + Addend = 0xbcbcbcbc;
> > + Status = SafeUint32Add(Augend, Addend, &Result);
> > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> > +
> > + return UNIT_TEST_PASSED;
> > +}
> > +
> > +UNIT_TEST_STATUS
> > +EFIAPI
> > +TestSafeUint64Add (
> > + IN UNIT_TEST_CONTEXT Context
> > + )
> > +{
> > + EFI_STATUS Status;
> > + UINT64 Augend;
> > + UINT64 Addend;
> > + UINT64 Result;
> > +
> > + //
> > + // If the result of addition doesn't overflow
> MAX_UINT64, then it's addition
> > + //
> > + Augend = 0x3a3a3a3a12121212;
> > + Addend = 0x3a3a3a3a12121212;
> > + Result = 0;
> > + Status = SafeUint64Add(Augend, Addend, &Result);
> > + UT_ASSERT_NOT_EFI_ERROR(Status);
> > + UT_ASSERT_EQUAL(0x7474747424242424, Result);
> > +
> > + //
> > + // Otherwise should result in an error status
> > + //
> > + Augend = 0xababababefefefef;
> > + Addend = 0xbcbcbcbcdededede;
> > + Status = SafeUint64Add(Augend, Addend, &Result);
> > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> > +
> > + return UNIT_TEST_PASSED;
> > +}
> > +
> > +UNIT_TEST_STATUS
> > +EFIAPI
> > +TestSafeInt8Add (
> > + IN UNIT_TEST_CONTEXT Context
> > + )
> > +{
> > + EFI_STATUS Status;
> > + INT8 Augend;
> > + INT8 Addend;
> > + INT8 Result;
> > +
> > + //
> > + // If the result of addition doesn't overflow
> MAX_INT8
> > + // and doesn't underflow MIN_INT8, then it's
> addition
> > + //
> > + Augend = 0x3a;
> > + Addend = 0x3a;
> > + Result = 0;
> > + Status = SafeInt8Add(Augend, Addend, &Result);
> > + UT_ASSERT_NOT_EFI_ERROR(Status);
> > + UT_ASSERT_EQUAL(0x74, Result);
> > +
> > + Augend = (-58);
> > + Addend = (-58);
> > + Status = SafeInt8Add(Augend, Addend, &Result);
> > + UT_ASSERT_NOT_EFI_ERROR(Status);
> > + UT_ASSERT_EQUAL((-116), Result);
> > +
> > + //
> > + // Otherwise should result in an error status
> > + //
> > + Augend = 0x5a;
> > + Addend = 0x5a;
> > + Status = SafeInt8Add(Augend, Addend, &Result);
> > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> > +
> > + Augend = (-90);
> > + Addend = (-90);
> > + Status = SafeInt8Add(Augend, Addend, &Result);
> > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> > +
> > + return UNIT_TEST_PASSED;
> > +
> > +}
> > +
> > +UNIT_TEST_STATUS
> > +EFIAPI
> > +TestSafeInt16Add (
> > + IN UNIT_TEST_CONTEXT Context
> > + )
> > +{
> > + EFI_STATUS Status;
> > + INT16 Augend;
> > + INT16 Addend;
> > + INT16 Result;
> > +
> > + //
> > + // If the result of addition doesn't overflow
> MAX_INT16
> > + // and doesn't underflow MIN_INT16, then it's
> addition
> > + //
> > + Augend = 0x3a3a;
> > + Addend = 0x3a3a;
> > + Result = 0;
> > + Status = SafeInt16Add(Augend, Addend, &Result);
> > + UT_ASSERT_NOT_EFI_ERROR(Status);
> > + UT_ASSERT_EQUAL(0x7474, Result);
> > +
> > + Augend = (-14906);
> > + Addend = (-14906);
> > + Status = SafeInt16Add(Augend, Addend, &Result);
> > + UT_ASSERT_NOT_EFI_ERROR(Status);
> > + UT_ASSERT_EQUAL((-29812), Result);
> > +
> > + //
> > + // Otherwise should result in an error status
> > + //
> > + Augend = 0x5a5a;
> > + Addend = 0x5a5a;
> > + Status = SafeInt16Add(Augend, Addend, &Result);
> > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> > +
> > + Augend = (-23130);
> > + Addend = (-23130);
> > + Status = SafeInt16Add(Augend, Addend, &Result);
> > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> > +
> > + return UNIT_TEST_PASSED;
> > +}
> > +
> > +UNIT_TEST_STATUS
> > +EFIAPI
> > +TestSafeInt32Add (
> > + IN UNIT_TEST_CONTEXT Context
> > + )
> > +{
> > + EFI_STATUS Status;
> > + INT32 Augend;
> > + INT32 Addend;
> > + INT32 Result;
> > +
> > + //
> > + // If the result of addition doesn't overflow
> MAX_INT32
> > + // and doesn't underflow MIN_INT32, then it's
> addition
> > + //
> > + Augend = 0x3a3a3a3a;
> > + Addend = 0x3a3a3a3a;
> > + Result = 0;
> > + Status = SafeInt32Add(Augend, Addend, &Result);
> > + UT_ASSERT_NOT_EFI_ERROR(Status);
> > + UT_ASSERT_EQUAL(0x74747474, Result);
> > +
> > + Augend = (-976894522);
> > + Addend = (-976894522);
> > + Status = SafeInt32Add(Augend, Addend, &Result);
> > + UT_ASSERT_NOT_EFI_ERROR(Status);
> > + UT_ASSERT_EQUAL((-1953789044), Result);
> > +
> > + //
> > + // Otherwise should result in an error status
> > + //
> > + Augend = 0x5a5a5a5a;
> > + Addend = 0x5a5a5a5a;
> > + Status = SafeInt32Add(Augend, Addend, &Result);
> > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> > +
> > + Augend = (-1515870810);
> > + Addend = (-1515870810);
> > + Status = SafeInt32Add(Augend, Addend, &Result);
> > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> > +
> > + return UNIT_TEST_PASSED;
> > +}
> > +
> > +UNIT_TEST_STATUS
> > +EFIAPI
> > +TestSafeInt64Add (
> > + IN UNIT_TEST_CONTEXT Context
> > + )
> > +{
> > + EFI_STATUS Status;
> > + INT64 Augend;
> > + INT64 Addend;
> > + INT64 Result;
> > +
> > + //
> > + // If the result of addition doesn't overflow
> MAX_INT64
> > + // and doesn't underflow MIN_INT64, then it's
> addition
> > + //
> > + Augend = 0x3a3a3a3a3a3a3a3a;
> > + Addend = 0x3a3a3a3a3a3a3a3a;
> > + Result = 0;
> > + Status = SafeInt64Add(Augend, Addend, &Result);
> > + UT_ASSERT_NOT_EFI_ERROR(Status);
> > + UT_ASSERT_EQUAL(0x7474747474747474, Result);
> > +
> > + Augend = (-4195730024608447034);
> > + Addend = (-4195730024608447034);
> > + Status = SafeInt64Add(Augend, Addend, &Result);
> > + UT_ASSERT_NOT_EFI_ERROR(Status);
> > + UT_ASSERT_EQUAL((-8391460049216894068), Result);
> > +
> > + //
> > + // Otherwise should result in an error status
> > + //
> > + Augend = 0x5a5a5a5a5a5a5a5a;
> > + Addend = 0x5a5a5a5a5a5a5a5a;
> > + Status = SafeInt64Add(Augend, Addend, &Result);
> > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> > +
> > + Augend = (-6510615555426900570);
> > + Addend = (-6510615555426900570);
> > + Status = SafeInt64Add(Augend, Addend, &Result);
> > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> > +
> > + return UNIT_TEST_PASSED;
> > +}
> > +
> > +//
> > +// Subtraction function tests:
> > +//
> > +UNIT_TEST_STATUS
> > +EFIAPI
> > +TestSafeUint8Sub (
> > + IN UNIT_TEST_CONTEXT Context
> > + )
> > +{
> > + EFI_STATUS Status;
> > + UINT8 Minuend;
> > + UINT8 Subtrahend;
> > + UINT8 Result;
> > +
> > + //
> > + // If Minuend >= Subtrahend, then it's subtraction
> > + //
> > + Minuend = 0x5a;
> > + Subtrahend = 0x3b;
> > + Result = 0;
> > + Status = SafeUint8Sub(Minuend, Subtrahend,
> &Result);
> > + UT_ASSERT_NOT_EFI_ERROR(Status);
> > + UT_ASSERT_EQUAL(0x1f, Result);
> > +
> > + //
> > + // Otherwise should result in an error status
> > + //
> > + Minuend = 0x5a;
> > + Subtrahend = 0x6d;
> > + Status = SafeUint8Sub(Minuend, Subtrahend,
> &Result);
> > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> > +
> > + return UNIT_TEST_PASSED;
> > +}
> > +
> > +UNIT_TEST_STATUS
> > +EFIAPI
> > +TestSafeUint16Sub (
> > + IN UNIT_TEST_CONTEXT Context
> > + )
> > +{
> > + EFI_STATUS Status;
> > + UINT16 Minuend;
> > + UINT16 Subtrahend;
> > + UINT16 Result;
> > +
> > + //
> > + // If Minuend >= Subtrahend, then it's subtraction
> > + //
> > + Minuend = 0x5a5a;
> > + Subtrahend = 0x3b3b;
> > + Result = 0;
> > + Status = SafeUint16Sub(Minuend, Subtrahend,
> &Result);
> > + UT_ASSERT_NOT_EFI_ERROR(Status);
> > + UT_ASSERT_EQUAL(0x1f1f, Result);
> > +
> > + //
> > + // Otherwise should result in an error status
> > + //
> > + Minuend = 0x5a5a;
> > + Subtrahend = 0x6d6d;
> > + Status = SafeUint16Sub(Minuend, Subtrahend,
> &Result);
> > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> > +
> > + return UNIT_TEST_PASSED;
> > +}
> > +
> > +UNIT_TEST_STATUS
> > +EFIAPI
> > +TestSafeUint32Sub (
> > + IN UNIT_TEST_CONTEXT Context
> > + )
> > +{
> > + EFI_STATUS Status;
> > + UINT32 Minuend;
> > + UINT32 Subtrahend;
> > + UINT32 Result;
> > +
> > + //
> > + // If Minuend >= Subtrahend, then it's subtraction
> > + //
> > + Minuend = 0x5a5a5a5a;
> > + Subtrahend = 0x3b3b3b3b;
> > + Result = 0;
> > + Status = SafeUint32Sub(Minuend, Subtrahend,
> &Result);
> > + UT_ASSERT_NOT_EFI_ERROR(Status);
> > + UT_ASSERT_EQUAL(0x1f1f1f1f, Result);
> > +
> > + //
> > + // Otherwise should result in an error status
> > + //
> > + Minuend = 0x5a5a5a5a;
> > + Subtrahend = 0x6d6d6d6d;
> > + Status = SafeUint32Sub(Minuend, Subtrahend,
> &Result);
> > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> > +
> > + return UNIT_TEST_PASSED;
> > +}
> > +
> > +UNIT_TEST_STATUS
> > +EFIAPI
> > +TestSafeUint64Sub (
> > + IN UNIT_TEST_CONTEXT Context
> > + )
> > +{
> > + EFI_STATUS Status;
> > + UINT64 Minuend;
> > + UINT64 Subtrahend;
> > + UINT64 Result;
> > +
> > + //
> > + // If Minuend >= Subtrahend, then it's subtraction
> > + //
> > + Minuend = 0x5a5a5a5a5a5a5a5a;
> > + Subtrahend = 0x3b3b3b3b3b3b3b3b;
> > + Result = 0;
> > + Status = SafeUint64Sub(Minuend, Subtrahend,
> &Result);
> > + UT_ASSERT_NOT_EFI_ERROR(Status);
> > + UT_ASSERT_EQUAL(0x1f1f1f1f1f1f1f1f, Result);
> > +
> > + //
> > + // Otherwise should result in an error status
> > + //
> > + Minuend = 0x5a5a5a5a5a5a5a5a;
> > + Subtrahend = 0x6d6d6d6d6d6d6d6d;
> > + Status = SafeUint64Sub(Minuend, Subtrahend,
> &Result);
> > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> > +
> > + return UNIT_TEST_PASSED;
> > +}
> > +
> > +UNIT_TEST_STATUS
> > +EFIAPI
> > +TestSafeInt8Sub (
> > + IN UNIT_TEST_CONTEXT Context
> > + )
> > +{
> > + EFI_STATUS Status;
> > + INT8 Minuend;
> > + INT8 Subtrahend;
> > + INT8 Result;
> > +
> > + //
> > + // If the result of subtractions doesn't overflow
> MAX_INT8 or
> > + // underflow MIN_INT8, then it's subtraction
> > + //
> > + Minuend = 0x5a;
> > + Subtrahend = 0x3a;
> > + Result = 0;
> > + Status = SafeInt8Sub(Minuend, Subtrahend,
> &Result);
> > + UT_ASSERT_NOT_EFI_ERROR(Status);
> > + UT_ASSERT_EQUAL(0x20, Result);
> > +
> > + Minuend = 58;
> > + Subtrahend = 78;
> > + Status = SafeInt8Sub(Minuend, Subtrahend,
> &Result);
> > + UT_ASSERT_NOT_EFI_ERROR(Status);
> > + UT_ASSERT_EQUAL((-20), Result);
> > +
> > + //
> > + // Otherwise should result in an error status
> > + //
> > + Minuend = (-80);
> > + Subtrahend = 80;
> > + Status = SafeInt8Sub(Minuend, Subtrahend,
> &Result);
> > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> > +
> > + Minuend = (80);
> > + Subtrahend = (-80);
> > + Status = SafeInt8Sub(Minuend, Subtrahend,
> &Result);
> > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> > +
> > + return UNIT_TEST_PASSED;
> > +}
> > +
> > +UNIT_TEST_STATUS
> > +EFIAPI
> > +TestSafeInt16Sub (
> > + IN UNIT_TEST_CONTEXT Context
> > + )
> > +{
> > + EFI_STATUS Status;
> > + INT16 Minuend;
> > + INT16 Subtrahend;
> > + INT16 Result;
> > +
> > + //
> > + // If the result of subtractions doesn't overflow
> MAX_INT16 or
> > + // underflow MIN_INT16, then it's subtraction
> > + //
> > + Minuend = 0x5a5a;
> > + Subtrahend = 0x3a3a;
> > + Result = 0;
> > + Status = SafeInt16Sub(Minuend, Subtrahend,
> &Result);
> > + UT_ASSERT_NOT_EFI_ERROR(Status);
> > + UT_ASSERT_EQUAL(0x2020, Result);
> > +
> > + Minuend = 0x3a3a;
> > + Subtrahend = 0x5a5a;
> > + Status = SafeInt16Sub(Minuend, Subtrahend,
> &Result);
> > + UT_ASSERT_NOT_EFI_ERROR(Status);
> > + UT_ASSERT_EQUAL((-8224), Result);
> > +
> > + //
> > + // Otherwise should result in an error status
> > + //
> > + Minuend = (-31354);
> > + Subtrahend = 31354;
> > + Status = SafeInt16Sub(Minuend, Subtrahend,
> &Result);
> > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> > +
> > + Minuend = (31354);
> > + Subtrahend = (-31354);
> > + Status = SafeInt16Sub(Minuend, Subtrahend,
> &Result);
> > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> > +
> > + return UNIT_TEST_PASSED;
> > +}
> > +
> > +UNIT_TEST_STATUS
> > +EFIAPI
> > +TestSafeInt32Sub (
> > + IN UNIT_TEST_CONTEXT Context
> > + )
> > +{
> > + EFI_STATUS Status;
> > + INT32 Minuend;
> > + INT32 Subtrahend;
> > + INT32 Result;
> > +
> > + //
> > + // If the result of subtractions doesn't overflow
> MAX_INT32 or
> > + // underflow MIN_INT32, then it's subtraction
> > + //
> > + Minuend = 0x5a5a5a5a;
> > + Subtrahend = 0x3a3a3a3a;
> > + Result = 0;
> > + Status = SafeInt32Sub(Minuend, Subtrahend,
> &Result);
> > + UT_ASSERT_NOT_EFI_ERROR(Status);
> > + UT_ASSERT_EQUAL(0x20202020, Result);
> > +
> > + Minuend = 0x3a3a3a3a;
> > + Subtrahend = 0x5a5a5a5a;
> > + Status = SafeInt32Sub(Minuend, Subtrahend,
> &Result);
> > + UT_ASSERT_NOT_EFI_ERROR(Status);
> > + UT_ASSERT_EQUAL((-538976288), Result);
> > +
> > + //
> > + // Otherwise should result in an error status
> > + //
> > + Minuend = (-2054847098);
> > + Subtrahend = 2054847098;
> > + Status = SafeInt32Sub(Minuend, Subtrahend,
> &Result);
> > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> > +
> > + Minuend = (2054847098);
> > + Subtrahend = (-2054847098);
> > + Status = SafeInt32Sub(Minuend, Subtrahend,
> &Result);
> > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> > +
> > + return UNIT_TEST_PASSED;
> > +}
> > +
> > +UNIT_TEST_STATUS
> > +EFIAPI
> > +TestSafeInt64Sub (
> > + IN UNIT_TEST_CONTEXT Context
> > + )
> > +{
> > + EFI_STATUS Status;
> > + INT64 Minuend;
> > + INT64 Subtrahend;
> > + INT64 Result;
> > +
> > + //
> > + // If the result of subtractions doesn't overflow
> MAX_INT64 or
> > + // underflow MIN_INT64, then it's subtraction
> > + //
> > + Minuend = 0x5a5a5a5a5a5a5a5a;
> > + Subtrahend = 0x3a3a3a3a3a3a3a3a;
> > + Result = 0;
> > + Status = SafeInt64Sub(Minuend, Subtrahend,
> &Result);
> > + UT_ASSERT_NOT_EFI_ERROR(Status);
> > + UT_ASSERT_EQUAL(0x2020202020202020, Result);
> > +
> > + Minuend = 0x3a3a3a3a3a3a3a3a;
> > + Subtrahend = 0x5a5a5a5a5a5a5a5a;
> > + Status = SafeInt64Sub(Minuend, Subtrahend,
> &Result);
> > + UT_ASSERT_NOT_EFI_ERROR(Status);
> > + UT_ASSERT_EQUAL((-2314885530818453536), Result);
> > +
> > + //
> > + // Otherwise should result in an error status
> > + //
> > + Minuend = (-8825501086245354106);
> > + Subtrahend = 8825501086245354106;
> > + Status = SafeInt64Sub(Minuend, Subtrahend,
> &Result);
> > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> > +
> > + Minuend = (8825501086245354106);
> > + Subtrahend = (-8825501086245354106);
> > + Status = SafeInt64Sub(Minuend, Subtrahend,
> &Result);
> > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> > +
> > + return UNIT_TEST_PASSED;
> > +}
> > +
> > +//
> > +// Multiplication function tests:
> > +//
> > +UNIT_TEST_STATUS
> > +EFIAPI
> > +TestSafeUint8Mult (
> > + IN UNIT_TEST_CONTEXT Context
> > + )
> > +{
> > + EFI_STATUS Status;
> > + UINT8 Multiplicand;
> > + UINT8 Multiplier;
> > + UINT8 Result;
> > +
> > + //
> > + // If the result of multiplication doesn't
> overflow MAX_UINT8, it will succeed
> > + //
> > + Multiplicand = 0x12;
> > + Multiplier = 0xa;
> > + Result = 0;
> > + Status = SafeUint8Mult(Multiplicand, Multiplier,
> &Result);
> > + UT_ASSERT_NOT_EFI_ERROR(Status);
> > + UT_ASSERT_EQUAL(0xb4, Result);
> > +
> > + //
> > + // Otherwise should result in an error status
> > + //
> > + Multiplicand = 0x12;
> > + Multiplier = 0x23;
> > + Status = SafeUint8Mult(Multiplicand, Multiplier,
> &Result);
> > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> > +
> > + return UNIT_TEST_PASSED;
> > +}
> > +
> > +UNIT_TEST_STATUS
> > +EFIAPI
> > +TestSafeUint16Mult (
> > + IN UNIT_TEST_CONTEXT Context
> > + )
> > +{
> > + EFI_STATUS Status;
> > + UINT16 Multiplicand;
> > + UINT16 Multiplier;
> > + UINT16 Result;
> > +
> > + //
> > + // If the result of multiplication doesn't
> overflow MAX_UINT16, it will succeed
> > + //
> > + Multiplicand = 0x212;
> > + Multiplier = 0x7a;
> > + Result = 0;
> > + Status = SafeUint16Mult(Multiplicand, Multiplier,
> &Result);
> > + UT_ASSERT_NOT_EFI_ERROR(Status);
> > + UT_ASSERT_EQUAL(0xfc94, Result);
> > +
> > + //
> > + // Otherwise should result in an error status
> > + //
> > + Multiplicand = 0x1234;
> > + Multiplier = 0x213;
> > + Status = SafeUint16Mult(Multiplicand, Multiplier,
> &Result);
> > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> > +
> > + return UNIT_TEST_PASSED;
> > +}
> > +
> > +UNIT_TEST_STATUS
> > +EFIAPI
> > +TestSafeUint32Mult (
> > + IN UNIT_TEST_CONTEXT Context
> > + )
> > +{
> > + EFI_STATUS Status;
> > + UINT32 Multiplicand;
> > + UINT32 Multiplier;
> > + UINT32 Result;
> > +
> > + //
> > + // If the result of multiplication doesn't
> overflow MAX_UINT32, it will succeed
> > + //
> > + Multiplicand = 0xa122a;
> > + Multiplier = 0xd23;
> > + Result = 0;
> > + Status = SafeUint32Mult(Multiplicand, Multiplier,
> &Result);
> > + UT_ASSERT_NOT_EFI_ERROR(Status);
> > + UT_ASSERT_EQUAL(0x844c9dbe, Result);
> > +
> > + //
> > + // Otherwise should result in an error status
> > + //
> > + Multiplicand = 0xa122a;
> > + Multiplier = 0xed23;
> > + Status = SafeUint32Mult(Multiplicand, Multiplier,
> &Result);
> > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> > +
> > + return UNIT_TEST_PASSED;
> > +}
> > +
> > +UNIT_TEST_STATUS
> > +EFIAPI
> > +TestSafeUint64Mult (
> > + IN UNIT_TEST_CONTEXT Context
> > + )
> > +{
> > + EFI_STATUS Status;
> > + UINT64 Multiplicand;
> > + UINT64 Multiplier;
> > + UINT64 Result;
> > +
> > + //
> > + // If the result of multiplication doesn't
> overflow MAX_UINT64, it will succeed
> > + //
> > + Multiplicand = 0x123456789a;
> > + Multiplier = 0x1234567;
> > + Result = 0;
> > + Status = SafeUint64Mult(Multiplicand, Multiplier,
> &Result);
> > + UT_ASSERT_NOT_EFI_ERROR(Status);
> > + UT_ASSERT_EQUAL(0x14b66db9745a07f6, Result);
> > +
> > + //
> > + // Otherwise should result in an error status
> > + //
> > + Multiplicand = 0x123456789a;
> > + Multiplier = 0x12345678;
> > + Status = SafeUint64Mult(Multiplicand, Multiplier,
> &Result);
> > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> > +
> > + return UNIT_TEST_PASSED;
> > +}
> > +
> > +UNIT_TEST_STATUS
> > +EFIAPI
> > +TestSafeInt8Mult (
> > + IN UNIT_TEST_CONTEXT Context
> > + )
> > +{
> > + EFI_STATUS Status;
> > + INT8 Multiplicand;
> > + INT8 Multiplier;
> > + INT8 Result;
> > +
> > + //
> > + // If the result of multiplication doesn't
> overflow MAX_INT8 and doesn't
> > + // underflow MIN_UINT8, it will succeed
> > + //
> > + Multiplicand = 0x12;
> > + Multiplier = 0x7;
> > + Result = 0;
> > + Status = SafeInt8Mult(Multiplicand, Multiplier,
> &Result);
> > + UT_ASSERT_NOT_EFI_ERROR(Status);
> > + UT_ASSERT_EQUAL(0x7e, Result);
> > +
> > + //
> > + // Otherwise should result in an error status
> > + //
> > + Multiplicand = 0x12;
> > + Multiplier = 0xa;
> > + Status = SafeInt8Mult(Multiplicand, Multiplier,
> &Result);
> > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> > +
> > + return UNIT_TEST_PASSED;
> > +}
> > +
> > +UNIT_TEST_STATUS
> > +EFIAPI
> > +TestSafeInt16Mult (
> > + IN UNIT_TEST_CONTEXT Context
> > + )
> > +{
> > + EFI_STATUS Status;
> > + INT16 Multiplicand;
> > + INT16 Multiplier;
> > + INT16 Result;
> > +
> > + //
> > + // If the result of multiplication doesn't
> overflow MAX_INT16 and doesn't
> > + // underflow MIN_UINT16, it will succeed
> > + //
> > + Multiplicand = 0x123;
> > + Multiplier = 0x67;
> > + Result = 0;
> > + Status = SafeInt16Mult(Multiplicand, Multiplier,
> &Result);
> > + UT_ASSERT_NOT_EFI_ERROR(Status);
> > + UT_ASSERT_EQUAL(0x7515, Result);
> > +
> > + //
> > + // Otherwise should result in an error status
> > + //
> > + Multiplicand = 0x123;
> > + Multiplier = 0xab;
> > + Status = SafeInt16Mult(Multiplicand, Multiplier,
> &Result);
> > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> > +
> > + return UNIT_TEST_PASSED;
> > +}
> > +
> > +UNIT_TEST_STATUS
> > +EFIAPI
> > +TestSafeInt32Mult (
> > + IN UNIT_TEST_CONTEXT Context
> > + )
> > +{
> > + EFI_STATUS Status;
> > + INT32 Multiplicand;
> > + INT32 Multiplier;
> > + INT32 Result;
> > +
> > + //
> > + // If the result of multiplication doesn't
> overflow MAX_INT32 and doesn't
> > + // underflow MIN_UINT32, it will succeed
> > + //
> > + Multiplicand = 0x123456;
> > + Multiplier = 0x678;
> > + Result = 0;
> > + Status = SafeInt32Mult(Multiplicand, Multiplier,
> &Result);
> > + UT_ASSERT_NOT_EFI_ERROR(Status);
> > + UT_ASSERT_EQUAL(0x75c28c50, Result);
> > +
> > + //
> > + // Otherwise should result in an error status
> > + //
> > + Multiplicand = 0x123456;
> > + Multiplier = 0xabc;
> > + Status = SafeInt32Mult(Multiplicand, Multiplier,
> &Result);
> > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> > +
> > + return UNIT_TEST_PASSED;
> > +}
> > +
> > +UNIT_TEST_STATUS
> > +EFIAPI
> > +TestSafeInt64Mult (
> > + IN UNIT_TEST_CONTEXT Context
> > + )
> > +{
> > + EFI_STATUS Status;
> > + INT64 Multiplicand;
> > + INT64 Multiplier;
> > + INT64 Result;
> > +
> > + //
> > + // If the result of multiplication doesn't
> overflow MAX_INT64 and doesn't
> > + // underflow MIN_UINT64, it will succeed
> > + //
> > + Multiplicand = 0x123456789;
> > + Multiplier = 0x6789abcd;
> > + Result = 0;
> > + Status = SafeInt64Mult(Multiplicand, Multiplier,
> &Result);
> > + UT_ASSERT_NOT_EFI_ERROR(Status);
> > + UT_ASSERT_EQUAL(0x75cd9045220d6bb5, Result);
> > +
> > + //
> > + // Otherwise should result in an error status
> > + //
> > + Multiplicand = 0x123456789;
> > + Multiplier = 0xa789abcd;
> > + Status = SafeInt64Mult(Multiplicand, Multiplier,
> &Result);
> > + UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);
> > +
> > + return UNIT_TEST_PASSED;
> > +}
> > +
> > +/**
> > +
> > + Main fuction sets up the unit test environment
> > +
> > +**/
> > +EFI_STATUS
> > +EFIAPI
> > +UefiTestMain (
> > + VOID
> > + )
> > +{
> > + EFI_STATUS Status;
> > + UNIT_TEST_FRAMEWORK_HANDLE Framework;
> > + UNIT_TEST_SUITE_HANDLE ConversionTestSuite;
> > + UNIT_TEST_SUITE_HANDLE
> AdditionSubtractionTestSuite;
> > + UNIT_TEST_SUITE_HANDLE
> MultiplicationTestSuite;
> > +
> > + Framework = NULL;
> > + ConversionTestSuite = NULL;
> > + AdditionSubtractionTestSuite = NULL;
> > + MultiplicationTestSuite = NULL;
> > +
> > + DEBUG((DEBUG_INFO, "%a v%a\n", UNIT_TEST_NAME,
> UNIT_TEST_VERSION));
> > +
> > + //
> > + // Start setting up the test framework for running
> the tests.
> > + //
> > + Status = InitUnitTestFramework (&Framework,
> UNIT_TEST_NAME, gEfiCallerBaseName, UNIT_TEST_VERSION);
> > + if (EFI_ERROR(Status)) {
> > + DEBUG((DEBUG_ERROR, "Failed in
> InitUnitTestFramework. Status = %r\n", Status));
> > + goto EXIT;
> > + }
> > +
> > + ///
> > + // Test the conversion functions
> > + //
> > + Status = CreateUnitTestSuite
> (&ConversionTestSuite, Framework, "Int Safe Conversions
> Test Suite", "Common.SafeInt.Convert", NULL,
> > NULL);
> > + if (EFI_ERROR(Status)) {
> > + DEBUG((DEBUG_ERROR, "Failed in
> CreateUnitTestSuite for Conversions Test Suite\n"));
> > + Status = EFI_OUT_OF_RESOURCES;
> > + goto EXIT;
> > + }
> > + AddTestCase(ConversionTestSuite, "Test
> SafeInt8ToUint8", "TestSafeInt8ToUint8",
> TestSafeInt8ToUint8, NULL, NULL, NULL);
> > + AddTestCase(ConversionTestSuite, "Test
> SafeInt8ToUint16", "TestSafeInt8ToUint16",
> TestSafeInt8ToUint16, NULL, NULL, NULL);
> > + AddTestCase(ConversionTestSuite, "Test
> SafeInt8ToUint32", "TestSafeInt8ToUint32",
> TestSafeInt8ToUint32, NULL, NULL, NULL);
> > + AddTestCase(ConversionTestSuite, "Test
> SafeInt8ToUintn", "TestSafeInt8ToUintn",
> TestSafeInt8ToUintn, NULL, NULL, NULL);
> > + AddTestCase(ConversionTestSuite, "Test
> SafeInt8ToUint64", "TestSafeInt8ToUint64",
> TestSafeInt8ToUint64, NULL, NULL, NULL);
> > + AddTestCase(ConversionTestSuite, "Test
> SafeUint8ToInt8", "TestSafeUint8ToInt8",
> TestSafeUint8ToInt8, NULL, NULL, NULL);
> > + AddTestCase(ConversionTestSuite, "Test
> SafeUint8ToChar8", "TestSafeUint8ToChar8",
> TestSafeUint8ToChar8, NULL, NULL, NULL);
> > + AddTestCase(ConversionTestSuite, "Test
> SafeInt16ToInt8", "TestSafeInt16ToInt8",
> TestSafeInt16ToInt8, NULL, NULL, NULL);
> > + AddTestCase(ConversionTestSuite, "Test
> SafeInt16ToChar8", "TestSafeInt16ToChar8",
> TestSafeInt16ToChar8, NULL, NULL, NULL);
> > + AddTestCase(ConversionTestSuite, "Test
> SafeInt16ToUint8", "TestSafeInt16ToUint8",
> TestSafeInt16ToUint8, NULL, NULL, NULL);
> > + AddTestCase(ConversionTestSuite, "Test
> SafeInt16ToUint16", "TestSafeInt16ToUint16",
> TestSafeInt16ToUint16, NULL, NULL, NULL);
> > + AddTestCase(ConversionTestSuite, "Test
> SafeInt16ToUint32", "TestSafeInt16ToUint32",
> TestSafeInt16ToUint32, NULL, NULL, NULL);
> > + AddTestCase(ConversionTestSuite, "Test
> SafeInt16ToUintn", "TestSafeInt16ToUintn",
> TestSafeInt16ToUintn, NULL, NULL, NULL);
> > + AddTestCase(ConversionTestSuite, "Test
> SafeInt16ToUint64", "TestSafeInt16ToUint64",
> TestSafeInt16ToUint64, NULL, NULL, NULL);
> > + AddTestCase(ConversionTestSuite, "Test
> SafeUint16ToInt8", "TestSafeUint16ToInt8",
> TestSafeUint16ToInt8, NULL, NULL, NULL);
> > + AddTestCase(ConversionTestSuite, "Test
> SafeUint16ToChar8", "TestSafeUint16ToChar8",
> TestSafeUint16ToChar8, NULL, NULL, NULL);
> > + AddTestCase(ConversionTestSuite, "Test
> SafeUint16ToUint8", "TestSafeUint16ToUint8",
> TestSafeUint16ToUint8, NULL, NULL, NULL);
> > + AddTestCase(ConversionTestSuite, "Test
> SafeUint16ToInt16", "TestSafeUint16ToInt16",
> TestSafeUint16ToInt16, NULL, NULL, NULL);
> > + AddTestCase(ConversionTestSuite, "Test
> SafeInt32ToInt8", "TestSafeInt32ToInt8",
> TestSafeInt32ToInt8, NULL, NULL, NULL);
> > + AddTestCase(ConversionTestSuite, "Test
> SafeInt32ToChar8", "TestSafeInt32ToChar8",
> TestSafeInt32ToChar8, NULL, NULL, NULL);
> > + AddTestCase(ConversionTestSuite, "Test
> SafeInt32ToUint8", "TestSafeInt32ToUint8",
> TestSafeInt32ToUint8, NULL, NULL, NULL);
> > + AddTestCase(ConversionTestSuite, "Test
> SafeInt32ToInt16", "TestSafeInt32ToInt16",
> TestSafeInt32ToInt16, NULL, NULL, NULL);
> > + AddTestCase(ConversionTestSuite, "Test
> SafeInt32ToUint16", "TestSafeInt32ToUint16",
> TestSafeInt32ToUint16, NULL, NULL, NULL);
> > + AddTestCase(ConversionTestSuite, "Test
> SafeInt32ToUint32", "TestSafeInt32ToUint32",
> TestSafeInt32ToUint32, NULL, NULL, NULL);
> > + AddTestCase(ConversionTestSuite, "Test
> SafeInt32ToUintn", "TestSafeInt32ToUintn",
> TestSafeInt32ToUintn, NULL, NULL, NULL);
> > + AddTestCase(ConversionTestSuite, "Test
> SafeInt32ToUint64", "TestSafeInt32ToUint64",
> TestSafeInt32ToUint64, NULL, NULL, NULL);
> > + AddTestCase(ConversionTestSuite, "Test
> SafeUint32ToInt8", "TestSafeUint32ToInt8",
> TestSafeUint32ToInt8, NULL, NULL, NULL);
> > + AddTestCase(ConversionTestSuite, "Test
> SafeUint32ToChar8", "TestSafeUint32ToChar8",
> TestSafeUint32ToChar8, NULL, NULL, NULL);
> > + AddTestCase(ConversionTestSuite, "Test
> SafeUint32ToUint8", "TestSafeUint32ToUint8",
> TestSafeUint32ToUint8, NULL, NULL, NULL);
> > + AddTestCase(ConversionTestSuite, "Test
> SafeUint32ToInt16", "TestSafeUint32ToInt16",
> TestSafeUint32ToInt16, NULL, NULL, NULL);
> > + AddTestCase(ConversionTestSuite, "Test
> SafeUint32ToUint16", "TestSafeUint32ToUint16",
> TestSafeUint32ToUint16, NULL, NULL,
> > NULL);
> > + AddTestCase(ConversionTestSuite, "Test
> SafeUint32ToInt32", "TestSafeUint32ToInt32",
> TestSafeUint32ToInt32, NULL, NULL, NULL);
> > + AddTestCase(ConversionTestSuite, "Test
> SafeUint32ToIntn", "TestSafeUint32ToIntn",
> TestSafeUint32ToIntn, NULL, NULL, NULL);
> > + AddTestCase(ConversionTestSuite, "Test
> SafeIntnToInt8", "TestSafeIntnToInt8",
> TestSafeIntnToInt8, NULL, NULL, NULL);
> > + AddTestCase(ConversionTestSuite, "Test
> SafeIntnToChar8", "TestSafeIntnToChar8",
> TestSafeIntnToChar8, NULL, NULL, NULL);
> > + AddTestCase(ConversionTestSuite, "Test
> SafeIntnToUint8", "TestSafeIntnToUint8",
> TestSafeIntnToUint8, NULL, NULL, NULL);
> > + AddTestCase(ConversionTestSuite, "Test
> SafeIntnToInt16", "TestSafeIntnToInt16",
> TestSafeIntnToInt16, NULL, NULL, NULL);
> > + AddTestCase(ConversionTestSuite, "Test
> SafeIntnToUint16", "TestSafeIntnToUint16",
> TestSafeIntnToUint16, NULL, NULL, NULL);
> > + AddTestCase(ConversionTestSuite, "Test
> SafeIntnToInt32", "TestSafeIntnToInt32",
> TestSafeIntnToInt32, NULL, NULL, NULL);
> > + AddTestCase(ConversionTestSuite, "Test
> SafeIntnToUint32", "TestSafeIntnToUint32",
> TestSafeIntnToUint32, NULL, NULL, NULL);
> > + AddTestCase(ConversionTestSuite, "Test
> SafeIntnToUintn", "TestSafeIntnToUintn",
> TestSafeIntnToUintn, NULL, NULL, NULL);
> > + AddTestCase(ConversionTestSuite, "Test
> SafeIntnToUint64", "TestSafeIntnToUint64",
> TestSafeIntnToUint64, NULL, NULL, NULL);
> > + AddTestCase(ConversionTestSuite, "Test
> SafeUintnToInt8", "TestSafeUintnToInt8",
> TestSafeUintnToInt8, NULL, NULL, NULL);
> > + AddTestCase(ConversionTestSuite, "Test
> SafeUintnToChar8", "TestSafeUintnToChar8",
> TestSafeUintnToChar8, NULL, NULL, NULL);
> > + AddTestCase(ConversionTestSuite, "Test
> SafeUintnToUint8", "TestSafeUintnToUint8",
> TestSafeUintnToUint8, NULL, NULL, NULL);
> > + AddTestCase(ConversionTestSuite, "Test
> SafeUintnToInt16", "TestSafeUintnToInt16",
> TestSafeUintnToInt16, NULL, NULL, NULL);
> > + AddTestCase(ConversionTestSuite, "Test
> SafeUintnToUint16", "TestSafeUintnToUint16",
> TestSafeUintnToUint16, NULL, NULL, NULL);
> > + AddTestCase(ConversionTestSuite, "Test
> SafeUintnToInt32", "TestSafeUintnToInt32",
> TestSafeUintnToInt32, NULL, NULL, NULL);
> > + AddTestCase(ConversionTestSuite, "Test
> SafeUintnToUint32", "TestSafeUintnToUint32",
> TestSafeUintnToUint32, NULL, NULL, NULL);
> > + AddTestCase(ConversionTestSuite, "Test
> SafeUintnToIntn", "TestSafeUintnToIntn",
> TestSafeUintnToIntn, NULL, NULL, NULL);
> > + AddTestCase(ConversionTestSuite, "Test
> SafeUintnToInt64", "TestSafeUintnToInt64",
> TestSafeUintnToInt64, NULL, NULL, NULL);
> > + AddTestCase(ConversionTestSuite, "Test
> SafeInt64ToInt8", "TestSafeInt64ToInt8",
> TestSafeInt64ToInt8, NULL, NULL, NULL);
> > + AddTestCase(ConversionTestSuite, "Test
> SafeInt64ToChar8", "TestSafeInt64ToChar8",
> TestSafeInt64ToChar8, NULL, NULL, NULL);
> > + AddTestCase(ConversionTestSuite, "Test
> SafeInt64ToUint8", "TestSafeInt64ToUint8",
> TestSafeInt64ToUint8, NULL, NULL, NULL);
> > + AddTestCase(ConversionTestSuite, "Test
> SafeInt64ToInt16", "TestSafeInt64ToInt16",
> TestSafeInt64ToInt16, NULL, NULL, NULL);
> > + AddTestCase(ConversionTestSuite, "Test
> SafeInt64ToUint16", "TestSafeInt64ToUint16",
> TestSafeInt64ToUint16, NULL, NULL, NULL);
> > + AddTestCase(ConversionTestSuite, "Test
> SafeInt64ToInt32", "TestSafeInt64ToInt32",
> TestSafeInt64ToInt32, NULL, NULL, NULL);
> > + AddTestCase(ConversionTestSuite, "Test
> SafeInt64ToUint32", "TestSafeInt64ToUint32",
> TestSafeInt64ToUint32, NULL, NULL, NULL);
> > + AddTestCase(ConversionTestSuite, "Test
> SafeInt64ToIntn", "TestSafeInt64ToIntn",
> TestSafeInt64ToIntn, NULL, NULL, NULL);
> > + AddTestCase(ConversionTestSuite, "Test
> SafeInt64ToUintn", "TestSafeInt64ToUintn",
> TestSafeInt64ToUintn, NULL, NULL, NULL);
> > + AddTestCase(ConversionTestSuite, "Test
> SafeInt64ToUint64", "TestSafeInt64ToUint64",
> TestSafeInt64ToUint64, NULL, NULL, NULL);
> > + AddTestCase(ConversionTestSuite, "Test
> SafeUint64ToInt8", "TestSafeUint64ToInt8",
> TestSafeUint64ToInt8, NULL, NULL, NULL);
> > + AddTestCase(ConversionTestSuite, "Test
> SafeUint64ToChar8", "TestSafeUint64ToChar8",
> TestSafeUint64ToChar8, NULL, NULL, NULL);
> > + AddTestCase(ConversionTestSuite, "Test
> SafeUint64ToUint8", "TestSafeUint64ToUint8",
> TestSafeUint64ToUint8, NULL, NULL, NULL);
> > + AddTestCase(ConversionTestSuite, "Test
> SafeUint64ToInt16", "TestSafeUint64ToInt16",
> TestSafeUint64ToInt16, NULL, NULL, NULL);
> > + AddTestCase(ConversionTestSuite, "Test
> SafeUint64ToUint16", "TestSafeUint64ToUint16",
> TestSafeUint64ToUint16, NULL, NULL,
> > NULL);
> > + AddTestCase(ConversionTestSuite, "Test
> SafeUint64ToInt32", "TestSafeUint64ToInt32",
> TestSafeUint64ToInt32, NULL, NULL, NULL);
> > + AddTestCase(ConversionTestSuite, "Test
> SafeUint64ToUint32", "TestSafeUint64ToUint32",
> TestSafeUint64ToUint32, NULL, NULL,
> > NULL);
> > + AddTestCase(ConversionTestSuite, "Test
> SafeUint64ToIntn", "TestSafeUint64ToIntn",
> TestSafeUint64ToIntn, NULL, NULL, NULL);
> > + AddTestCase(ConversionTestSuite, "Test
> SafeUint64ToUintn", "TestSafeUint64ToUintn",
> TestSafeUint64ToUintn, NULL, NULL, NULL);
> > + AddTestCase(ConversionTestSuite, "Test
> SafeUint64ToInt64", "TestSafeUint64ToInt64",
> TestSafeUint64ToInt64, NULL, NULL, NULL);
> > +
> > + //
> > + // Test the addition and subtraction functions
> > + //
> > + Status =
> CreateUnitTestSuite(&AdditionSubtractionTestSuite,
> Framework, "Int Safe Add/Subtract Test Suite",
> > "Common.SafeInt.AddSubtract", NULL, NULL);
> > + if (EFI_ERROR(Status)) {
> > + DEBUG((DEBUG_ERROR, "Failed in
> CreateUnitTestSuite for Int Safe Add/Subtract Test
> Suite\n"));
> > + Status = EFI_OUT_OF_RESOURCES;
> > + goto EXIT;
> > + }
> > + AddTestCase(AdditionSubtractionTestSuite, "Test
> SafeUint8Add", "TestSafeUint8Add", TestSafeUint8Add,
> NULL, NULL, NULL);
> > + AddTestCase(AdditionSubtractionTestSuite, "Test
> SafeUint16Add", "TestSafeUint16Add", TestSafeUint16Add,
> NULL, NULL, NULL);
> > + AddTestCase(AdditionSubtractionTestSuite, "Test
> SafeUint32Add", "TestSafeUint32Add", TestSafeUint32Add,
> NULL, NULL, NULL);
> > + AddTestCase(AdditionSubtractionTestSuite, "Test
> SafeUintnAdd", "TestSafeUintnAdd", TestSafeUintnAdd,
> NULL, NULL, NULL);
> > + AddTestCase(AdditionSubtractionTestSuite, "Test
> SafeUint64Add", "TestSafeUint64Add", TestSafeUint64Add,
> NULL, NULL, NULL);
> > + AddTestCase(AdditionSubtractionTestSuite, "Test
> SafeInt8Add", "TestSafeInt8Add", TestSafeInt8Add,
> NULL, NULL, NULL);
> > + AddTestCase(AdditionSubtractionTestSuite, "Test
> SafeInt16Add", "TestSafeInt16Add", TestSafeInt16Add,
> NULL, NULL, NULL);
> > + AddTestCase(AdditionSubtractionTestSuite, "Test
> SafeInt32Add", "TestSafeInt32Add", TestSafeInt32Add,
> NULL, NULL, NULL);
> > + AddTestCase(AdditionSubtractionTestSuite, "Test
> SafeIntnAdd", "TestSafeIntnAdd", TestSafeIntnAdd,
> NULL, NULL, NULL);
> > + AddTestCase(AdditionSubtractionTestSuite, "Test
> SafeInt64Add", "TestSafeInt64Add", TestSafeInt64Add,
> NULL, NULL, NULL);
> > + AddTestCase(AdditionSubtractionTestSuite, "Test
> SafeUint8Sub", "TestSafeUint8Sub", TestSafeUint8Sub,
> NULL, NULL, NULL);
> > + AddTestCase(AdditionSubtractionTestSuite, "Test
> SafeUint16Sub", "TestSafeUint16Sub", TestSafeUint16Sub,
> NULL, NULL, NULL);
> > + AddTestCase(AdditionSubtractionTestSuite, "Test
> SafeUint32Sub", "TestSafeUint32Sub", TestSafeUint32Sub,
> NULL, NULL, NULL);
> > + AddTestCase(AdditionSubtractionTestSuite, "Test
> SafeUintnSub", "TestSafeUintnSub", TestSafeUintnSub,
> NULL, NULL, NULL);
> > + AddTestCase(AdditionSubtractionTestSuite, "Test
> SafeUint64Sub", "TestSafeUint64Sub", TestSafeUint64Sub,
> NULL, NULL, NULL);
> > + AddTestCase(AdditionSubtractionTestSuite, "Test
> SafeInt8Sub", "TestSafeInt8Sub", TestSafeInt8Sub,
> NULL, NULL, NULL);
> > + AddTestCase(AdditionSubtractionTestSuite, "Test
> SafeInt16Sub", "TestSafeInt16Sub", TestSafeInt16Sub,
> NULL, NULL, NULL);
> > + AddTestCase(AdditionSubtractionTestSuite, "Test
> SafeInt32Sub", "TestSafeInt32Sub", TestSafeInt32Sub,
> NULL, NULL, NULL);
> > + AddTestCase(AdditionSubtractionTestSuite, "Test
> SafeIntnSub", "TestSafeIntnSub", TestSafeIntnSub,
> NULL, NULL, NULL);
> > + AddTestCase(AdditionSubtractionTestSuite, "Test
> SafeInt64Sub", "TestSafeInt64Sub", TestSafeInt64Sub,
> NULL, NULL, NULL);
> > +
> > + //
> > + // Test the multiplication functions
> > + //
> > + Status =
> CreateUnitTestSuite(&MultiplicationTestSuite,
> Framework, "Int Safe Multiply Test Suite",
> "Common.SafeInt.Multiply", NULL,
> > NULL);
> > + if (EFI_ERROR(Status)) {
> > + DEBUG((DEBUG_ERROR, "Failed in
> CreateUnitTestSuite for Int Safe Multiply Test
> Suite\n"));
> > + Status = EFI_OUT_OF_RESOURCES;
> > + goto EXIT;
> > + }
> > + AddTestCase(MultiplicationTestSuite, "Test
> SafeUint8Mult", "TestSafeUint8Mult",
> TestSafeUint8Mult, NULL, NULL, NULL);
> > + AddTestCase(MultiplicationTestSuite, "Test
> SafeUint16Mult", "TestSafeUint16Mult",
> TestSafeUint16Mult, NULL, NULL, NULL);
> > + AddTestCase(MultiplicationTestSuite, "Test
> SafeUint32Mult", "TestSafeUint32Mult",
> TestSafeUint32Mult, NULL, NULL, NULL);
> > + AddTestCase(MultiplicationTestSuite, "Test
> SafeUintnMult", "TestSafeUintnMult",
> TestSafeUintnMult, NULL, NULL, NULL);
> > + AddTestCase(MultiplicationTestSuite, "Test
> SafeUint64Mult", "TestSafeUint64Mult",
> TestSafeUint64Mult, NULL, NULL, NULL);
> > + AddTestCase(MultiplicationTestSuite, "Test
> SafeInt8Mult", "TestSafeInt8Mult",
> TestSafeInt8Mult, NULL, NULL, NULL);
> > + AddTestCase(MultiplicationTestSuite, "Test
> SafeInt16Mult", "TestSafeInt16Mult",
> TestSafeInt16Mult, NULL, NULL, NULL);
> > + AddTestCase(MultiplicationTestSuite, "Test
> SafeInt32Mult", "TestSafeInt32Mult",
> TestSafeInt32Mult, NULL, NULL, NULL);
> > + AddTestCase(MultiplicationTestSuite, "Test
> SafeIntnMult", "TestSafeIntnMult",
> TestSafeIntnMult, NULL, NULL, NULL);
> > + AddTestCase(MultiplicationTestSuite, "Test
> SafeInt64Mult", "TestSafeInt64Mult",
> TestSafeInt64Mult, NULL, NULL, NULL);
> > +
> > + //
> > + // Execute the tests.
> > + //
> > + Status = RunAllTestSuites(Framework);
> > +
> > +EXIT:
> > + if (Framework != NULL) {
> > + FreeUnitTestFramework(Framework);
> > + }
> > +
> > + return Status;
> > +}
> > +
> > +EFI_STATUS
> > +EFIAPI
> > +PeiEntryPoint (
> > + IN EFI_PEI_FILE_HANDLE FileHandle,
> > + IN CONST EFI_PEI_SERVICES **PeiServices
> > + )
> > +{
> > + return UefiTestMain ();
> > +}
> > +
> > +EFI_STATUS
> > +EFIAPI
> > +DxeEntryPoint (
> > + IN EFI_HANDLE ImageHandle,
> > + IN EFI_SYSTEM_TABLE *SystemTable
> > + )
> > +{
> > + return UefiTestMain ();
> > +}
> > +
> > +int
> > +main (
> > + int argc,
> > + char *argv[]
> > + )
> > +{
> > + return UefiTestMain ();
> > +}
> > diff --git
> a/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseS
> afeIntLib.h
> >
> b/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseS
> afeIntLib.h
> > new file mode 100644
> > index 0000000000..7957c99a85
> > --- /dev/null
> > +++
> b/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseS
> afeIntLib.h
> > @@ -0,0 +1,123 @@
> > +/** @file
> > + UEFI OS based application for unit testing the
> SafeIntLib.
> > +
> > + Copyright (c) Microsoft Corporation.<BR>
> > + Copyright (c) 2018 - 2020, Intel Corporation. All
> rights reserved.<BR>
> > + SPDX-License-Identifier: BSD-2-Clause-Patent
> > +
> > +**/
> > +
> > +#ifndef _TEST_BASE_SAFE_INT_LIB_H_
> > +#define _TEST_BASE_SAFE_INT_LIB_H_
> > +
> > +#include <PiPei.h>
> > +#include <Uefi.h>
> > +#include <Library/UefiLib.h>
> > +#include <Library/DebugLib.h>
> > +#include <Library/MemoryAllocationLib.h>
> > +#include <Library/UnitTestLib.h>
> > +#include <Library/SafeIntLib.h>
> > +
> > +UNIT_TEST_STATUS
> > +EFIAPI
> > +TestSafeInt32ToUintn(
> > + IN UNIT_TEST_CONTEXT Context
> > + );
> > +
> > +UNIT_TEST_STATUS
> > +EFIAPI
> > +TestSafeUint32ToIntn(
> > + IN UNIT_TEST_CONTEXT Context
> > + );
> > +
> > +UNIT_TEST_STATUS
> > +EFIAPI
> > +TestSafeIntnToInt32(
> > + IN UNIT_TEST_CONTEXT Context
> > + );
> > +
> > +UNIT_TEST_STATUS
> > +EFIAPI
> > +TestSafeIntnToUint32(
> > + IN UNIT_TEST_CONTEXT Context
> > + );
> > +
> > +UNIT_TEST_STATUS
> > +EFIAPI
> > +TestSafeUintnToUint32(
> > + IN UNIT_TEST_CONTEXT Context
> > + );
> > +
> > +UNIT_TEST_STATUS
> > +EFIAPI
> > +TestSafeUintnToIntn(
> > + IN UNIT_TEST_CONTEXT Context
> > + );
> > +
> > +UNIT_TEST_STATUS
> > +EFIAPI
> > +TestSafeUintnToInt64(
> > + IN UNIT_TEST_CONTEXT Context
> > + );
> > +
> > +UNIT_TEST_STATUS
> > +EFIAPI
> > +TestSafeInt64ToIntn(
> > + IN UNIT_TEST_CONTEXT Context
> > + );
> > +
> > +UNIT_TEST_STATUS
> > +EFIAPI
> > +TestSafeInt64ToUintn(
> > + IN UNIT_TEST_CONTEXT Context
> > + );
> > +
> > +UNIT_TEST_STATUS
> > +EFIAPI
> > +TestSafeUint64ToIntn(
> > + IN UNIT_TEST_CONTEXT Context
> > + );
> > +
> > +UNIT_TEST_STATUS
> > +EFIAPI
> > +TestSafeUint64ToUintn(
> > + IN UNIT_TEST_CONTEXT Context
> > + );
> > +
> > +UNIT_TEST_STATUS
> > +EFIAPI
> > +TestSafeUintnAdd(
> > + IN UNIT_TEST_CONTEXT Context
> > + );
> > +
> > +UNIT_TEST_STATUS
> > +EFIAPI
> > +TestSafeIntnAdd(
> > + IN UNIT_TEST_CONTEXT Context
> > + );
> > +
> > +UNIT_TEST_STATUS
> > +EFIAPI
> > +TestSafeUintnSub(
> > + IN UNIT_TEST_CONTEXT Context
> > + );
> > +
> > +UNIT_TEST_STATUS
> > +EFIAPI
> > +TestSafeIntnSub(
> > + IN UNIT_TEST_CONTEXT Context
> > + );
> > +
> > +UNIT_TEST_STATUS
> > +EFIAPI
> > +TestSafeUintnMult(
> > + IN UNIT_TEST_CONTEXT Context
> > + );
> > +
> > +UNIT_TEST_STATUS
> > +EFIAPI
> > +TestSafeIntnMult(
> > + IN UNIT_TEST_CONTEXT Context
> > + );
> > +
> > +#endif
> > diff --git
> a/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseS
> afeIntLib.uni
> >
> b/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseS
> afeIntLib.uni
> > new file mode 100644
> > index 0000000000..956835c30d
> > --- /dev/null
> > +++
> b/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseS
> afeIntLib.uni
> > @@ -0,0 +1,13 @@
> > +// /** @file
> > +// Application that Unit Tests the SafeIntLib
> > +//
> > +// Copyright (c) 2020, Intel Corporation. All rights
> reserved.<BR>
> > +//
> > +// SPDX-License-Identifier: BSD-2-Clause-Patent
> > +//
> > +// **/
> > +
> > +#string STR_MODULE_ABSTRACT #language
> en-US "Application that Unit Tests the SafeIntLib"
> > +
> > +#string STR_MODULE_DESCRIPTION #language
> en-US "Application that Unit Tests the SafeIntLib."
> > +
> > diff --git
> a/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseS
> afeIntLibDxe.inf
> >
> b/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseS
> afeIntLibDxe.inf
> > new file mode 100644
> > index 0000000000..de67b04bd5
> > --- /dev/null
> > +++
> b/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseS
> afeIntLibDxe.inf
> > @@ -0,0 +1,45 @@
> > +## @file
> > +# DXE Driver that Unit Tests the SafeIntLib
> > +#
> > +# Copyright (c) Microsoft Corporation.<BR>
> > +# Copyright (c) 2019 - 2020, Intel Corporation. All
> rights reserved.<BR>
> > +# SPDX-License-Identifier: BSD-2-Clause-Patent
> > +##
> > +
> > +[Defines]
> > + INF_VERSION = 0x00010005
> > + BASE_NAME = TestBaseSafeIntLibDxe
> > + MODULE_UNI_FILE = TestBaseSafeIntLib.uni
> > + FILE_GUID = 9729DB60-FB9D-4625-9EE1-
> 93B21EC246B8
> > + MODULE_TYPE = DXE_DRIVER
> > + VERSION_STRING = 1.0
> > + ENTRY_POINT = DxeEntryPoint
> > +
> > +#
> > +# The following information is for reference only
> and not required by the build tools.
> > +#
> > +# VALID_ARCHITECTURES = IA32 X64
> > +#
> > +
> > +[Sources]
> > + TestBaseSafeIntLib.c
> > + TestBaseSafeIntLib.h
> > +
> > +[Sources.Ia32, Sources.ARM]
> > + SafeIntLibUintnIntnUnitTests32.c
> > +
> > +[Sources.X64, Sources.AARCH64]
> > + SafeIntLibUintnIntnUnitTests64.c
> > +
> > +[Packages]
> > + MdePkg/MdePkg.dec
> > +
> > +[LibraryClasses]
> > + UefiDriverEntryPoint
> > + BaseLib
> > + DebugLib
> > + SafeIntLib
> > + UnitTestLib
> > +
> > +[Depex]
> > + TRUE
> > diff --git
> a/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseS
> afeIntLibHost.inf
> >
> b/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseS
> afeIntLibHost.inf
> > new file mode 100644
> > index 0000000000..35c93fdeac
> > --- /dev/null
> > +++
> b/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseS
> afeIntLibHost.inf
> > @@ -0,0 +1,40 @@
> > +## @file
> > +# Host OS based Application that Unit Tests the
> SafeIntLib
> > +#
> > +# Copyright (c) Microsoft Corporation.<BR>
> > +# Copyright (c) 2019 - 2020, Intel Corporation. All
> rights reserved.<BR>
> > +# SPDX-License-Identifier: BSD-2-Clause-Patent
> > +##
> > +
> > +[Defines]
> > + INF_VERSION = 0x00010005
> > + BASE_NAME = TestBaseSafeIntLibHost
> > + MODULE_UNI_FILE = TestBaseSafeIntLib.uni
> > + FILE_GUID = 95487689-9E30-41AD-B773-
> 3650C94BCBE2
> > + MODULE_TYPE = HOST_APPLICATION
> > + VERSION_STRING = 1.0
> > +
> > +#
> > +# The following information is for reference only
> and not required by the build tools.
> > +#
> > +# VALID_ARCHITECTURES = IA32 X64
> > +#
> > +
> > +[Sources]
> > + TestBaseSafeIntLib.c
> > + TestBaseSafeIntLib.h
> > +
> > +[Sources.Ia32, Sources.ARM]
> > + SafeIntLibUintnIntnUnitTests32.c
> > +
> > +[Sources.X64, Sources.AARCH64]
> > + SafeIntLibUintnIntnUnitTests64.c
> > +
> > +[Packages]
> > + MdePkg/MdePkg.dec
> > +
> > +[LibraryClasses]
> > + BaseLib
> > + DebugLib
> > + SafeIntLib
> > + UnitTestLib
> > diff --git
> a/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseS
> afeIntLibPei.inf
> >
> b/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseS
> afeIntLibPei.inf
> > new file mode 100644
> > index 0000000000..c8ba4f44ef
> > --- /dev/null
> > +++
> b/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseS
> afeIntLibPei.inf
> > @@ -0,0 +1,45 @@
> > +## @file
> > +# PEIM that Unit Tests the SafeIntLib
> > +#
> > +# Copyright (c) Microsoft Corporation.<BR>
> > +# Copyright (c) 2019 - 2020, Intel Corporation. All
> rights reserved.<BR>
> > +# SPDX-License-Identifier: BSD-2-Clause-Patent
> > +##
> > +
> > +[Defines]
> > + INF_VERSION = 0x00010005
> > + BASE_NAME = TestBaseSafeIntLibPei
> > + MODULE_UNI_FILE = TestBaseSafeIntLib.uni
> > + FILE_GUID = 7D910602-ED53-45E6-826E-
> 8266705B9734
> > + MODULE_TYPE = PEIM
> > + VERSION_STRING = 1.0
> > + ENTRY_POINT = PeiEntryPoint
> > +
> > +#
> > +# The following information is for reference only
> and not required by the build tools.
> > +#
> > +# VALID_ARCHITECTURES = IA32 X64
> > +#
> > +
> > +[Sources]
> > + TestBaseSafeIntLib.c
> > + TestBaseSafeIntLib.h
> > +
> > +[Sources.Ia32, Sources.ARM]
> > + SafeIntLibUintnIntnUnitTests32.c
> > +
> > +[Sources.X64, Sources.AARCH64]
> > + SafeIntLibUintnIntnUnitTests64.c
> > +
> > +[Packages]
> > + MdePkg/MdePkg.dec
> > +
> > +[LibraryClasses]
> > + PeimEntryPoint
> > + BaseLib
> > + DebugLib
> > + SafeIntLib
> > + UnitTestLib
> > +
> > +[Depex]
> > + TRUE
> > diff --git
> a/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseS
> afeIntLibSmm.inf
> >
> b/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseS
> afeIntLibSmm.inf
> > new file mode 100644
> > index 0000000000..df7288501d
> > --- /dev/null
> > +++
> b/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseS
> afeIntLibSmm.inf
> > @@ -0,0 +1,45 @@
> > +## @file
> > +# SMM Driver that Unit Tests the SafeIntLib
> > +#
> > +# Copyright (c) Microsoft Corporation.<BR>
> > +# Copyright (c) 2019 - 2020, Intel Corporation. All
> rights reserved.<BR>
> > +# SPDX-License-Identifier: BSD-2-Clause-Patent
> > +##
> > +
> > +[Defines]
> > + INF_VERSION = 0x00010005
> > + BASE_NAME = TestBaseSafeIntLibSmm
> > + MODULE_UNI_FILE = TestBaseSafeIntLib.uni
> > + FILE_GUID = 2F2A1907-B1B4-4E33-8B83-
> 62A60AB4F0D4
> > + MODULE_TYPE = DXE_SMM_DRIVER
> > + VERSION_STRING = 1.0
> > + ENTRY_POINT = DxeEntryPoint
> > +
> > +#
> > +# The following information is for reference only
> and not required by the build tools.
> > +#
> > +# VALID_ARCHITECTURES = IA32 X64
> > +#
> > +
> > +[Sources]
> > + TestBaseSafeIntLib.c
> > + TestBaseSafeIntLib.h
> > +
> > +[Sources.Ia32, Sources.ARM]
> > + SafeIntLibUintnIntnUnitTests32.c
> > +
> > +[Sources.X64, Sources.AARCH64]
> > + SafeIntLibUintnIntnUnitTests64.c
> > +
> > +[Packages]
> > + MdePkg/MdePkg.dec
> > +
> > +[LibraryClasses]
> > + UefiDriverEntryPoint
> > + BaseLib
> > + DebugLib
> > + SafeIntLib
> > + UnitTestLib
> > +
> > +[Depex]
> > + TRUE
> > diff --git
> a/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseS
> afeIntLibUefiShell.inf
> >
> b/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseS
> afeIntLibUefiShell.inf
> > new file mode 100644
> > index 0000000000..5a13c1c845
> > --- /dev/null
> > +++
> b/MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseS
> afeIntLibUefiShell.inf
> > @@ -0,0 +1,42 @@
> > +## @file
> > +# UEFI Shell based Application that Unit Tests the
> SafeIntLib
> > +#
> > +# Copyright (c) Microsoft Corporation.<BR>
> > +# Copyright (c) 2019 - 2020, Intel Corporation. All
> rights reserved.<BR>
> > +# SPDX-License-Identifier: BSD-2-Clause-Patent
> > +##
> > +
> > +[Defines]
> > + INF_VERSION = 0x00010005
> > + BASE_NAME = TestBaseSafeIntLibUefiShell
> > + MODULE_UNI_FILE = TestBaseSafeIntLib.uni
> > + FILE_GUID = 1F91B73E-5B6A-4317-80E8-
> E7C36A3C7AF4
> > + MODULE_TYPE = UEFI_APPLICATION
> > + VERSION_STRING = 1.0
> > + ENTRY_POINT = DxeEntryPoint
> > +
> > +#
> > +# The following information is for reference only
> and not required by the build tools.
> > +#
> > +# VALID_ARCHITECTURES = IA32 X64
> > +#
> > +
> > +[Sources]
> > + TestBaseSafeIntLib.c
> > + TestBaseSafeIntLib.h
> > +
> > +[Sources.Ia32, Sources.ARM]
> > + SafeIntLibUintnIntnUnitTests32.c
> > +
> > +[Sources.X64, Sources.AARCH64]
> > + SafeIntLibUintnIntnUnitTests64.c
> > +
> > +[Packages]
> > + MdePkg/MdePkg.dec
> > +
> > +[LibraryClasses]
> > + UefiApplicationEntryPoint
> > + BaseLib
> > + DebugLib
> > + SafeIntLib
> > + UnitTestLib
> > --
> > 2.21.0.windows.1
-=-=-=-=-=-=-=-=-=-=-=-
Groups.io Links: You receive all messages sent to this group.
View/Reply Online (#54049): https://edk2.groups.io/g/devel/message/54049
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]
-=-=-=-=-=-=-=-=-=-=-=-
© 2016 - 2026 Red Hat, Inc.