mirror of https://github.com/acidanthera/audk.git
639 lines
20 KiB
C
639 lines
20 KiB
C
/** @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 ();
|
|
}
|