//
// TDS
//
EFI_STATUS
BBTestLengthParameterAutoTest (
IN EFI_BB_TEST_PROTOCOL *This,
IN VOID *ClientInterface,
IN EFI_TEST_LEVEL TestLevel,
IN EFI_HANDLE SupportHandle
)
{
EFI_STANDARD_TEST_LIBRARY_PROTOCOL *StandardLib;
EFI_STATUS Status;
EFI_DRIVER_SUPPORTED_EFI_VERSION_PROTOCOL *DriverSupportedEfiVersion;
EFI_TEST_ASSERTION AssertionType;
UINT32 EfiVersionProtocolLength;
//
// Get the Standard Library Interface
//
Status = gtBS->HandleProtocol (
SupportHandle,
&gEfiStandardTestLibraryGuid,
&StandardLib
);
if (EFI_ERROR(Status)) {
StandardLib->RecordAssertion (
StandardLib,
EFI_TEST_ASSERTION_FAILED,
gTestGenericFailureGuid,
L"BS.HandleProtocol - Handle standard test library",
L"%a:%d:Status - %r",
__FILE__,
(UINTN)__LINE__,
Status
);
return Status;
}
DriverSupportedEfiVersion = (EFI_DRIVER_SUPPORTED_EFI_VERSION_PROTOCOL *)ClientInterface;
EfiVersionProtocolLength =sizeof( EFI_DRIVER_SUPPORTED_EFI_VERSION_PROTOCOL);
if(DriverSupportedEfiVersion->Length ==EfiVersionProtocolLength){
AssertionType = EFI_TEST_ASSERTION_PASSED;
}else{
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gDriverSupportedEfiVersionTestAssertionGuid001,
L"EFI_DRIVER_SUPPORTED_EFI_VERSION_PROTOCOL.Length,compare with length of EfiVersionProtocol",
L"%a:%d: Length = %d, EfiVersionProtocolLength = %d, Expected=%r",
__FILE__,
(UINTN)__LINE__,
DriverSupportedEfiVersion->Length,
EfiVersionProtocolLength,
EFI_SUCCESS
);
return EFI_SUCCESS;
}
//
// TDS 4.3
//
EFI_STATUS
BBTestGetVersionConformanceTest (
IN EFI_BB_TEST_PROTOCOL *This,
IN VOID *ClientInterface,
IN EFI_TEST_LEVEL TestLevel,
IN EFI_HANDLE SupportHandle
)
{
EFI_STANDARD_TEST_LIBRARY_PROTOCOL *StandardLib;
EFI_STATUS Status;
EFI_TEST_ASSERTION AssertionType;
EFI_EBC_PROTOCOL *EbcInterface;
//
// Verify whether it is one of IHV interfaces
//
if (! IsIhvInterface (ClientInterface, SupportHandle)) {
return EFI_UNSUPPORTED;
}
//
// Get the Standard Library Interface
//
Status = gtBS->HandleProtocol (
SupportHandle,
&gEfiStandardTestLibraryGuid,
&StandardLib
);
if ( EFI_ERROR(Status) ) {
return Status;
}
//
// Get the EFI_EBC_PROTOCOL Protocol interface to be tested
//
EbcInterface = (EFI_EBC_PROTOCOL *)ClientInterface;
//
// 4.3.2.1 Call GetVersion() with Invalid Parameters
//
Status = EbcInterface->GetVersion(EbcInterface, NULL);
if (Status == EFI_INVALID_PARAMETER) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gEbcBBTestConformanceAssertionGuid003,
L"EFI_EBC_PROTOCOL.GetVersion - Call GetVersion() with Invalid Parameters",
L"%a:%d:Status - %r",
__FILE__,
__LINE__,
Status
);
return EFI_SUCCESS;
}
//
// TDS 3.4
//
EFI_STATUS
BBTestGetVersionBasicTest (
IN EFI_BB_TEST_PROTOCOL *This,
IN VOID *ClientInterface,
IN EFI_TEST_LEVEL TestLevel,
IN EFI_HANDLE SupportHandle
)
{
EFI_STANDARD_TEST_LIBRARY_PROTOCOL *StandardLib;
EFI_STATUS Status;
EFI_TEST_ASSERTION AssertionType;
EFI_EBC_PROTOCOL *EbcInterface;
UINT64 Version;
//
// Get the Standard Library Interface
//
Status = gtBS->HandleProtocol (
SupportHandle,
&gEfiStandardTestLibraryGuid,
&StandardLib
);
if (EFI_ERROR(Status)) {
return Status;
}
//
// Get the EFI_EBC_PROTOCOL Protocol interface to be tested
//
EbcInterface = (EFI_EBC_PROTOCOL *)ClientInterface;
//
// 3.4.2.1 GetVersion() Basic Functionality
//
Status = EbcInterface->GetVersion (EbcInterface, &Version);
if (Status == EFI_SUCCESS) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gEbcBBTestFunctionAssertionGuid006,
L"EFI_EBC_PROTOCOL.GetVersion - Call GetVersion to get ebc interpreter version",
L"%a:%d:Status - %r, Version - 0x%lx",
__FILE__,
__LINE__,
Status,
Version
);
return EFI_SUCCESS;
}
/**
* @brief For Check the value of MX CSR test
* @param This a pointer of EFI_BB_TEST_PROTOCOL
* @param ClientInterface A pointer to the interface array under test
* @param TestLevel Test "thoroughness" control
* @param SupportHandle A handle containing protocols required
* @return EFI_SUCCESS
*/
EFI_STATUS
BBTestMxCsrTest (
IN EFI_BB_TEST_PROTOCOL *This,
IN VOID *ClientInterface,
IN EFI_TEST_LEVEL TestLevel,
IN EFI_HANDLE SupportHandle
)
{
EFI_STANDARD_TEST_LIBRARY_PROTOCOL *StandardLib;
EFI_STATUS Status;
EFI_TEST_ASSERTION AssertionType;
UINT32 MxCsr;
//
// Get the Standard Library Interface
//
Status = gtBS->HandleProtocol (
SupportHandle,
&gEfiStandardTestLibraryGuid,
&StandardLib
);
if (EFI_ERROR (Status)) {
return Status;
}
//
// record assertion for the returned MX CSR.
//
Status = GetMxCsr(&MxCsr);
if (MxCsr == MX_CSR_VALUE) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gBasicTestAssertionGuid002,
L"EFI_EXE_MODE - Get MX CSR",
L"%a:%d:MX CSR got %x",
__FILE__,
__LINE__,
MxCsr
);
//
//done successfully.
//
return EFI_SUCCESS;
}
//
// TDS 3.4.5
//
EFI_STATUS
DevicePathUtilitiesGetNextDevicePathInstanceConformanceTest (
IN EFI_BB_TEST_PROTOCOL *This,
IN VOID *ClientInterface,
IN EFI_TEST_LEVEL TestLevel,
IN EFI_HANDLE SupportHandle
)
{
EFI_STANDARD_TEST_LIBRARY_PROTOCOL *StandardLib;
EFI_STATUS Status;
EFI_DEVICE_PATH_UTILITIES_PROTOCOL *DevicePathUtilities;
EFI_TEST_ASSERTION AssertionType;
EFI_DEVICE_PATH_PROTOCOL *pDevicePath1;
EFI_DEVICE_PATH_PROTOCOL *pDevicePath2;
UINTN DevicePathInstanceSize;
//
// Get the Standard Library Interface
//
Status = gtBS->HandleProtocol (
SupportHandle,
&gEfiStandardTestLibraryGuid,
&StandardLib
);
if (EFI_ERROR (Status)) {
return Status;
}
DevicePathUtilities = (EFI_DEVICE_PATH_UTILITIES_PROTOCOL *) ClientInterface;
//
// TDS 3.4.5.2.1
//
pDevicePath1 = NULL;
pDevicePath2 = DevicePathUtilities->GetNextDevicePathInstance (&pDevicePath1, &DevicePathInstanceSize);
if (pDevicePath2 == NULL) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gDevicePathUtilitiesBBTestFunctionAssertionGuid064,
L"EFI_DEVICE_PATH_UTILITIES_PROTOCOL - GetNextDevicePathInstance should not succeed with DevicePathInstance set to be NULL",
L"%a:%d:Status - %r",
__FILE__,
(UINTN)__LINE__
);
return EFI_SUCCESS;
}
//
// TDS 4.2
//
EFI_STATUS
BBTestUnloadImageConformanceTest (
IN EFI_BB_TEST_PROTOCOL *This,
IN VOID *ClientInterface,
IN EFI_TEST_LEVEL TestLevel,
IN EFI_HANDLE SupportHandle
)
{
EFI_STANDARD_TEST_LIBRARY_PROTOCOL *StandardLib;
EFI_STATUS Status;
EFI_TEST_ASSERTION AssertionType;
EFI_EBC_PROTOCOL *EbcInterface;
//
// Get the Standard Library Interface
//
Status = gtBS->HandleProtocol (
SupportHandle,
&gEfiStandardTestLibraryGuid,
&StandardLib
);
if (EFI_ERROR(Status)) {
return Status;
}
//
// Get the EFI_EBC_PROTOCOL Protocol interface to be tested
//
EbcInterface = (EFI_EBC_PROTOCOL *)ClientInterface;
//
// 4.2.2.1 Call UnloadImage() with Invalid Parameters
//
Status = EbcInterface->UnloadImage (EbcInterface, (EFI_HANDLE)((UINTN)gDummyImageHandle+1));
if (Status == EFI_INVALID_PARAMETER) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gEbcBBTestConformanceAssertionGuid002,
L"EFI_EBC_PROTOCOL.UnloadImage - Call UnloadImage() with Invalid Parameters",
L"%a:%d:Status - %r",
__FILE__,
(UINTN)__LINE__,
Status
);
return EFI_SUCCESS;
}
//
// TDS 3.1
//
EFI_STATUS
BBTestGetTimeConsistencyTest (
IN EFI_BB_TEST_PROTOCOL *This,
IN VOID *ClientInterface,
IN EFI_TEST_LEVEL TestLevel,
IN EFI_HANDLE SupportHandle
)
{
EFI_STANDARD_TEST_LIBRARY_PROTOCOL *StandardLib;
EFI_STATUS Status;
EFI_TEST_ASSERTION AssertionType;
//
// Get the Standard Library Interface
//
Status = gtBS->HandleProtocol (
SupportHandle,
&gEfiStandardTestLibraryGuid,
&StandardLib
);
if (EFI_ERROR(Status)) {
return Status;
}
//
// 3.1.2.1 GetTime should not succeed when Time is NULL
//
// BUG:2744
Status = gtRT->GetTime (
NULL,
NULL
);
if (Status == EFI_INVALID_PARAMETER) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gTimeServicesBBTestConformanceAssertionGuid001,
L"RT.GetTime - Time is NULL",
L"%a:%d:Status - %r",
__FILE__,
__LINE__,
Status
);
return EFI_SUCCESS;
}
//
// TDS 3.4.1
//
EFI_STATUS
DevicePathUtilitiesCreateDeviceNodeConformanceTest (
IN EFI_BB_TEST_PROTOCOL *This,
IN VOID *ClientInterface,
IN EFI_TEST_LEVEL TestLevel,
IN EFI_HANDLE SupportHandle
)
{
EFI_STANDARD_TEST_LIBRARY_PROTOCOL *StandardLib;
EFI_STATUS Status;
EFI_DEVICE_PATH_UTILITIES_PROTOCOL *DevicePathUtilities;
EFI_TEST_ASSERTION AssertionType;
EFI_DEVICE_PATH_PROTOCOL *pDevicePath;
//
// Get the Standard Library Interface
//
Status = gtBS->HandleProtocol (
SupportHandle,
&gEfiStandardTestLibraryGuid,
&StandardLib
);
if (EFI_ERROR (Status)) {
return Status;
}
DevicePathUtilities = (EFI_DEVICE_PATH_UTILITIES_PROTOCOL *) ClientInterface;
//
// TDS 3.4.1.2.1
//
pDevicePath = DevicePathUtilities->CreateDeviceNode (PCINodeType, PCINodeSubType, InvalidNodeLength);
if (pDevicePath == NULL) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gDevicePathUtilitiesBBTestFunctionAssertionGuid052,
L"EFI_DEVICE_PATH_UTILITIES_PROTOCOL - CreatDeviceNode should not succeed with invalid NodeLength set",
L"%a:%d:Status - %r",
__FILE__,
(UINTN)__LINE__
);
return EFI_SUCCESS;
}
EFI_STATUS
DevicePathUtilitiesDuplicateDevicePathConformanceTest (
IN EFI_BB_TEST_PROTOCOL *This,
IN VOID *ClientInterface,
IN EFI_TEST_LEVEL TestLevel,
IN EFI_HANDLE SupportHandle
)
{
EFI_STANDARD_TEST_LIBRARY_PROTOCOL *StandardLib;
EFI_STATUS Status;
EFI_DEVICE_PATH_UTILITIES_PROTOCOL *DevicePathUtilities;
EFI_TEST_ASSERTION AssertionType;
EFI_DEVICE_PATH_PROTOCOL *pDevicePath;
//
// Get the Standard Library Interface
//
Status = gtBS->HandleProtocol (
SupportHandle,
&gEfiStandardTestLibraryGuid,
&StandardLib
);
if (EFI_ERROR (Status)) {
return Status;
}
DevicePathUtilities = (EFI_DEVICE_PATH_UTILITIES_PROTOCOL *) ClientInterface;
pDevicePath = DevicePathUtilities->DuplicateDevicePath(NULL);
if (pDevicePath == NULL) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gDevicePathUtilitiesBBTestFunctionAssertionGuid071,
L"EFI_DEVICE_PATH_UTILITIES_PROTOCOL - DuplicateDevicePath() should return NULL if DevicePath is NULL",
L"%a:%d",
__FILE__,
(UINTN)__LINE__
);
return EFI_SUCCESS;
}
//
// TDS 3.1
//
EFI_STATUS
BBTestDevicePathNodeConformanceAutoTest (
IN EFI_BB_TEST_PROTOCOL *This,
IN VOID *ClientInterface,
IN EFI_TEST_LEVEL TestLevel,
IN EFI_HANDLE SupportHandle
)
{
EFI_STANDARD_TEST_LIBRARY_PROTOCOL *StandardLib;
EFI_STATUS Status;
EFI_DEVICE_PATH_PROTOCOL *DevicePath;
EFI_TEST_ASSERTION AssertionType;
UINT16 Type;
UINT16 SubType;
UINT16 Length;
MEMMAP_DEVICE_PATH *MemMap;
IPv4_DEVICE_PATH *IPv4;
IPv6_DEVICE_PATH *IPv6;
ATAPI_DEVICE_PATH *Atapi;
UART_DEVICE_PATH *Uart;
VENDOR_DEVICE_PATH *Vendor;
HARDDRIVE_DEVICE_PATH *Hd;
CHAR16 *DevStr;
//
// Verify whether it is one of IHV interfaces
//
if (! IsIhvInterface (ClientInterface, SupportHandle)) {
return EFI_UNSUPPORTED;
}
//
// Get the Standard Library Interface
//
Status = gtBS->HandleProtocol (
SupportHandle,
&gEfiStandardTestLibraryGuid,
&StandardLib
);
if (EFI_ERROR(Status)) {
StandardLib->RecordAssertion (
StandardLib,
EFI_TEST_ASSERTION_FAILED,
gTestGenericFailureGuid,
L"BS.HandleProtocol - Handle standard test library",
L"%a:%d:Status - %r",
__FILE__,
__LINE__,
Status
);
return Status;
}
DevicePath = (EFI_DEVICE_PATH_PROTOCOL *)ClientInterface;
DevStr = DevicePathToStr (DevicePath);
StandardLib->RecordMessage (
StandardLib,
EFI_VERBOSE_LEVEL_QUIET,
L"\nVerifying device path: %s\n",
DevStr
);
gtBS->FreePool (DevStr);
while (!IsDevicePathEnd (DevicePath)) {
Type = (UINT16)DevicePathType (DevicePath);
SubType = (UINT16)DevicePathSubType (DevicePath);
Length = (UINT16)DevicePathNodeLength (DevicePath);
//
// Assertion Point 3.1.2.2
// Check End of Hardware Device Path: End This Device Path
//
if ((Type == 0x7F || Type == 0xFF) && (SubType == 0x01)) {
if (Length == 4) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gDevicePathBBTestFunctionAssertionGuid001,
L"EFI_DEVICE_PATH_PROTOCOL - End of Hardware Device Path - End This Device Path",
L"%a:%d:Type - %d, Subtype - %d, Length - %d",
__FILE__,
__LINE__,
Type,
SubType,
Length
);
}
//
// Assertion Point 3.1.2.3
// Check Hardware Device Path: PCI Device Path
//
else if ((Type == 1) && (SubType == 1)) {
if (Length == 6) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gDevicePathBBTestFunctionAssertionGuid002,
L"EFI_DEVICE_PATH_PROTOCOL - Hardware Device Path - PCI Device Path",
L"%a:%d:Type - %d, Subtype - %d, Length - %d",
__FILE__,
__LINE__,
Type,
SubType,
Length
);
}
//
// Assertion Point 3.1.2.4
// Check Hardware Device Path: PCCARD Device Path
//
else if ((Type == 1) && (SubType == 2)) {
if (Length == 5) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gDevicePathBBTestFunctionAssertionGuid003,
L"EFI_DEVICE_PATH_PROTOCOL - Hardware Device Path - PCCARD Device Path",
L"%a:%d:Type - %d, Subtype - %d, Length - %d",
__FILE__,
__LINE__,
Type,
SubType,
Length
);
}
//
// Assertion Point 3.1.2.5
// Check Hardware Device Path: Memory Mapped Device Path
//
else if ((Type == 1) && (SubType == 3)) {
MemMap = (MEMMAP_DEVICE_PATH *)DevicePath;
if ((Length == 24) &&
(MemMap->MemoryType < EfiMaxMemoryType || MemMap->MemoryType > 0x7FFFFFFF) &&
(MemMap->EndingAddress >= MemMap->StartingAddress)) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gDevicePathBBTestFunctionAssertionGuid004,
L"EFI_DEVICE_PATH_PROTOCOL - Hardware Device Path - Memory Mapped Device Path",
L"%a:%d:Type - %d, Subtype - %d, Length - %d",
__FILE__,
__LINE__,
Type,
SubType,
Length
);
}
//
// Assertion Point 3.1.2.6
// Check Hardware Device Path: Vendor Device Path
//
else if ((Type == 1) && (SubType == 4)) {
if (Length >= 20) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gDevicePathBBTestFunctionAssertionGuid005,
L"EFI_DEVICE_PATH_PROTOCOL - Hardware Device Path - Vendor Device Path",
L"%a:%d:Type - %d, Subtype - %d, Length - %d",
__FILE__,
__LINE__,
Type,
SubType,
Length
);
}
//
// Assertion Point 3.1.2.7
// Check Hardware Device Path: Controller Device Path
//
else if ((Type == 1) && (SubType == 5)) {
if (Length == 8) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gDevicePathBBTestFunctionAssertionGuid006,
L"EFI_DEVICE_PATH_PROTOCOL - Hardware Device Path - Controller Device Path",
L"%a:%d:Type - %d, Subtype - %d, Length - %d",
__FILE__,
__LINE__,
Type,
SubType,
Length
);
}
//
// Assertion Point 3.1.2.8
// Check ACPI Device Path: ACPI Device Path
//
else if ((Type == 2) && (SubType == 1)) {
if (Length == 12) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gDevicePathBBTestFunctionAssertionGuid007,
L"EFI_DEVICE_PATH_PROTOCOL - ACPI Device Path - ACPI Device Path",
L"%a:%d:Type - %d, Subtype - %d, Length - %d",
__FILE__,
__LINE__,
Type,
SubType,
Length
);
}
//
// Assertion Point 3.1.2.9
// Check ACPI Device Path: Expanded ACPI Device Path
//
else if ((Type == 2) && (SubType == 2)) {
if (Length >= 19) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gDevicePathBBTestFunctionAssertionGuid008,
L"EFI_DEVICE_PATH_PROTOCOL - ACPI Device Path - Expanded ACPI Device Path",
L"%a:%d:Type - %d, Subtype - %d, Length - %d",
__FILE__,
__LINE__,
Type,
SubType,
Length
);
}
//
// Assertion Point 3.1.2.10
// Check Messaging Device Path: ATAPI Device Path
//
else if ((Type == 3) && (SubType == 1)) {
Atapi = (ATAPI_DEVICE_PATH*)DevicePath;
if ((Length == 8) &&
(Atapi->PrimarySecondary == 0 || Atapi->PrimarySecondary == 1) &&
(Atapi->SlaveMaster == 0 || Atapi->SlaveMaster == 1)) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gDevicePathBBTestFunctionAssertionGuid009,
L"EFI_DEVICE_PATH_PROTOCOL - Messaging Device Path - ATAPI Device Path",
L"%a:%d:Type - %d, Subtype - %d, Length - %d",
__FILE__,
__LINE__,
Type,
SubType,
Length
);
}
//
// Assertion Point 3.1.2.11
// Check Messaging Device Path: SCSI Device Path
//
else if ((Type == 3) && (SubType == 2)) {
if (Length == 8) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gDevicePathBBTestFunctionAssertionGuid010,
L"EFI_DEVICE_PATH_PROTOCOL - Messaging Device Path - SCSI Device Path",
L"%a:%d:Type - %d, Subtype - %d, Length - %d",
__FILE__,
__LINE__,
Type,
SubType,
Length
);
}
//
// Assertion Point 3.1.2.12
// Check Messaging Device Path: Fibre Channel Device Path
//
else if ((Type == 3) && (SubType == 3)) {
if (Length == 24) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gDevicePathBBTestFunctionAssertionGuid011,
L"EFI_DEVICE_PATH_PROTOCOL - Messaging Device Path - Fibre Channel Device Path",
L"%a:%d:Type - %d, Subtype - %d, Length - %d",
__FILE__,
__LINE__,
Type,
SubType,
Length
);
}
//
// Assertion Point 3.1.2.13
// Check Messaging Device Path: 1394 Device Path
//
else if ((Type == 3) && (SubType == 4)) {
if (Length == 16) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gDevicePathBBTestFunctionAssertionGuid012,
L"EFI_DEVICE_PATH_PROTOCOL - Messaging Device Path - 1394 Device Path",
L"%a:%d:Type - %d, Subtype - %d, Length - %d",
__FILE__,
__LINE__,
Type,
SubType,
Length
);
}
//
// Assertion Point 3.1.2.14
// Check Messaging Device Path: USB Device Path
//
else if ((Type == 3) && (SubType == 5)) {
if (Length == 6) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gDevicePathBBTestFunctionAssertionGuid013,
L"EFI_DEVICE_PATH_PROTOCOL - Messaging Device Path - USB Device Path",
L"%a:%d:Type - %d, Subtype - %d, Length - %d",
__FILE__,
__LINE__,
Type,
SubType,
Length
);
}
//
// Assertion Point 3.1.2.15
// Check Messaging Device Path: USB Class Device Path
//
else if ((Type == 3) && (SubType == 15)) {
if (Length == 11) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gDevicePathBBTestFunctionAssertionGuid014,
L"EFI_DEVICE_PATH_PROTOCOL - Messaging Device Path - USB Class Device Path",
L"%a:%d:Type - %d, Subtype - %d, Length - %d",
__FILE__,
__LINE__,
Type,
SubType,
Length
);
}
//
// Assertion Point 3.1.2.16
// Check Messaging Device Path: I2O Device Path
//
else if ((Type == 3) && (SubType == 6)) {
if (Length == 8) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gDevicePathBBTestFunctionAssertionGuid015,
L"EFI_DEVICE_PATH_PROTOCOL - Messaging Device Path - I2O Device Path",
L"%a:%d:Type - %d, Subtype - %d, Length - %d",
__FILE__,
__LINE__,
Type,
SubType,
Length
);
}
//
// Assertion Point 3.1.2.17
// Check Messaging Device Path: MAC Address Device Path
//
else if ((Type == 3) && (SubType == 11)) {
if (Length == 37) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gDevicePathBBTestFunctionAssertionGuid016,
L"EFI_DEVICE_PATH_PROTOCOL - Messaging Device Path - MAC Address Device Path",
L"%a:%d:Type - %d, Subtype - %d, Length - %d",
__FILE__,
__LINE__,
Type,
SubType,
Length
);
}
//
// Assertion Point 3.1.2.18
// Check Messaging Device Path: IPv4 Device Path
//
else if ((Type == 3) && (SubType == 12)) {
IPv4 = (IPv4_DEVICE_PATH*)DevicePath;
if ((Length == 19) &&
(IPv4->StaticIpAddress == 0 || IPv4->StaticIpAddress == 1)) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gDevicePathBBTestFunctionAssertionGuid017,
L"EFI_DEVICE_PATH_PROTOCOL - Messaging Device Path - IPv4 Device Path",
L"%a:%d:Type - %d, Subtype - %d, Length - %d",
__FILE__,
__LINE__,
Type,
SubType,
Length
);
}
//
// Assertion Point 3.1.2.19
// Check Messaging Device Path: IPv6 Device Path
//
else if ((Type == 3) && (SubType == 13)) {
IPv6 = (IPv6_DEVICE_PATH*)DevicePath;
if ((Length == 43) &&
(IPv6->StaticIpAddress == 0 || IPv6->StaticIpAddress == 1)) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gDevicePathBBTestFunctionAssertionGuid018,
L"EFI_DEVICE_PATH_PROTOCOL - Messaging Device Path - IPv6 Device Path",
L"%a:%d:Type - %d, Subtype - %d, Length - %d",
__FILE__,
__LINE__,
Type,
SubType,
Length
);
}
//
// Assertion Point 3.1.2.20
// Check Messaging Device Path: InfiniBand Device Path
//
else if ((Type == 3) && (SubType == 9)) {
if (Length == 48) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gDevicePathBBTestFunctionAssertionGuid019,
L"EFI_DEVICE_PATH_PROTOCOL - Messaging Device Path - InfiniBand Device Path",
L"%a:%d:Type - %d, Subtype - %d, Length - %d",
__FILE__,
__LINE__,
Type,
SubType,
Length
);
}
//
// Assertion Point 3.1.2.21
// Check Messaging Device Path: UART Device Path
//
else if ((Type == 3) && (SubType == 14)) {
Uart = (UART_DEVICE_PATH*)DevicePath;
if ((Length == 19) &&
(Uart->Parity >= 0x00 && Uart->Parity <= 0x05) &&
(Uart->StopBits >= 0x00 && Uart->StopBits <= 0x03)) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gDevicePathBBTestFunctionAssertionGuid020,
L"EFI_DEVICE_PATH_PROTOCOL - Messaging Device Path - UART Device Path",
L"%a:%d:Type - %d, Subtype - %d, Length - %d",
__FILE__,
__LINE__,
Type,
SubType,
Length
);
}
else if ((Type == 3) && (SubType == 10)) {
Vendor = (VENDOR_DEVICE_PATH*)DevicePath;
//
// Assertion Point 3.1.2.22
// Check Messaging Device Path: Vendor-Defined Device Path
//
if (CompareMem (&Vendor->Guid, &gEfiDevicePathMessagingUartFlowControlGuid, sizeof (EFI_GUID)) != 0) {
if (Length >= 20) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gDevicePathBBTestFunctionAssertionGuid021,
L"EFI_DEVICE_PATH_PROTOCOL - Messaging Device Path - Vendor-Defined Device Path",
L"%a:%d:Type - %d, Subtype - %d, Length - %d",
__FILE__,
__LINE__,
Type,
SubType,
Length
);
}
//
// Assertion Point 3.1.2.23
// Check Messaging Device Path: UART Flow Control Messaging Path
//
else {
if (Length == 24) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gDevicePathBBTestFunctionAssertionGuid022,
L"EFI_DEVICE_PATH_PROTOCOL - Messaging Device Path - UART Flow Control Messaging Path",
L"%a:%d:Type - %d, Subtype - %d, Length - %d",
__FILE__,
__LINE__,
Type,
SubType,
Length
);
}
}
//
// Assertion Point 3.1.2.24
// Check Media Device Path: Hard Drive Media Device Path
//
else if ((Type == 4) && (SubType == 1)) {
Hd = (HARDDRIVE_DEVICE_PATH*)DevicePath;
if ((Length == 42) &&
(Hd->MBRType == 0x01 || Hd->MBRType == 0x02) &&
(Hd->SignatureType == 0x00 || Hd->SignatureType == 0x01 || Hd->SignatureType == 0x02)) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gDevicePathBBTestFunctionAssertionGuid023,
L"EFI_DEVICE_PATH_PROTOCOL - Media Device Path - Hard Drive Media Device Path",
L"%a:%d:Type - %d, Subtype - %d, Length - %d",
__FILE__,
__LINE__,
Type,
SubType,
Length
);
}
//
// Assertion Point 3.1.2.25
// Check Media Device Path: CD-ROM Media Device Path
//
else if ((Type == 4) && (SubType == 2)) {
if (Length == 24) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gDevicePathBBTestFunctionAssertionGuid024,
L"EFI_DEVICE_PATH_PROTOCOL - Media Device Path - CD-ROM Media Device Path",
L"%a:%d:Type - %d, Subtype - %d, Length - %d",
__FILE__,
__LINE__,
Type,
SubType,
Length
);
}
//
// Assertion Point 3.1.2.26
// Check Media Device Path: Vendor-Defined Media Device Path
//
else if ((Type == 4) && (SubType == 3)) {
if (Length >= 20) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gDevicePathBBTestFunctionAssertionGuid025,
L"EFI_DEVICE_PATH_PROTOCOL - Media Device Path - Vendor-Defined Media Device Path",
L"%a:%d:Type - %d, Subtype - %d, Length - %d",
__FILE__,
__LINE__,
Type,
SubType,
Length
);
}
//
// Assertion Point 3.1.2.27
// Check Media Device Path: File Path Media Device Path
//
else if ((Type == 4) && (SubType == 4)) {
if (Length >= 4) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gDevicePathBBTestFunctionAssertionGuid026,
L"EFI_DEVICE_PATH_PROTOCOL - Media Device Path - File Path Media Device Path",
L"%a:%d:Type - %d, Subtype - %d, Length - %d",
__FILE__,
__LINE__,
Type,
SubType,
Length
);
}
//
// Assertion Point 3.1.2.28
// Check Media Device Path: Media Protocol Device Path
//
else if ((Type == 4) && (SubType == 5)) {
if (Length == 20) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gDevicePathBBTestFunctionAssertionGuid027,
L"EFI_DEVICE_PATH_PROTOCOL - Media Device Path - Media Protocol Device Path",
L"%a:%d:Type - %d, Subtype - %d, Length - %d",
__FILE__,
__LINE__,
Type,
SubType,
Length
);
}
//
// Assertion Point 3.1.2.29
// Check BIOS Boot Specification Device Path
//
else if ((Type == 5) && (SubType == 1)) {
if (Length >= 8) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gDevicePathBBTestFunctionAssertionGuid028,
L"EFI_DEVICE_PATH_PROTOCOL - BIOS Boot Specification Device Path",
L"%a:%d:Type - %d, Subtype - %d, Length - %d",
__FILE__,
__LINE__,
Type,
SubType,
Length
);
} else {
StandardLib->RecordMessage (
StandardLib,
EFI_VERBOSE_LEVEL_QUIET,
L"Unknown Node(Type - %d, Subtype - %d, Length - %d)\n",
Type,
SubType,
Length
);
}
DevicePath = NextDevicePathNode (DevicePath);
}
//
// Assertion Point 3.1.2.1
// Check End of Hardware Device Path: End Entire Device Path
//
Type = (UINT16)DevicePathType (DevicePath);
SubType = (UINT16)DevicePathSubType (DevicePath);
Length = (UINT16)DevicePathNodeLength (DevicePath);
if ((Type == 0x7F || Type == 0xFF) && (SubType == 0xFF)) {
if (Length == 4) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gDevicePathBBTestFunctionAssertionGuid029,
L"EFI_DEVICE_PATH_PROTOCOL - End of Hardware Device Path - End Entire Device Path",
L"%a:%d:Type - %d, Subtype - %d, Length - %d",
__FILE__,
__LINE__,
Type,
SubType,
Length
);
}
return EFI_SUCCESS;
}
//
// TDS 3.2
//
EFI_STATUS
BBTestSetTimeConsistencyTest (
IN EFI_BB_TEST_PROTOCOL *This,
IN VOID *ClientInterface,
IN EFI_TEST_LEVEL TestLevel,
IN EFI_HANDLE SupportHandle
)
{
EFI_STANDARD_TEST_LIBRARY_PROTOCOL *StandardLib;
EFI_STATUS Status;
EFI_TEST_ASSERTION AssertionType;
EFI_TIME Time;
EFI_TIME OldTime;
//
// Get the Standard Library Interface
//
Status = gtBS->HandleProtocol (
SupportHandle,
&gEfiStandardTestLibraryGuid,
&StandardLib
);
if (EFI_ERROR(Status)) {
return Status;
}
//
// 3.2.2.1 SetTime should not succeed when a time field is out of range
//
Status = gtRT->GetTime (
&OldTime,
NULL
);
if (EFI_ERROR(Status)) {
StandardLib->RecordAssertion (
StandardLib,
EFI_TEST_ASSERTION_FAILED,
gTestGenericFailureGuid,
L"RT.SetTime - GetTime",
L"%a:%d:Status - %r",
__FILE__,
__LINE__,
Status
);
} else {
Time = OldTime;
Time.Year = 1997;
Status = gtRT->SetTime (
&Time
);
if (Status == EFI_INVALID_PARAMETER) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gTimeServicesBBTestConformanceAssertionGuid002,
L"RT.SetTime - Time.Year is 1997",
L"%a:%d:Status - %r",
__FILE__,
__LINE__,
Status
);
Time = OldTime;
Time.Year = 2100;
Status = gtRT->SetTime (
&Time
);
if (Status == EFI_INVALID_PARAMETER) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gTimeServicesBBTestConformanceAssertionGuid003,
L"RT.SetTime - Time.Year is 2100",
L"%a:%d:Status - %r",
__FILE__,
__LINE__,
Status
);
Time = OldTime;
Time.Year = (UINT16)-1;
Status = gtRT->SetTime (
&Time
);
if (Status == EFI_INVALID_PARAMETER) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gTimeServicesBBTestConformanceAssertionGuid004,
L"RT.SetTime - Time.Year is -1",
L"%a:%d:Status - %r",
__FILE__,
__LINE__,
Status
);
Time = OldTime;
Time.Month = 0;
Status = gtRT->SetTime (
&Time
);
if (Status == EFI_INVALID_PARAMETER) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gTimeServicesBBTestConformanceAssertionGuid005,
L"RT.SetTime - Time.Month is 0",
L"%a:%d:Status - %r",
__FILE__,
__LINE__,
Status
);
Time = OldTime;
Time.Month = 13;
Status = gtRT->SetTime (
&Time
);
if (Status == EFI_INVALID_PARAMETER) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gTimeServicesBBTestConformanceAssertionGuid006,
L"RT.SetTime - Time.Month is 13",
L"%a:%d:Status - %r",
__FILE__,
__LINE__,
Status
);
Time = OldTime;
Time.Month = (UINT8)-1;
Status = gtRT->SetTime (
&Time
);
if (Status == EFI_INVALID_PARAMETER) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gTimeServicesBBTestConformanceAssertionGuid007,
L"RT.SetTime - Time.Month is -1",
L"%a:%d:Status - %r",
__FILE__,
__LINE__,
Status
);
Time = OldTime;
Time.Day = 0;
Status = gtRT->SetTime (
&Time
);
if (Status == EFI_INVALID_PARAMETER) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gTimeServicesBBTestConformanceAssertionGuid008,
L"RT.SetTime - Time.Day is 0",
L"%a:%d:Status - %r",
__FILE__,
__LINE__,
Status
);
Time = OldTime;
Time.Day = 32;
Status = gtRT->SetTime (
&Time
);
if (Status == EFI_INVALID_PARAMETER) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gTimeServicesBBTestConformanceAssertionGuid009,
L"RT.SetTime - Time.Day is 32",
L"%a:%d:Status - %r",
__FILE__,
__LINE__,
Status
);
Time = OldTime;
Time.Day = (UINT8)-1;
Status = gtRT->SetTime (
&Time
);
if (Status == EFI_INVALID_PARAMETER) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gTimeServicesBBTestConformanceAssertionGuid010,
L"RT.SetTime - Time.Day is -1",
L"%a:%d:Status - %r",
__FILE__,
__LINE__,
Status
);
Time = OldTime;
Time.Month = 4;
Time.Day = 31;
Status = gtRT->SetTime (
&Time
);
if (Status == EFI_INVALID_PARAMETER) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gTimeServicesBBTestConformanceAssertionGuid011,
L"RT.SetTime - Time.Month is 4 and Time.Day is 31",
L"%a:%d:Status - %r",
__FILE__,
__LINE__,
Status
);
Time = OldTime;
Time.Hour = 24;
Status = gtRT->SetTime (
&Time
);
if (Status == EFI_INVALID_PARAMETER) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gTimeServicesBBTestConformanceAssertionGuid012,
L"RT.SetTime - Time.Hour is 24",
L"%a:%d:Status - %r",
__FILE__,
__LINE__,
Status
);
Time = OldTime;
Time.Hour = (UINT8)-1;
Status = gtRT->SetTime (
&Time
);
if (Status == EFI_INVALID_PARAMETER) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gTimeServicesBBTestConformanceAssertionGuid013,
L"RT.SetTime - Time.Hour is -1",
L"%a:%d:Status - %r",
__FILE__,
__LINE__,
Status
);
Time = OldTime;
Time.Minute = 60;
Status = gtRT->SetTime (
&Time
);
if (Status == EFI_INVALID_PARAMETER) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gTimeServicesBBTestConformanceAssertionGuid014,
L"RT.SetTime - Time.Minute is 60",
L"%a:%d:Status - %r",
__FILE__,
__LINE__,
Status
);
Time = OldTime;
Time.Minute = (UINT8)-1;
Status = gtRT->SetTime (
&Time
);
if (Status == EFI_INVALID_PARAMETER) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gTimeServicesBBTestConformanceAssertionGuid015,
L"RT.SetTime - Time.Minute is -1",
L"%a:%d:Status - %r",
__FILE__,
__LINE__,
Status
);
Time = OldTime;
Time.Second = 60;
Status = gtRT->SetTime (
&Time
);
if (Status == EFI_INVALID_PARAMETER) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gTimeServicesBBTestConformanceAssertionGuid016,
L"RT.SetTime - Time.Second is 60",
L"%a:%d:Status - %r",
__FILE__,
__LINE__,
Status
);
Time = OldTime;
Time.Second = (UINT8)-1;
Status = gtRT->SetTime (
&Time
);
if (Status == EFI_INVALID_PARAMETER) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gTimeServicesBBTestConformanceAssertionGuid017,
L"RT.SetTime - Time.Second is -1",
L"%a:%d:Status - %r",
__FILE__,
__LINE__,
Status
);
Time = OldTime;
Time.Nanosecond = 1000000000;
Status = gtRT->SetTime (
&Time
);
if (Status == EFI_INVALID_PARAMETER) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gTimeServicesBBTestConformanceAssertionGuid018,
L"RT.SetTime - Time.Nanosecond is 1000000000",
L"%a:%d:Status - %r",
__FILE__,
__LINE__,
Status
);
Time = OldTime;
Time.Nanosecond = (UINT32)-1;
Status = gtRT->SetTime (
&Time
);
if (Status == EFI_INVALID_PARAMETER) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gTimeServicesBBTestConformanceAssertionGuid019,
L"RT.SetTime - Time.Nanosecond is -1",
L"%a:%d:Status - %r",
__FILE__,
__LINE__,
Status
);
Time = OldTime;
Time.TimeZone = -1441;
Status = gtRT->SetTime (
&Time
);
if (Status == EFI_INVALID_PARAMETER) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gTimeServicesBBTestConformanceAssertionGuid020,
L"RT.SetTime - Time.TimeZone is -1441",
L"%a:%d:Status - %r",
__FILE__,
__LINE__,
Status
);
Time = OldTime;
Time.TimeZone = 1441;
Status = gtRT->SetTime (
&Time
);
if (Status == EFI_INVALID_PARAMETER) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gTimeServicesBBTestConformanceAssertionGuid021,
L"RT.SetTime - Time.TimeZone is 1441",
L"%a:%d:Status - %r",
__FILE__,
__LINE__,
Status
);
Time = OldTime;
Time.Year = 2001;
Time.Month = 2;
Time.Day = 29;
Status = gtRT->SetTime (
&Time
);
if (Status == EFI_INVALID_PARAMETER) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gTimeServicesBBTestConformanceAssertionGuid022,
L"RT.SetTime - Time is 2001/2/29",
L"%a:%d:Status - %r",
__FILE__,
__LINE__,
Status
);
//
// restore the time
//
Status = gtRT->SetTime (
&OldTime
);
}
return EFI_SUCCESS;
}
//
// TDS 4.4
//
EFI_STATUS
BBTestResetTargetConformanceAutoTest (
IN EFI_BB_TEST_PROTOCOL *This,
IN VOID *ClientInterface,
IN EFI_TEST_LEVEL TestLevel,
IN EFI_HANDLE SupportHandle
)
{
EFI_STANDARD_TEST_LIBRARY_PROTOCOL *StandardLib;
EFI_STATUS Status;
EFI_SCSI_PASS_THRU_PROTOCOL *ScsiPassThru;
EFI_TEST_ASSERTION AssertionType;
UINT32 Target;
UINT64 Lun;
UINT32 NewTarget;
UINT64 NewLun;
//
// Get the Standard Library Interface
//
Status = gtBS->HandleProtocol (
SupportHandle,
&gEfiStandardTestLibraryGuid,
&StandardLib
);
if (EFI_ERROR(Status)) {
StandardLib->RecordAssertion (
StandardLib,
EFI_TEST_ASSERTION_FAILED,
gTestGenericFailureGuid,
L"BS.HandleProtocol - Handle standard test library",
L"%a:%d:Status - %r",
__FILE__,
__LINE__,
Status
);
return Status;
}
ScsiPassThru = (EFI_SCSI_PASS_THRU_PROTOCOL *)ClientInterface;
//
// Assertion Point 4.4.2.1
// Call ResetTarget() with invalid Target and invalid Lun.
//
Status = GetScsiDevice (ScsiPassThru, &NewTarget, &NewLun);
if (EFI_ERROR(Status)) {
StandardLib->RecordAssertion (
StandardLib,
EFI_TEST_ASSERTION_FAILED,
gTestGenericFailureGuid,
L"Can't Get any Scsi Device",
L"%a:%d:Status - %r",
__FILE__,
__LINE__,
Status
);
return EFI_UNSUPPORTED;
}
//
// Check point 1, call GetNextDevice with invalid Target.
//
Target = 0xEEEEEEEE;
Lun = NewLun;
Status = ScsiPassThru->ResetTarget (ScsiPassThru, Target, Lun);
if (Status == EFI_INVALID_PARAMETER) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gScsiPassThruBBTestConformanceAssertionGuid011,
L"EFI_SCSI_PASS_THRU_PROTOCOL.ResetTarget - call ResetTarget with invalid Target.",
L"%a:%d:Status - %r, Target - %d, Lun - %ld",
__FILE__,
__LINE__,
Status,
Target,
Lun
);
//
// Check point 2, call GetNextDevice with invalid Lun.
//
Target = NewTarget;
Lun = 0xEEEEEEEE;
Status = ScsiPassThru->ResetTarget (ScsiPassThru, Target, Lun);
if (Status == EFI_INVALID_PARAMETER) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gScsiPassThruBBTestConformanceAssertionGuid012,
L"EFI_SCSI_PASS_THRU_PROTOCOL.ResetTarget - call ResetTarget with invalid Lun.",
L"%a:%d:Status - %r, Target - %d, Lun - %ld",
__FILE__,
__LINE__,
Status,
Target,
Lun
);
return EFI_SUCCESS;
}
//
// TDS 4.1
//
EFI_STATUS
BBTestGetNextDeviceConformanceAutoTest (
IN EFI_BB_TEST_PROTOCOL *This,
IN VOID *ClientInterface,
IN EFI_TEST_LEVEL TestLevel,
IN EFI_HANDLE SupportHandle
)
{
EFI_STANDARD_TEST_LIBRARY_PROTOCOL *StandardLib;
EFI_STATUS Status;
EFI_SCSI_PASS_THRU_PROTOCOL *ScsiPassThru;
EFI_TEST_ASSERTION AssertionType;
UINT32 Target;
UINT64 Lun;
UINT32 NewTarget;
UINT64 NewLun;
//
// Get the Standard Library Interface
//
Status = gtBS->HandleProtocol (
SupportHandle,
&gEfiStandardTestLibraryGuid,
&StandardLib
);
if (EFI_ERROR(Status)) {
StandardLib->RecordAssertion (
StandardLib,
EFI_TEST_ASSERTION_FAILED,
gTestGenericFailureGuid,
L"BS.HandleProtocol - Handle standard test library",
L"%a:%d:Status - %r",
__FILE__,
__LINE__,
Status
);
return Status;
}
ScsiPassThru = (EFI_SCSI_PASS_THRU_PROTOCOL *)ClientInterface;
//
// Assertion Point 4.1.2.1
// Call GetNextDevice() with invalid parameter.
//
NewTarget = 0xFFFFFFFF;
//
// Get First Device Target and Lun.
//
Status = ScsiPassThru->GetNextDevice (ScsiPassThru, &NewTarget, &NewLun);
if (EFI_ERROR(Status)) {
StandardLib->RecordAssertion (
StandardLib,
EFI_TEST_ASSERTION_FAILED,
gTestGenericFailureGuid,
L"EFI_SCSI_PASS_THRU_PROTOCOL.GetNextDevice",
L"%a:%d:Status - %r",
__FILE__,
__LINE__,
Status
);
return EFI_UNSUPPORTED;
}
//
// Check point 1, call GetNextDevice with invalid Target.
//
Target = 0xEEEEEEEE;
Lun = NewLun;
Status = ScsiPassThru->GetNextDevice (ScsiPassThru, &Target, &Lun);
if (Status == EFI_INVALID_PARAMETER) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gScsiPassThruBBTestConformanceAssertionGuid002,
L"EFI_SCSI_PASS_THRU_PROTOCOL.GetNextDevice - call GetNextDevice with invalid Target.",
L"%a:%d:Status - %r, Target - %d, Lun - %ld",
__FILE__,
__LINE__,
Status,
Target,
Lun
);
//
// Check point 2, call GetNextDevice with invalid Lun.
//
Target = NewTarget;
Lun = 0xEEEEEEEE;
Status = ScsiPassThru->GetNextDevice (ScsiPassThru, &Target, &Lun);
if (Status == EFI_INVALID_PARAMETER) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gScsiPassThruBBTestConformanceAssertionGuid003,
L"EFI_SCSI_PASS_THRU_PROTOCOL.GetNextDevice - call GetNextDevice with invalid Lun.",
L"%a:%d:Status - %r, Target - %d, Lun - %ld",
__FILE__,
__LINE__,
Status,
Target,
Lun
);
//
// Check point 3, Call GetNextDevice() with Target=0xFFFFFFFF to get the
// first device. Then call it again to get the next device.
// Use the Target and Lun return from the first call to call
// the function.
//
Target = NewTarget;
Lun = NewLun;
//
// Get the second Device Target and Lun.
//
Status = ScsiPassThru->GetNextDevice (ScsiPassThru, &NewTarget, &NewLun);
if (EFI_ERROR(Status)) {
StandardLib->RecordAssertion (
StandardLib,
EFI_TEST_ASSERTION_FAILED,
gTestGenericFailureGuid,
L"EFI_SCSI_PASS_THRU_PROTOCOL.GetNextDevice",
L"%a:%d:Status - %r",
__FILE__,
__LINE__,
Status
);
return EFI_UNSUPPORTED;
}
return EFI_SUCCESS;
}
//
// TDS 4.1.5
//
EFI_STATUS
BBTestFatToStrFunctionAutoTest (
IN EFI_BB_TEST_PROTOCOL *This,
IN VOID *ClientInterface,
IN EFI_TEST_LEVEL TestLevel,
IN EFI_HANDLE SupportHandle
)
{
EFI_STANDARD_TEST_LIBRARY_PROTOCOL *StandardLib;
EFI_STATUS Status;
EFI_UNICODE_COLLATION_PROTOCOL *UnicodeCollation;
UINTN Index;
UINTN FatSize;
EFI_TEST_ASSERTION AssertionType;
//
// Test Data
//
CHAR8 *TestData[] ={
"filename.c",
"longfilename.c",
"\x10\x11\x20\x22\x50\x51\x61\x62",
};
CHAR16 Result[MAX_SIZE_OF_STRING + 1];
//
// Verify whether it is one of IHV interfaces
//
if (! IsIhvInterface (ClientInterface, SupportHandle)) {
return EFI_UNSUPPORTED;
}
//
// Get the Standard Library Interface
//
Status = gtBS->HandleProtocol (
SupportHandle,
&gEfiStandardTestLibraryGuid,
&StandardLib
);
if (EFI_ERROR(Status)) {
StandardLib->RecordAssertion (
StandardLib,
EFI_TEST_ASSERTION_FAILED,
gTestGenericFailureGuid,
L"BS.HandleProtocol - Handle standard test library",
L"%a:%d:Status - %r",
__FILE__,
__LINE__,
Status
);
return Status;
}
UnicodeCollation = (EFI_UNICODE_COLLATION_PROTOCOL *)ClientInterface;
for (Index = 0; Index < sizeof (TestData) / sizeof (CHAR8*); Index++) {
//
// For each test data, test the FatToStr functionality.
//
//
// FatSize reflect length of TestData[Index] correctly
//
FatSize = GetStrLen8 (TestData[Index]);
UnicodeCollation->FatToStr (
UnicodeCollation,
FatSize,
TestData[Index],
Result
);
if (CheckFatToStr (TestData[Index], FatSize, Result) == TRUE) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gUnicodeCollationFunctionTestAssertionGuid007,
L"EFI_UNICODE_COLLATION_PROTOCOL.FatToStr - Verification of FatToStr interface",
L"%a:%d: Fat='%s', FatToStr='%s', FatSize=%d, StrSize=%d",
__FILE__,
__LINE__,
TestData[Index],
Result,
FatSize,
GetStrLen16 (Result)
);
//
// FatSize is larger then length of TestData[Index]
//
FatSize = GetStrLen8 (TestData[Index]) + 2;
if (FatSize >= 0 || FatSize <= MAX_SIZE_OF_STRING) {
UnicodeCollation->FatToStr (
UnicodeCollation,
FatSize,
TestData[Index],
Result
);
if (CheckFatToStr (TestData[Index], FatSize, Result) == TRUE) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gUnicodeCollationFunctionTestAssertionGuid008,
L"EFI_UNICODE_COLLATION_PROTOCOL.FatToStr - Verification of FatToStr interface",
L"%a:%d: Fat='%s', FatToStr='%s', FatSize=%d, StrSize=%d",
__FILE__,
__LINE__,
TestData[Index],
Result,
FatSize,
GetStrLen16 (Result)
);
}
//
// FatSize is less then length of TestData[Index]
//
FatSize = GetStrLen8 (TestData[Index]) - 2;
if (FatSize >= 0 || FatSize <= MAX_SIZE_OF_STRING) {
UnicodeCollation->FatToStr (
UnicodeCollation,
FatSize,
TestData[Index],
Result
);
if (CheckFatToStr (TestData[Index], FatSize, Result) == TRUE) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gUnicodeCollationFunctionTestAssertionGuid009,
L"EFI_UNICODE_COLLATION_PROTOCOL.FatToStr - Verification of FatToStr interface",
L"%a:%d: Fat='%s', FatToStr='%s', FatSize=%d, StrSize=%d",
__FILE__,
__LINE__,
TestData[Index],
Result,
FatSize,
GetStrLen16 (Result)
);
}
};
return EFI_SUCCESS;
}
//
// TDS 3.1.1
//
EFI_STATUS
BBTestGetDeviceTypeFunctionAutoTest (
IN EFI_BB_TEST_PROTOCOL *This,
IN VOID *ClientInterface,
IN EFI_TEST_LEVEL TestLevel,
IN EFI_HANDLE SupportHandle
)
{
EFI_STANDARD_TEST_LIBRARY_PROTOCOL *StandardLib;
EFI_STATUS Status;
EFI_SCSI_IO_PROTOCOL *ScsiIo;
EFI_TEST_ASSERTION AssertionType;
UINT8 DeviceType;
//
// Get the Standard Library Interface
//
Status = gtBS->HandleProtocol (
SupportHandle,
&gEfiStandardTestLibraryGuid,
&StandardLib
);
if ( EFI_ERROR(Status) ) {
StandardLib->RecordAssertion (
StandardLib,
EFI_TEST_ASSERTION_FAILED,
gTestGenericFailureGuid,
L"BS.HandleProtocol - Handle standard test library",
L"%a:%d:Status - %r",
__FILE__,
(UINTN)__LINE__,
Status
);
return Status;
}
ScsiIo = (EFI_SCSI_IO_PROTOCOL *)ClientInterface;
//
// Assertion Point 3.1.1.2.1
// GetDeviceType should return EFI_SUCCESS with SCSI device correctly installed
//
Status = ScsiIo->GetDeviceType (ScsiIo, &DeviceType);
if (Status == EFI_SUCCESS) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gScsiIoBBTestFunctionAssertionGuid001,
L"EFI_SCSI_IO_PROTOCOL.GetDeviceType - Invoke GetDeviceType() and verify interface correctness within test case",
L"%a:%d:Status - %r",
__FILE__,
(UINTN)__LINE__,
Status
);
return EFI_SUCCESS;
}
//
// TDS 4.1.1
//
EFI_STATUS
BBTestStriCollFunctionAutoTest (
IN EFI_BB_TEST_PROTOCOL *This,
IN VOID *ClientInterface,
IN EFI_TEST_LEVEL TestLevel,
IN EFI_HANDLE SupportHandle
)
{
EFI_STANDARD_TEST_LIBRARY_PROTOCOL *StandardLib;
EFI_STATUS Status;
EFI_UNICODE_COLLATION_PROTOCOL *UnicodeCollation;
UINTN Index;
INTN Result;
EFI_TEST_ASSERTION AssertionType;
//
// Test Data
//
STRICOLL_TEST_DATA_FIELD TestData[] ={
{
L"",
L"",
STRING_COMPARE_EQUAL
},
{
L"\x01\x02\x11\x12\x21\x22\x31\x32\x41\x42\x43\x44\x45\x46\x47\x48\x49\x4A\x4B\x4C\x4D\x4E\x4F\x50\x51\x52\x53\x54\x55\x56\x57\x58\x59\x5Ax61\x62\x7D\x7E",
L"\x01\x02\x11\x12\x21\x22\x31\x32\x61\x62\x63\x64\x65\x66\x67\x68\x69\x6A\x6B\x6C\x6D\x6E\x6F\x70\x71\x72\x73\x74\x75\x76\x77\x78\x79\x7Ax61\x62\x7D\x7E",
STRING_COMPARE_EQUAL
},
{
L"\x01\x02\x11\x12\x21\x22\x31\x32\x61\x62\x63\x64\x65\x66\x67\x68\x69\x6A\x6B\x6C\x6D\x6E\x6F\x70\x71\x72\x73\x74\x75\x76\x77\x78\x79\x7Ax61\x62\x7D\x7E",
L"\x01\x02\x11\x12\x21\x22\x31\x32\x41\x42\x43\x44\x45\x46\x47\x48\x49\x4A\x4B\x4C\x4D\x4E\x4F\x50\x51\x52\x53\x54\x55\x56\x57\x58\x59\x5Ax61\x62\x7D\x7E",
STRING_COMPARE_EQUAL
},
{
L"\x01\x02\x11\x12\x21\x22\x31\x32\x41\x42\x43\x44\x45\x46\x47\x48\x49\x4A\x4B\x4C\x4D\x4E\x4F\x50\x51\x52\x53\x54\x55\x56\x57\x58\x59\x5A\x61\x62\x7D\x7E",
L"\x01\x02\x11\x12\x21\x22\x31\x32\x41\x42\x43\x44\x45\x46\x47\x48\x49\x4A\x4B\x4C\x4D\x4E\x4F\x50\x51\x52\x53\x54\x55\x56\x57\x58\x59\x5A\x61\x62\x7D\x7D",
STRING_COMPARE_MORE
},
{
L"\x01\x02\x11\x12\x21\x22\x31\x32\x41\x42\x43\x44\x45\x46\x47\x48\x49\x4A\x4B\x4C\x4D\x4E\x4F\x50\x51\x52\x53\x54\x55\x56\x57\x58\x59\x5A\x61\x62\x7D\x7E",
L"\x01\x02\x11\x12\x21\x22\x31\x32\x41\x42\x43\x44\x45\x46\x47\x48\x49\x4A\x4B\x4C\x4D\x4E\x4F\x50\x51\x52\x53\x54\x55\x56\x57\x58\x59\x5A\x61\x62\x7D\x7F",
STRING_COMPARE_LESS
},
{
L"\x01",
L"",
STRING_COMPARE_MORE
},
{
L"",
L"\x01\x02",
STRING_COMPARE_LESS
},
};
//
// Verify whether it is one of IHV interfaces
//
if (! IsIhvInterface (ClientInterface, SupportHandle)) {
return EFI_UNSUPPORTED;
}
//
// Get the Standard Library Interface
//
Status = gtBS->HandleProtocol (
SupportHandle,
&gEfiStandardTestLibraryGuid,
&StandardLib
);
if (EFI_ERROR(Status)) {
StandardLib->RecordAssertion (
StandardLib,
EFI_TEST_ASSERTION_FAILED,
gTestGenericFailureGuid,
L"BS.HandleProtocol - Handle standard test library",
L"%a:%d:Status - %r",
__FILE__,
__LINE__,
Status
);
return Status;
}
UnicodeCollation = (EFI_UNICODE_COLLATION_PROTOCOL *)ClientInterface;
for (Index = 0; Index < sizeof (TestData) / sizeof (STRICOLL_TEST_DATA_FIELD); Index++) {
//
// For each test data, test the StriColl functionality.
//
Result = UnicodeCollation->StriColl (
UnicodeCollation,
TestData[Index].S1,
TestData[Index].S2
);
if ((Result < 0) && (TestData[Index].Result < 0) ||
(Result == 0) && (TestData[Index].Result == 0) ||
(Result > 0) && (TestData[Index].Result > 0)) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gUnicodeCollationFunctionTestAssertionGuid001,
L"EFI_UNICODE_COLLATION_PROTOCOL.StriColl - Verification of StriColl interface",
L"%a:%d: S1='%s', S2='%s', Result=%d",
__FILE__,
__LINE__,
TestData[Index].S1,
TestData[Index].S2,
Result
);
};
return EFI_SUCCESS;
}
//
// TDS 4.1.4
//
EFI_STATUS
BBTestStrUprFunctionAutoTest (
IN EFI_BB_TEST_PROTOCOL *This,
IN VOID *ClientInterface,
IN EFI_TEST_LEVEL TestLevel,
IN EFI_HANDLE SupportHandle
)
{
EFI_STANDARD_TEST_LIBRARY_PROTOCOL *StandardLib;
EFI_STATUS Status;
EFI_UNICODE_COLLATION_PROTOCOL *UnicodeCollation;
UINTN Index;
EFI_TEST_ASSERTION AssertionType;
//
// Test Data
//
CHAR16 *TestData[] ={
L"\x21\x22\x31\x32\x41\x42\x43\x44\x45\x46\x47\x48\x49\x4A\x4B\x4C\x4D\x4E\x4F\x50\x51\x52\x53\x54\x55\x56\x57\x58\x59\x5Ax61\x62\x7D\x7E",
L"\x30\x50[abcdzyxw!)(@#*]\x40\x20\x30\x50\ab\x40\x20",
L"\x30\x50[A-D]\x40\x20\x30\x50f\x40\x20",
L""
};
CHAR16 TestDataSav[MAX_SIZE_OF_STRING + 1];
//
// Verify whether it is one of IHV interfaces
//
if (! IsIhvInterface (ClientInterface, SupportHandle)) {
return EFI_UNSUPPORTED;
}
//
// Get the Standard Library Interface
//
Status = gtBS->HandleProtocol (
SupportHandle,
&gEfiStandardTestLibraryGuid,
&StandardLib
);
if (EFI_ERROR(Status)) {
StandardLib->RecordAssertion (
StandardLib,
EFI_TEST_ASSERTION_FAILED,
gTestGenericFailureGuid,
L"BS.HandleProtocol - Handle standard test library",
L"%a:%d:Status - %r",
__FILE__,
__LINE__,
Status
);
return Status;
}
UnicodeCollation = (EFI_UNICODE_COLLATION_PROTOCOL *)ClientInterface;
for (Index = 0; Index < sizeof (TestData) / sizeof (CHAR16*); Index++) {
//
// Backup current test data
//
CopyUnicodeString (TestDataSav, TestData[Index]);
//
// For each test data, test the StrUpr functionality.
//
UnicodeCollation->StrUpr (UnicodeCollation, TestData[Index]);
if (CheckStrUpr (TestDataSav, TestData[Index])) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gUnicodeCollationFunctionTestAssertionGuid005,
L"EFI_UNICODE_COLLATION_PROTOCOL.StrUpr - Verification of StrUpr interface",
L"%a:%d: Original=%s-- ToUpper=%s",
__FILE__,
__LINE__,
TestDataSav,
TestData[Index]
);
CopyUnicodeString (TestDataSav, TestData[Index]);
UnicodeCollation->StrLwr (UnicodeCollation, TestData[Index]);
UnicodeCollation->StrUpr (UnicodeCollation, TestData[Index]);
if (CheckStrEql (TestDataSav, TestData[Index])) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gUnicodeCollationFunctionTestAssertionGuid006,
L"EFI_UNICODE_COLLATION_PROTOCOL.StrUpr - Verification of StrUpr interface",
L"%a:%d: Original=%s -- ToUpper=%s",
__FILE__,
__LINE__,
TestDataSav,
TestData[Index]
);
};
return EFI_SUCCESS;
}
//
// TDS 4.2.2
//
EFI_STATUS
BBTestBltConformanceAutoTest (
IN EFI_BB_TEST_PROTOCOL *This,
IN VOID *ClientInterface,
IN EFI_TEST_LEVEL TestLevel,
IN EFI_HANDLE SupportHandle
)
{
EFI_STANDARD_TEST_LIBRARY_PROTOCOL *StandardLib;
EFI_STATUS Status;
EFI_UGA_DRAW_PROTOCOL *UgaDraw;
EFI_TEST_ASSERTION AssertionType;
EFI_UGA_PIXEL BltBuffer[10];
UINTN SourceX, SourceY;
UINTN DestinationX, DestinationY;
UINTN Width, Height;
UINTN Delta;
UINTN Index;
EFI_UGA_BLT_OPERATION BltOperation;
EFI_DEVICE_PATH_PROTOCOL *DevicePath;
CHAR16 *DevicePathStr;
SourceX = 0;
SourceY = 0;
DestinationX = 0;
DestinationY = 0;
Width = 1;
Height = 1;
Delta = 0;
//
// Get the Standard Library Interface
//
Status = gtBS->HandleProtocol (
SupportHandle,
&gEfiStandardTestLibraryGuid,
&StandardLib
);
if (EFI_ERROR(Status)) {
StandardLib->RecordAssertion (
StandardLib,
EFI_TEST_ASSERTION_FAILED,
gTestGenericFailureGuid,
L"BS.HandleProtocol - Handle standard test library",
L"%a:%d:Status - %r",
__FILE__,
__LINE__,
Status
);
return Status;
}
UgaDraw = (EFI_UGA_DRAW_PROTOCOL *)ClientInterface;
//
// Get Device Path of current Uga_Draw_Protocol
// And out put device path or device name
//
Status = LocateDevicePathFromUgaDraw (UgaDraw, &DevicePath, StandardLib);
if (Status == EFI_SUCCESS) {
DevicePathStr = DevicePathToStr (DevicePath);
if (DevicePathStr != NULL) {
StandardLib->RecordMessage (
StandardLib,
EFI_VERBOSE_LEVEL_DEFAULT,
L"\r\nCurrent Device: %s",
DevicePathStr
);
Status = gtBS->FreePool (DevicePathStr);
if (EFI_ERROR(Status)) {
StandardLib->RecordAssertion (
StandardLib,
EFI_TEST_ASSERTION_FAILED,
gTestGenericFailureGuid,
L"BS.FreePool - Free pool",
L"%a:%d:Status - %r",
__FILE__,
__LINE__,
Status
);
return Status;
}
DevicePathStr = NULL;
}
} else {
//
// Console Splitter/UgaDraw
//
StandardLib->RecordMessage (
StandardLib,
EFI_VERBOSE_LEVEL_DEFAULT,
L"\r\nCurrent Device: ConsoleSplitter/UgaDraw"
);
#ifdef TEST_CHIPSET_UGA_ONLY
return EFI_SUCCESS;
#endif
}
//
// Assertion Point 4.2.2.2.1
// Blt should not succeed with invalid parameter
//
for (Index = 0; Index < 6; Index++) {
switch (Index) {
case 0:
BltOperation = EfiUgaBltMax;
break;
case 1:
BltOperation = EfiUgaBltMax + 1;
break;
case 2:
BltOperation = EfiUgaBltMax + 10;
break;
case 3:
BltOperation = EfiUgaBltMax + 100;
break;
case 4:
BltOperation = EfiUgaBltMax + 1000;
break;
case 5:
BltOperation = -1;
break;
default:
BltOperation = EfiUgaBltMax - 1;
break;
}
//
// test data verification
//
Status = UgaDraw->Blt (
UgaDraw,
BltBuffer,
BltOperation,
SourceX,
SourceY,
DestinationX,
DestinationY,
Width,
Height,
Delta
);
if (Status!=EFI_INVALID_PARAMETER) {
AssertionType = EFI_TEST_ASSERTION_FAILED;
} else {
AssertionType = EFI_TEST_ASSERTION_PASSED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gUgaDrawConformanceTestAssertionGuid005,
L"EFI_UGA_DRAW_PROTOCOL.Blt - Blt() with invalid BltOperation",
L"%a:%d: Status = %r,Expected = %r, Source=(%dx%d), Destination=(%dx%d), Width=%d, Height=%d, Delta=%d,BltOperation=%d",
__FILE__,
__LINE__,
Status,
EFI_INVALID_PARAMETER,
DestinationX,
DestinationY,
0,
0,
Width,
Height,
Delta,
BltOperation
);
}
return EFI_SUCCESS;
}
//
// TDS 4.1.6
//
EFI_STATUS
BBTestStrToFatFunctionAutoTest (
IN EFI_BB_TEST_PROTOCOL *This,
IN VOID *ClientInterface,
IN EFI_TEST_LEVEL TestLevel,
IN EFI_HANDLE SupportHandle
)
{
EFI_STANDARD_TEST_LIBRARY_PROTOCOL *StandardLib;
EFI_STATUS Status;
EFI_UNICODE_COLLATION_PROTOCOL *UnicodeCollation;
UINTN Index;
UINTN SubIndex;
UINTN FatSize;
EFI_TEST_ASSERTION AssertionType;
//
// Test Data
//
CHAR16 *TestData[] ={
L"longfilename.c",
L"\x40\x50[]-\x20\x30",
L"\x40\x50.\x20\x30",
L"\x40\x50 \x20\x30",
L"\x40\x50\x1234\x20\x30",
L"\x40\x50\x1234\x20\x30",
L"filename.c",
L"longfilename.c"
};
CHAR8 Result[MAX_SIZE_OF_STRING + 1];
CHAR16 UnicodeBuf[MAX_SIZE_OF_STRING + 1];
BOOLEAN IsLongFileName;
//
// Verify whether it is one of IHV interfaces
//
if (! IsIhvInterface (ClientInterface, SupportHandle)) {
return EFI_UNSUPPORTED;
}
//
// Get the Standard Library Interface
//
Status = gtBS->HandleProtocol (
SupportHandle,
&gEfiStandardTestLibraryGuid,
&StandardLib
);
if (EFI_ERROR(Status)) {
StandardLib->RecordAssertion (
StandardLib,
EFI_TEST_ASSERTION_FAILED,
gTestGenericFailureGuid,
L"BS.HandleProtocol - Handle standard test library",
L"%a:%d:Status - %r",
__FILE__,
__LINE__,
Status
);
return Status;
}
UnicodeCollation = (EFI_UNICODE_COLLATION_PROTOCOL *)ClientInterface;
for (Index = 0; Index < sizeof (TestData) / sizeof (CHAR16*); Index++) {
//
// For each test data, test the StrToFat functionality.
//
for (SubIndex = 0; SubIndex < MAX_SIZE_OF_STRING; SubIndex++) {
Result[SubIndex] = 'x';
}
Result[MAX_SIZE_OF_STRING] = 0;
//
// FatSize is equal to the length of TestData[Index]
//
FatSize = GetStrLen16 (TestData[Index]);
IsLongFileName = UnicodeCollation->StrToFat (
UnicodeCollation,
TestData[Index],
FatSize,
Result
);
if (CheckStrToFat (TestData[Index], FatSize, Result, IsLongFileName) == TRUE &&
IsLongFileName == CheckLongFileName (TestData[Index], FatSize)) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
//
// Change Char8 to Char16 for record log
//
UnicodeCollation->FatToStr (
UnicodeCollation,
FatSize,
Result,
UnicodeBuf
);
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gUnicodeCollationFunctionTestAssertionGuid010,
L"EFI_UNICODE_COLLATION_PROTOCOL.StrToFat - Verification of StrToFat interface",
L"%a:%d: Str='%s', StrSize=%d, Parameter FatSize=%d, Fat='%s', Return Fat Length= %d, LongFileNmae=%d, Expected=%d",
__FILE__,
__LINE__,
TestData[Index],
GetStrLen16 (TestData[Index]),
FatSize,
UnicodeBuf,
GetStrLen8 (Result),
IsLongFileName,
CheckLongFileName (TestData[Index], FatSize)
);
//
// FatSize is larger than the length of TestData[Index]
//
FatSize = GetStrLen16 (TestData[Index]) + 2;
IsLongFileName = UnicodeCollation->StrToFat (
UnicodeCollation,
TestData[Index],
FatSize,
Result
);
if (CheckStrToFat (TestData[Index], FatSize, Result, IsLongFileName) == TRUE &&
IsLongFileName == CheckLongFileName (TestData[Index], FatSize)) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
//
// Change Char8 to Char16 for record log
//
UnicodeCollation->FatToStr (
UnicodeCollation,
FatSize,
Result,
UnicodeBuf
);
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gUnicodeCollationFunctionTestAssertionGuid011,
L"EFI_UNICODE_COLLATION_PROTOCOL.StrToFat - Verification of StrToFat interface",
L"%a:%d: Str='%s', StrSize=%d, Parameter FatSize=%d, Fat='%s', Return Fat Length= %d, LongFileNmae=%d, Expected=%d",
__FILE__,
__LINE__,
TestData[Index],
GetStrLen16 (TestData[Index]),
FatSize,
UnicodeBuf,
GetStrLen8 (Result),
IsLongFileName,
CheckLongFileName (TestData[Index], FatSize)
);
//
// FatSize is smaller than the length of TestData[Index]
//
FatSize = GetStrLen16 (TestData[Index]) - 2;
IsLongFileName = UnicodeCollation->StrToFat (
UnicodeCollation,
TestData[Index],
FatSize,
Result
);
if (CheckStrToFat (TestData[Index], FatSize, Result, IsLongFileName) == TRUE &&
IsLongFileName == CheckLongFileName (TestData[Index], FatSize)) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
//
// Change Char8 to Char16 for record log
//
UnicodeCollation->FatToStr (
UnicodeCollation,
FatSize,
Result,
UnicodeBuf
);
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gUnicodeCollationFunctionTestAssertionGuid012,
L"EFI_UNICODE_COLLATION_PROTOCOL.StrToFat - Verification of StrToFat interface",
L"%a:%d: Str='%s', StrSize=%d, Parameter FatSize=%d, Fat='%s', Return Fat Length= %d, ConversionFail=%d, Expected=%d",
__FILE__,
__LINE__,
TestData[Index],
GetStrLen16 (TestData[Index]),
FatSize,
UnicodeBuf,
GetStrLen8 (Result),
IsLongFileName,
CheckLongFileName (TestData[Index], FatSize)
);
};
return EFI_SUCCESS;
}
//
// TDS 4.2.1
//
EFI_STATUS
BBTestGetModeConformanceAutoTest (
IN EFI_BB_TEST_PROTOCOL *This,
IN VOID *ClientInterface,
IN EFI_TEST_LEVEL TestLevel,
IN EFI_HANDLE SupportHandle
)
{
EFI_STANDARD_TEST_LIBRARY_PROTOCOL *StandardLib;
EFI_STATUS Status;
EFI_UGA_DRAW_PROTOCOL *UgaDraw;
EFI_TEST_ASSERTION AssertionType;
UINT32 HorizontalResolution;
UINT32 VerticalResolution;
UINT32 ColorDepth;
UINT32 RefreshRate;
EFI_DEVICE_PATH_PROTOCOL *DevicePath;
CHAR16 *DevicePathStr;
//
// Get the Standard Library Interface
//
Status = gtBS->HandleProtocol (
SupportHandle,
&gEfiStandardTestLibraryGuid,
&StandardLib
);
if (EFI_ERROR(Status)) {
StandardLib->RecordAssertion (
StandardLib,
EFI_TEST_ASSERTION_FAILED,
gTestGenericFailureGuid,
L"BS.HandleProtocol - Handle standard test library",
L"%a:%d:Status - %r",
__FILE__,
__LINE__,
Status
);
return Status;
}
UgaDraw = (EFI_UGA_DRAW_PROTOCOL *)ClientInterface;
//
// Get Device Path of current Uga_Draw_Protocol
// And out put device path or device name
//
Status = LocateDevicePathFromUgaDraw (UgaDraw, &DevicePath, StandardLib);
if (Status == EFI_SUCCESS) {
DevicePathStr = DevicePathToStr (DevicePath);
if (DevicePathStr != NULL) {
StandardLib->RecordMessage (
StandardLib,
EFI_VERBOSE_LEVEL_DEFAULT,
L"\r\nCurrent Device: %s",
DevicePathStr
);
Status = gtBS->FreePool (DevicePathStr);
if (EFI_ERROR(Status)) {
StandardLib->RecordAssertion (
StandardLib,
EFI_TEST_ASSERTION_FAILED,
gTestGenericFailureGuid,
L"BS.FreePool - Free pool",
L"%a:%d:Status - %r",
__FILE__,
__LINE__,
Status
);
return Status;
}
DevicePathStr = NULL;
}
} else {
//
// Console Splitter/UgaDraw
//
StandardLib->RecordMessage (
StandardLib,
EFI_VERBOSE_LEVEL_DEFAULT,
L"\r\nCurrent Device: ConsoleSplitter/UgaDraw"
);
#ifdef TEST_CHIPSET_UGA_ONLY
return EFI_SUCCESS;
#endif
}
//
// Assertion Point 4.2.1.2.1
// GetMode should not succeed with invalid parameter
//
//
// Call GetMode with HorizontalResolution being NULL
//
Status = UgaDraw->GetMode (
UgaDraw,
NULL,
&VerticalResolution,
&ColorDepth,
&RefreshRate
);
if (Status!=EFI_INVALID_PARAMETER) {
AssertionType = EFI_TEST_ASSERTION_FAILED;
} else {
AssertionType = EFI_TEST_ASSERTION_PASSED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gUgaDrawConformanceTestAssertionGuid001,
L"EFI_UGA_DRAW_PROTOCOL.GetMode - GetMode() with HorizontalResolution being NULL",
L"%a:%d:Status:%r, Expected:%r",
__FILE__,
__LINE__,
Status,
EFI_INVALID_PARAMETER
);
//
// Call GetMode with VerticalResolution being NULL
//
Status = UgaDraw->GetMode (
UgaDraw,
&HorizontalResolution,
NULL,
&ColorDepth,
&RefreshRate
);
if (Status!=EFI_INVALID_PARAMETER) {
AssertionType = EFI_TEST_ASSERTION_FAILED;
} else {
AssertionType = EFI_TEST_ASSERTION_PASSED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gUgaDrawConformanceTestAssertionGuid002,
L"EFI_UGA_DRAW_PROTOCOL.GetMode - GetMode() with VerticalResolution being NULL",
L"%a:%d:Status:%r, Expected:%r",
__FILE__,
__LINE__,
Status,
EFI_INVALID_PARAMETER
);
//
// Call GetMode with RefreshRate being NULL
//
Status = UgaDraw->GetMode (
UgaDraw,
&HorizontalResolution,
&VerticalResolution,
&ColorDepth,
NULL
);
if (Status!=EFI_INVALID_PARAMETER) {
AssertionType = EFI_TEST_ASSERTION_FAILED;
} else {
AssertionType = EFI_TEST_ASSERTION_PASSED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gUgaDrawConformanceTestAssertionGuid003,
L"EFI_UGA_DRAW_PROTOCOL.GetMode - GetMode() with RefreshRate being NULL",
L"%a:%d:Status:%r, Expected:%r",
__FILE__,
__LINE__,
Status,
EFI_INVALID_PARAMETER
);
//
// Call GetMode with ColorDepth being NULL
//
Status = UgaDraw->GetMode (
UgaDraw,
&HorizontalResolution,
&VerticalResolution,
NULL,
&RefreshRate
);
if (Status!=EFI_INVALID_PARAMETER) {
AssertionType = EFI_TEST_ASSERTION_FAILED;
} else {
AssertionType = EFI_TEST_ASSERTION_PASSED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gUgaDrawConformanceTestAssertionGuid004,
L"EFI_UGA_DRAW_PROTOCOL.GetMode - GetMode() with ColorDepth being NULL",
L"%a:%d:Status:%r, Expected:%r",
__FILE__,
__LINE__,
Status,
EFI_INVALID_PARAMETER
);
return EFI_SUCCESS;
}
//
// TDS 4.3
//
EFI_STATUS
BBTestGetTargetLunConformanceAutoTest (
IN EFI_BB_TEST_PROTOCOL *This,
IN VOID *ClientInterface,
IN EFI_TEST_LEVEL TestLevel,
IN EFI_HANDLE SupportHandle
)
{
EFI_STANDARD_TEST_LIBRARY_PROTOCOL *StandardLib;
EFI_STATUS Status;
EFI_SCSI_PASS_THRU_PROTOCOL *ScsiPassThru;
EFI_TEST_ASSERTION AssertionType;
UINT32 Target;
UINT64 Lun;
EFI_DEVICE_PATH_PROTOCOL *DevicePath;
//
// Get the Standard Library Interface
//
Status = gtBS->HandleProtocol (
SupportHandle,
&gEfiStandardTestLibraryGuid,
&StandardLib
);
if (EFI_ERROR(Status)) {
StandardLib->RecordAssertion (
StandardLib,
EFI_TEST_ASSERTION_FAILED,
gTestGenericFailureGuid,
L"BS.HandleProtocol - Handle standard test library",
L"%a:%d:Status - %r",
__FILE__,
__LINE__,
Status
);
return Status;
}
ScsiPassThru = (EFI_SCSI_PASS_THRU_PROTOCOL *)ClientInterface;
//
// Assertion Point 4.3.2.1
// Call GetTargetLun()with NULL DevicePath, NULL Target and NULL Lun.
//
Status = GetScsiDevice (ScsiPassThru, &Target, &Lun);
if (EFI_ERROR(Status)) {
StandardLib->RecordAssertion (
StandardLib,
EFI_TEST_ASSERTION_FAILED,
gTestGenericFailureGuid,
L"Can't Get any Scsi Device",
L"%a:%d:Status - %r",
__FILE__,
__LINE__,
Status
);
return EFI_UNSUPPORTED;
}
//
// Get the valid Device Path Node.
//
Status = ScsiPassThru->BuildDevicePath (ScsiPassThru, Target, Lun, &DevicePath);
if (EFI_ERROR(Status)) {
StandardLib->RecordAssertion (
StandardLib,
EFI_TEST_ASSERTION_FAILED,
gTestGenericFailureGuid,
L"EFI_SCSI_PASS_THRU_PROTOCOL.BuildDevicePath",
L"%a:%d:Status - %r, Target - %d, Lun - %ld",
__FILE__,
__LINE__,
Status,
Target,
Lun
);
return EFI_UNSUPPORTED;
}
//
// Check Point 1. NULL Device Path.
//
Status = ScsiPassThru->GetTargetLun (ScsiPassThru, NULL, &Target, &Lun);
if (Status == EFI_INVALID_PARAMETER) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gScsiPassThruBBTestConformanceAssertionGuid007,
L"EFI_SCSI_PASS_THRU_PROTOCOL.GetTargetLun - Invoke GetTargetLun() with NULL Device Path",
L"%a:%d:Status - %r",
__FILE__,
__LINE__,
Status
);
//
// Check Point 2. NULL Target.
//
Status = ScsiPassThru->GetTargetLun (ScsiPassThru, DevicePath, NULL, &Lun);
if (Status == EFI_INVALID_PARAMETER) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gScsiPassThruBBTestConformanceAssertionGuid008,
L"EFI_SCSI_PASS_THRU_PROTOCOL.GetTargetLun - Invoke GetTargetLun() with NULL Target",
L"%a:%d:Status - %r",
__FILE__,
__LINE__,
Status
);
//
// Check Point 3. NULL Lun.
//
Status = ScsiPassThru->GetTargetLun (ScsiPassThru, DevicePath, &Target, NULL);
if (Status == EFI_INVALID_PARAMETER) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gScsiPassThruBBTestConformanceAssertionGuid009,
L"EFI_SCSI_PASS_THRU_PROTOCOL.GetTargetLun - Invoke GetTargetLun() with NULL Lun",
L"%a:%d:Status - %r",
__FILE__,
__LINE__,
Status
);
//
// Assertion Point 4.3.2.2
// Call GetTargetLun()with unsupported DevicePath.
//
//
// Set the Device Path to Non Scsi Device Path.
//
DevicePath->Type = 5;
DevicePath->SubType = 1;
Status = ScsiPassThru->GetTargetLun (ScsiPassThru, DevicePath, &Target, &Lun);
if (Status == EFI_UNSUPPORTED) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
//Free the DevicePath.
gtBS->FreePool (DevicePath);
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gScsiPassThruBBTestConformanceAssertionGuid010,
L"EFI_SCSI_PASS_THRU_PROTOCOL.GetTargetLun - Invoke GetTargetLun() with unsupported Device Path",
L"%a:%d:Status - %r",
__FILE__,
__LINE__,
Status
);
return EFI_SUCCESS;
}
//
// TDS 4.2
//
EFI_STATUS
BBTestSetTimeInterfaceTest (
IN EFI_BB_TEST_PROTOCOL *This,
IN VOID *ClientInterface,
IN EFI_TEST_LEVEL TestLevel,
IN EFI_HANDLE SupportHandle
)
{
EFI_STANDARD_TEST_LIBRARY_PROTOCOL *StandardLib;
EFI_TEST_RECOVERY_LIBRARY_PROTOCOL *RecoveryLib;
EFI_TEST_LOGGING_LIBRARY_PROTOCOL *LoggingLib;
EFI_STATUS Status;
EFI_TEST_ASSERTION AssertionType;
UINTN Index;
EFI_TPL OldTpl;
EFI_TIME OldTime;
EFI_TIME NewTime;
EFI_TIME Time;
UINTN RecoveryDataSize;
UINT8 *RecoveryData;
//
// Get test support library interfaces
//
Status = GetTestSupportLibrary (
SupportHandle,
&StandardLib,
&RecoveryLib,
&LoggingLib
);
if (EFI_ERROR(Status)) {
return Status;
}
//
// Allocate memory for recovery data
//
Status = gtBS->AllocatePool (
EfiLoaderData,
1024,
(VOID **)&RecoveryData
);
if (EFI_ERROR(Status)) {
return Status;
}
//
// Read reset record
//
RecoveryDataSize = 1024;
Status = RecoveryLib->ReadResetRecord (
RecoveryLib,
&RecoveryDataSize,
RecoveryData
);
if (!EFI_ERROR(Status) && (RecoveryDataSize > 0)) {
switch (RecoveryData[0]) {
case 1:
goto step1;
case 2:
goto step2;
case 3:
goto step3;
case 4:
goto step4;
default:
goto step5;
}
}
for (Index = 0; Index < TPL_ARRAY_SIZE; Index++) {
//
// 4.2.2.1 SetTime must succeed with valid parameters
//
Status = gtRT->GetTime (
&OldTime,
NULL
);
if (EFI_ERROR(Status)) {
StandardLib->RecordAssertion (
StandardLib,
EFI_TEST_ASSERTION_FAILED,
gTestGenericFailureGuid,
L"RT.GetTime - Get time",
L"%a:%d:Status - %r, TPL - %d",
__FILE__,
(UINTN)__LINE__,
Status,
TplArray[Index]
);
continue;
}
//
// Change year
// NOTES: The new year must be set as a leap year.
//
Time = OldTime;
if (Time.Year != 2012) {
Time.Year = 2012;
} else {
Time.Year = 2016;
}
// skip 2012 12 31 11:59:59 corner case
Time.Day = 1;
OldTpl = gtBS->RaiseTPL (TplArray[Index]);
Status = gtRT->SetTime (
&Time
);
gtBS->RestoreTPL (OldTpl);
if (Status == EFI_SUCCESS) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
Index==0? \
gTimeServicesBBTestFunctionAssertionGuid013: \
(Index == 1? \
gTimeServicesBBTestFunctionAssertionGuid014: \
gTimeServicesBBTestFunctionAssertionGuid015),
L"RT.SetTime - Change year",
L"%a:%d:Status - %r, TPL - %d, Year - %d",
__FILE__,
(UINTN)__LINE__,
Status,
TplArray[Index],
OldTime.Year
);
//
// Write reset record
//
RecoveryData[0] = 1;
RecoveryData[1] = (UINT8)(Index);
gtBS->CopyMem (&RecoveryData[2], &OldTime, sizeof(EFI_TIME));
RecoveryLib->WriteResetRecord (RecoveryLib, sizeof(EFI_TIME)+2, RecoveryData);
gtBS->FreePool (RecoveryData);
//
// Prompt the user about the cold reset and reset the system
//
if (LoggingLib != NULL) {
LoggingLib->EnterFunction (
LoggingLib,
L"\r\nSetTime Test",
L"System will cold reset after 1 second..."
);
}
gtBS->Stall (1000000);
gtRT->ResetSystem (EfiResetCold, EFI_SUCCESS, 0, NULL);
step1:
//
// Restore the env
//
RecoveryData[0] = 0;
Index = RecoveryData[1];
gtBS->CopyMem (&OldTime, &RecoveryData[2], sizeof(EFI_TIME));
//
// Call GetTime() to check the result of SetTime()
//
Status = gtRT->GetTime (
&NewTime,
NULL
);
if (EFI_ERROR(Status)) {
StandardLib->RecordAssertion (
StandardLib,
EFI_TEST_ASSERTION_FAILED,
gTestGenericFailureGuid,
L"RT.GetTime - Get new time 1",
L"%a:%d:Status - %r, TPL - %d",
__FILE__,
(UINTN)__LINE__,
Status,
TplArray[Index]
);
} else {
if (((OldTime.Year == 2012) && (NewTime.Year == 2016)) ||
((OldTime.Year != 2012) && (NewTime.Year == 2012))) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
Index==0? \
gTimeServicesBBTestFunctionAssertionGuid016: \
(Index == 1? \
gTimeServicesBBTestFunctionAssertionGuid017: \
gTimeServicesBBTestFunctionAssertionGuid018),
L"RT.SetTime - Verity year after change",
L"%a:%d:Status - %r, TPL - %d",
__FILE__,
(UINTN)__LINE__,
Status,
TplArray[Index]
);
}
//
// Change month
//
Time = OldTime;
if (Time.Month != 1) {
Time.Month = 1;
} else {
Time.Month = 12;
}
// skip 2012 12 31 11:59:59 corner case
Time.Day = 1;
OldTpl = gtBS->RaiseTPL (TplArray[Index]);
Status = gtRT->SetTime (
&Time
);
gtBS->RestoreTPL (OldTpl);
if (Status == EFI_SUCCESS) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
Index==0? \
gTimeServicesBBTestFunctionAssertionGuid019: \
(Index == 1? \
gTimeServicesBBTestFunctionAssertionGuid020: \
gTimeServicesBBTestFunctionAssertionGuid021),
L"RT.SetTime - Change month",
L"%a:%d:Status - %r, TPL - %d",
__FILE__,
(UINTN)__LINE__,
Status,
TplArray[Index]
);
//
// Write reset record
//
RecoveryData[0] = 2;
RecoveryData[1] = (UINT8)Index;
gtBS->CopyMem (&RecoveryData[2], &OldTime, sizeof(EFI_TIME));
RecoveryLib->WriteResetRecord (RecoveryLib, sizeof(EFI_TIME)+2, RecoveryData);
gtBS->FreePool (RecoveryData);
//
// Prompt the user about the cold reset and reset the system
//
if (LoggingLib != NULL) {
LoggingLib->EnterFunction (
LoggingLib,
L"\r\nSetTime Test",
L"System will cold reset after 1 second..."
);
}
gtBS->Stall (1000000);
gtRT->ResetSystem (EfiResetCold, EFI_SUCCESS, 0, NULL);
step2:
//
// Restore the env
//
RecoveryData[0] = 0;
Index = RecoveryData[1];
gtBS->CopyMem (&OldTime, &RecoveryData[2], sizeof(EFI_TIME));
//
// Call GetTime() to check the result of SetTime()
//
Status = gtRT->GetTime (
&NewTime,
NULL
);
if (EFI_ERROR(Status)) {
StandardLib->RecordAssertion (
StandardLib,
EFI_TEST_ASSERTION_FAILED,
gTestGenericFailureGuid,
L"RT.GetTime - Get new time 2",
L"%a:%d:Status - %r, TPL - %d",
__FILE__,
(UINTN)__LINE__,
Status,
TplArray[Index]
);
} else {
if (((OldTime.Month == 1) && (NewTime.Month == 12)) ||
((OldTime.Month != 1) && (NewTime.Month == 1))) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
Index==0? \
gTimeServicesBBTestFunctionAssertionGuid022: \
(Index == 1? \
gTimeServicesBBTestFunctionAssertionGuid023: \
gTimeServicesBBTestFunctionAssertionGuid024),
L"RT.SetTime - Verity month after change",
L"%a:%d:Status - %r, TPL - %d",
__FILE__,
(UINTN)__LINE__,
Status,
TplArray[Index]
);
}
//
// Change daylight
//
Time = OldTime;
if (Time.Daylight & EFI_TIME_ADJUST_DAYLIGHT) {
Time.Daylight &= ~EFI_TIME_ADJUST_DAYLIGHT;
} else {
Time.Daylight |= EFI_TIME_ADJUST_DAYLIGHT;
}
// reverse EFI_TIME_IN_DAYLIGHT bit
Time.Daylight ^= EFI_TIME_IN_DAYLIGHT;
OldTpl = gtBS->RaiseTPL (TplArray[Index]);
Status = gtRT->SetTime (
&Time
);
gtBS->RestoreTPL (OldTpl);
if (Status == EFI_SUCCESS) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
Index==0? \
gTimeServicesBBTestFunctionAssertionGuid025: \
(Index == 1? \
gTimeServicesBBTestFunctionAssertionGuid026: \
gTimeServicesBBTestFunctionAssertionGuid027),
L"RT.SetTime - Change daylight",
L"%a:%d:Status - %r, TPL - %d",
__FILE__,
(UINTN)__LINE__,
Status,
TplArray[Index]
);
//
// Write reset record
//
RecoveryData[0] = 3;
RecoveryData[1] = (UINT8)Index;
gtBS->CopyMem (&RecoveryData[2], &OldTime, sizeof(EFI_TIME));
RecoveryLib->WriteResetRecord (RecoveryLib, sizeof(EFI_TIME)+2, RecoveryData);
gtBS->FreePool (RecoveryData);
//
// Prompt the user about the cold reset and reset the system
//
if (LoggingLib != NULL) {
LoggingLib->EnterFunction (
LoggingLib,
L"\r\nSetTime Test",
L"System will cold reset after 1 second..."
);
}
gtBS->Stall (1000000);
gtRT->ResetSystem (EfiResetCold, EFI_SUCCESS, 0, NULL);
step3:
//
// Restore the env
//
RecoveryData[0] = 0;
Index = RecoveryData[1];
gtBS->CopyMem (&OldTime, &RecoveryData[2], sizeof(EFI_TIME));
//
// Call GetTime() to check the result of SetTime()
//
Status = gtRT->GetTime (
&NewTime,
NULL
);
if (EFI_ERROR(Status)) {
StandardLib->RecordAssertion (
StandardLib,
EFI_TEST_ASSERTION_FAILED,
gTestGenericFailureGuid,
L"RT.GetTime - Get new time 3",
L"%a:%d:Status - %r, TPL - %d",
__FILE__,
(UINTN)__LINE__,
Status,
TplArray[Index]
);
} else {
if ((OldTime.Daylight ^ NewTime.Daylight) == (EFI_TIME_ADJUST_DAYLIGHT | EFI_TIME_IN_DAYLIGHT)) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
Index==0? \
gTimeServicesBBTestFunctionAssertionGuid028: \
(Index == 1? \
gTimeServicesBBTestFunctionAssertionGuid029: \
gTimeServicesBBTestFunctionAssertionGuid030),
L"RT.SetTime - Verity daylight after change",
L"%a:%d:Status - %r, TPL - %d",
__FILE__,
(UINTN)__LINE__,
Status,
TplArray[Index]
);
}
//
// Change time zone
//
Time = OldTime;
if (Time.TimeZone != 0) {
Time.TimeZone = 0;
} else {
Time.TimeZone = 1;
}
OldTpl = gtBS->RaiseTPL (TplArray[Index]);
Status = gtRT->SetTime (
&Time
);
gtBS->RestoreTPL (OldTpl);
if (Status == EFI_SUCCESS) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
Index==0? \
gTimeServicesBBTestFunctionAssertionGuid031: \
(Index == 1? \
gTimeServicesBBTestFunctionAssertionGuid032: \
gTimeServicesBBTestFunctionAssertionGuid033),
L"RT.SetTime - Change time zone",
L"%a:%d:Status - %r, TPL - %d",
__FILE__,
(UINTN)__LINE__,
Status,
TplArray[Index]
);
//
// Write reset record
//
RecoveryData[0] = 4;
RecoveryData[1] = (UINT8)Index;
gtBS->CopyMem (&RecoveryData[2], &OldTime, sizeof(EFI_TIME));
RecoveryLib->WriteResetRecord (RecoveryLib, sizeof(EFI_TIME)+2, RecoveryData);
gtBS->FreePool (RecoveryData);
//
// Prompt the user about the cold reset and reset the system
//
if (LoggingLib != NULL) {
LoggingLib->EnterFunction (
LoggingLib,
L"\r\nSetTime Test",
L"System will cold reset after 1 second..."
);
}
// Print (L"System will cold reset after 1 second...");
gtBS->Stall (1000000);
gtRT->ResetSystem (EfiResetCold, EFI_SUCCESS, 0, NULL);
step4:
//
// Restore the env
//
RecoveryData[0] = 0;
Index = RecoveryData[1];
gtBS->CopyMem (&OldTime, &RecoveryData[2], sizeof(EFI_TIME));
//
// Call GetTime() to check the result of SetTime()
//
Status = gtRT->GetTime (
&NewTime,
NULL
);
if (EFI_ERROR(Status)) {
StandardLib->RecordAssertion (
StandardLib,
EFI_TEST_ASSERTION_FAILED,
gTestGenericFailureGuid,
L"RT.GetTime - Get new time 4",
L"%a:%d:Status - %r, TPL - %d",
__FILE__,
(UINTN)__LINE__,
Status,
TplArray[Index]
);
} else {
if (((OldTime.TimeZone == 0) && (NewTime.TimeZone == 1)) ||
((OldTime.TimeZone != 0) && (NewTime.TimeZone == 0))) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
Index==0? \
gTimeServicesBBTestFunctionAssertionGuid034: \
(Index == 1? \
gTimeServicesBBTestFunctionAssertionGuid035: \
gTimeServicesBBTestFunctionAssertionGuid036),
L"RT.SetTime - Verity time zone after change",
L"%a:%d:Status - %r, TPL - %d",
__FILE__,
(UINTN)__LINE__,
Status,
TplArray[Index]
);
}
//
// Restore the time
//
Status = gtRT->SetTime (
&OldTime
);
if (EFI_ERROR(Status)) {
StandardLib->RecordAssertion (
StandardLib,
EFI_TEST_ASSERTION_FAILED,
gTestGenericFailureGuid,
L"RT.SetTime - Restore time",
L"%a:%d:Status - %r, TPL - %d",
__FILE__,
(UINTN)__LINE__,
Status,
TplArray[Index]
);
}
}
step5:
gtBS->FreePool (RecoveryData);
return EFI_SUCCESS;
}
//
// TDS 4.5
//
EFI_STATUS
BBTestPassThruConformanceAutoTest (
IN EFI_BB_TEST_PROTOCOL *This,
IN VOID *ClientInterface,
IN EFI_TEST_LEVEL TestLevel,
IN EFI_HANDLE SupportHandle
)
{
EFI_STANDARD_TEST_LIBRARY_PROTOCOL *StandardLib;
EFI_STATUS Status;
EFI_SCSI_PASS_THRU_PROTOCOL *ScsiPassThru;
EFI_TEST_ASSERTION AssertionType;
UINT32 Target;
UINT64 Lun;
EFI_SCSI_PASS_THRU_SCSI_REQUEST_PACKET Packet;
UINT8 Cdb[6];
UINT8 Data[100];
//UINT8 Count;
//
// Get the Standard Library Interface
//
Status = gtBS->HandleProtocol (
SupportHandle,
&gEfiStandardTestLibraryGuid,
&StandardLib
);
if (EFI_ERROR(Status)) {
StandardLib->RecordAssertion (
StandardLib,
EFI_TEST_ASSERTION_FAILED,
gTestGenericFailureGuid,
L"BS.HandleProtocol - Handle standard test library",
L"%a:%d:Status - %r",
__FILE__,
__LINE__,
Status
);
return Status;
}
ScsiPassThru = (EFI_SCSI_PASS_THRU_PROTOCOL *)ClientInterface;
//
// Assertion Point 4.5.2.1
// Call PassThru() with too long TransferLength.
//
Status = GetScsiDevice (ScsiPassThru, &Target, &Lun);
if (EFI_ERROR(Status)) {
StandardLib->RecordAssertion (
StandardLib,
EFI_TEST_ASSERTION_FAILED,
gTestGenericFailureGuid,
L"Can't Get any Scsi Device",
L"%a:%d:Status - %r",
__FILE__,
__LINE__,
Status
);
return EFI_UNSUPPORTED;
}
//
// Initialize the Request Packet.
//
EfiCommonLibZeroMem (&Packet, sizeof (EFI_SCSI_PASS_THRU_SCSI_REQUEST_PACKET));
EfiCommonLibZeroMem (Cdb, 6);
EfiCommonLibZeroMem (Data, 100);
// Set to OP_INQUIRY.
Cdb[0] = 0x12;
Cdb[1] = (UINT8)(((UINT8)Lun << 5) & 0xE0);
Cdb[4] = 100;
Packet.Timeout = 0;
Packet.Cdb = Cdb;
Packet.CdbLength = 6;
Packet.DataBuffer = Data;
Packet.TransferLength = 0xFFFFFFFF;
Packet.DataDirection = 0;
Status = ScsiPassThru->PassThru (ScsiPassThru, Target, Lun, &Packet, NULL);
if (Status == EFI_BAD_BUFFER_SIZE) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gScsiPassThruBBTestConformanceAssertionGuid013,
L"EFI_SCSI_PASS_THRU_PROTOCOL.PassThru - Call PassThru() with with too long TransferLength",
L"%a:%d:Status - %r, Target - %d, Lun - %ld, The max length is %d",
__FILE__,
__LINE__,
Status,
Target,
Lun,
Packet.TransferLength
);
//
// Assertion Point 4.5.2.3
// Call PassThru() with invalid parameter.
//
EfiCommonLibZeroMem (&Packet, sizeof (EFI_SCSI_PASS_THRU_SCSI_REQUEST_PACKET));
EfiCommonLibZeroMem (Cdb, 6);
EfiCommonLibZeroMem (Data, 100);
// Set to OP_INQUIRY.
Cdb[0] = 0x12;
Cdb[1] = (UINT8)(((UINT8)Lun << 5) & 0xE0);
Cdb[4] = 100;
Packet.Timeout = 0;
Packet.Cdb = Cdb;
Packet.CdbLength = 6;
Packet.DataBuffer = Data;
Packet.TransferLength = 100;
Packet.DataDirection = 0;
//
// Check Point 1. Invalid Target
//
Status = ScsiPassThru->PassThru (ScsiPassThru, 0xEEEEEEEE, Lun, &Packet, NULL);
if (Status == EFI_INVALID_PARAMETER) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gScsiPassThruBBTestConformanceAssertionGuid016,
L"EFI_SCSI_PASS_THRU_PROTOCOL.PassThru - Call PassThru() with invalid Target",
L"%a:%d:Status - %r",
__FILE__,
__LINE__,
Status
);
//
// Check Point 2. Invalid Lun
//
EfiCommonLibZeroMem (&Packet, sizeof (EFI_SCSI_PASS_THRU_SCSI_REQUEST_PACKET));
EfiCommonLibZeroMem (Cdb, 6);
EfiCommonLibZeroMem (Data, 100);
// Set to OP_INQUIRY.
Cdb[0] = 0x12;
Cdb[1] = (UINT8)(((UINT8)Lun << 5) & 0xE0);
Cdb[4] = 100;
Packet.Timeout = 0;
Packet.Cdb = Cdb;
Packet.CdbLength = 6;
Packet.DataBuffer = Data;
Packet.TransferLength = 100;
Packet.DataDirection = 0;
Status = ScsiPassThru->PassThru (ScsiPassThru, Target, 0xEEEEEEEE, &Packet, NULL);
if (Status == EFI_INVALID_PARAMETER) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gScsiPassThruBBTestConformanceAssertionGuid017,
L"EFI_SCSI_PASS_THRU_PROTOCOL.PassThru - Call PassThru() with invalid Lun",
L"%a:%d:Status - %r",
__FILE__,
__LINE__,
Status
);
//
// Check Point 3. Invalid ScsiRequestPacket.
//
EfiCommonLibZeroMem (&Packet, sizeof (EFI_SCSI_PASS_THRU_SCSI_REQUEST_PACKET));
Status = ScsiPassThru->PassThru (ScsiPassThru, Target, Lun, &Packet, NULL);
if (Status == EFI_INVALID_PARAMETER) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gScsiPassThruBBTestConformanceAssertionGuid018,
L"EFI_SCSI_PASS_THRU_PROTOCOL.PassThru - Call PassThru() with invalid ScsiRequestPacket",
L"%a:%d:Status - %r",
__FILE__,
__LINE__,
Status
);
return EFI_SUCCESS;
}
//
// TDS 4.1
//
EFI_STATUS
BBTestGetTimeInterfaceTest (
IN EFI_BB_TEST_PROTOCOL *This,
IN VOID *ClientInterface,
IN EFI_TEST_LEVEL TestLevel,
IN EFI_HANDLE SupportHandle
)
{
EFI_STANDARD_TEST_LIBRARY_PROTOCOL *StandardLib;
EFI_STATUS Status;
EFI_TEST_ASSERTION AssertionType;
UINTN Index;
EFI_TPL OldTpl;
EFI_TIME Time;
EFI_TIME_CAPABILITIES Capabilities;
//
// Get the Standard Library Interface
//
Status = gtBS->HandleProtocol (
SupportHandle,
&gEfiStandardTestLibraryGuid,
&StandardLib
);
if (EFI_ERROR(Status)) {
return Status;
}
for (Index = 0; Index < TPL_ARRAY_SIZE; Index++) {
//
// 4.1.2.1 GetTime must succeed with valid parameters
//
OldTpl = gtBS->RaiseTPL (TplArray[Index]);
Status = gtRT->GetTime (
&Time,
&Capabilities
);
gtBS->RestoreTPL (OldTpl);
if (Status == EFI_SUCCESS) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
Index==0? \
gTimeServicesBBTestFunctionAssertionGuid001: \
(Index == 1? \
gTimeServicesBBTestFunctionAssertionGuid002: \
gTimeServicesBBTestFunctionAssertionGuid003),
L"RT.GetTime - Valid parameters",
L"%a:%d:Status - %r, TPL - %d",
__FILE__,
(UINTN)__LINE__,
Status,
TplArray[Index]
);
if (TimeFieldsValid (&Time)) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
Index==0? \
gTimeServicesBBTestFunctionAssertionGuid004: \
(Index == 1? \
gTimeServicesBBTestFunctionAssertionGuid005: \
gTimeServicesBBTestFunctionAssertionGuid006),
L"RT.GetTime - Verify returned time",
L"%a:%d:Status - %r, TPL - %d",
__FILE__,
(UINTN)__LINE__,
Status,
TplArray[Index]
);
//
// 4.1.2.2 GetTime must succeed with Capabilities set to NULL
//
OldTpl = gtBS->RaiseTPL (TplArray[Index]);
Status = gtRT->GetTime (
&Time,
NULL
);
gtBS->RestoreTPL (OldTpl);
if (Status == EFI_SUCCESS) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
Index==0? \
gTimeServicesBBTestFunctionAssertionGuid007: \
(Index == 1? \
gTimeServicesBBTestFunctionAssertionGuid008: \
gTimeServicesBBTestFunctionAssertionGuid009),
L"RT.GetTime - Capabilities set to NULL",
L"%a:%d:Status - %r, TPL - %d",
__FILE__,
(UINTN)__LINE__,
Status,
TplArray[Index]
);
if (TimeFieldsValid (&Time)) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
Index==0? \
gTimeServicesBBTestFunctionAssertionGuid010: \
(Index == 1? \
gTimeServicesBBTestFunctionAssertionGuid011: \
gTimeServicesBBTestFunctionAssertionGuid012),
L"RT.GetTime - Verify returned time",
L"%a:%d:Status - %r, TPL - %d",
__FILE__,
(UINTN)__LINE__,
Status,
TplArray[Index]
);
}
return EFI_SUCCESS;
}
//
// TDS 3.3
//
EFI_STATUS
BBTestGetWakeupTimeConsistencyTest (
IN EFI_BB_TEST_PROTOCOL *This,
IN VOID *ClientInterface,
IN EFI_TEST_LEVEL TestLevel,
IN EFI_HANDLE SupportHandle
)
{
EFI_STANDARD_TEST_LIBRARY_PROTOCOL *StandardLib;
EFI_STATUS Status;
EFI_TEST_ASSERTION AssertionType;
BOOLEAN Enabled;
BOOLEAN Pending;
EFI_TIME Time;
//
// Get the Standard Library Interface
//
Status = gtBS->HandleProtocol (
SupportHandle,
&gEfiStandardTestLibraryGuid,
&StandardLib
);
if (EFI_ERROR(Status)) {
return Status;
}
//
// 3.3.2.1 GetWakeupTime should not succeed when Enabled is NULL
//
// BUG:2745
Status = gtRT->GetWakeupTime (
NULL, // invalid
&Pending,
&Time
);
if (Status == EFI_UNSUPPORTED) {
StandardLib->RecordAssertion (
StandardLib,
EFI_TEST_ASSERTION_WARNING,
gTestGenericFailureGuid,
L"RT.GetWakeupTime - Unsupported",
L"%a:%d:Status - %r",
__FILE__,
__LINE__,
Status
);
return EFI_SUCCESS;
}
if (Status == EFI_INVALID_PARAMETER) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gTimeServicesBBTestConformanceAssertionGuid023,
L"RT.GetWakeupTime - Enabled is NULL",
L"%a:%d:Status - %r",
__FILE__,
__LINE__,
Status
);
//
// 3.3.2.2 GetWakeupTime should not succeed when Pending is NULL
//
// BUG:2746
Status = gtRT->GetWakeupTime (
&Enabled,
NULL, // invalid
&Time
);
if (Status == EFI_UNSUPPORTED) {
StandardLib->RecordAssertion (
StandardLib,
EFI_TEST_ASSERTION_WARNING,
gTestGenericFailureGuid,
L"RT.GetWakeupTime - Unsupported",
L"%a:%d:Status - %r",
__FILE__,
__LINE__,
Status
);
return EFI_SUCCESS;
}
if (Status == EFI_INVALID_PARAMETER) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gTimeServicesBBTestConformanceAssertionGuid024,
L"RT.GetWakeupTime - Pending is NULL",
L"%a:%d:Status - %r",
__FILE__,
__LINE__,
Status
);
//
// 3.3.2.3 GetWakeupTime should not succeed when Time is NULL
//
// BUG:2747
Status = gtRT->GetWakeupTime (
&Enabled,
&Pending,
NULL // invalid
);
if (Status == EFI_UNSUPPORTED) {
StandardLib->RecordAssertion (
StandardLib,
EFI_TEST_ASSERTION_WARNING,
gTestGenericFailureGuid,
L"RT.GetWakeupTime - Unsupported",
L"%a:%d:Status - %r",
__FILE__,
__LINE__,
Status
);
return EFI_SUCCESS;
}
if (Status == EFI_INVALID_PARAMETER) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gTimeServicesBBTestConformanceAssertionGuid025,
L"RT.GetWakeupTime - Time is NULL",
L"%a:%d:Status - %r",
__FILE__,
__LINE__,
Status
);
return EFI_SUCCESS;
}
//
// TDS 4.3
//
EFI_STATUS
BBTestGetWakeupTimeInterfaceTest (
IN EFI_BB_TEST_PROTOCOL *This,
IN VOID *ClientInterface,
IN EFI_TEST_LEVEL TestLevel,
IN EFI_HANDLE SupportHandle
)
{
EFI_STANDARD_TEST_LIBRARY_PROTOCOL *StandardLib;
EFI_STATUS Status;
EFI_TEST_ASSERTION AssertionType;
UINTN Index;
EFI_TPL OldTpl;
BOOLEAN Enable;
BOOLEAN Pending;
EFI_TIME Time;
//
// Get the Standard Library Interface
//
Status = gtBS->HandleProtocol (
SupportHandle,
&gEfiStandardTestLibraryGuid,
&StandardLib
);
if (EFI_ERROR(Status)) {
return Status;
}
for (Index = 0; Index < TPL_ARRAY_SIZE; Index++) {
//
// 4.3.2.1 GetWakeupTime must succeed with valid parameters
//
OldTpl = gtBS->RaiseTPL (TplArray[Index]);
Status = gtRT->GetWakeupTime (
&Enable,
&Pending,
&Time
);
gtBS->RestoreTPL (OldTpl);
if (Status == EFI_UNSUPPORTED) {
StandardLib->RecordAssertion (
StandardLib,
EFI_TEST_ASSERTION_WARNING,
gTestGenericFailureGuid,
L"RT.GetWakeupTime - Unsupported",
L"%a:%d:Status - %r",
__FILE__,
(UINTN)__LINE__,
Status
);
return EFI_SUCCESS;
}
if (Status == EFI_SUCCESS) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
Index==0? \
gTimeServicesBBTestFunctionAssertionGuid037: \
(Index == 1? \
gTimeServicesBBTestFunctionAssertionGuid038: \
gTimeServicesBBTestFunctionAssertionGuid039),
L"RT.GetWakeupTime - Valid parameters",
L"%a:%d:Status - %r, TPL - %d",
__FILE__,
(UINTN)__LINE__,
Status,
TplArray[Index]
);
if (Enable == TRUE) {
if (TimeFieldsValid (&Time)) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
Index==0? \
gTimeServicesBBTestFunctionAssertionGuid040: \
(Index == 1? \
gTimeServicesBBTestFunctionAssertionGuid041: \
gTimeServicesBBTestFunctionAssertionGuid042),
L"RT.GetWakeupTime - Verify returned time",
L"%a:%d:Status - %r, TPL - %d",
__FILE__,
(UINTN)__LINE__,
Status,
TplArray[Index]
);
}
}
return EFI_SUCCESS;
}
//
// TDS 4.1
//
EFI_STATUS
BBTestResetSystemInterfaceTest (
IN EFI_BB_TEST_PROTOCOL *This,
IN VOID *ClientInterface,
IN EFI_TEST_LEVEL TestLevel,
IN EFI_HANDLE SupportHandle
)
{
EFI_STANDARD_TEST_LIBRARY_PROTOCOL *StandardLib;
EFI_TEST_RECOVERY_LIBRARY_PROTOCOL *RecoveryLib;
EFI_STATUS Status;
EFI_TEST_ASSERTION AssertionType;
UINTN Index;
EFI_TPL OldTpl;
UINT8 Buffer[1024];
RESET_DATA *ResetData;
UINTN Size;
//
// Get the Standard Library Interface
//
Status = gtBS->HandleProtocol (
SupportHandle,
&gEfiStandardTestLibraryGuid,
&StandardLib
);
if (EFI_ERROR(Status)) {
return Status;
}
//
// Get the Recovery Library Interface
//
Status = gtBS->HandleProtocol (
SupportHandle,
&gEfiTestRecoveryLibraryGuid,
&RecoveryLib
);
if (EFI_ERROR(Status)) {
StandardLib->RecordAssertion (
StandardLib,
EFI_TEST_ASSERTION_FAILED,
gTestGenericFailureGuid,
L"BS.HandleProtocol - Handle recovery library",
L"%a:%d:Status - %r",
__FILE__,
__LINE__,
Status
);
return Status;
}
//
// Read reset record
//
Status = RecoveryLib->ReadResetRecord (
RecoveryLib,
&Size,
Buffer
);
ResetData = (RESET_DATA *)Buffer;
if (EFI_ERROR(Status) || (Size < sizeof(RESET_DATA))) {
//
// Step 1
//
} else if (ResetData->Step == 1) {
//
// Step 2
//
if (ResetData->TplIndex < TPL_ARRAY_SIZE) {
Index = ResetData->TplIndex;
AssertionType = EFI_TEST_ASSERTION_PASSED;
goto ResetSystemStep2;
}
} else if (ResetData->Step == 2) {
//
// Step 3
//
if (ResetData->TplIndex < TPL_ARRAY_SIZE) {
Index = ResetData->TplIndex;
AssertionType = EFI_TEST_ASSERTION_PASSED;
goto ResetSystemStep3;
}
} else {
return EFI_LOAD_ERROR;
}
for (Index = 0; Index < TPL_ARRAY_SIZE; Index++) {
//
// 4.1.2.1 ResetSystem must succeed when ResetType is EfiResetCold
//
ResetData->Step = 1;
ResetData->TplIndex = Index;
Status = RecoveryLib->WriteResetRecord (
RecoveryLib,
sizeof (RESET_DATA),
Buffer
);
if (EFI_ERROR(Status)) {
StandardLib->RecordAssertion (
StandardLib,
EFI_TEST_ASSERTION_FAILED,
gTestGenericFailureGuid,
L"TestRecoveryLib - WriteResetRecord",
L"%a:%d:Status - %r, TPL - %d",
__FILE__,
__LINE__,
Status,
TplArray[Index]
);
return Status;
}
//
// Print out some information to avoid the user thought it is an error
//
Print (L"System will cold reset after 1 second...");
gtBS->Stall (1000000);
OldTpl = gtBS->RaiseTPL (TplArray[Index]);
gtRT->ResetSystem (
EfiResetCold,
EFI_SUCCESS,
0,
NULL
);
gtBS->RestoreTPL (OldTpl);
AssertionType = EFI_TEST_ASSERTION_FAILED;
ResetSystemStep2:
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
Index==0? \
gMiscRuntimeServicesInterfaceTestAssertionGuid001: \
(Index == 1? \
gMiscRuntimeServicesBBTestFunctionAssertionGuid001: \
gMiscRuntimeServicesBBTestFunctionAssertionGuid002),
L"RT.ResetSystem - EfiResetCold",
L"%a:%d:Status - %r, TPL - %d",
__FILE__,
__LINE__,
Status,
TplArray[Index]
);
//
// 4.1.2.2 ResetSystem must succeed when ResetType is EfiResetWarm
//
ResetData->Step = 2;
ResetData->TplIndex = Index;
Status = RecoveryLib->WriteResetRecord (
RecoveryLib,
sizeof (RESET_DATA),
Buffer
);
if (EFI_ERROR(Status)) {
StandardLib->RecordAssertion (
StandardLib,
EFI_TEST_ASSERTION_FAILED,
gTestGenericFailureGuid,
L"TestRecoveryLib - WriteResetRecord",
L"%a:%d:Status - %r, TPL - %d",
__FILE__,
__LINE__,
Status,
TplArray[Index]
);
return Status;
}
//
// Print out some information to avoid the user thought it is an error
//
Print (L"System will warm reset after 1 second...");
gtBS->Stall (1000000);
OldTpl = gtBS->RaiseTPL (TplArray[Index]);
gtRT->ResetSystem (
EfiResetWarm,
EFI_SUCCESS,
0,
NULL
);
gtBS->RestoreTPL (OldTpl);
AssertionType = EFI_TEST_ASSERTION_FAILED;
ResetSystemStep3:
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
Index==0? \
gMiscRuntimeServicesInterfaceTestAssertionGuid002: \
(Index == 1? \
gMiscRuntimeServicesBBTestFunctionAssertionGuid003: \
gMiscRuntimeServicesBBTestFunctionAssertionGuid004),
L"RT.ResetSystem - EfiResetWarm",
L"%a:%d:Status - %r, TPL - %d",
__FILE__,
__LINE__,
Status,
TplArray[Index]
);
}
return EFI_SUCCESS;
}
//
// TDS 4.4
//
EFI_STATUS
BBTestSetWakeupTimeInterfaceTest (
IN EFI_BB_TEST_PROTOCOL *This,
IN VOID *ClientInterface,
IN EFI_TEST_LEVEL TestLevel,
IN EFI_HANDLE SupportHandle
)
{
EFI_STANDARD_TEST_LIBRARY_PROTOCOL *StandardLib;
EFI_TEST_RECOVERY_LIBRARY_PROTOCOL *RecoveryLib;
EFI_TEST_LOGGING_LIBRARY_PROTOCOL *LoggingLib;
EFI_STATUS Status;
EFI_TEST_ASSERTION AssertionType;
UINTN Index;
EFI_TPL OldTpl;
EFI_TIME OldTime;
EFI_TIME NewTime;
BOOLEAN Enable;
BOOLEAN Pending;
UINTN RecoveryDataSize;
UINT8 *RecoveryData;
//
// Get test support library interfaces
//
Status = GetTestSupportLibrary (
SupportHandle,
&StandardLib,
&RecoveryLib,
&LoggingLib
);
if (EFI_ERROR(Status)) {
return Status;
}
//
// Allocate memory for recovery data
//
Status = gtBS->AllocatePool (
EfiLoaderData,
1024,
(VOID **)&RecoveryData
);
if (EFI_ERROR(Status)) {
return Status;
}
//
// Read reset record
//
RecoveryDataSize = 1024;
Status = RecoveryLib->ReadResetRecord (
RecoveryLib,
&RecoveryDataSize,
RecoveryData
);
if (!EFI_ERROR(Status) && (RecoveryDataSize > 0)) {
switch (RecoveryData[0]) {
case 1:
goto step1;
case 2:
goto step2;
default:
goto step3;
}
}
for (Index = 0; Index < TPL_ARRAY_SIZE; Index++) {
//
// 4.4.2.1 SetWakeupTime must succeed when set the system wakeup alarm clock
//
Status = gtRT->GetTime (
&OldTime,
NULL
);
if (EFI_ERROR(Status)) {
StandardLib->RecordAssertion (
StandardLib,
EFI_TEST_ASSERTION_FAILED,
gTestGenericFailureGuid,
L"RT.GetTime - Get time",
L"%a:%d:Status - %r, TPL - %d",
__FILE__,
(UINTN)__LINE__,
Status,
TplArray[Index]
);
continue;
}
//
// Change hour
//
AddOneHour (&OldTime);
OldTpl = gtBS->RaiseTPL (TplArray[Index]);
Status = gtRT->SetWakeupTime (
TRUE,
&OldTime
);
gtBS->RestoreTPL (OldTpl);
if (Status == EFI_UNSUPPORTED) {
StandardLib->RecordAssertion (
StandardLib,
EFI_TEST_ASSERTION_WARNING,
gTestGenericFailureGuid,
L"RT.SetWakeupTime - Unsupported",
L"%a:%d:Status - %r",
__FILE__,
(UINTN)__LINE__,
Status
);
return EFI_SUCCESS;
}
if (Status == EFI_SUCCESS) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
Index==0? \
gTimeServicesBBTestFunctionAssertionGuid043: \
(Index == 1? \
gTimeServicesBBTestFunctionAssertionGuid044: \
gTimeServicesBBTestFunctionAssertionGuid045),
L"RT.SetWakeupTime - Set wakeup time",
L"%a:%d:Status - %r, TPL - %d",
__FILE__,
(UINTN)__LINE__,
Status,
TplArray[Index]
);
//
// Write reset record
//
RecoveryData[0] = 1;
RecoveryData[1] = (UINT8)(Index);
gtBS->CopyMem (&RecoveryData[2], &OldTime, sizeof(EFI_TIME));
RecoveryLib->WriteResetRecord (RecoveryLib, sizeof(EFI_TIME)+2, RecoveryData);
gtBS->FreePool (RecoveryData);
//
// Prompt the user about the cold reset and reset the system
//
if (LoggingLib != NULL) {
LoggingLib->EnterFunction (
LoggingLib,
L"\r\nSetTime Test",
L"System will cold reset after 1 second..."
);
}
gtBS->Stall (1000000);
gtRT->ResetSystem (EfiResetCold, EFI_SUCCESS, 0, NULL);
step1:
//
// Restore the env
//
RecoveryData[0] = 0;
Index = RecoveryData[1];
gtBS->CopyMem (&OldTime, &RecoveryData[2], sizeof(EFI_TIME));
Status = gtRT->GetWakeupTime (
&Enable,
&Pending,
&NewTime
);
if (EFI_ERROR(Status)) {
StandardLib->RecordAssertion (
StandardLib,
EFI_TEST_ASSERTION_FAILED,
gTestGenericFailureGuid,
L"RT.GetTime - Get wakeup time 1",
L"%a:%d:Status - %r, TPL - %d",
__FILE__,
(UINTN)__LINE__,
Status,
TplArray[Index]
);
} else {
if (Enable == TRUE) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
Index==0? \
gTimeServicesBBTestFunctionAssertionGuid046: \
(Index == 1? \
gTimeServicesBBTestFunctionAssertionGuid047: \
gTimeServicesBBTestFunctionAssertionGuid048),
L"RT.SetWakeupTime - Wakeup timer should be enabled",
L"%a:%d:Status - %r, TPL - %d",
__FILE__,
(UINTN)__LINE__,
Status,
TplArray[Index]
);
if (Pending == FALSE) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
Index==0? \
gTimeServicesBBTestFunctionAssertionGuid049: \
(Index == 1? \
gTimeServicesBBTestFunctionAssertionGuid050: \
gTimeServicesBBTestFunctionAssertionGuid051),
L"RT.SetWakeupTime - Timer should not be pending",
L"%a:%d:Status - %r, TPL - %d",
__FILE__,
(UINTN)__LINE__,
Status,
TplArray[Index]
);
if ((OldTime.Year != NewTime.Year) || (OldTime.Month != NewTime.Month) || (OldTime.Day != NewTime.Day) ||
(OldTime.Hour != NewTime.Hour) || (OldTime.Minute != NewTime.Minute) || (OldTime.Second != NewTime.Second) ||
(OldTime.TimeZone != NewTime.TimeZone) || (OldTime.Daylight != NewTime.Daylight)) {
AssertionType = EFI_TEST_ASSERTION_FAILED;
} else {
AssertionType = EFI_TEST_ASSERTION_PASSED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
Index==0? \
gTimeServicesBBTestFunctionAssertionGuid052: \
(Index == 1? \
gTimeServicesBBTestFunctionAssertionGuid053: \
gTimeServicesBBTestFunctionAssertionGuid054),
L"RT.SetWakeupTime - Verify wakeup time after change",
L"%a:%d:Status - %r, TPL - %d, YMD-%d,%d,%d,%d,%d,%d, HMS-%d,%d,%d,%d,%d,%d, NDT-%d,%d,%d,%d,%d,%d",
__FILE__,
(UINTN)__LINE__,
Status,
TplArray[Index],
OldTime.Year, NewTime.Year,
OldTime.Month, NewTime.Month,
OldTime.Day, NewTime.Day,
OldTime.Hour, NewTime.Hour,
OldTime.Minute, NewTime.Minute,
OldTime.Second, NewTime.Second,
OldTime.Nanosecond, NewTime.Nanosecond,
OldTime.Daylight, NewTime.Daylight,
OldTime.TimeZone, NewTime.TimeZone
);
}
//
// 4.4.2.2 SetWakeupTime must succeed when disable the wakeup alarm clock
//
OldTpl = gtBS->RaiseTPL (TplArray[Index]);
Status = gtRT->SetWakeupTime (
FALSE,
NULL
);
gtBS->RestoreTPL (OldTpl);
if (Status == EFI_UNSUPPORTED) {
StandardLib->RecordAssertion (
StandardLib,
EFI_TEST_ASSERTION_WARNING,
gTestGenericFailureGuid,
L"RT.SetWakeupTime - Unsupported",
L"%a:%d:Status - %r",
__FILE__,
(UINTN)__LINE__,
Status
);
return EFI_SUCCESS;
}
if (Status == EFI_SUCCESS) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
Index==0? \
gTimeServicesBBTestFunctionAssertionGuid055: \
(Index == 1? \
gTimeServicesBBTestFunctionAssertionGuid056: \
gTimeServicesBBTestFunctionAssertionGuid057),
L"RT.SetWakeupTime - Disable wakeup time",
L"%a:%d:Status - %r, TPL - %d",
__FILE__,
(UINTN)__LINE__,
Status,
TplArray[Index]
);
//
// Write reset record
//
RecoveryData[0] = 2;
RecoveryData[1] = (UINT8)(Index);
RecoveryLib->WriteResetRecord (RecoveryLib, 2, RecoveryData);
gtBS->FreePool (RecoveryData);
//
// Prompt the user about the cold reset and reset the system
//
if (LoggingLib != NULL) {
LoggingLib->EnterFunction (
LoggingLib,
L"\r\nSetTime Test",
L"System will cold reset after 1 second..."
);
}
gtBS->Stall (1000000);
gtRT->ResetSystem (EfiResetCold, EFI_SUCCESS, 0, NULL);
step2:
//
// Restore the env
//
RecoveryData[0] = 0;
Index = RecoveryData[1];
Status = gtRT->GetWakeupTime (
&Enable,
&Pending,
&NewTime
);
if (EFI_ERROR(Status)) {
StandardLib->RecordAssertion (
StandardLib,
EFI_TEST_ASSERTION_FAILED,
gTestGenericFailureGuid,
L"RT.GetTime - Get wakeup time 2",
L"%a:%d:Status - %r, TPL - %d",
__FILE__,
(UINTN)__LINE__,
Status,
TplArray[Index]
);
} else {
if (Enable == FALSE) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
Index==0? \
gTimeServicesBBTestFunctionAssertionGuid058: \
(Index == 1? \
gTimeServicesBBTestFunctionAssertionGuid059: \
gTimeServicesBBTestFunctionAssertionGuid060),
L"RT.SetWakeupTime - Wakeup timer should be disabled",
L"%a:%d:Status - %r, TPL - %d",
__FILE__,
(UINTN)__LINE__,
Status,
TplArray[Index]
);
}
}
step3:
gtBS->FreePool (RecoveryData);
return EFI_SUCCESS;
}
//
// TDS 3.2
//
EFI_STATUS
BBTestWholeDevicePathConformanceAutoTest (
IN EFI_BB_TEST_PROTOCOL *This,
IN VOID *ClientInterface,
IN EFI_TEST_LEVEL TestLevel,
IN EFI_HANDLE SupportHandle
)
{
EFI_STANDARD_TEST_LIBRARY_PROTOCOL *StandardLib;
EFI_STATUS Status;
EFI_DEVICE_PATH_PROTOCOL *DevicePath;
EFI_TEST_ASSERTION AssertionType;
UINT16 Type;
UINT16 SubType;
UINT16 Length;
UINT16 Count;
UINT16 PCIRootFirst;
UINT16 SCSICount;
UINT16 ATAPICount;
ACPI_HID_DEVICE_PATH *Acpi;
CHAR16 *DevStr;
//
// Verify whether it is one of IHV interfaces
//
if (! IsIhvInterface (ClientInterface, SupportHandle)) {
return EFI_UNSUPPORTED;
}
//
// Get the Standard Library Interface
//
Status = gtBS->HandleProtocol (
SupportHandle,
&gEfiStandardTestLibraryGuid,
&StandardLib
);
if (EFI_ERROR(Status)) {
StandardLib->RecordAssertion (
StandardLib,
EFI_TEST_ASSERTION_FAILED,
gTestGenericFailureGuid,
L"BS.HandleProtocol - Handle standard test library",
L"%a:%d:Status - %r",
__FILE__,
__LINE__,
Status
);
return Status;
}
DevicePath = (EFI_DEVICE_PATH_PROTOCOL *)ClientInterface;
DevStr = DevicePathToStr (DevicePath);
StandardLib->RecordMessage (
StandardLib,
EFI_VERBOSE_LEVEL_QUIET,
L"\nVerifying device path: %s\n",
DevStr
);
gtBS->FreePool (DevStr);
Count = 0;
PCIRootFirst = 0;
SCSICount = 0;
ATAPICount = 0;
while (!IsDevicePathEnd (DevicePath)) {
Type = (UINT16)DevicePathType (DevicePath);
SubType = (UINT16)DevicePathSubType (DevicePath);
Length = (UINT16)DevicePathNodeLength (DevicePath);
Count++;
//
// Assertion Point 3.2.2.1
// BIOS Root Specification Device Path
//
if ((Type == 5) && (SubType == 1)) {
if (Count != 1) {
AssertionType = EFI_TEST_ASSERTION_FAILED;
} else {
DevicePath = NextDevicePathNode (DevicePath);
if(IsDevicePathEnd (DevicePath)) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gDevicePathBBTestFunctionAssertionGuid030,
L"EFI_DEVICE_PATH_PROTOCOL - BIOS Root Specification Device Path",
L"%a:%d:Type - %d, Subtype - %d, Length - %d",
__FILE__,
__LINE__,
Type,
SubType,
Length
);
break;
}
//
// Assertion Point 3.2.2.2
// PCI Root Bus Device Path Node
//
else if ((Type == 2) && (SubType == 1 || SubType == 2)) {
Acpi = (ACPI_HID_DEVICE_PATH*)DevicePath;
if (EISA_ID_TO_NUM(Acpi->HID) == 0x0A03) {
if (Count == 1) {
PCIRootFirst++;
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gDevicePathBBTestFunctionAssertionGuid031,
L"EFI_DEVICE_PATH_PROTOCOL - PCI Root Bus Device Path Node",
L"%a:%d:Type - %d, Subtype - %d, Length - %d",
__FILE__,
__LINE__,
Type,
SubType,
Length
);
}
//
// Assertion Point 3.2.2.5
// EISA Device Path Node
//
else if ((EISA_ID_TO_NUM(Acpi->HID) == 0x0604) ||
(EISA_ID_TO_NUM(Acpi->HID) == 0x0303) ||
(EISA_ID_TO_NUM(Acpi->HID) == 0x0F03) ||
(EISA_ID_TO_NUM(Acpi->HID) == 0x0501) ||
(EISA_ID_TO_NUM(Acpi->HID) == 0x0401)) {
if (Count == (PCIRootFirst + 1)) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gDevicePathBBTestFunctionAssertionGuid032,
L"EFI_DEVICE_PATH_PROTOCOL - EISA Device Path Node",
L"%a:%d:Type - %d, Subtype - %d, Length - %d",
__FILE__,
__LINE__,
Type,
SubType,
Length
);
}
}
//
// Assertion Point 3.2.2.3
// PCI Device Path Node
//
else if ((Type == 1) && (SubType == 1)) {
if (Count == (PCIRootFirst + 1)) {
PCIRootFirst++;
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gDevicePathBBTestFunctionAssertionGuid033,
L"EFI_DEVICE_PATH_PROTOCOL - PCI Device Path Node",
L"%a:%d:Type - %d, Subtype - %d, Length - %d",
__FILE__,
__LINE__,
Type,
SubType,
Length
);
}
//
// Assertion Point 3.2.2.4
// Memory Mapped Device Path Node
//
else if ((Type == 1) && (SubType == 3)) {
if (Count == 1) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gDevicePathBBTestFunctionAssertionGuid034,
L"EFI_DEVICE_PATH_PROTOCOL - Memory Mapped Device Path Node",
L"%a:%d:Type - %d, Subtype - %d, Length - %d",
__FILE__,
__LINE__,
Type,
SubType,
Length
);
}
//
// Assertion Point 3.2.2.6
// ATAPI Device Path Node
//
else if ((Type == 3) && (SubType == 1)) {
if (Count == (PCIRootFirst + 1)) {
ATAPICount = (UINT16)(PCIRootFirst + 1);
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gDevicePathBBTestFunctionAssertionGuid035,
L"EFI_DEVICE_PATH_PROTOCOL - ATAPI Device Path Node",
L"%a:%d:Type - %d, Subtype - %d, Length - %d",
__FILE__,
__LINE__,
Type,
SubType,
Length
);
}
DevicePath = NextDevicePathNode (DevicePath);
}
//
// Assertion Point 3.2.2.10
// Device Path must be terminated
//
Type = (UINT16)DevicePathType (DevicePath);
SubType = (UINT16)DevicePathSubType (DevicePath);
Length = (UINT16)DevicePathNodeLength (DevicePath);
if ((Type == 0x7F || Type == 0xFF) && (SubType == 0xFF)) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gDevicePathBBTestFunctionAssertionGuid039,
L"EFI_DEVICE_PATH_PROTOCOL - Device Path must be terminated",
L"%a:%d:Type - %d, Subtype - %d, Length - %d",
__FILE__,
__LINE__,
Type,
SubType,
Length
);
return EFI_SUCCESS;
}
//
// TDS 4.1.2
//
EFI_STATUS
BBTestMetaiMatchFunctionAutoTest (
IN EFI_BB_TEST_PROTOCOL *This,
IN VOID *ClientInterface,
IN EFI_TEST_LEVEL TestLevel,
IN EFI_HANDLE SupportHandle
)
{
EFI_STANDARD_TEST_LIBRARY_PROTOCOL *StandardLib;
EFI_STATUS Status;
EFI_UNICODE_COLLATION_PROTOCOL *UnicodeCollation;
UINTN Index;
BOOLEAN Result;
EFI_TEST_ASSERTION AssertionType;
//
// Test Data
//
METAIMATCH_TEST_DATA_FIELD TestData[] ={
{L"", L"\x30\x50zz\x40\x20", FALSE},
{L"\x30\x50*\x40\x20", L"", FALSE},
{L"", L"", TRUE},
{L"\x30\x50*\x40\x20", L"\x30\x50zz\x40\x20", TRUE},
{L"\x30\x50*\x40\x20", L"\x30\x50\x30\x20", FALSE},
{L"\x30\x50?\x40\x20", L"\x30\x50H\x40\x20", TRUE},
{L"\x30\x50?\x40\x20", L"\x30\x50\x40\x20", FALSE},
{L"\x30\x50[abcdzyxw!)(@#*]\x40\x20", L"\x30\x50Z\x40\x20", TRUE},
{L"\x30\x50[abcdZyxw!)(@#*]\x40\x20", L"\x30\x50Z\x40\x20", TRUE},
{L"\x30\x50[abcdZyxw!)(@#*]\x40\x20", L"\x30\x50z\x40\x20", TRUE},
{L"\x30\x50[abcdzyxw!)(@#*]\x40\x20", L"\x30\x50z\x40\x20", TRUE},
{L"\x30\x50[abcdzyxw!)(@#*]\x40\x20", L"\x30\x50W\x40\x20", TRUE},
{L"\x30\x50[abcdzyxw!)(@#*]\x40\x20", L"\x30\x50w\x40\x20", TRUE},
{L"\x30\x50[abcdzyxw!)(@#*]\x40\x20", L"\x30\x50@\x40\x20", TRUE},
{L"\x30\x50[abcdzyxw!)(@#*]\x40\x20", L"\x30\x50*\x40\x20", TRUE},
{L"\x30\x50[abcdzyxw!)(@#*?]\x40\x20", L"\x30\x50?\x40\x20", TRUE},
{L"\x30\x50[abcdzyxw!)(@#*]\x40\x20", L"\x30\x50g\x40\x20", FALSE},
{L"\x30\x50[abcdzyxw!)(@#*]\x40\x20", L"\x30\x50q\x40\x20", FALSE},
{L"\x30\x50[abcdzyxw!)(@#*]\x40\x20", L"\x30\x50W\x40\x20", TRUE},
//
// Index = 19
//
{L"[a-z]", L"b", TRUE},
{L"[a-z]", L"B", TRUE},
{L"[bcd]", L"B", TRUE},
{L"\x30\x50[R-Z]\x40\x20", L"\x30\x50r\x40\x20", TRUE},
{L"\x30\x50[R-Z]\x40\x20", L"\x30\x50R\x40\x20", TRUE},
{L"\x30\x50[R-Z]\x40\x20", L"\x30\x50Z\x40\x20", TRUE},
{L"\x30\x50[R-Z]\x40\x20", L"\x30\x50z\x40\x20", TRUE},
{L"\x30\x50[R-Z]\x40\x20", L"\x30\x50Y\x40\x20", TRUE},
{L"\x30\x50[R-Z]\x40\x20", L"\x30\x50s\x40\x20", TRUE},
{L"\x30\x50[R-Z]\x40\x20", L"\x30\x50k\x40\x20", FALSE},
{L"\x30\x50[R-Z]\x40\x20", L"\x30\x50K\x40\x20", FALSE},
//
// Index = 30
//
{L"\x30\x50[\x20-\x25]\x40\x20", L"\x30\x50\x20\x40\x20", TRUE},
{L"\x30\x50[\x20-\x25]\x40\x20", L"\x30\x50\x25\x40\x20", TRUE},
{L"\x30\x50[\x20-\x25]\x40\x20", L"\x30\x50\x22\x40\x20", TRUE},
{L"\x30\x50[\x20-\x25]\x40\x20", L"\x30\x50\x10\x40\x20", FALSE},
};
//
// Verify whether it is one of IHV interfaces
//
if (! IsIhvInterface (ClientInterface, SupportHandle)) {
return EFI_UNSUPPORTED;
}
//
// Get the Standard Library Interface
//
Status = gtBS->HandleProtocol (
SupportHandle,
&gEfiStandardTestLibraryGuid,
&StandardLib
);
if (EFI_ERROR(Status)) {
StandardLib->RecordAssertion (
StandardLib,
EFI_TEST_ASSERTION_FAILED,
gTestGenericFailureGuid,
L"BS.HandleProtocol - Handle standard test library",
L"%a:%d:Status - %r",
__FILE__,
__LINE__,
Status
);
return Status;
}
UnicodeCollation = (EFI_UNICODE_COLLATION_PROTOCOL *)ClientInterface;
for (Index = 0; Index < sizeof (TestData) / sizeof (METAIMATCH_TEST_DATA_FIELD); Index ++) {
//
// For each test data, test the MetaiMatch functionality.
//
Result = UnicodeCollation->MetaiMatch (
UnicodeCollation,
TestData[Index].String,
TestData[Index].Pattern
);
if (Result == TestData[Index].Result) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gUnicodeCollationFunctionTestAssertionGuid002,
L"EFI_UNICODE_COLLATION_PROTOCOL.MetaiMatch - Verification of MetaiMatch interface",
L"%a:%d: Index = %d, String='%s', Pattern='%s', Result=%d, Expected Result=%d",
__FILE__,
__LINE__,
Index,
TestData[Index].String,
TestData[Index].Pattern,
Result,
TestData[Index].Result
);
};
return EFI_SUCCESS;
}
