vendor/edk2/edk2-stable202411

1 files changed, 370 insertions, 0 deletions

diff --git a/MdePkg/Test/UnitTest/Library/DevicePathLib/TestDevicePathStringConversions.c b/MdePkg/Test/UnitTest/Library/DevicePathLib/TestDevicePathStringConversions.c
new file mode 100644
index 000000000000..52bf4df9a125
--- /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;
+}