diff options
Diffstat (limited to 'MdePkg/Test/UnitTest/Library/DevicePathLib/TestDevicePathLib.c')
| -rw-r--r-- | MdePkg/Test/UnitTest/Library/DevicePathLib/TestDevicePathLib.c | 636 |
1 files changed, 636 insertions, 0 deletions
diff --git a/MdePkg/Test/UnitTest/Library/DevicePathLib/TestDevicePathLib.c b/MdePkg/Test/UnitTest/Library/DevicePathLib/TestDevicePathLib.c new file mode 100644 index 000000000000..0a7be44527e6 --- /dev/null +++ b/MdePkg/Test/UnitTest/Library/DevicePathLib/TestDevicePathLib.c @@ -0,0 +1,636 @@ +/** @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); + + Appended = AppendDevicePathInstance ((EFI_DEVICE_PATH_PROTOCOL *)&mSimpleDevicePath, (EFI_DEVICE_PATH_PROTOCOL *)&mInvalidSimpleDevicePath); + UT_ASSERT_EQUAL ((uintptr_t)Appended, (uintptr_t)NULL); + + 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 (); +} |