This commit adds host-based unit tests for device path lib.
Cc: Michael D Kinney <michael.d.kin...@intel.com>
Cc: Liming Gao <gaolim...@byosoft.com.cn>
Cc: Zhiguang Liu <zhiguang....@intel.com>
Signed-off-by: Mateusz Albecki <mateusz.albe...@intel.com>
---
MdePkg/MdePkg.ci.yaml | 5 +-
MdePkg/Test/MdePkgHostTest.dsc | 2 +
.../Library/DevicePathLib/TestDevicePathLib.c | 638 ++++++++++++++++++
.../Library/DevicePathLib/TestDevicePathLib.h | 26 +
.../DevicePathLib/TestDevicePathLibHost.inf | 33 +
.../TestDevicePathStringConversions.c | 370 ++++++++++
6 files changed, 1073 insertions(+), 1 deletion(-)
create mode 100644
MdePkg/Test/UnitTest/Library/DevicePathLib/TestDevicePathLib.c
create mode 100644
MdePkg/Test/UnitTest/Library/DevicePathLib/TestDevicePathLib.h
create mode 100644
MdePkg/Test/UnitTest/Library/DevicePathLib/TestDevicePathLibHost.inf
create mode 100644
MdePkg/Test/UnitTest/Library/DevicePathLib/TestDevicePathStringConversions.c
diff --git a/MdePkg/MdePkg.ci.yaml b/MdePkg/MdePkg.ci.yaml
index c3faf4913d..45f4fb537b 100644
--- a/MdePkg/MdePkg.ci.yaml
+++ b/MdePkg/MdePkg.ci.yaml
@@ -74,7 +74,10 @@
"Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntLib.c",
"Library/BaseFdtLib",
"Library/MipiSysTLib/mipi_syst.h",
- "Include/Register/Amd/SmramSaveStateMap.h"
+ "Include/Register/Amd/SmramSaveStateMap.h",
+ "Test/UnitTest/Library/DevicePathLib/TestDevicePathLib.c",
+ "Test/UnitTest/Library/DevicePathLib/TestDevicePathLib.h",
+
"Test/UnitTest/Library/DevicePathLib/TestDevicePathStringConversions.c"
]
},
## options defined ci/Plugin/CompilerPlugin
diff --git a/MdePkg/Test/MdePkgHostTest.dsc b/MdePkg/Test/MdePkgHostTest.dsc
index 529ea69024..b92b564d43 100644
--- a/MdePkg/Test/MdePkgHostTest.dsc
+++ b/MdePkg/Test/MdePkgHostTest.dsc
@@ -21,6 +21,7 @@
[LibraryClasses]
SafeIntLib|MdePkg/Library/BaseSafeIntLib/BaseSafeIntLib.inf
+ DevicePathLib|MdePkg/Library/UefiDevicePathLib/UefiDevicePathLibBase.inf
[Components]
#
@@ -29,6 +30,7 @@
MdePkg/Test/UnitTest/Library/BaseSafeIntLib/TestBaseSafeIntLibHost.inf
MdePkg/Test/UnitTest/Library/BaseLib/BaseLibUnitTestsHost.inf
MdePkg/Test/GoogleTest/Library/BaseSafeIntLib/GoogleTestBaseSafeIntLib.inf
+ MdePkg/Test/UnitTest/Library/DevicePathLib/TestDevicePathLibHost.inf
#
# Build HOST_APPLICATION Libraries
diff --git a/MdePkg/Test/UnitTest/Library/DevicePathLib/TestDevicePathLib.c
b/MdePkg/Test/UnitTest/Library/DevicePathLib/TestDevicePathLib.c
new file mode 100644
index 0000000000..687497278c
--- /dev/null
+++ b/MdePkg/Test/UnitTest/Library/DevicePathLib/TestDevicePathLib.c
@@ -0,0 +1,638 @@
+/** @file
+ UEFI OS based application for unit testing the DevicePathLib.
+
+ Copyright (c) 2023, Intel Corporation. All rights reserved.<BR>
+ SPDX-License-Identifier: BSD-2-Clause-Patent
+**/
+
+#include "TestDevicePathLib.h"
+
+#define UNIT_TEST_NAME "DevicePathLib Unit Test Application"
+#define UNIT_TEST_VERSION "0.1"
+
+typedef struct {
+ ACPI_HID_DEVICE_PATH AcpiPath;
+ PCI_DEVICE_PATH PciPathRootPort;
+ PCI_DEVICE_PATH PciPathEndPoint;
+ USB_DEVICE_PATH UsbPath;
+ EFI_DEVICE_PATH_PROTOCOL End;
+} TEST_COMPLEX_DEVICE_PATH;
+
+GLOBAL_REMOVE_IF_UNREFERENCED TEST_COMPLEX_DEVICE_PATH mComplexDevicePath = {
+ { // ACPI device path with root bridge EISA_PNP_ID
+ {
+ ACPI_DEVICE_PATH,
+ ACPI_DP,
+ {
+ (UINT8)(sizeof (ACPI_HID_DEVICE_PATH)),
+ (UINT8)((sizeof (ACPI_HID_DEVICE_PATH)) >> 8)
+ }
+ },
+ EISA_PNP_ID (0x0A03),
+ 0
+ },
+ { // PCI device path - root port (0x2:0x0)
+ {
+ HARDWARE_DEVICE_PATH,
+ HW_PCI_DP,
+ {
+ (UINT8)(sizeof (PCI_DEVICE_PATH)),
+ (UINT8)((sizeof (PCI_DEVICE_PATH)) >> 8)
+ }
+ },
+ 0x2,
+ 0x0
+ },
+ { // PCI device path - endpoint (0x0:0x0)
+ {
+ HARDWARE_DEVICE_PATH,
+ HW_PCI_DP,
+ {
+ (UINT8)(sizeof (PCI_DEVICE_PATH)),
+ (UINT8)((sizeof (PCI_DEVICE_PATH)) >> 8)
+ }
+ },
+ 0x0,
+ 0x0
+ },
+ { // USB interface
+ {
+ MESSAGING_DEVICE_PATH,
+ MSG_USB_DP,
+ {
+ (UINT8)(sizeof (USB_DEVICE_PATH)),
+ (UINT8)((sizeof (USB_CLASS_DEVICE_PATH)) >> 8)
+ }
+ },
+ 0,
+ 2
+ },
+ {
+ END_DEVICE_PATH_TYPE,
+ END_ENTIRE_DEVICE_PATH_SUBTYPE,
+ {
+ (UINT8)(sizeof (EFI_DEVICE_PATH_PROTOCOL)),
+ (UINT8)((sizeof (EFI_DEVICE_PATH_PROTOCOL)) >> 8)
+ }
+ }
+};
+
+CONST GLOBAL_REMOVE_IF_UNREFERENCED CHAR16 *mComplexDevicePathString =
L"PciRoot(0x0)/Pci(0x0,0x2)/Pci(0x0,0x0)/USB(0x0,0x2)";
+
+CONST GLOBAL_REMOVE_IF_UNREFERENCED CHAR16 *mPciEndPointPathString =
L"Pci(0x0, 0x0)";
+
+typedef struct {
+ ACPI_HID_DEVICE_PATH AcpiPath;
+ EFI_DEVICE_PATH_PROTOCOL End;
+} TEST_SIMPLE_DEVICE_PATH;
+
+GLOBAL_REMOVE_IF_UNREFERENCED TEST_SIMPLE_DEVICE_PATH mSimpleDevicePath = {
+ { // ACPI device path with root bridge EISA_PNP_ID
+ {
+ ACPI_DEVICE_PATH,
+ ACPI_DP,
+ {
+ (UINT8)(sizeof (ACPI_HID_DEVICE_PATH)),
+ (UINT8)((sizeof (ACPI_HID_DEVICE_PATH)) >> 8)
+ }
+ },
+ EISA_PNP_ID (0x0A03),
+ 0
+ },
+ {
+ END_DEVICE_PATH_TYPE,
+ END_ENTIRE_DEVICE_PATH_SUBTYPE,
+ {
+ (UINT8)(sizeof (EFI_DEVICE_PATH_PROTOCOL)),
+ (UINT8)((sizeof (EFI_DEVICE_PATH_PROTOCOL)) >> 8)
+ }
+ }
+};
+
+GLOBAL_REMOVE_IF_UNREFERENCED TEST_SIMPLE_DEVICE_PATH
mInvalidSimpleDevicePath = {
+ { // ACPI device path with root bridge EISA_PNP_ID
+ {
+ ACPI_DEVICE_PATH,
+ ACPI_DP,
+ {
+ 0,
+ 0
+ }
+ },
+ EISA_PNP_ID (0x0A03),
+ 0
+ },
+ {
+ END_DEVICE_PATH_TYPE,
+ END_ENTIRE_DEVICE_PATH_SUBTYPE,
+ {
+ (UINT8)(sizeof (EFI_DEVICE_PATH_PROTOCOL)),
+ (UINT8)((sizeof (EFI_DEVICE_PATH_PROTOCOL)) >> 8)
+ }
+ }
+};
+
+typedef struct {
+ TEST_SIMPLE_DEVICE_PATH *SimpleDevicePath;
+ TEST_SIMPLE_DEVICE_PATH *InvalidDevicePath;
+ TEST_COMPLEX_DEVICE_PATH *ComplexDevicePath;
+} SIMPLE_TEST_SUITE_CONTEXT;
+
+UNIT_TEST_STATUS
+EFIAPI
+TestIsDevicePathValid (
+ IN UNIT_TEST_CONTEXT Context
+ )
+{
+ BOOLEAN IsValid;
+ SIMPLE_TEST_SUITE_CONTEXT *TestContext;
+
+ TestContext = (SIMPLE_TEST_SUITE_CONTEXT *)Context;
+
+ IsValid = IsDevicePathValid ((EFI_DEVICE_PATH_PROTOCOL
*)TestContext->SimpleDevicePath, sizeof (TEST_SIMPLE_DEVICE_PATH));
+ UT_ASSERT_TRUE (IsValid);
+
+ IsValid = IsDevicePathValid ((EFI_DEVICE_PATH_PROTOCOL
*)TestContext->ComplexDevicePath, sizeof (TEST_COMPLEX_DEVICE_PATH));
+ UT_ASSERT_TRUE (IsValid);
+
+ IsValid = IsDevicePathValid ((EFI_DEVICE_PATH_PROTOCOL
*)TestContext->ComplexDevicePath, 0);
+ UT_ASSERT_TRUE (IsValid);
+
+ // Device path can't be NULL
+ IsValid = IsDevicePathValid (NULL, 0);
+ UT_ASSERT_FALSE (IsValid);
+
+ // MaxSize can't be less then the size of the device path
+ IsValid = IsDevicePathValid ((EFI_DEVICE_PATH_PROTOCOL
*)TestContext->SimpleDevicePath, sizeof (TEST_SIMPLE_DEVICE_PATH) - 1);
+ UT_ASSERT_FALSE (IsValid);
+
+ // If MaxSize != 0 it must be bigger then EFI_DEVICE_PATH_PROTOCOL
+ IsValid = IsDevicePathValid ((EFI_DEVICE_PATH_PROTOCOL
*)TestContext->SimpleDevicePath, sizeof (EFI_DEVICE_PATH_PROTOCOL) - 1);
+ UT_ASSERT_FALSE (IsValid);
+
+ IsValid = IsDevicePathValid ((EFI_DEVICE_PATH_PROTOCOL
*)TestContext->InvalidDevicePath, 0);
+ UT_ASSERT_FALSE (IsValid);
+
+ return UNIT_TEST_PASSED;
+}
+
+UNIT_TEST_STATUS
+EFIAPI
+TestDevicePathType (
+ IN UNIT_TEST_CONTEXT Context
+ )
+{
+ UINT8 Type;
+ SIMPLE_TEST_SUITE_CONTEXT *TestContext;
+
+ TestContext = (SIMPLE_TEST_SUITE_CONTEXT *)Context;
+
+ // Test 2 types just in case the implementation is returning constant value
+ // NOTE: passing NULL to this function causes NULL pointer dereference.
+ Type = DevicePathType (&TestContext->ComplexDevicePath->AcpiPath);
+ UT_ASSERT_EQUAL (Type, ACPI_DEVICE_PATH);
+
+ Type = DevicePathType (&TestContext->ComplexDevicePath->PciPathRootPort);
+ UT_ASSERT_EQUAL (Type, HARDWARE_DEVICE_PATH);
+
+ return UNIT_TEST_PASSED;
+}
+
+UNIT_TEST_STATUS
+EFIAPI
+TestDevicePathSubType (
+ IN UNIT_TEST_CONTEXT Context
+ )
+{
+ UINT8 SubType;
+ SIMPLE_TEST_SUITE_CONTEXT *TestContext;
+
+ TestContext = (SIMPLE_TEST_SUITE_CONTEXT *)Context;
+
+ // Test 2 sub types just in case the implementation is returning constant
value
+ // NOTE: passing NULL to this function causes NULL pointer dereference.
+ SubType = DevicePathSubType (&TestContext->ComplexDevicePath->AcpiPath);
+ UT_ASSERT_EQUAL (SubType, ACPI_DP);
+
+ SubType = DevicePathSubType
(&TestContext->ComplexDevicePath->PciPathRootPort);
+ UT_ASSERT_EQUAL (SubType, HW_PCI_DP);
+
+ return UNIT_TEST_PASSED;
+}
+
+UNIT_TEST_STATUS
+EFIAPI
+TestDevicePathNodeLength (
+ IN UNIT_TEST_CONTEXT Context
+ )
+{
+ UINTN Length;
+ SIMPLE_TEST_SUITE_CONTEXT *TestContext;
+
+ TestContext = (SIMPLE_TEST_SUITE_CONTEXT *)Context;
+
+ // Test 2 nodes just in case the implementation is returning constant value
+ // NOTE: passing NULL to this function causes NULL pointer dereference.
+ Length = DevicePathNodeLength (&TestContext->ComplexDevicePath->AcpiPath);
+ UT_ASSERT_EQUAL (Length, sizeof (ACPI_HID_DEVICE_PATH));
+
+ Length = DevicePathNodeLength
(&TestContext->ComplexDevicePath->PciPathRootPort);
+ UT_ASSERT_EQUAL (Length, sizeof (PCI_DEVICE_PATH));
+
+ return UNIT_TEST_PASSED;
+}
+
+UNIT_TEST_STATUS
+EFIAPI
+TestNextDevicePathNode (
+ IN UNIT_TEST_CONTEXT Context
+ )
+{
+ VOID *Node;
+ SIMPLE_TEST_SUITE_CONTEXT *TestContext;
+
+ TestContext = (SIMPLE_TEST_SUITE_CONTEXT *)Context;
+
+ Node = &mComplexDevicePath;
+ Node = NextDevicePathNode (Node);
+ UT_ASSERT_MEM_EQUAL (Node, &TestContext->ComplexDevicePath->PciPathRootPort,
DevicePathNodeLength (Node));
+
+ Node = NextDevicePathNode (Node);
+ UT_ASSERT_MEM_EQUAL (Node, &TestContext->ComplexDevicePath->PciPathEndPoint,
DevicePathNodeLength (Node));
+
+ return UNIT_TEST_PASSED;
+}
+
+UNIT_TEST_STATUS
+EFIAPI
+TestIsDevicePathEndType (
+ IN UNIT_TEST_CONTEXT Context
+ )
+{
+ BOOLEAN IsEndType;
+ SIMPLE_TEST_SUITE_CONTEXT *TestContext;
+
+ TestContext = (SIMPLE_TEST_SUITE_CONTEXT *)Context;
+
+ IsEndType = IsDevicePathEndType
(&TestContext->ComplexDevicePath->PciPathRootPort);
+ UT_ASSERT_FALSE (IsEndType);
+
+ IsEndType = IsDevicePathEndType (&TestContext->ComplexDevicePath->End);
+ UT_ASSERT_TRUE (IsEndType);
+
+ return UNIT_TEST_PASSED;
+}
+
+UNIT_TEST_STATUS
+EFIAPI
+TestIsDevicePathEnd (
+ IN UNIT_TEST_CONTEXT Context
+ )
+{
+ BOOLEAN IsEnd;
+ SIMPLE_TEST_SUITE_CONTEXT *TestContext;
+
+ TestContext = (SIMPLE_TEST_SUITE_CONTEXT *)Context;
+
+ IsEnd = IsDevicePathEnd (&TestContext->ComplexDevicePath->PciPathRootPort);
+ UT_ASSERT_FALSE (IsEnd);
+
+ IsEnd = IsDevicePathEnd (&TestContext->ComplexDevicePath->End);
+ UT_ASSERT_TRUE (IsEnd);
+
+ return UNIT_TEST_PASSED;
+}
+
+UNIT_TEST_STATUS
+EFIAPI
+TestSetDevicePathNodeLength (
+ IN UNIT_TEST_CONTEXT Context
+ )
+{
+ EFI_DEVICE_PATH_PROTOCOL DevPath;
+
+ // NOTE: Node == NULL or NodeLength >= 0x10000 NodeLength < sizeof
(EFI_DEVICE_PATH_PROTOCOL)
+ // are all invalid parameters. However there are only ASSERTS added to catch
them so there is no
+ // way to test it.
+ SetDevicePathNodeLength (&DevPath, sizeof (EFI_DEVICE_PATH_PROTOCOL));
+ UT_ASSERT_EQUAL (DevicePathNodeLength (&DevPath), sizeof
(EFI_DEVICE_PATH_PROTOCOL));
+
+ return UNIT_TEST_PASSED;
+}
+
+UNIT_TEST_STATUS
+EFIAPI
+TestSetDevicePathEndNode (
+ IN UNIT_TEST_CONTEXT Context
+ )
+{
+ EFI_DEVICE_PATH_PROTOCOL EndNode;
+
+ SetDevicePathEndNode (&EndNode);
+ UT_ASSERT_EQUAL (EndNode.Type, END_DEVICE_PATH_TYPE);
+ UT_ASSERT_EQUAL (EndNode.SubType, END_ENTIRE_DEVICE_PATH_SUBTYPE);
+ UT_ASSERT_EQUAL (DevicePathNodeLength (&EndNode), END_DEVICE_PATH_LENGTH);
+
+ return UNIT_TEST_PASSED;
+}
+
+UNIT_TEST_STATUS
+EFIAPI
+TestGetDevicePathSize (
+ IN UNIT_TEST_CONTEXT Context
+ )
+{
+ UINTN Size;
+ SIMPLE_TEST_SUITE_CONTEXT *TestContext;
+
+ TestContext = (SIMPLE_TEST_SUITE_CONTEXT *)Context;
+
+ Size = GetDevicePathSize ((EFI_DEVICE_PATH_PROTOCOL
*)TestContext->SimpleDevicePath);
+ UT_ASSERT_EQUAL (Size, sizeof (TEST_SIMPLE_DEVICE_PATH));
+
+ Size = GetDevicePathSize ((EFI_DEVICE_PATH_PROTOCOL
*)TestContext->ComplexDevicePath);
+ UT_ASSERT_EQUAL (Size, sizeof (TEST_COMPLEX_DEVICE_PATH));
+
+ return UNIT_TEST_PASSED;
+}
+
+UNIT_TEST_STATUS
+EFIAPI
+TestDuplicateDevicePath (
+ IN UNIT_TEST_CONTEXT Context
+ )
+{
+ EFI_DEVICE_PATH_PROTOCOL *Duplicate;
+ SIMPLE_TEST_SUITE_CONTEXT *TestContext;
+
+ TestContext = (SIMPLE_TEST_SUITE_CONTEXT *)Context;
+
+ Duplicate = DuplicateDevicePath ((EFI_DEVICE_PATH_PROTOCOL
*)TestContext->ComplexDevicePath);
+ UT_ASSERT_EQUAL (GetDevicePathSize (Duplicate), GetDevicePathSize
((EFI_DEVICE_PATH_PROTOCOL *)TestContext->ComplexDevicePath));
+ UT_ASSERT_MEM_EQUAL (Duplicate, TestContext->ComplexDevicePath,
GetDevicePathSize ((EFI_DEVICE_PATH_PROTOCOL *)TestContext->ComplexDevicePath));
+ FreePool (Duplicate);
+
+ return UNIT_TEST_PASSED;
+}
+
+UNIT_TEST_STATUS
+EFIAPI
+TestAppendDevicePath (
+ IN UNIT_TEST_CONTEXT Context
+ )
+{
+ EFI_DEVICE_PATH_PROTOCOL *Appended;
+ EFI_DEVICE_PATH_PROTOCOL *NextNode;
+
+ Appended = AppendDevicePath ((EFI_DEVICE_PATH_PROTOCOL *)&mSimpleDevicePath,
(EFI_DEVICE_PATH_PROTOCOL *)&mComplexDevicePath);
+ NextNode = NextDevicePathNode (Appended);
+ UT_ASSERT_MEM_EQUAL (NextNode, &mSimpleDevicePath.AcpiPath, sizeof
(ACPI_HID_DEVICE_PATH));
+ FreePool (Appended);
+
+ // If one of the paths is invalid result device path should be NULL
+ Appended = AppendDevicePath ((EFI_DEVICE_PATH_PROTOCOL *)&mSimpleDevicePath,
(EFI_DEVICE_PATH_PROTOCOL *)&mInvalidSimpleDevicePath);
+ UT_ASSERT_EQUAL ((uintptr_t)Appended, (uintptr_t)NULL);
+
+ Appended = AppendDevicePath (NULL, NULL);
+ UT_ASSERT_EQUAL (Appended->Type, END_DEVICE_PATH_TYPE);
+ UT_ASSERT_EQUAL (Appended->SubType, END_ENTIRE_DEVICE_PATH_SUBTYPE);
+ UT_ASSERT_EQUAL (DevicePathNodeLength (Appended), END_DEVICE_PATH_LENGTH);
+ FreePool (Appended);
+
+ return UNIT_TEST_PASSED;
+}
+
+UNIT_TEST_STATUS
+EFIAPI
+TestAppendDevicePathNode (
+ IN UNIT_TEST_CONTEXT Context
+ )
+{
+ EFI_DEVICE_PATH_PROTOCOL *Appended;
+ EFI_DEVICE_PATH_PROTOCOL *NextNode;
+ BOOLEAN IsValid;
+ ACPI_HID_DEVICE_PATH AcpiPath =
+ {
+ {
+ ACPI_DEVICE_PATH,
+ ACPI_DP,
+ {
+ (UINT8)(sizeof (ACPI_HID_DEVICE_PATH)),
+ (UINT8)((sizeof (ACPI_HID_DEVICE_PATH)) >> 8)
+ }
+ },
+ EISA_PNP_ID (0x0AAB),
+ 0
+ };
+
+ Appended = AppendDevicePathNode ((EFI_DEVICE_PATH_PROTOCOL
*)&mSimpleDevicePath, (EFI_DEVICE_PATH_PROTOCOL *)&AcpiPath);
+ NextNode = NextDevicePathNode (Appended);
+ UT_ASSERT_MEM_EQUAL (NextNode, &AcpiPath, sizeof (ACPI_HID_DEVICE_PATH));
+ FreePool (Appended);
+
+ Appended = AppendDevicePathNode (NULL, (EFI_DEVICE_PATH_PROTOCOL
*)&AcpiPath);
+ UT_ASSERT_MEM_EQUAL (Appended, &AcpiPath, sizeof (ACPI_HID_DEVICE_PATH));
+ IsValid = IsDevicePathValid (Appended, 0);
+ UT_ASSERT_TRUE (IsValid);
+ FreePool (Appended);
+
+ Appended = AppendDevicePathNode (NULL, NULL);
+ UT_ASSERT_EQUAL (Appended->Type, END_DEVICE_PATH_TYPE);
+ UT_ASSERT_EQUAL (Appended->SubType, END_ENTIRE_DEVICE_PATH_SUBTYPE);
+ UT_ASSERT_EQUAL (DevicePathNodeLength (Appended), END_DEVICE_PATH_LENGTH);
+ FreePool (Appended);
+
+ return UNIT_TEST_PASSED;
+}
+
+UNIT_TEST_STATUS
+EFIAPI
+TestAppendDevicePathInstance (
+ IN UNIT_TEST_CONTEXT Context
+ )
+{
+ EFI_DEVICE_PATH_PROTOCOL *Appended;
+ EFI_DEVICE_PATH_PROTOCOL *NextInstance;
+ EFI_DEVICE_PATH_PROTOCOL *NextInstanceRet;
+ BOOLEAN IsMultiInstance;
+ UINTN Size;
+
+ Appended = AppendDevicePathInstance ((EFI_DEVICE_PATH_PROTOCOL
*)&mSimpleDevicePath, (EFI_DEVICE_PATH_PROTOCOL *)&mComplexDevicePath);
+ IsMultiInstance = IsDevicePathMultiInstance (Appended);
+ UT_ASSERT_TRUE (IsMultiInstance);
+ UT_ASSERT_MEM_EQUAL (Appended, &mSimpleDevicePath, sizeof
(ACPI_DEVICE_PATH));
+ NextInstance = Appended;
+ NextInstanceRet = GetNextDevicePathInstance (&NextInstance, &Size);
+ UT_ASSERT_MEM_EQUAL (NextInstance, &mComplexDevicePath, Size);
+ FreePool (Appended);
+ FreePool (NextInstanceRet);
+
+ Appended = AppendDevicePathInstance (NULL, (EFI_DEVICE_PATH_PROTOCOL
*)&mSimpleDevicePath);
+ UT_ASSERT_MEM_EQUAL (Appended, &mSimpleDevicePath, sizeof
(TEST_SIMPLE_DEVICE_PATH));
+ FreePool (Appended);
+
+ Appended = AppendDevicePathInstance (NULL, NULL);
+ UT_ASSERT_EQUAL ((uintptr_t)Appended, (uintptr_t)NULL);
+ FreePool (Appended);
+
+ Appended = AppendDevicePathInstance ((EFI_DEVICE_PATH_PROTOCOL
*)&mSimpleDevicePath, (EFI_DEVICE_PATH_PROTOCOL *)&mInvalidSimpleDevicePath);
+ UT_ASSERT_EQUAL ((uintptr_t)Appended, (uintptr_t)NULL);
+ FreePool (Appended);
+
+ return UNIT_TEST_PASSED;
+}
+
+UNIT_TEST_STATUS
+EFIAPI
+TestDevicePathFromHandle (
+ IN UNIT_TEST_CONTEXT Context
+ )
+{
+ EFI_HANDLE Handle;
+ EFI_DEVICE_PATH_PROTOCOL *DevicePath;
+ UINTN FakeHandle;
+
+ Handle = NULL;
+ DevicePath = DevicePathFromHandle (Handle);
+ UT_ASSERT_EQUAL ((uintptr_t)DevicePath, (uintptr_t)NULL);
+
+ Handle = (EFI_HANDLE)&FakeHandle;
+ DevicePath = DevicePathFromHandle (Handle);
+ UT_ASSERT_EQUAL ((uintptr_t)DevicePath, (uintptr_t)NULL);
+
+ return UNIT_TEST_PASSED;
+}
+
+UNIT_TEST_STATUS
+EFIAPI
+TestCreateDeviceNode (
+ IN UNIT_TEST_CONTEXT Context
+ )
+{
+ EFI_DEVICE_PATH_PROTOCOL *DevNode;
+
+ DevNode = CreateDeviceNode (HARDWARE_DEVICE_PATH, HW_PCI_DP, sizeof
(PCI_DEVICE_PATH));
+ UT_ASSERT_EQUAL (DevNode->Type, HARDWARE_DEVICE_PATH);
+ UT_ASSERT_EQUAL (DevNode->SubType, HW_PCI_DP);
+ UT_ASSERT_EQUAL (DevicePathNodeLength (DevNode), sizeof (PCI_DEVICE_PATH));
+
+ return UNIT_TEST_PASSED;
+}
+
+UNIT_TEST_STATUS
+EFIAPI
+TestFileDevicePath (
+ IN UNIT_TEST_CONTEXT Context
+ )
+{
+ EFI_HANDLE Handle;
+ FILEPATH_DEVICE_PATH *DevicePath;
+ CONST CHAR16 *TestFilePath = L"FS0:/Boot/EFI/BootMgr.efi";
+
+ Handle = NULL;
+ DevicePath = (FILEPATH_DEVICE_PATH *)FileDevicePath (Handle, TestFilePath);
+ UT_ASSERT_NOT_NULL (DevicePath);
+ UT_ASSERT_EQUAL (DevicePath->Header.Type, MEDIA_DEVICE_PATH);
+ UT_ASSERT_EQUAL (DevicePath->Header.Type, MEDIA_FILEPATH_DP);
+ UT_ASSERT_MEM_EQUAL (DevicePath->PathName, TestFilePath, StrSize
(TestFilePath));
+
+ 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 DevicePathSimpleTestSuite;
+ UNIT_TEST_SUITE_HANDLE DevicePathAppendTestSuite;
+ UNIT_TEST_SUITE_HANDLE DevicePathFileTestSuite;
+ SIMPLE_TEST_SUITE_CONTEXT SimpleTestContext;
+
+ DEBUG ((DEBUG_INFO, "%a v%a\n", UNIT_TEST_NAME, UNIT_TEST_VERSION));
+
+ Framework = NULL;
+ DevicePathSimpleTestSuite = NULL;
+ DevicePathAppendTestSuite = NULL;
+ DevicePathFileTestSuite = NULL;
+
+ 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;
+ }
+
+ Status = CreateUnitTestSuite (&DevicePathSimpleTestSuite, Framework, "Simple
device path operations test suite", "Common.DevicePath.SimpleOps", NULL, NULL);
+ if (EFI_ERROR (Status)) {
+ DEBUG ((DEBUG_ERROR, "Failed to create simple device path test suite\n"));
+ goto EXIT;
+ }
+
+ SimpleTestContext.SimpleDevicePath = &mSimpleDevicePath;
+ SimpleTestContext.InvalidDevicePath = &mInvalidSimpleDevicePath;
+ SimpleTestContext.ComplexDevicePath = &mComplexDevicePath;
+
+ AddTestCase (DevicePathSimpleTestSuite, "Test IsDevicePathValid",
"TestIsDevicePathValid", TestIsDevicePathValid, NULL, NULL, &SimpleTestContext);
+ AddTestCase (DevicePathSimpleTestSuite, "Test DevicePathType",
"TestDevicePathType", TestDevicePathType, NULL, NULL, &SimpleTestContext);
+ AddTestCase (DevicePathSimpleTestSuite, "Test DevicePathSubType",
"TestDevicePathSubType", TestDevicePathSubType, NULL, NULL, &SimpleTestContext);
+ AddTestCase (DevicePathSimpleTestSuite, "Test DevicePathNodeLength",
"TestDevicePathNodeLength", TestDevicePathNodeLength, NULL, NULL,
&SimpleTestContext);
+ AddTestCase (DevicePathSimpleTestSuite, "Test NextDevicePathNode",
"TestNextDevicePathNode", TestNextDevicePathNode, NULL, NULL,
&SimpleTestContext);
+ AddTestCase (DevicePathSimpleTestSuite, "Test IsDevicePathEndType",
"TestIsDevicePathEndType", TestIsDevicePathEndType, NULL, NULL,
&SimpleTestContext);
+ AddTestCase (DevicePathSimpleTestSuite, "Test IsDevicePathEnd",
"TestIsDevicePathEnd", TestIsDevicePathEnd, NULL, NULL, &SimpleTestContext);
+ AddTestCase (DevicePathSimpleTestSuite, "Test SetDevicePathNodeLength",
"TestSetDevicePathNodeLength", TestSetDevicePathNodeLength, NULL, NULL,
&SimpleTestContext);
+ AddTestCase (DevicePathSimpleTestSuite, "Test GetDevicePathSize",
"TestGetDevicePathSize", TestGetDevicePathSize, NULL, NULL, &SimpleTestContext);
+ AddTestCase (DevicePathSimpleTestSuite, "Test CreateDeviceNode",
"TestCreateDeviceNode", TestCreateDeviceNode, NULL, NULL, &SimpleTestContext);
+ AddTestCase (DevicePathSimpleTestSuite, "Test SetDevicePathEndNode",
"TestSetDevicePathEndNode", TestSetDevicePathEndNode, NULL, NULL,
&SimpleTestContext);
+ AddTestCase (DevicePathAppendTestSuite, "Test DuplicateDevicePath",
"TestDuplicateDevicePath", TestDuplicateDevicePath, NULL, NULL,
&SimpleTestContext);
+
+ Status = CreateUnitTestSuite (&DevicePathAppendTestSuite, Framework, "Device
path append operations test suite", "Common.DevicePath.Append", NULL, NULL);
+ if (EFI_ERROR (Status)) {
+ DEBUG ((DEBUG_ERROR, "Failed to create append device path test suite\n"));
+ goto EXIT;
+ }
+
+ AddTestCase (DevicePathAppendTestSuite, "Test AppendDevicePath",
"TestAppendDevicePath", TestAppendDevicePath, NULL, NULL, NULL);
+ AddTestCase (DevicePathAppendTestSuite, "Test AppendDevicePathNode",
"TestAppendDevicePathNode", TestAppendDevicePathNode, NULL, NULL, NULL);
+ AddTestCase (DevicePathAppendTestSuite, "Test AppendDevicePathInstance",
"TestAppendDevicePathInstance", TestAppendDevicePathInstance, NULL, NULL, NULL);
+
+ Status = CreateDevicePathStringConversionsTestSuite (Framework);
+ if (EFI_ERROR (Status)) {
+ DEBUG ((DEBUG_ERROR, "Failed to create conversions test suite\n"));
+ goto EXIT;
+ }
+
+ Status = CreateUnitTestSuite (&DevicePathFileTestSuite, Framework, "Device
path file operations test suite", "Common.DevicePath.FileDevPath", NULL, NULL);
+ if (EFI_ERROR (Status)) {
+ DEBUG ((DEBUG_ERROR, "Failed to create device path file test suite\n"));
+ goto EXIT;
+ }
+
+ AddTestCase (DevicePathFileTestSuite, "Test DevicePathFromHandle",
"TestDevicePathFromHandle", TestDevicePathFromHandle, NULL, NULL, NULL);
+ AddTestCase (DevicePathFileTestSuite, "Test FileDevicePath",
"TestFileDevicePath", TestFileDevicePath, NULL, NULL, NULL);
+
+ Status = RunAllTestSuites (Framework);
+
+EXIT:
+ if (Framework != NULL) {
+ FreeUnitTestFramework (Framework);
+ }
+
+ return Status;
+}
+
+int
+main (
+ int argc,
+ char *argv[]
+ )
+{
+ return UefiTestMain ();
+}
diff --git a/MdePkg/Test/UnitTest/Library/DevicePathLib/TestDevicePathLib.h
b/MdePkg/Test/UnitTest/Library/DevicePathLib/TestDevicePathLib.h
new file mode 100644
index 0000000000..4a0c3d4c43
--- /dev/null
+++ b/MdePkg/Test/UnitTest/Library/DevicePathLib/TestDevicePathLib.h
@@ -0,0 +1,26 @@
+/** @file
+ UEFI OS based application for unit testing the DevicePathLib.
+
+ Copyright (c) 2023, Intel Corporation. All rights reserved.<BR>
+ SPDX-License-Identifier: BSD-2-Clause-Patent
+**/
+
+#ifndef __TEST_DEVICE_PATH_LIB_H__
+#define __TEST_DEVICE_PATH_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 <Protocol/DevicePath.h>
+#include <Library/DevicePathLib.h>
+#include <stdint.h>
+
+EFI_STATUS
+CreateDevicePathStringConversionsTestSuite (
+ IN UNIT_TEST_FRAMEWORK_HANDLE Framework
+ );
+
+#endif
diff --git
a/MdePkg/Test/UnitTest/Library/DevicePathLib/TestDevicePathLibHost.inf
b/MdePkg/Test/UnitTest/Library/DevicePathLib/TestDevicePathLibHost.inf
new file mode 100644
index 0000000000..9f9c36946a
--- /dev/null
+++ b/MdePkg/Test/UnitTest/Library/DevicePathLib/TestDevicePathLibHost.inf
@@ -0,0 +1,33 @@
+## @file
+# Host OS based Application that Unit Tests the UefiDevicePathLib
+#
+# Copyright (c) 2023, Intel Corporation. All rights reserved.<BR>
+# SPDX-License-Identifier: BSD-2-Clause-Patent
+##
+
+[Defines]
+ INF_VERSION = 0x00010005
+ BASE_NAME = TestDevicePathLibHost
+ MODULE_UNI_FILE = TestDevicePathLib.uni
+ FILE_GUID = F1505A0E-D71F-4431-99BE-736776842E38
+ 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]
+ TestDevicePathLib.c
+ TestDevicePathStringConversions.c
+
+[Packages]
+ MdePkg/MdePkg.dec
+
+[LibraryClasses]
+ BaseLib
+ DebugLib
+ DevicePathLib
+ UnitTestLib
diff --git
a/MdePkg/Test/UnitTest/Library/DevicePathLib/TestDevicePathStringConversions.c
b/MdePkg/Test/UnitTest/Library/DevicePathLib/TestDevicePathStringConversions.c
new file mode 100644
index 0000000000..4ea25ec142
--- /dev/null
+++
b/MdePkg/Test/UnitTest/Library/DevicePathLib/TestDevicePathStringConversions.c
@@ -0,0 +1,370 @@
+/** @file
+ UEFI OS based application for unit testing the DevicePathLib.
+
+ Copyright (c) 2023, Intel Corporation. All rights reserved.<BR>
+ SPDX-License-Identifier: BSD-2-Clause-Patent
+
+**/
+
+#include "TestDevicePathLib.h"
+
+typedef struct {
+ EFI_DEVICE_PATH_PROTOCOL *DevPath;
+ CONST CHAR16 *DevPathString;
+} DEVICE_PATH_CONVERSIONS_TEST_CONTEXT;
+
+GLOBAL_REMOVE_IF_UNREFERENCED PCI_DEVICE_PATH mPciDevicePathNode =
+{
+ // PCI device path - root port (0x2:0x0)
+ {
+ HARDWARE_DEVICE_PATH,
+ HW_PCI_DP,
+ {
+ (UINT8)(sizeof (PCI_DEVICE_PATH)),
+ (UINT8)((sizeof (PCI_DEVICE_PATH)) >> 8)
+ }
+ },
+ 0x2,
+ 0x0
+};
+
+GLOBAL_REMOVE_IF_UNREFERENCED ACPI_HID_DEVICE_PATH
mAcpiPciRootHidDevicePathNode =
+{
+ // ACPI PCI root - PciRoot(0x0)
+ {
+ ACPI_DEVICE_PATH,
+ ACPI_DP,
+ {
+ (UINT8)(sizeof (ACPI_HID_DEVICE_PATH)),
+ (UINT8)((sizeof (ACPI_HID_DEVICE_PATH)) >> 8)
+ }
+ },
+ EISA_PNP_ID (0x0A03),
+ 0
+};
+
+GLOBAL_REMOVE_IF_UNREFERENCED ACPI_HID_DEVICE_PATH
mAcpiNonPciRootHidDevicePathNode =
+{
+ // Random ACPI device - ACPI(PNPB0C0, 1)
+ {
+ ACPI_DEVICE_PATH,
+ ACPI_DP,
+ {
+ (UINT8)(sizeof (ACPI_HID_DEVICE_PATH)),
+ (UINT8)((sizeof (ACPI_HID_DEVICE_PATH)) >> 8)
+ }
+ },
+ EISA_PNP_ID (0xB0C0),
+ 1
+};
+
+#define HID_STR_SIZE 8
+#define CID_STR_SIZE 8
+#define UID_STR_SIZE 8
+
+typedef struct {
+ ACPI_EXTENDED_HID_DEVICE_PATH AcpiEx;
+ CHAR8 HidStr[HID_STR_SIZE];
+ CHAR8 CidStr[CID_STR_SIZE];
+ CHAR8 UidStr[UID_STR_SIZE];
+} ACPI_EXTENDED_HID_DEVICE_PATH_FULL;
+
+GLOBAL_REMOVE_IF_UNREFERENCED ACPI_EXTENDED_HID_DEVICE_PATH_FULL
mAcpiExtendedDevicePathFull =
+{
+ // ACPI Extended HID PciRoot device node
+ {
+ {
+ ACPI_DEVICE_PATH,
+ ACPI_EXTENDED_DP,
+ {
+ (UINT8)(sizeof (ACPI_EXTENDED_HID_DEVICE_PATH_FULL)),
+ (UINT8)((sizeof (ACPI_EXTENDED_HID_DEVICE_PATH_FULL)) >> 8)
+ }
+ },
+ 0,
+ 0,
+ 0,
+ },
+ { 'P', 'N', 'P', 'B', '0', 'C', '0', '\0' }, // HIDSTR
+ { 'P', 'N', 'P', '0', '0', '0', '1', '\0' }, // CIDSTR
+ { 'U', 'I', 'D', '0', '0', '0', '0', '\0' } // UIDSTR
+};
+
+typedef struct {
+ ACPI_EXTENDED_HID_DEVICE_PATH AcpiEx;
+ CHAR8 HidStr[HID_STR_SIZE];
+} ACPI_EXTENDED_HID_DEVICE_PATH_PARTIAL;
+
+GLOBAL_REMOVE_IF_UNREFERENCED ACPI_EXTENDED_HID_DEVICE_PATH_PARTIAL
mAcpiExtendedDevicePathPartial =
+{
+ {
+ {
+ ACPI_DEVICE_PATH,
+ ACPI_EXTENDED_DP,
+ {
+ (UINT8)(sizeof (ACPI_EXTENDED_HID_DEVICE_PATH_PARTIAL)),
+ (UINT8)((sizeof (ACPI_EXTENDED_HID_DEVICE_PATH_PARTIAL)) >> 8)
+ }
+ },
+ 0,
+ 2,
+ 0,
+ },
+ { 'P', 'N', 'P', 'B', '0', '\0', '\0', '\0' }, // HIDSTR
+};
+
+typedef struct {
+ ACPI_EXTENDED_HID_DEVICE_PATH AcpiEx;
+ CHAR8 UidStr[UID_STR_SIZE];
+} ACPI_EXPANDED_DEVICE_PATH;
+
+GLOBAL_REMOVE_IF_UNREFERENCED ACPI_EXPANDED_DEVICE_PATH
mAcpiExpandedDevicePathUidOnly =
+{
+ {
+ {
+ ACPI_DEVICE_PATH,
+ ACPI_EXTENDED_DP,
+ {
+ (UINT8)(sizeof (ACPI_EXPANDED_DEVICE_PATH)),
+ (UINT8)((sizeof (ACPI_EXPANDED_DEVICE_PATH)) >> 8)
+ }
+ },
+ EISA_PNP_ID (0xAAAA),
+ 0,
+ 0,
+ },
+ { '\0', 'U', 'I', 'D', '0', '0', '\0', '\0' } // UIDSTR
+};
+
+GLOBAL_REMOVE_IF_UNREFERENCED ACPI_EXPANDED_DEVICE_PATH
mAcpiExpandedDevicePathUidOnlyWithCid =
+{
+ {
+ {
+ ACPI_DEVICE_PATH,
+ ACPI_EXTENDED_DP,
+ {
+ (UINT8)(sizeof (ACPI_EXPANDED_DEVICE_PATH)),
+ (UINT8)((sizeof (ACPI_EXPANDED_DEVICE_PATH)) >> 8)
+ }
+ },
+ EISA_PNP_ID (0xAAAA),
+ 0,
+ EISA_PNP_ID (0xAADD),
+ },
+ { '\0', 'U', 'I', 'D', '0', '0', '\0', '\0' } // UIDSTR
+};
+
+GLOBAL_REMOVE_IF_UNREFERENCED DEVICE_PATH_CONVERSIONS_TEST_CONTEXT
mDevPathNodeToFromTextContext[] = {
+ {
+ (EFI_DEVICE_PATH_PROTOCOL *)&mPciDevicePathNode,
+ L"Pci(0x0,0x2)"
+ },
+ {
+ (EFI_DEVICE_PATH_PROTOCOL *)&mAcpiPciRootHidDevicePathNode,
+ L"PciRoot(0x0)"
+ },
+ {
+ (EFI_DEVICE_PATH_PROTOCOL *)&mAcpiNonPciRootHidDevicePathNode,
+ L"Acpi(PNPB0C0,0x1)"
+ },
+ {
+ (EFI_DEVICE_PATH_PROTOCOL *)&mAcpiExtendedDevicePathFull,
+ L"AcpiEx(@@@0000,@@@0000,0x0,PNPB0C0,UID0000,PNP0001)"
+ },
+ {
+ (EFI_DEVICE_PATH_PROTOCOL *)&mAcpiExtendedDevicePathPartial,
+ L"AcpiEx(@@@0000,@@@0000,0x2,PNPB0,,)"
+ },
+ {
+ (EFI_DEVICE_PATH_PROTOCOL *)&mAcpiExpandedDevicePathUidOnly,
+ L"AcpiExp(PNPAAAA,0,UID00)"
+ },
+ {
+ (EFI_DEVICE_PATH_PROTOCOL *)&mAcpiExpandedDevicePathUidOnlyWithCid,
+ L"AcpiExp(PNPAAAA,PNPAADD,UID00)"
+ }
+};
+
+typedef struct {
+ ACPI_HID_DEVICE_PATH AcpiPath;
+ PCI_DEVICE_PATH PciPathRootPort;
+ PCI_DEVICE_PATH PciPathEndPoint;
+ USB_DEVICE_PATH UsbPath;
+ EFI_DEVICE_PATH_PROTOCOL End;
+} TEST_CONVERSIONS_DEVICE_PATH;
+
+GLOBAL_REMOVE_IF_UNREFERENCED TEST_CONVERSIONS_DEVICE_PATH
mConversionsDevicePath = {
+ { // ACPI device path with root bridge EISA_PNP_ID
+ {
+ ACPI_DEVICE_PATH,
+ ACPI_DP,
+ {
+ (UINT8)(sizeof (ACPI_HID_DEVICE_PATH)),
+ (UINT8)((sizeof (ACPI_HID_DEVICE_PATH)) >> 8)
+ }
+ },
+ EISA_PNP_ID (0x0A03),
+ 0
+ },
+ { // PCI device path - root port (0x2:0x0)
+ {
+ HARDWARE_DEVICE_PATH,
+ HW_PCI_DP,
+ {
+ (UINT8)(sizeof (PCI_DEVICE_PATH)),
+ (UINT8)((sizeof (PCI_DEVICE_PATH)) >> 8)
+ }
+ },
+ 0x2,
+ 0x0
+ },
+ { // PCI device path - endpoint (0x0:0x0)
+ {
+ HARDWARE_DEVICE_PATH,
+ HW_PCI_DP,
+ {
+ (UINT8)(sizeof (PCI_DEVICE_PATH)),
+ (UINT8)((sizeof (PCI_DEVICE_PATH)) >> 8)
+ }
+ },
+ 0x0,
+ 0x0
+ },
+ { // USB interface
+ {
+ MESSAGING_DEVICE_PATH,
+ MSG_USB_DP,
+ {
+ (UINT8)(sizeof (USB_DEVICE_PATH)),
+ (UINT8)((sizeof (USB_CLASS_DEVICE_PATH)) >> 8)
+ }
+ },
+ 0,
+ 2
+ },
+ {
+ END_DEVICE_PATH_TYPE,
+ END_ENTIRE_DEVICE_PATH_SUBTYPE,
+ {
+ (UINT8)(sizeof (EFI_DEVICE_PATH_PROTOCOL)),
+ (UINT8)((sizeof (EFI_DEVICE_PATH_PROTOCOL)) >> 8)
+ }
+ }
+};
+
+GLOBAL_REMOVE_IF_UNREFERENCED DEVICE_PATH_CONVERSIONS_TEST_CONTEXT
mDevPathToFromTextContext[] = {
+ {
+ (EFI_DEVICE_PATH_PROTOCOL *)&mConversionsDevicePath,
+ L"PciRoot(0x0)/Pci(0x0,0x2)/Pci(0x0,0x0)/USB(0x0,0x2)"
+ }
+};
+
+UNIT_TEST_STATUS
+EFIAPI
+TestConvertDevicePathToText (
+ IN UNIT_TEST_CONTEXT Context
+ )
+{
+ CHAR16 *DevPathString;
+ DEVICE_PATH_CONVERSIONS_TEST_CONTEXT *TestContext;
+
+ TestContext = (DEVICE_PATH_CONVERSIONS_TEST_CONTEXT *)Context;
+
+ DevPathString = ConvertDevicePathToText (TestContext->DevPath, FALSE, FALSE);
+ UT_ASSERT_EQUAL (StrLen (DevPathString), StrLen
(TestContext->DevPathString));
+ UT_ASSERT_MEM_EQUAL (DevPathString, TestContext->DevPathString, StrLen
(TestContext->DevPathString));
+ FreePool (DevPathString);
+
+ return UNIT_TEST_PASSED;
+}
+
+UNIT_TEST_STATUS
+EFIAPI
+TestConvertTextToDevicePath (
+ IN UNIT_TEST_CONTEXT Context
+ )
+{
+ EFI_DEVICE_PATH_PROTOCOL *ConvertedDevPath;
+ DEVICE_PATH_CONVERSIONS_TEST_CONTEXT *TestContext;
+
+ TestContext = (DEVICE_PATH_CONVERSIONS_TEST_CONTEXT *)Context;
+
+ ConvertedDevPath = ConvertTextToDevicePath (TestContext->DevPathString);
+ UT_ASSERT_EQUAL (GetDevicePathSize (ConvertedDevPath), GetDevicePathSize
(TestContext->DevPath));
+ UT_ASSERT_MEM_EQUAL (ConvertedDevPath, TestContext->DevPath,
GetDevicePathSize (TestContext->DevPath));
+ FreePool (ConvertedDevPath);
+
+ return UNIT_TEST_PASSED;
+}
+
+UNIT_TEST_STATUS
+EFIAPI
+TestConvertDeviceNodeToText (
+ IN UNIT_TEST_CONTEXT Context
+ )
+{
+ CHAR16 *DevPathNodeString;
+ DEVICE_PATH_CONVERSIONS_TEST_CONTEXT *TestContext;
+
+ TestContext = (DEVICE_PATH_CONVERSIONS_TEST_CONTEXT *)Context;
+
+ DevPathNodeString = ConvertDeviceNodeToText (TestContext->DevPath, FALSE,
FALSE);
+ UT_ASSERT_EQUAL (StrLen (DevPathNodeString), StrLen
(TestContext->DevPathString));
+ UT_ASSERT_MEM_EQUAL (DevPathNodeString, TestContext->DevPathString, StrLen
(TestContext->DevPathString));
+ FreePool (DevPathNodeString);
+
+ return UNIT_TEST_PASSED;
+}
+
+UNIT_TEST_STATUS
+EFIAPI
+TestConvertTextToDeviceNode (
+ IN UNIT_TEST_CONTEXT Context
+ )
+{
+ EFI_DEVICE_PATH_PROTOCOL *DevPath;
+ DEVICE_PATH_CONVERSIONS_TEST_CONTEXT *TestContext;
+
+ TestContext = (DEVICE_PATH_CONVERSIONS_TEST_CONTEXT *)Context;
+
+ DevPath = ConvertTextToDeviceNode (TestContext->DevPathString);
+ UT_ASSERT_EQUAL (DevicePathNodeLength (DevPath), DevicePathNodeLength
(TestContext->DevPath));
+ UT_ASSERT_MEM_EQUAL (DevPath, TestContext->DevPath, DevicePathNodeLength
(TestContext->DevPath));
+ FreePool (DevPath);
+
+ return UNIT_TEST_PASSED;
+}
+
+EFI_STATUS
+CreateDevicePathStringConversionsTestSuite (
+ IN UNIT_TEST_FRAMEWORK_HANDLE Framework
+ )
+{
+ EFI_STATUS Status;
+ UNIT_TEST_SUITE_HANDLE DevicePathTextConversionSuite = NULL;
+ UINTN Index;
+
+ Status = CreateUnitTestSuite (&DevicePathTextConversionSuite, Framework,
"Device path text conversion operations test suite",
"Common.DevicePath.TextConversions", NULL, NULL);
+ if (EFI_ERROR (Status)) {
+ DEBUG ((DEBUG_ERROR, "Failed to create device path text conversions test
suite\n"));
+ return Status;
+ }
+
+ for (Index = 0; Index < ARRAY_SIZE (mDevPathNodeToFromTextContext); Index++)
{
+ AddTestCase (DevicePathTextConversionSuite, "Test
ConvertDeviceNodeToText", "TestConvertDeviceNodeToText",
TestConvertDeviceNodeToText, NULL, NULL, &mDevPathNodeToFromTextContext[Index]);
+ }
+
+ for (Index = 0; Index < ARRAY_SIZE (mDevPathNodeToFromTextContext); Index++)
{
+ AddTestCase (DevicePathTextConversionSuite, "Test
ConvertTextToDeviceNode", "TestConvertTextToDeviceNode",
TestConvertTextToDeviceNode, NULL, NULL, &mDevPathNodeToFromTextContext[Index]);
+ }
+
+ for (Index = 0; Index < ARRAY_SIZE (mDevPathToFromTextContext); Index++) {
+ AddTestCase (DevicePathTextConversionSuite, "Test
ConvertDevicePathToText", "TestConvertDevicePathToText",
TestConvertDevicePathToText, NULL, NULL, &mDevPathToFromTextContext[Index]);
+ }
+
+ for (Index = 0; Index < ARRAY_SIZE (mDevPathToFromTextContext); Index++) {
+ AddTestCase (DevicePathTextConversionSuite, "Test
ConvertTextToDevicePath", "TestConvertTextToDevicePath",
TestConvertTextToDevicePath, NULL, NULL, &mDevPathToFromTextContext[Index]);
+ }
+
+ return EFI_SUCCESS;
+}
--
2.39.2
---------------------------------------------------------------------
Intel Technology Poland sp. z o.o.
ul. Slowackiego 173 | 80-298 Gdansk | Sad Rejonowy Gdansk Polnoc | VII Wydzial
Gospodarczy Krajowego Rejestru Sadowego - KRS 101882 | NIP 957-07-52-316 |
Kapital zakladowy 200.000 PLN.
Spolka oswiadcza, ze posiada status duzego przedsiebiorcy w rozumieniu ustawy z
dnia 8 marca 2013 r. o przeciwdzialaniu nadmiernym opoznieniom w transakcjach
handlowych.
Ta wiadomosc wraz z zalacznikami jest przeznaczona dla okreslonego adresata i
moze zawierac informacje poufne. W razie przypadkowego otrzymania tej
wiadomosci, prosimy o powiadomienie nadawcy oraz trwale jej usuniecie;
jakiekolwiek przegladanie lub rozpowszechnianie jest zabronione.
This e-mail and any attachments may contain confidential material for the sole
use of the intended recipient(s). If you are not the intended recipient, please
contact the sender and delete all copies; any review or distribution by others
is strictly prohibited.
-=-=-=-=-=-=-=-=-=-=-=-
Groups.io Links: You receive all messages sent to this group.
View/Reply Online (#109126): https://edk2.groups.io/g/devel/message/109126
Mute This Topic: https://groups.io/mt/101619981/21656
Group Owner: devel+ow...@edk2.groups.io
Unsubscribe: https://edk2.groups.io/g/devel/unsub [arch...@mail-archive.com]
-=-=-=-=-=-=-=-=-=-=-=-
