//
//TDS 4.3.1
//
EFI_STATUS
Attributes_Stress (
IN EFI_BB_TEST_PROTOCOL *This,
IN VOID *ClientInterface,
IN EFI_TEST_LEVEL TestLevel,
IN EFI_HANDLE SupportHandle
)
{
EFI_STATUS Status;
EFI_STATUS Status1;
PCI_IO_PROTOCOL_DEVICE *PciIoDevice;
EFI_PCI_IO_PROTOCOL *PciIo;
EFI_STANDARD_TEST_LIBRARY_PROTOCOL *StandardLib;
EFI_TEST_ASSERTION AssertionType;
UINT64 SupportedAttributes;
UINT64 CurrentAttributes;
UINT64 OriginalAttributes;
UINT64 CommonAttributes;
UINTN Index;
UINTN PciIoAttributesNumber;
UINT64 ThisAttribute;
CHAR16 *DevicePathStr;
//
//get tested interface.
//
PciIo = (EFI_PCI_IO_PROTOCOL *)ClientInterface;
//
// Get the Standard Library Interface
//
Status = gtBS->HandleProtocol (
SupportHandle,
&gEfiStandardTestLibraryGuid,
&StandardLib
);
if (EFI_ERROR(Status)) {
return Status;
}
InitializeCaseEnvironment ();
//
//get PciIoDevice struct pointer.
//
PciIoDevice = NULL;
PciIoDevice = GetPciIoDevice (PciIo);
if (PciIoDevice == NULL) {
return EFI_ABORTED;
}
//
//print the device path of pci device.
//
// Status = PrintPciIoDevice (PciIoDevice->DevicePath);
// if (EFI_ERROR(Status)) {
// return Status;
// }
DevicePathStr = DevicePathToStr (PciIoDevice->DevicePath);
if (DevicePathStr == NULL) {
StandardLib->RecordMessage (
StandardLib,
EFI_VERBOSE_LEVEL_DEFAULT,
L"\r\nCannot get DevicePath"
);
} else {
StandardLib->RecordMessage (
StandardLib,
EFI_VERBOSE_LEVEL_DEFAULT,
L"\r\nCurrent Device: %s",
DevicePathStr
);
gtBS->FreePool (DevicePathStr);
}
//
//call Attributes with operation EfiPciIoAttributeOperationGet to
//get current attributes.
//
PciIo->Attributes (
PciIo,
EfiPciIoAttributeOperationGet,
0,
&OriginalAttributes
);
//
//call Attribtes with operation EfiPciIoAttributeOperationSupported to
//get the supported attributes of the pci controller.
//
PciIo->Attributes (
PciIo,
EfiPciIoAttributeOperationSupported,
0,
&SupportedAttributes
);
//
//for each pci io attributes call Attributes with EfiPciIoAttributeOperationSet
//
PciIoAttributesNumber = 19;
for (Index = 0; Index < PciIoAttributesNumber; Index++) {
//
//first get current attributes.
//
PciIo->Attributes (
PciIo,
EfiPciIoAttributeOperationGet,
0,
&CurrentAttributes
);
ThisAttribute = 1 << Index;
Status = PciIo->Attributes (
PciIo,
EfiPciIoAttributeOperationSet,
ThisAttribute,
NULL
);
//
//get current attributes after Call Set
//
PciIo->Attributes (
PciIo,
EfiPciIoAttributeOperationGet,
0,
&CommonAttributes
);
//
//call Attributes to set the orininal value before output to console
//
Status1 = PciIo->Attributes (
PciIo,
EfiPciIoAttributeOperationSet,
OriginalAttributes,
NULL
);
if (EFI_ERROR(Status1)) {
AssertionType = EFI_TEST_ASSERTION_FAILED;
//
//record assertion
//
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gPciIoBBTestStressAssertionGuid017,
L"EFI_PCI_IO_PROTOCOL.Attributes - Set Original Supported attribute the Status Must be EFI_SUCCESS",
L"%a:%d:Status - %r",
__FILE__,
__LINE__,
Status1
);
return Status1;
} else {
AssertionType = EFI_TEST_ASSERTION_PASSED;
}
if (ThisAttribute & SupportedAttributes) {
if (!EFI_ERROR(Status) || (Status == EFI_UNSUPPORTED)) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
//
//record assertion
//
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gPciIoBBTestStressAssertionGuid001,
L"EFI_PCI_IO_PROTOCOL.Attributes - Set Supported attribute status must be EFI_SUCCESS or EFI_UNSUPPORTED.",
L"%a:%d:Status - %r, Set Attributes - %lXh, Supported Attributes - %lXh",
__FILE__,
__LINE__,
Status,
ThisAttribute,
SupportedAttributes
);
if (!EFI_ERROR(Status)) {
//
//verify the attributes was really set.
//
if (CommonAttributes == ThisAttribute) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
//
//record assertion
//
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gPciIoBBTestStressAssertionGuid002,
L"EFI_PCI_IO_PROTOCOL.Attributes - Supported attribute are really set",
L"%a:%d:Set Attributes - %lXh, Supported Attributes - %lXh, Original Attribute - %lXh, Current Attributes - %lXh",
__FILE__,
__LINE__,
ThisAttribute,
SupportedAttributes,
CurrentAttributes,
CommonAttributes
);
}
} else {
//
//unsupported attributes.
//
if (Status == EFI_UNSUPPORTED) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
//
//record assertion
//
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gPciIoBBTestStressAssertionGuid003,
L"EFI_PCI_IO_PROTOCOL.Attributes - Set UnSupported attribute status must be EFI_UNSUPPORTED",
L"%a:%d:Status - %r",
__FILE__,
__LINE__,
Status
);
//
//verify the attributes remain unchanged
//
if (CommonAttributes == CurrentAttributes) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
//
//record assertion
//
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gPciIoBBTestStressAssertionGuid004,
L"EFI_PCI_IO_PROTOCOL.Attributes - set UnSupported attribute the Attributes can not been changed",
L"%a:%d:Set Attributes - %lXh, Supported Attributes - %lXh, Original Attribute - %lXh, Current Attributes - %lXh",
__FILE__,
__LINE__,
ThisAttribute,
SupportedAttributes,
CurrentAttributes,
CommonAttributes
);
}
}
//
//call Attributes to set the orininal value
//
Status = PciIo->Attributes (
PciIo,
EfiPciIoAttributeOperationSet,
OriginalAttributes,
NULL
);
if (!EFI_ERROR(Status)) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
//
//record assertion
//
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gPciIoBBTestStressAssertionGuid005,
L"EFI_PCI_IO_PROTOCOL.Attributes - Set Original Supported attribute the Status Must be EFI_SUCCESS",
L"%a:%d:Status - %r",
__FILE__,
__LINE__,
Status
);
//
//call get attributes to verify.
//
PciIo->Attributes (
PciIo,
EfiPciIoAttributeOperationGet,
0,
&CommonAttributes
);
if (CommonAttributes == OriginalAttributes) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
//
//record assertion
//
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gPciIoBBTestStressAssertionGuid006,
L"EFI_PCI_IO_PROTOCOL.Attributes - Set Original Supported attribute the Attributes must be really set.",
L"%a:%d:Set attributes - %lXh, gotted attributes - %lXh",
__FILE__,
__LINE__,
OriginalAttributes,
CommonAttributes
);
//
//for each pci io attributes call Attributes with EfiPciIoAttributeOperationDisable.
//
PciIoAttributesNumber = 19;
for (Index = 0; Index < PciIoAttributesNumber; Index++) {
//
//first get current attributes.
//
PciIo->Attributes (
PciIo,
EfiPciIoAttributeOperationGet,
0,
&CurrentAttributes
);
ThisAttribute = 1 << Index;
Status = PciIo->Attributes (
PciIo,
EfiPciIoAttributeOperationDisable,
ThisAttribute,
NULL
);
//
//get current attributes
//
PciIo->Attributes (
PciIo,
EfiPciIoAttributeOperationGet,
0,
&CommonAttributes
);
//
//call Attributes to set the orininal value before output to console
//
Status1 = PciIo->Attributes (
PciIo,
EfiPciIoAttributeOperationSet,
OriginalAttributes,
NULL
);
if (EFI_ERROR(Status1)) {
AssertionType = EFI_TEST_ASSERTION_FAILED;
//
//record assertion
//
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gPciIoBBTestStressAssertionGuid017,
L"EFI_PCI_IO_PROTOCOL.Attributes - Set Original Supported attribute the Status Must be EFI_SUCCESS",
L"%a:%d:Status - %r",
__FILE__,
__LINE__,
Status1
);
return Status;
} else {
AssertionType = EFI_TEST_ASSERTION_PASSED;
}
if ((ThisAttribute & SupportedAttributes) == ThisAttribute) {
if (!EFI_ERROR(Status)) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
//
//record assertion
//
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gPciIoBBTestStressAssertionGuid007,
L"EFI_PCI_IO_PROTOCOL.Attributes - disable Supported attribute status must be EFI_SUCCESS",
L"%a:%d:Status - %r, Disabled Attributes - %lXh, Supported Attributes - %lXh",
__FILE__,
__LINE__,
Status,
ThisAttribute,
SupportedAttributes
);
//
//verify the attributes really disabled
//
if ((ThisAttribute & CommonAttributes) != ThisAttribute) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
//
//record assertion
//
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gPciIoBBTestStressAssertionGuid008,
L"EFI_PCI_IO_PROTOCOL.Attributes - disable Supported attribute are really diabled",
L"%a:%d:Disable Attributes - %lXh, Supported Attributes - %lXh, Original Attribute - %lXh, Current Attributes - %lXh",
__FILE__,
__LINE__,
ThisAttribute,
SupportedAttributes,
CurrentAttributes,
CommonAttributes
);
} else {
//
//unsupported attributes
//
if (Status == EFI_UNSUPPORTED) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
//
//record assertion
//
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gPciIoBBTestStressAssertionGuid009,
L"EFI_PCI_IO_PROTOCOL.Attributes - disable UnSupported attribute status must be EFI_UNSUPPORTED",
L"%a:%d:Status - %r, Disabled Attributes - %lXh, Supported Attributes - %lXh",
__FILE__,
__LINE__,
Status,
ThisAttribute,
SupportedAttributes
);
//
//verify the attributes remain unchanged after Disable operation
//
if (CommonAttributes == CurrentAttributes) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
//
//record assertion
//
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gPciIoBBTestStressAssertionGuid010,
L"EFI_PCI_IO_PROTOCOL.Attributes - disable UnSupported attribute the Attributes can not been changed",
L"%a:%d:Disable Attributes - %lXh, Supported Attributes - %lXh, Original Attribute - %lXh, Current Attributes - %lXh",
__FILE__,
__LINE__,
ThisAttribute,
SupportedAttributes,
CurrentAttributes,
CommonAttributes
);
}
}
//
//call Attributes to set the orininal value
//
Status = PciIo->Attributes (
PciIo,
EfiPciIoAttributeOperationSet,
OriginalAttributes,
NULL
);
if (!EFI_ERROR(Status)) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
//
//record assertion
//
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gPciIoBBTestStressAssertionGuid011,
L"EFI_PCI_IO_PROTOCOL.Attributes - Set Original Supported attribute the Status Must be EFI_SUCCESS",
L"%a:%d:Status - %r",
__FILE__,
__LINE__,
Status
);
//
//call get attributes to verify.
//
PciIo->Attributes (
PciIo,
EfiPciIoAttributeOperationGet,
0,
&CommonAttributes
);
if (CommonAttributes == OriginalAttributes) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
//
//record assertion
//
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gPciIoBBTestStressAssertionGuid012,
L"EFI_PCI_IO_PROTOCOL.Attributes - Set Original Supported attribute the Attributes must be really set.",
L"%a:%d:Set Attributes - %lXh, gotted attributes - %lXh",
__FILE__,
__LINE__,
OriginalAttributes,
CommonAttributes
);
//
//for each pci io attributes call Attributes with EfiPciIoAttributeOperationEnable.
//
PciIoAttributesNumber = 19;
for (Index = 1; Index <= PciIoAttributesNumber; Index++) {
//
//first get current attributes.
//
PciIo->Attributes (
PciIo,
EfiPciIoAttributeOperationGet,
0,
&CurrentAttributes
);
ThisAttribute = 1 << Index;
Status = PciIo->Attributes (
PciIo,
EfiPciIoAttributeOperationEnable,
ThisAttribute,
&CommonAttributes
);
//
//get current attributes after Enable
//
PciIo->Attributes (
PciIo,
EfiPciIoAttributeOperationGet,
0,
&CommonAttributes
);
//
//call Attributes to set the orininal value before output to console
//
Status1 = PciIo->Attributes (
PciIo,
EfiPciIoAttributeOperationSet,
OriginalAttributes,
NULL
);
if (EFI_ERROR(Status1)) {
AssertionType = EFI_TEST_ASSERTION_FAILED;
//
//record assertion
//
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gPciIoBBTestStressAssertionGuid017,
L"EFI_PCI_IO_PROTOCOL.Attributes - Set Original Supported attribute the Status Must be EFI_SUCCESS",
L"%a:%d:Status - %r",
__FILE__,
__LINE__,
Status1
);
return Status1;
} else {
AssertionType = EFI_TEST_ASSERTION_PASSED;
}
if ((ThisAttribute & SupportedAttributes) == ThisAttribute) {
if (!EFI_ERROR(Status) || (Status == EFI_UNSUPPORTED)) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
//
//record assertion
//
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gPciIoBBTestStressAssertionGuid013,
L"EFI_PCI_IO_PROTOCOL.Attributes - enable Supported attribute status must be EFI_SUCCESS or EFI_UNSUPPORTED",
L"%a:%d:Status - %r, Enabled Attributes - %lXh, Supported Attributes - %lXh",
__FILE__,
__LINE__,
Status,
ThisAttribute,
SupportedAttributes
);
if (!EFI_ERROR(Status)) {
//
//verify the attributes really enabled
//
if ((ThisAttribute & CommonAttributes) == ThisAttribute) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
//
//record assertion
//
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gPciIoBBTestStressAssertionGuid014,
L"EFI_PCI_IO_PROTOCOL.Attributes - enable Supported attribute are really enabled",
L"%a:%d:Enable Attributes - %lXh, Supported Attributes - %lXh, Original Attribute - %lXh, Current Attributes - %lXh",
__FILE__,
__LINE__,
ThisAttribute,
SupportedAttributes,
CurrentAttributes,
CommonAttributes
);
}
} else {
//
//unsupported attributes
//
if (Status == EFI_UNSUPPORTED) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
//
//record assertion
//
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gPciIoBBTestStressAssertionGuid015,
L"EFI_PCI_IO_PROTOCOL.Attributes - enable UnSupported attribute status must be EFI_UNSUPPORTED",
L"%a:%d:Status - %r, Enabled Attributes - %lXh, Supported Attributes - %lXh",
__FILE__,
__LINE__,
Status,
ThisAttribute,
SupportedAttributes
);
//
//verify the attributes remain unchanged
//
if (CommonAttributes == CurrentAttributes) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
//
//record assertion
//
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gPciIoBBTestStressAssertionGuid016,
L"EFI_PCI_IO_PROTOCOL.Attributes - enable UnSupported attribute the Attributes can not been changed",
L"%a:%d:Enalbe Attributes - %lXh, Supported Attributes - %lXh, Original Attribute - %lXh, Current Attributes - %lXh",
__FILE__,
__LINE__,
ThisAttribute,
SupportedAttributes,
CurrentAttributes,
CommonAttributes
);
}
}
//
//call Attributes to set the orininal value
//
Status = PciIo->Attributes (
PciIo,
EfiPciIoAttributeOperationSet,
OriginalAttributes,
NULL
);
if (!EFI_ERROR(Status)) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
//
//record assertion
//
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gPciIoBBTestStressAssertionGuid017,
L"EFI_PCI_IO_PROTOCOL.Attributes - Set Original Supported attribute the Status Must be EFI_SUCCESS",
L"%a:%d:Status - %r",
__FILE__,
__LINE__,
Status
);
//
//call get attributes to verify.
//
Status = PciIo->Attributes (
PciIo,
EfiPciIoAttributeOperationGet,
0,
&CommonAttributes
);
if (CommonAttributes == OriginalAttributes) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
//
//record assertion
//
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gPciIoBBTestStressAssertionGuid018,
L"EFI_PCI_IO_PROTOCOL.Attributes - Set Original Supported attribute the Attributes must be really set.",
L"%a:%d:Set Attributes - %lXh, gotted attributes - %lXh",
__FILE__,
__LINE__,
OriginalAttributes,
CommonAttributes
);
//
//done successfully
//
return EFI_SUCCESS;
}
//
// TDS 4.2.6
//
EFI_STATUS
BBTestSetCursorPositionConformanceAutoTest (
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_SIMPLE_TEXT_OUT_PROTOCOL *SimpleOut;
EFI_TEST_ASSERTION AssertionType;
EFI_SIMPLE_TEXT_OUTPUT_MODE ModeOrg, ModeExpected;
INT32 Mode;
UINTN ColumnTest[10], RowTest[10];
UINTN Column, Row;
UINTN Index;
EFI_GRAPHICS_OUTPUT_PROTOCOL *GraphicsOutput;
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__,
(UINTN)__LINE__,
Status
);
return Status;
}
SimpleOut = (EFI_SIMPLE_TEXT_OUT_PROTOCOL *)ClientInterface;
//
// Get Device Path of current Simple_Text_Output_Protocol
// And out put device path or device name
//
Status = LocateDevicePathFromSimpleTextOut (SimpleOut, &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__,
(UINTN)__LINE__,
Status
);
return Status;
}
DevicePathStr = NULL;
}
} else {
Status = LocateGopFromSimpleTextOut (SimpleOut, &GraphicsOutput, StandardLib);
if (EFI_ERROR(Status)) {
//
// Console Splitter/StdErr
//
StandardLib->RecordMessage (
StandardLib,
EFI_VERBOSE_LEVEL_DEFAULT,
L"\r\nCurrent Device: ConsoleSplitter/StdErr"
);
} else {
//
// Console Splitter/ConOut
//
StandardLib->RecordMessage (
StandardLib,
EFI_VERBOSE_LEVEL_DEFAULT,
L"\r\nCurrent Device: ConsoleSplitter/ConOut"
);
}
}
//
// Backup Mode
//
BackupMode (SimpleOut, &ModeOrg);
//
// For each mode supported!
//
for (Mode = 0; Mode < SimpleOut->Mode->MaxMode; Mode++) {
//
// Change mode
//
Status = SimpleOut->SetMode (SimpleOut, Mode);
if (EFI_ERROR(Status)) {
AssertionType = EFI_TEST_ASSERTION_FAILED;
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gTestGenericFailureGuid,
L"EFI_SIMPLE_TEXT_OUT_PROTOCOL.SetMode - SetMode() with valid mode",
L"%a:%d: Status = %r, Mode = %d",
__FILE__,
(UINTN)__LINE__,
Status,
Mode
);
continue;
}
//
// Get Mode's screen boundary
//
Status = SimpleOut->QueryMode (SimpleOut, Mode, &Column, &Row);
if (EFI_ERROR(Status)) {
AssertionType = EFI_TEST_ASSERTION_FAILED;
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gTestGenericFailureGuid,
L"EFI_SIMPLE_TEXT_OUT_PROTOCOL.QueryMode - QueryMode() with valid mode",
L"%a:%d: Status = %r, Mode = %d",
__FILE__,
(UINTN)__LINE__,
Status,
Mode
);
continue;
}
//
// Prepare test data
//
ColumnTest[0] = Column;
RowTest[0] = Row - 1;
ColumnTest[1] = Column;
RowTest[1] = 0;
ColumnTest[2] = Column + 1;
RowTest[2] = Row - 1;
ColumnTest[3] = Column + 1;
RowTest[3] = 0;
ColumnTest[4] = 0;
RowTest[4] = Row;
ColumnTest[5] = Column - 1;
RowTest[5] = Row;
ColumnTest[6] = Column - 1;
RowTest[6] = Row + 1;
ColumnTest[7] = 0;
RowTest[7] = Row + 1;
for (Index = 0; Index < 8; Index++) {
//
// Prepare expected Mode after call Reset.
//
BackupMode (SimpleOut, &ModeExpected);
//
// Call SetAttribute with invalid Attribute
//
Status = SimpleOut->SetCursorPosition (SimpleOut, ColumnTest[Index], RowTest[Index]);
//
// Mode itegrity test
//
if (CheckModeIntegrity (&ModeExpected, SimpleOut->Mode) == FALSE) {
AssertionType = EFI_TEST_ASSERTION_FAILED;
} else {
AssertionType = EFI_TEST_ASSERTION_PASSED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gSimpleTextOutputConformanceTestAssertionGuid009,
L"EFI_SIMPLE_TEXT_OUT_PROTOCOL.SetCursorPosition - SetCursorPosition() with invalid position, mode position integrity",
L"%a:%d: Mode=%d, Positoin=(%d x %d) Current: Cursor Position(%d x %d), Mode=%d, MaxMode=%d, Attribute=%d, CursorVisible=%d. "\
L" Expected:Cursor Position(%d x %d), Mode=%d, MaxMode=%d, Attribute=%d, CursorVisible=%d.",
__FILE__,
(UINTN)__LINE__,
Mode,
ColumnTest[Index],
RowTest[Index],
SimpleOut->Mode->CursorColumn,
SimpleOut->Mode->CursorRow,
SimpleOut->Mode->Mode,
SimpleOut->Mode->MaxMode,
SimpleOut->Mode->Attribute,
SimpleOut->Mode->CursorVisible,
ModeExpected.CursorColumn,
ModeExpected.CursorRow,
ModeExpected.Mode,
ModeExpected.MaxMode,
ModeExpected.Attribute,
ModeExpected.CursorVisible
);
//
// Status check
//
if (Status!=EFI_UNSUPPORTED) {
AssertionType = EFI_TEST_ASSERTION_FAILED;
} else {
AssertionType = EFI_TEST_ASSERTION_PASSED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gSimpleTextOutputConformanceTestAssertionGuid010,
L"EFI_SIMPLE_TEXT_OUT_PROTOCOL.SetCursorPosition - SetCursorPositoin() with invalid Position",
L"%a:%d: Status = %r, Mode = %d, Position = (%d x %d)",
__FILE__,
(UINTN)__LINE__,
Status,
Mode,
ColumnTest[Index],
RowTest[Index]
);
}
}
return RestoreMode (SimpleOut, &ModeOrg, StandardLib);
}
//
// TDS 4.2.3
//
EFI_STATUS
BBTestQueryModeConformanceAutoTest (
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_SIMPLE_TEXT_OUT_PROTOCOL *SimpleOut;
EFI_TEST_ASSERTION AssertionType;
EFI_SIMPLE_TEXT_OUTPUT_MODE ModeExpected;
UINTN ModeNumber[5];
UINTN Column, Row;
UINTN Index;
EFI_GRAPHICS_OUTPUT_PROTOCOL *GraphicsOutput;
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__,
(UINTN)__LINE__,
Status
);
return Status;
}
SimpleOut = (EFI_SIMPLE_TEXT_OUT_PROTOCOL *)ClientInterface;
//
// Get Device Path of current Simple_Text_Output_Protocol
// And out put device path or device name
//
Status = LocateDevicePathFromSimpleTextOut (SimpleOut, &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__,
(UINTN)__LINE__,
Status
);
return Status;
}
DevicePathStr = NULL;
}
} else {
Status = LocateGopFromSimpleTextOut (SimpleOut, &GraphicsOutput, StandardLib);
if (EFI_ERROR(Status)) {
//
// Console Splitter/StdErr
//
StandardLib->RecordMessage (
StandardLib,
EFI_VERBOSE_LEVEL_DEFAULT,
L"\r\nCurrent Device: ConsoleSplitter/StdErr"
);
} else {
//
// Console Splitter/ConOut
//
StandardLib->RecordMessage (
StandardLib,
EFI_VERBOSE_LEVEL_DEFAULT,
L"\r\nCurrent Device: ConsoleSplitter/ConOut"
);
}
}
//
// Prepare test data
//
ModeNumber[0] = SimpleOut->Mode->MaxMode;
ModeNumber[1] = SimpleOut->Mode->MaxMode + 1;
ModeNumber[2] = SimpleOut->Mode->MaxMode + 2;
ModeNumber[3] = SimpleOut->Mode->MaxMode + 100;
Column = 0;
Row = 0;
for (Index = 0; Index <= 3; Index++) {
//
// Clear Screen
//
SimpleOut->ClearScreen (SimpleOut);
//
// Prepare expected Mode after call Reset.
//
BackupMode (SimpleOut, &ModeExpected);
//
// Call QueryMode with invalid ModeNumber
//
Status = SimpleOut->QueryMode (SimpleOut, ModeNumber[Index], &Column, &Row);
//
// Mode itegrity test
//
if (CheckModeIntegrity (&ModeExpected, SimpleOut->Mode) == FALSE) {
AssertionType = EFI_TEST_ASSERTION_FAILED;
} else {
AssertionType = EFI_TEST_ASSERTION_PASSED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gSimpleTextOutputConformanceTestAssertionGuid001,
L"EFI_SIMPLE_TEXT_OUT_PROTOCOL.QueryMode - QueryMode() with invalid ModeNumber, mode position integrity",
L"%a:%d: ModeNumber=%d Current: Cursor Position(%d x %d), Mode=%d, MaxMode=%d, Attribute=%d, CursorVisible=%d. "\
L" Expected:Cursor Position(%d x %d), Mode=%d, MaxMode=%d, Attribute=%d, CursorVisible=%d.",
__FILE__,
(UINTN)__LINE__,
ModeNumber[Index],
SimpleOut->Mode->CursorColumn,
SimpleOut->Mode->CursorRow,
SimpleOut->Mode->Mode,
SimpleOut->Mode->Attribute,
SimpleOut->Mode->MaxMode,
SimpleOut->Mode->CursorVisible,
ModeExpected.CursorColumn,
ModeExpected.CursorRow,
ModeExpected.Mode,
ModeExpected.MaxMode,
ModeExpected.Attribute,
ModeExpected.CursorVisible
);
//
// Status check
//
if (Status!=EFI_UNSUPPORTED) {
AssertionType = EFI_TEST_ASSERTION_FAILED;
} else {
AssertionType = EFI_TEST_ASSERTION_PASSED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gSimpleTextOutputConformanceTestAssertionGuid002,
L"EFI_SIMPLE_TEXT_OUT_PROTOCOL.QueryMode - QueryMode() with invalid ModeNumber",
L"%a:%d: Status = %r, ModeNumber = %d, MaxModeNumber=%d, Column=%d, Row=%d",
__FILE__,
(UINTN)__LINE__,
Status,
ModeNumber[Index],
SimpleOut->Mode->MaxMode,
Column,
Row
);
}
return EFI_SUCCESS;
}
//
// TDS 4.1.2
//
EFI_STATUS
BBTestResetFunctionManualTest (
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_SIMPLE_TEXT_IN_PROTOCOL *SimpleIn;
EFI_TEST_ASSERTION AssertionType;
EFI_DEVICE_PATH_PROTOCOL *DevicePath;
CHAR16 *DevicePathStr;
EFI_INPUT_KEY Key;
//
// 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;
}
SimpleIn = (EFI_SIMPLE_TEXT_IN_PROTOCOL *)ClientInterface;
//
// Get Device Path of current Simple_Text_In_Protocol
// And out put device path or device name
//
Status = LocateDevicePathFromSimpleTextIn (SimpleIn, &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/StdErr
//
StandardLib->RecordMessage (
StandardLib,
EFI_VERBOSE_LEVEL_DEFAULT,
L"\r\nCurrent Device: ConsoleSplitter/TxtIn"
);
}
Print (L"\r\nReset Function Test Start!\r\n");
WaitTimeOrKey (5);
//
// Assertion Point 4.1.2.2.1
// Reset without Extended Verification & Reset with Extended Verification
//
//
// Call SimpleTextIn.Reset() with ExtendedVerification as FALSE
//
Status = SimpleIn->Reset (SimpleIn, FALSE);
if (EFI_ERROR(Status)) {
AssertionType = EFI_TEST_ASSERTION_FAILED;
} else {
AssertionType = EFI_TEST_ASSERTION_PASSED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gSimpleTextInInterfaceTestAssertionGuid003,
L"EFI_SIMPLE_TEXT_IN_PROTOCOL.Reset - Reset() with ExtendedVerification as FALSE",
L"%a:%d, Status = %r",
__FILE__,
__LINE__,
Status
);
//
// Prompt tester to input some characters
//
Print (L"Press some displayble keys in 5 second!");
//
// Wait 5 seconds
//
gtBS->Stall (5000000);
//
// Call SimpleTextIn.Reset with ExtendedVerification as FALSE again
//
Status = SimpleIn->Reset (SimpleIn, FALSE);
if (EFI_ERROR(Status)) {
AssertionType = EFI_TEST_ASSERTION_FAILED;
} else {
AssertionType = EFI_TEST_ASSERTION_PASSED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gSimpleTextInInterfaceTestAssertionGuid004,
L"EFI_SIMPLE_TEXT_IN_PROTOCOL.Reset - Reset() with ExtendedVerification as FALSE",
L"%a:%d, Status = %r",
__FILE__,
__LINE__,
Status
);
//
// Call SimpleTextIn.ReadKeyStroke() to check key buffer
//
Status = SimpleIn->ReadKeyStroke (SimpleIn, &Key);
if (Status!=EFI_NOT_READY) {
AssertionType = EFI_TEST_ASSERTION_FAILED;
} else {
AssertionType = EFI_TEST_ASSERTION_PASSED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gSimpleTextInInterfaceTestAssertionGuid005,
L"EFI_SIMPLE_TEXT_IN_PROTOCOL.Reset - Reset() with ExtendedVerification as FALSE, ReadKeyStroke() verification",
L"%a:%d, Status = %r, Expected=%r",
__FILE__,
__LINE__,
Status,
EFI_NOT_READY
);
//
// Assertion Point 4.1.2.2.2
//
//
// Call SimpleTextIn.Reset() with ExtendedVerification as TRUE
//
Status = SimpleIn->Reset (SimpleIn, TRUE);
if (EFI_ERROR(Status)) {
AssertionType = EFI_TEST_ASSERTION_FAILED;
} else {
AssertionType = EFI_TEST_ASSERTION_PASSED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gSimpleTextInInterfaceTestAssertionGuid006,
L"EFI_SIMPLE_TEXT_IN_PROTOCOL.Reset - Reset() with ExtendedVerification as TRUE",
L"%a:%d, Status = %r",
__FILE__,
__LINE__,
Status
);
//
// Prompt tester to input some characters
//
Print (L"Press some displayble keys in 5 second AGAIN!");
//
// Wait 5 seconds
//
gtBS->Stall (5000000);
//
// Call SimpleTextIn.Reset with ExtendedVerification as TRUE again
//
Status = SimpleIn->Reset (SimpleIn, TRUE);
if (EFI_ERROR(Status)) {
AssertionType = EFI_TEST_ASSERTION_FAILED;
} else {
AssertionType = EFI_TEST_ASSERTION_PASSED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gSimpleTextInInterfaceTestAssertionGuid007,
L"EFI_SIMPLE_TEXT_IN_PROTOCOL.Reset - Reset() with ExtendedVerification as TRUE",
L"%a:%d, Status = %r",
__FILE__,
__LINE__,
Status
);
//
// Call SimpleTextIn.ReadKeyStroke() to check key buffer
//
Status = SimpleIn->ReadKeyStroke (SimpleIn, &Key);
if (Status!=EFI_NOT_READY) {
AssertionType = EFI_TEST_ASSERTION_FAILED;
} else {
AssertionType = EFI_TEST_ASSERTION_PASSED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gSimpleTextInInterfaceTestAssertionGuid008,
L"EFI_SIMPLE_TEXT_IN_PROTOCOL.Reset - Reset() with ExtendedVerification as TRUE, ReadKeyStroke() verification",
L"%a:%d, Status = %r, Expected=%r",
__FILE__,
__LINE__,
Status,
EFI_NOT_READY
);
return EFI_SUCCESS;
}
//
// TDS 4.2.5
//
EFI_STATUS
BBTestSetAttributeConformanceAutoTest (
IN EFI_BB_TEST_PROTOCOL *This,
IN VOID *ClientInterface,
IN EFI_TEST_LEVEL TestLevel,
IN EFI_HANDLE SupportHandle
)
{
//
// This test case should be obsolete according to Spec changed.
//
EFI_STANDARD_TEST_LIBRARY_PROTOCOL *StandardLib;
EFI_STATUS Status;
EFI_SIMPLE_TEXT_OUT_PROTOCOL *SimpleOut;
EFI_TEST_ASSERTION AssertionType;
EFI_SIMPLE_TEXT_OUTPUT_MODE ModeOrg, ModeExpected;
UINTN Attribute[10];
UINTN Index;
EFI_GRAPHICS_OUTPUT_PROTOCOL *GraphicsOutput;
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__,
(UINTN)__LINE__,
Status
);
return Status;
}
SimpleOut = (EFI_SIMPLE_TEXT_OUT_PROTOCOL *)ClientInterface;
//
// Get Device Path of current Simple_Text_Output_Protocol
// And out put device path or device name
//
Status = LocateDevicePathFromSimpleTextOut (SimpleOut, &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__,
(UINTN)__LINE__,
Status
);
return Status;
}
DevicePathStr = NULL;
}
} else {
Status = LocateGopFromSimpleTextOut (SimpleOut, &GraphicsOutput, StandardLib);
if (EFI_ERROR(Status)) {
//
// Console Splitter/StdErr
//
StandardLib->RecordMessage (
StandardLib,
EFI_VERBOSE_LEVEL_DEFAULT,
L"\r\nCurrent Device: ConsoleSplitter/StdErr"
);
} else {
//
// Console Splitter/ConOut
//
StandardLib->RecordMessage (
StandardLib,
EFI_VERBOSE_LEVEL_DEFAULT,
L"\r\nCurrent Device: ConsoleSplitter/ConOut"
);
}
}
//
// Prepare test data
//
Attribute[0] = 0xB3;
Attribute[1] = 0x80;
Attribute[2] = 0x91;
Attribute[3] = 0xA2;
Attribute[4] = 65538;
//
// Backup Mode
//
BackupMode (SimpleOut, &ModeOrg);
for (Index = 0; Index < 5; Index++) {
//
// Prepare expected Mode after call Reset.
//
BackupMode (SimpleOut, &ModeExpected);
//
// Call SetAttribute with invalid Attribute
//
Status = SimpleOut->SetAttribute (SimpleOut, Attribute[Index]);
//
// Mode itegrity test
//
ModeExpected.CursorColumn = SimpleOut->Mode->CursorColumn;
ModeExpected.CursorRow = SimpleOut->Mode->CursorRow;
if (CheckModeIntegrity (&ModeExpected, SimpleOut->Mode) == FALSE) {
AssertionType = EFI_TEST_ASSERTION_FAILED;
} else {
AssertionType = EFI_TEST_ASSERTION_PASSED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gSimpleTextOutputConformanceTestAssertionGuid005,
L"EFI_SIMPLE_TEXT_OUT_PROTOCOL.SetAttribute - SetAttribute() with invalid Attribute, mode position integrity",
L"%a:%d: Attribute=%x Current: Cursor Position(%d x %d), Mode=%d, MaxMode=%d, Attribute=%d, CursorVisible=%d. "\
L" Expected:Cursor Position(%d x %d), Mode=%d, MaxMode=%d, Attribute=%d, CursorVisible=%d.",
__FILE__,
(UINTN)__LINE__,
Attribute[Index],
SimpleOut->Mode->CursorColumn,
SimpleOut->Mode->CursorRow,
SimpleOut->Mode->Mode,
SimpleOut->Mode->MaxMode,
SimpleOut->Mode->Attribute,
SimpleOut->Mode->CursorVisible,
ModeExpected.CursorColumn,
ModeExpected.CursorRow,
ModeExpected.Mode,
ModeExpected.MaxMode,
ModeExpected.Attribute,
ModeExpected.CursorVisible
);
//
// Status check
//
if (Status!=EFI_UNSUPPORTED) {
AssertionType = EFI_TEST_ASSERTION_FAILED;
} else {
AssertionType = EFI_TEST_ASSERTION_PASSED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gSimpleTextOutputConformanceTestAssertionGuid006,
L"EFI_SIMPLE_TEXT_OUT_PROTOCOL.SetAttribute - SetAttribute() with invalid Attribute",
L"%a:%d: Status = %r, Attribute = %x",
__FILE__,
(UINTN)__LINE__,
Status,
Attribute[Index]
);
}
return RestoreMode (SimpleOut, &ModeOrg, StandardLib);
}
//
// 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 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
//
EFI_STATUS
BBTestGetStateExtensiveManualTest (
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_ABSOLUTE_POINTER_PROTOCOL *AbsolutePointer;
EFI_TEST_ASSERTION AssertionType;
EFI_DEVICE_PATH_PROTOCOL *DevicePath;
CHAR16 *DevicePathStr;
EFI_ABSOLUTE_POINTER_STATE State;
//EFI_ABSOLUTE_POINTER_MODE Mode;
UINTN WaitIndex;
UINT64 CurPosX, CurPosY,CurPosZ;
BOOLEAN SptAltActive, SptPressureAsZ;
//
// 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;
}
AbsolutePointer = (EFI_ABSOLUTE_POINTER_PROTOCOL *)ClientInterface;
//
// Get Device Path of current Absolute_Pointer_Protocol
// And out put device path or device name
//
Status = LocateDevicePathFromAbsolutePointer (AbsolutePointer, &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__,
(UINTN)__LINE__,
Status
);
return Status;
}
DevicePathStr=NULL;
}
} else {
//
// Console Splitter/AbsolutePointer
//
StandardLib->RecordMessage (
StandardLib,
EFI_VERBOSE_LEVEL_DEFAULT,
L"\r\nCurrent Device: ConsoleSplitter/AbsolutePointer"
);
}
Print (L"\r\nGetState Stress Test Start!\r\n");
WaitTimeOrKey (5);
//
// Call Reset () with ExtendedVerification being TRUE
//
Status = AbsolutePointer->Reset (AbsolutePointer, TRUE);
if (EFI_ERROR(Status)) {
AssertionType = EFI_TEST_ASSERTION_FAILED;
} else {
AssertionType = EFI_TEST_ASSERTION_PASSED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gTestGenericFailureGuid,
L"EFI_ABSOLUTE_POINTER_PROTOCOL.Reset() - Reset with ExtendedVerification being TRUE",
L"%a:%d, Status = %r, Expected = %r",
__FILE__,
(UINTN)__LINE__,
Status,
EFI_SUCCESS
);
//
// Prompt user to move or click pointer device continuously
//
Print (L"\r\nMove or Click pointer device for test!!\r\nAny key to quit!\r\n");
CurPosX = 0;
CurPosY = 0;
CurPosZ = 0;
//
// Capture mouse action continuously until key input
//
AssertionType = EFI_TEST_ASSERTION_PASSED;
while (TRUE) {
//
// Wait until mouse action
//
Status = gtBS->WaitForEvent (1, &(AbsolutePointer->WaitForInput), &WaitIndex);
if (EFI_ERROR(Status)) {
AssertionType = EFI_TEST_ASSERTION_FAILED;
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gTestGenericFailureGuid,
L"EFI_ABSOLUTE_POINTER_PROTOCOL.WaitForInput() - WaitForEvent after WaitForInput is signaled",
L"%a:%d, Status = %r, Expected = %r",
__FILE__,
(UINTN)__LINE__,
Status,
EFI_SUCCESS
);
}
//
// Call GetState to retrieve the state of device
//
Status = AbsolutePointer->GetState (AbsolutePointer, &State);
if (EFI_ERROR(Status)) {
AssertionType = EFI_TEST_ASSERTION_FAILED;
break;
}
if (PointerKeepSilent (AbsolutePointer->Mode, &State)==FALSE) {
//
// Output CurrentXYZ & CurPosXYZ
//
CurPosX += State.CurrentX;
CurPosY += State.CurrentY;
CurPosZ += State.CurrentZ;
Print (L"\r\nCurrentXYZ(%5d,%5d,%5d),CurPos(%5d,%5d,%5d)",
State.CurrentX,
State.CurrentY,
State.CurrentZ,
CurPosX,
CurPosY,
CurPosZ
);
}
//
// ActiveButton state TouchActive
//
SptAltActive = SupportAltActiveExt (AbsolutePointer->Mode,&State);
if ( SptAltActive==FALSE) {
SptPressureAsZ = SupportPressureAsZExt(AbsolutePointer->Mode,&State);
if (SptPressureAsZ ==FALSE && State.CurrentZ!=0) {
Print (L"\r\nActiveButton RELEASED!");
} else {
Print (L"\r\nActiveButton UNRELEASED!");
}
}
SptAltActive = SupportAltActive(AbsolutePointer->Mode,&State);
if (SptAltActive==TRUE) {
SptPressureAsZ = SupportPressureAsZ(AbsolutePointer->Mode,&State);
if (SptPressureAsZ==TRUE && State.CurrentZ==0) {
Print (L"\r\nActiveButton RELEASED!");
} else {
Print (L"\r\nActiveButton UNRELEASED!");
}
}
//
// If any key input, then quit the test
//
Status = gtBS->CheckEvent (gtST->ConIn->WaitForKey);
if (Status == EFI_SUCCESS) {
break;
}
}
//
//record assertion
//
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gAbsolutePointerExtensiveTestAssertionGuid011,
L"EFI_ABSOLUTE_POINTER_PROTOCOL.GetState() - GetState after mouse moved or button state changed",
L"%a:%d, Status = %r,expected -%r",
__FILE__,
(UINTN)__LINE__,
Status,
EFI_SUCCESS
);
//
// User's view.
//
if (AutoJudge (5, TRUE, L"\r\nThe state reflect mouse action correctly?\r\n")==TRUE) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gAbsolutePointerExtensiveTestAssertionGuid012,
L"EFI_Absolute_TEXT_POINTER_PROTOCOL.GetState() - Extensive test",
L"%a:%d",
__FILE__,
(UINTN)__LINE__
);
return EFI_SUCCESS;
}
//
// TDS
//
EFI_STATUS
BBTestResetClearanceManualTest (
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_ABSOLUTE_POINTER_PROTOCOL *AbsolutePointer;
EFI_TEST_ASSERTION AssertionType;
EFI_DEVICE_PATH_PROTOCOL *DevicePath;
CHAR16 *DevicePathStr;
EFI_ABSOLUTE_POINTER_STATE State;
UINTN WaitIndex;
//
// 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;
}
AbsolutePointer = (EFI_ABSOLUTE_POINTER_PROTOCOL *)ClientInterface;
//
// Get Device Path of current Absolute_Pointer_Protocol
// And out put device path or device name
//
Status = LocateDevicePathFromAbsolutePointer (AbsolutePointer, &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__,
(UINTN)__LINE__,
Status
);
return Status;
}
DevicePathStr=NULL;
}
} else {
//
// Console Splitter/AbsolutePointer
//
StandardLib->RecordMessage (
StandardLib,
EFI_VERBOSE_LEVEL_DEFAULT,
L"\r\nCurrent Device: ConsoleSplitter/AbsolutePointer"
);
}
Print (L"\r\nReset Clearence Test Start!\r\n");
WaitTimeOrKey (5);
//
// Assertion Point
// Reset() without Extended Verification should clears any pending pointer actions
//
//
// Call Reset() with ExtendedVerification being FALSE
//
Status = AbsolutePointer->Reset (AbsolutePointer, FALSE);
if (EFI_ERROR(Status)) {
AssertionType = EFI_TEST_ASSERTION_FAILED;
} else {
AssertionType = EFI_TEST_ASSERTION_PASSED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gAbsolutePointerExtensiveTestAssertionGuid001,
L"EFI_ABSOLUTE_POINTER_PROTOCOL.Reset() - Reset with ExtendedVerification being FALSE",
L"%a:%d, Status = %r, Expected = %r",
__FILE__,
(UINTN)__LINE__,
Status,
EFI_SUCCESS
);
//
// Call CheckEvent() on the WaitForInput event, should return EFI_NOT_READY
//
Status = gtBS->CheckEvent (AbsolutePointer->WaitForInput);
if (Status!=EFI_NOT_READY) {
AssertionType = EFI_TEST_ASSERTION_FAILED;
} else {
AssertionType = EFI_TEST_ASSERTION_PASSED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gAbsolutePointerExtensiveTestAssertionGuid002,
L"EFI_ABSOLUTE_POINTER_PROTOCOL.Reset() - CheckEvent on WaitForInput after Reset with FALSE",
L"%a:%d, Status = %r, Expected = %r",
__FILE__,
(UINTN)__LINE__,
Status,
EFI_NOT_READY
);
//
// Prompt user to input from pointer device
//
Print (L"\r\nPlease move the mouse or press some button!\r\n");
gtBS->Stall (5000000);
//
// Call WaitForEvent to test whether user had input
//
Status = gtBS->WaitForEvent (1, &(AbsolutePointer->WaitForInput), &WaitIndex);
if (EFI_ERROR(Status)) {
AssertionType = EFI_TEST_ASSERTION_FAILED;
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gTestGenericFailureGuid,
L"BS.WaitForEvent() - Error ",
L"%a:%d, Status = %r",
__FILE__,
(UINTN)__LINE__,
Status
);
}
//
// Call Reset() with ExtendedVerification as FALSE;
//
Status = AbsolutePointer->Reset (AbsolutePointer, FALSE);
if (EFI_ERROR(Status)) {
AssertionType = EFI_TEST_ASSERTION_FAILED;
} else {
AssertionType = EFI_TEST_ASSERTION_PASSED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gAbsolutePointerExtensiveTestAssertionGuid004,
L"EFI_ABSOLUTE_POINTER_PROTOCOL.Reset() - Reset with ExtendedVerification being FALSE",
L"%a:%d, Status = %r, Expected = %r",
__FILE__,
(UINTN)__LINE__,
Status,
EFI_SUCCESS
);
//
// Call CheckEvent on the WaitForInput Event
//
Status = gtBS->CheckEvent (AbsolutePointer->WaitForInput);
if (Status!=EFI_NOT_READY) {
AssertionType = EFI_TEST_ASSERTION_FAILED;
} else {
AssertionType = EFI_TEST_ASSERTION_PASSED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gAbsolutePointerExtensiveTestAssertionGuid005,
L"EFI_ABSOLUTE_POINTER_PROTOCOL.Reset() - CheckEvent after Reset with ExtendedVerification being FALSE, Clear WaitForEvent",
L"%a:%d, Status = %r, Expected = %r",
__FILE__,
(UINTN)__LINE__,
Status ,
EFI_NOT_READY
);
//
// Call GetState to verify pointer state;
//
Status = AbsolutePointer->GetState (AbsolutePointer, &State);
if (Status==EFI_SUCCESS) {
//
// State should indicate that pointer device keep silent
//
if (PointerKeepSilent (AbsolutePointer->Mode, &State) == FALSE) {
AssertionType = EFI_TEST_ASSERTION_FAILED;
} else {
AssertionType = EFI_TEST_ASSERTION_PASSED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gAbsolutePointerExtensiveTestAssertionGuid006,
L"EFI_ABSOLUTE_POINTER_PROTOCOL.Reset() - GetState after Reset with ExtendedVerification being FALSE, Pointer state check",
L"%a:%d: Status = %r,AbsoluteMinX=0x%lx,AbsoluteMaxX=0x%lx,CurrentX=0x%lx,AbsoluteMinY=0x%lx,AbsoluteMaxY=0x%lx,CurrentY=0x%lx,AbsoluteMinZ=0x%lx,AbsoluteMaxZ=0x%lx,CurrentZ=0x%lx,Attributes=0x%lx,ActiveButtons=0x%lx",
__FILE__,
(UINTN)__LINE__,
Status,
AbsolutePointer->Mode->AbsoluteMinX,
AbsolutePointer->Mode->AbsoluteMaxX,
State.CurrentX,
AbsolutePointer->Mode->AbsoluteMinY,
AbsolutePointer->Mode->AbsoluteMaxY,
State.CurrentY,
AbsolutePointer->Mode->AbsoluteMinZ,
AbsolutePointer->Mode->AbsoluteMaxZ,
State.CurrentZ,
AbsolutePointer->Mode->Attributes,
State.ActiveButtons
);
} else if (Status==EFI_NOT_READY) {
//
// This is expected status, no problem
//
AssertionType = EFI_TEST_ASSERTION_PASSED;
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gAbsolutePointerExtensiveTestAssertionGuid007,
L"EFI_ABSOLUTE_POINTER_PROTOCOL.Reset() - GetState after Reset with ExtendedVerification being FALSE",
L"%a:%d, Status = %r",
__FILE__,
(UINTN)__LINE__,
Status
);
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gTestGenericFailureGuid,
L"EFI_ABSOLUTE_POINTER_PROTOCOL.GetState() - GetState after Reset with ExtendedVerification being FALSE",
L"%a:%d, Status = %r",
__FILE__,
(UINTN)__LINE__,
Status
);
}
//
// Assertion Point
// Reset() with Extended Verification should clears any pending pointer actions
//
//
// Call Reset() with ExtendedVerification being TRUE
//
Status = AbsolutePointer->Reset (AbsolutePointer, TRUE);
if (EFI_ERROR(Status)) {
AssertionType = EFI_TEST_ASSERTION_FAILED;
} else {
AssertionType = EFI_TEST_ASSERTION_PASSED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gAbsolutePointerBBTestStressAssertionGuid001,
L"EFI_ABSOLUTE_POINTER_PROTOCOL.Reset() - Reset with ExtendedVerification being TRUE",
L"%a:%d, Status = %r, Expected = %r",
__FILE__,
(UINTN)__LINE__,
Status,
EFI_SUCCESS
);
//
// Call CheckEvent() on the WaitForInput event, should return EFI_NOT_READY
//
Status = gtBS->CheckEvent (AbsolutePointer->WaitForInput);
if (Status!=EFI_NOT_READY) {
AssertionType = EFI_TEST_ASSERTION_FAILED;
} else {
AssertionType = EFI_TEST_ASSERTION_PASSED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gAbsolutePointerBBTestStressAssertionGuid002,
L"EFI_ABSOLUTE_POINTER_PROTOCOL.Reset() - CheckEvent on WaitForInput after Reset with TRUE",
L"%a:%d, Status = %r, Expected = %r",
__FILE__,
(UINTN)__LINE__,
Status,
EFI_NOT_READY
);
//
// Prompt user to input from pointer device
//
Print (L"\r\nPlease move mouse or press some button AGAIN!\r\n");
gtBS->Stall (5000000);
//
// Call WaitForEvent to test whether user had input
//
Status = gtBS->WaitForEvent (1, &(AbsolutePointer->WaitForInput), &WaitIndex);
if (EFI_ERROR(Status)) {
AssertionType = EFI_TEST_ASSERTION_FAILED;
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gTestGenericFailureGuid,
L"BS.WaitForEvent() - Error ",
L"%a:%d, Status = %r",
__FILE__,
(UINTN)__LINE__,
Status
);
}
//
// Call Reset() with ExtendedVerification as TRUE;
//
Status = AbsolutePointer->Reset (AbsolutePointer, TRUE);
if (EFI_ERROR(Status)) {
AssertionType = EFI_TEST_ASSERTION_FAILED;
} else {
AssertionType = EFI_TEST_ASSERTION_PASSED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gAbsolutePointerBBTestStressAssertionGuid003,
L"EFI_ABSOLUTE_POINTER_PROTOCOL.Reset() - Reset with ExtendedVerification being TRUE",
L"%a:%d, Status = %r, Expected = %r",
__FILE__,
(UINTN)__LINE__,
Status,
EFI_SUCCESS
);
//
// Call CheckEvent on the WaitForInput Event
//
Status = gtBS->CheckEvent (AbsolutePointer->WaitForInput);
if (Status!=EFI_NOT_READY) {
AssertionType = EFI_TEST_ASSERTION_FAILED;
} else {
AssertionType = EFI_TEST_ASSERTION_PASSED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gAbsolutePointerBBTestStressAssertionGuid004,
L"EFI_ABSOLUTE_POINTER_PROTOCOL.Reset() - CheckEvent after Reset with ExtendedVerification being TRUE, Clear WaitForEvent",
L"%a:%d, Status = %r, Expected = %r",
__FILE__,
(UINTN)__LINE__,
Status ,
EFI_NOT_READY
);
//
// Call GetState to verify pointer state;
//
Status = AbsolutePointer->GetState (AbsolutePointer, &State);
if (Status==EFI_SUCCESS) {
//
// State should indicate that pointer device keep silent
//
if (PointerKeepSilent (AbsolutePointer->Mode, &State) == FALSE) {
AssertionType = EFI_TEST_ASSERTION_FAILED;
} else {
AssertionType = EFI_TEST_ASSERTION_PASSED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gAbsolutePointerBBTestStressAssertionGuid005,
L"EFI_ABSOLUTE_POINTER_PROTOCOL.Reset() - GetState after Reset with ExtendedVerification being FALSE, Pointer state check",
L"%a:%d: Status = %r,AbsoluteMinX=0x%lx,AbsoluteMaxX=0x%lx,CurrentX=0x%lx,AbsoluteMinY=0x%lx,AbsoluteMaxY=0x%lx,CurrentY=0x%lx,AbsoluteMinZ=0x%lx,AbsoluteMaxZ=0x%lx,CurrentZ=0x%lx,Attributes=0x%lx,ActiveButtons=0x%lx",
__FILE__,
(UINTN)__LINE__,
Status,
AbsolutePointer->Mode->AbsoluteMinX,
AbsolutePointer->Mode->AbsoluteMaxX,
State.CurrentX,
AbsolutePointer->Mode->AbsoluteMinY,
AbsolutePointer->Mode->AbsoluteMaxY,
State.CurrentY,
AbsolutePointer->Mode->AbsoluteMinZ,
AbsolutePointer->Mode->AbsoluteMaxZ,
State.CurrentZ,
AbsolutePointer->Mode->Attributes,
State.ActiveButtons
);
} else if (Status==EFI_NOT_READY) {
//
// This is expected status, no problem
//
AssertionType = EFI_TEST_ASSERTION_PASSED;
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gAbsolutePointerBBTestStressAssertionGuid006,
L"EFI_ABSOLUTE_POINTER_PROTOCOL.Reset() - GetState after Reset with ExtendedVerification being TRUE",
L"%a:%d, Status = %r",
__FILE__,
(UINTN)__LINE__,
Status
);
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gTestGenericFailureGuid,
L"EFI_ABSOLUTE_POINTER_PROTOCOL.GetState() - GetState after Reset with ExtendedVerification being FALSE",
L"%a:%d, Status = %r",
__FILE__,
(UINTN)__LINE__,
Status
);
}
return EFI_SUCCESS;
}
//
// TDS 3.1
//
EFI_STATUS
BBTestGetNextDeviceFunctionAutoTest (
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;
//
// 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\n",
__FILE__,
(UINTN)__LINE__,
Status
);
return Status;
}
ScsiPassThru = (EFI_SCSI_PASS_THRU_PROTOCOL *)ClientInterface;
//
// Assertion Point 3.1.2.1
// Retrieve the list of legal Target IDs and LUNs for SCSI devices on a SCSI channel.
//
Target = 0xFFFFFFFF;
Status = EFI_SUCCESS;
while (!EFI_ERROR(Status)) {
Status = ScsiPassThru->GetNextDevice (ScsiPassThru, &Target, &Lun);
if (!EFI_ERROR(Status )) {
StandardLib->RecordMessage (
StandardLib,
EFI_VERBOSE_LEVEL_QUIET,
L"SCSI device: Target - %d, Lun - %ld\n",
Target,
Lun
);
}
}
if (Status == EFI_NOT_FOUND) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gScsiPassThruBBTestFunctionAssertionGuid001,
L"EFI_SCSI_PASS_THRU_PROTOCOL.GetNextDevice - Invoke GetNextDevice() and verify interface correctness within test case",
L"%a:%d:Status - %r\n",
__FILE__,
(UINTN)__LINE__,
Status
);
return EFI_SUCCESS;
}
//
// TDS 4.3.2
//
EFI_STATUS
BBTestGetStateExtensiveManualTest (
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_SIMPLE_POINTER_PROTOCOL *SimplePointer;
EFI_TEST_ASSERTION AssertionType;
EFI_DEVICE_PATH_PROTOCOL *DevicePath;
CHAR16 *DevicePathStr;
EFI_SIMPLE_POINTER_STATE State;
UINTN WaitIndex;
INT32 CurPosX, CurPosY;
BOOLEAN ButtonDownL, ButtonDownR;
//
// 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;
}
SimplePointer = (EFI_SIMPLE_POINTER_PROTOCOL *)ClientInterface;
//
// Get Device Path of current Simple_Pointer_Protocol
// And out put device path or device name
//
Status = LocateDevicePathFromSimplePointer (SimplePointer, &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/SimplePointer
//
StandardLib->RecordMessage (
StandardLib,
EFI_VERBOSE_LEVEL_DEFAULT,
L"\r\nCurrent Device: ConsoleSplitter/SimplePointer"
);
}
Print (L"\r\nGetState Stress Test Start!\r\n");
WaitTimeOrKey (5);
//
// Call Reset () with ExtendedVerification being TRUE
//
Status = SimplePointer->Reset (SimplePointer, TRUE);
if (EFI_ERROR(Status)) {
AssertionType = EFI_TEST_ASSERTION_FAILED;
} else {
AssertionType = EFI_TEST_ASSERTION_PASSED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gTestGenericFailureGuid,
L"EFI_SIMPLE_POINTER_PROTOCOL.Reset() - Reset with ExtendedVerification being TRUE",
L"%a:%d, Status = %r, Expected = %r",
__FILE__,
__LINE__,
Status,
EFI_SUCCESS
);
//
// Prompt user to move or click pointer device continuously
//
Print (L"\r\nMove or Click pointer device for test!!\r\nAny key to quit!\r\n");
CurPosX = 0;
CurPosY = 0;
ButtonDownL = FALSE;
ButtonDownR = FALSE;
//
// Capture mouse action continuously until key input
//
AssertionType = EFI_TEST_ASSERTION_PASSED;
while (TRUE) {
//
// Wait until mouse action
//
Status = gtBS->WaitForEvent (1, &(SimplePointer->WaitForInput), &WaitIndex);
if (EFI_ERROR(Status)) {
AssertionType = EFI_TEST_ASSERTION_FAILED;
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gTestGenericFailureGuid,
L"EFI_SIMPLE_POINTER_PROTOCOL.WaitForInput() - WaitForEvent after WaitForInput is signaled",
L"%a:%d, Status = %r, Expected = %r",
__FILE__,
__LINE__,
Status,
EFI_SUCCESS
);
}
//
// Call GetState to retrieve the state of device
//
Status = SimplePointer->GetState (SimplePointer, &State);
if (EFI_ERROR(Status)) {
AssertionType = EFI_TEST_ASSERTION_FAILED;
break;
}
if (PointerKeepSilent (SimplePointer->Mode, &State)==FALSE) {
//
// Output RelativeXYZ & CurPosXY
//
CurPosX += State.RelativeMovementX;
CurPosY += State.RelativeMovementY;
Print (L"\r\nRelativeXYZ(%5d,%5d,%5d),CurPos(%5d,%5d)",
State.RelativeMovementX,
State.RelativeMovementY,
State.RelativeMovementZ,
CurPosX,
CurPosY
);
}
//
// Left button state changed?
//
if (SimplePointer->Mode->LeftButton && State.LeftButton!=ButtonDownL) {
ButtonDownL = State.LeftButton;
if (ButtonDownL) {
Print (L"\r\nLeft button DOWN!");
} else {
Print (L"\r\nLeft button UP!");
}
}
//
// Right button state changed?
//
if (SimplePointer->Mode->RightButton && State.RightButton!=ButtonDownR) {
ButtonDownR = State.RightButton;
if (ButtonDownR) {
Print (L"\r\nRight button DOWN!");
} else {
Print (L"\r\nRight button UP!");
}
}
//
// If any key input, then quit the test
//
Status = gtBS->CheckEvent (gtST->ConIn->WaitForKey);
if (Status == EFI_SUCCESS) {
break;
}
}
//
//record assertion
//
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gSimplePointerExtensiveTestAssertionGuid011,
L"EFI_SIMPLE_POINTER_PROTOCOL.GetState() - GetState after mouse moved or button state changed",
L"%a:%d, Status = %r,expected -%r",
__FILE__,
__LINE__,
Status,
EFI_SUCCESS
);
//
// User's view.
//
if (AutoJudge (5, TRUE, L"\r\nThe state reflect mouse action correctly?\r\n")==TRUE) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gSimplePointerExtensiveTestAssertionGuid012,
L"EFI_SIMPLE_TEXT_POINTER_PROTOCOL.GetState() - Extensive test",
L"%a:%d",
__FILE__,
__LINE__
);
return EFI_SUCCESS;
}
//
// TDS 4.1.4
//
EFI_STATUS
BBTestWaitForKeyFunctionManualTest (
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_SIMPLE_TEXT_IN_PROTOCOL *SimpleIn;
EFI_TEST_ASSERTION AssertionType;
EFI_INPUT_KEY Key;
EFI_DEVICE_PATH_PROTOCOL *DevicePath;
CHAR16 *DevicePathStr;
// BOOLEAN KeyPressed=FALSE, EscPressed=FALSE;
UINTN WaitIndex;
//
// 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;
}
SimpleIn = (EFI_SIMPLE_TEXT_IN_PROTOCOL *)ClientInterface;
//
// Get Device Path of current Simple_Text_In_Protocol
// And out put device path or device name
//
Status = LocateDevicePathFromSimpleTextIn (SimpleIn, &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/StdErr
//
StandardLib->RecordMessage (
StandardLib,
EFI_VERBOSE_LEVEL_DEFAULT,
L"\r\nCurrent Device: ConsoleSplitter/TxtIn"
);
}
//
// wait for times
//
Print (L"\r\nWaitForKey Function Test Start!\r\n");
WaitTimeOrKey (5);
Status = SimpleIn->Reset (SimpleIn, TRUE);
if (EFI_ERROR(Status)) {
AssertionType = EFI_TEST_ASSERTION_FAILED;
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gTestGenericFailureGuid,
L"EFI_SIMPLE_TEXT_IN_PROTOCOL.Reset - Reset with ExtendedVeirification as TRUE",
L"%a:%d, Status = %r",
__FILE__,
__LINE__,
Status
);
}
//
// Assertion Point 4.1.4.2.1
// WaitForKey()
//
Print (L"Press ONE displayable key! and NO More!");
//
// WaitForKey event
//
Status = gtBS->WaitForEvent (1, &(SimpleIn->WaitForKey), &WaitIndex);
if (EFI_ERROR(Status)) {
AssertionType = EFI_TEST_ASSERTION_FAILED;
} else {
AssertionType = EFI_TEST_ASSERTION_PASSED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gSimpleTextInInterfaceTestAssertionGuid011,
L"EFI_SIMPLE_TEXT_IN_PROTOCOL.WaitForKey - Wait for event with key input",
L"%a:%d, Status = %r, Expected = %r",
__FILE__,
__LINE__,
Status,
EFI_SUCCESS
);
//
// Call ReadKeyStroke repeatedly to receive the character.
//
Status = SimpleIn->ReadKeyStroke (SimpleIn, &Key);
if (EFI_ERROR(Status)) {
AssertionType = EFI_TEST_ASSERTION_FAILED;
} else {
AssertionType = EFI_TEST_ASSERTION_PASSED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gSimpleTextInInterfaceTestAssertionGuid014,
L"EFI_SIMPLE_TEXT_IN_PROTOCOL.ReadKeyStroke - ReadKeyStroke() with key input",
L"%a:%d, Status = %r",
__FILE__,
__LINE__,
Status
);
return EFI_SUCCESS;
}
//
// TDS 4.1.3
//
EFI_STATUS
BBTestReadKeyStrokeFunctionManualTest (
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_SIMPLE_TEXT_IN_PROTOCOL *SimpleIn;
EFI_TEST_ASSERTION AssertionType;
EFI_INPUT_KEY Key;
EFI_DEVICE_PATH_PROTOCOL *DevicePath;
CHAR16 *DevicePathStr;
BOOLEAN KeyPressed=FALSE, EscPressed=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;
}
SimpleIn = (EFI_SIMPLE_TEXT_IN_PROTOCOL *)ClientInterface;
//
// Get Device Path of current Simple_Text_In_Protocol
// And out put device path or device name
//
Status = LocateDevicePathFromSimpleTextIn (SimpleIn, &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/StdErr
//
StandardLib->RecordMessage (
StandardLib,
EFI_VERBOSE_LEVEL_DEFAULT,
L"\r\nCurrent Device: ConsoleSplitter/TxtIn"
);
}
//
// wait for times
//
Print (L"\r\nReadKeyStroke Function Test Start!\r\n");
WaitTimeOrKey (5);
//
// Assertion Point 4.1.3.2.1
// ReadKeyStroke()
//
Print (L"\r\nPress any key and wait for echo. Two ESC keys to quit");
while (TRUE) {
KeyPressed = WaitTimeOrKeySimpleIn (SimpleIn, 1);
if (KeyPressed==TRUE) {
Print (L"\r\nKey Pressed--");
//
// Key Pressed!
//
//
// Call ReadKeyStroke to retrieve the key
//
Status = SimpleIn->ReadKeyStroke (SimpleIn, &Key);
if (EFI_ERROR(Status)) {
AssertionType = EFI_TEST_ASSERTION_FAILED;
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gSimpleTextInInterfaceTestAssertionGuid009,
L"EFI_SIMPLE_TEXT_IN_PROTOCOL.ReadKeyStroke - ReadKeyStroke() with key input",
L"%a:%d, Status = %r",
__FILE__,
__LINE__,
Status
);
}
//
// Output what user input
//
if (Key.ScanCode==0) {
//
// Unicode character
//
APrint ((char*)(&Key.UnicodeChar));
} else {
//
// Scan code character
//
Print (ScanCodeDesc (Key.ScanCode));
}
if (Key.ScanCode==SCAN_ESC) {
if (EscPressed==TRUE) {
break;
}
EscPressed = TRUE;
} else {
EscPressed=FALSE;
}
}
}
if (AutoJudge (5, TRUE, L"\r\nEcho correct?\r\n")==TRUE) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gSimpleTextInInterfaceTestAssertionGuid010,
L"EFI_SIMPLE_TEXT_IN_PROTOCOL.ReadKeyStroke - ReadKeyStroke() with key input, user's view",
L"%a:%d",
__FILE__,
__LINE__
);
return EFI_SUCCESS;
}
//
// TDS 4.1.1
//
EFI_STATUS
BBTestResetFunctionAutoTest (
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_SIMPLE_TEXT_IN_PROTOCOL *SimpleIn;
EFI_TEST_ASSERTION AssertionType;
EFI_DEVICE_PATH_PROTOCOL *DevicePath;
CHAR16 *DevicePathStr;
UINTN Index;
EFI_INPUT_KEY Key;
//
// 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;
}
SimpleIn = (EFI_SIMPLE_TEXT_IN_PROTOCOL *)ClientInterface;
//
// Get Device Path of current Simple_Text_In_Protocol
// And out put device path or device name
//
Status = LocateDevicePathFromSimpleTextIn (SimpleIn, &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/StdErr
//
StandardLib->RecordMessage (
StandardLib,
EFI_VERBOSE_LEVEL_DEFAULT,
L"\r\nCurrent Device: ConsoleSplitter/TxtIn"
);
}
//
// Assertion Point 4.1.1.2.1
// Reset without Extended Verification & Reset with Extended Verification
//
for (Index=0;Index<REPEAT_EXECUTE_OF_TEST;Index++) {
//
// Call SimpleTextIn.Reset() with ExtendedVerification as FALSE
//
Status = SimpleIn->Reset (SimpleIn, FALSE);
if (EFI_ERROR(Status)) {
AssertionType = EFI_TEST_ASSERTION_FAILED;
} else {
AssertionType = EFI_TEST_ASSERTION_PASSED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gSimpleTextInInterfaceTestAssertionGuid001,
L"EFI_SIMPLE_TEXT_IN_PROTOCOL.Reset - Reset() with ExtendedVerification as FALSE",
L"%a:%d: Status = %r",
__FILE__,
__LINE__,
Status
);
//
//Auto test, after reset(), no key input, ReadKeyStroke() should return EFI_NOT_READY
//
Status = SimpleIn->ReadKeyStroke (SimpleIn, &Key);
if (Status != EFI_NOT_READY) {
AssertionType = EFI_TEST_ASSERTION_FAILED;
} else {
AssertionType = EFI_TEST_ASSERTION_PASSED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gSimpleTextInInterfaceTestAssertionGuid012,
L"EFI_SIMPLE_TEXT_IN_PROTOCOL.Reset - Reset() with ExtendedVerification as FALSE, ReadKeyStroke() verification with no key input",
L"%a:%d: Status = %r, Expected = %r",
__FILE__,
__LINE__,
Status,
EFI_NOT_READY
);
//
// Call SimpleTextIn.Reset() with ExtendedVerification as TRUE
//
Status = SimpleIn->Reset (SimpleIn, TRUE);
if (EFI_ERROR(Status)) {
AssertionType = EFI_TEST_ASSERTION_FAILED;
} else {
AssertionType = EFI_TEST_ASSERTION_PASSED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gSimpleTextInInterfaceTestAssertionGuid002,
L"EFI_SIMPLE_TEXT_IN_PROTOCOL.Reset - Reset() with ExtendedVerification as TRUE",
L"%a:%d: Status = %r",
__FILE__,
__LINE__,
Status
);
//
//Auto test, after reset(), no key input, ReadKeyStroke() should return EFI_NOT_READY
//
Status = SimpleIn->ReadKeyStroke (SimpleIn, &Key);
if (Status!=EFI_NOT_READY) {
AssertionType = EFI_TEST_ASSERTION_FAILED;
} else {
AssertionType = EFI_TEST_ASSERTION_PASSED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gSimpleTextInInterfaceTestAssertionGuid013,
L"EFI_SIMPLE_TEXT_IN_PROTOCOL.Reset - Reset() with ExtendedVerification as TRUE, ReadKeyStroke() verification with no key input",
L"%a:%d: Status = %r, Expected = %r",
__FILE__,
__LINE__,
Status,
EFI_NOT_READY
);
}
return EFI_SUCCESS;
}
//
//TDS 4.3.1
//
EFI_STATUS
SetAttributes_Stress (
IN EFI_BB_TEST_PROTOCOL *This,
IN VOID *ClientInterface,
IN EFI_TEST_LEVEL TestLevel,
IN EFI_HANDLE SupportHandle
)
{
EFI_STATUS Status;
EFI_PCI_ROOT_BRIDGE_IO_DEVICE *RBDev;
EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL *RootBridgeIo;
EFI_STANDARD_TEST_LIBRARY_PROTOCOL *StandardLib;
EFI_TEST_ASSERTION AssertionType;
UINT64 SupportedAttributes;
UINT64 CommonAttributes;
UINT64 CurrentAttributes;
UINT64 ResourceBase;
UINT64 ResourceLength;
UINTN Index;
UINTN AttributesNumber;
UINT64 ThisAttribute;
UINT64 AllAttributes[11] = {
EFI_PCI_ATTRIBUTE_ISA_MOTHERBOARD_IO,
EFI_PCI_ATTRIBUTE_ISA_IO,
EFI_PCI_ATTRIBUTE_VGA_PALETTE_IO,
EFI_PCI_ATTRIBUTE_VGA_MEMORY,
EFI_PCI_ATTRIBUTE_VGA_IO,
EFI_PCI_ATTRIBUTE_IDE_PRIMARY_IO,
EFI_PCI_ATTRIBUTE_IDE_SECONDARY_IO,
EFI_PCI_ATTRIBUTE_MEMORY_WRITE_COMBINE,
EFI_PCI_ATTRIBUTE_MEMORY_CACHED,
EFI_PCI_ATTRIBUTE_MEMORY_DISABLE,
EFI_PCI_ATTRIBUTE_DUAL_ADDRESS_CYCLE
};
//
//get tested interface.
//
RootBridgeIo = (EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL *)ClientInterface;
//
// Get the Standard Library Interface
//
Status = gtBS->HandleProtocol (
SupportHandle,
&gEfiStandardTestLibraryGuid,
&StandardLib
);
if (EFI_ERROR(Status)) {
return Status;
}
InitializeCaseEnvironment ();
//
//get RootBridgeIoDevice struct pointer.
//
RBDev = NULL;
RBDev = GetRootBridgeIoDevice (RootBridgeIo);
if (RBDev == NULL) {
return EFI_ABORTED;
}
//
//print the device path of root Bridge
//
Status = PrintRootBridgeDevPath (RBDev->DevicePath);
if (EFI_ERROR(Status)) {
return Status;
}
//
//get some valid memory resource controlled by this Root Bridge.
//
Status = GetSomeMemeryResource (
RBDev,
&ResourceBase,
&ResourceLength
);
if (EFI_ERROR(Status)) {
StandardLib->RecordMessage (
StandardLib,
EFI_VERBOSE_LEVEL_DEFAULT,
L"PCI_ROOT_BRIDGE_IO_PROTOCOL.SetAttributes-not found valid memory resource.\n"
L"%a:%d.\n",
__FILE__,
(UINTN)__LINE__
);
return EFI_SUCCESS;
}
if (ResourceLength > 0x1000) {
ResourceLength = 0x1000;
}
//
//call GetAttributes to get current supported attributes.
//
Status = RootBridgeIo->GetAttributes (
RootBridgeIo,
&SupportedAttributes,
NULL
);
if (!EFI_ERROR(Status)) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
//
//record assertion
//
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gTestGenericFailureGuid,
L"EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL.GetAttributes - Get Supported attribute status must be EFI_SUCCESS",
L"%a:%d:Status - %r",
__FILE__,
(UINTN)__LINE__,
Status
);
//
//for each atributes call Setattributes.
//
AttributesNumber = 11;
for (Index = 0; Index < AttributesNumber; Index ++) {
ThisAttribute = AllAttributes[Index];
//
//first get current attributes before call SetAttributes.
//
RootBridgeIo->GetAttributes (
RootBridgeIo,
NULL,
&CurrentAttributes
);
//
//call SetAttributes to set this attributes
//
Status = RootBridgeIo->SetAttributes (
RootBridgeIo,
ThisAttribute,
&ResourceBase,
&ResourceLength
);
//
//call get Attributes after SetAttributes () to get current attributes.
//
RootBridgeIo->GetAttributes (
RootBridgeIo,
NULL,
&CommonAttributes
);
if ((ThisAttribute & SupportedAttributes)) {
//
//supported attributes
//
if (!EFI_ERROR(Status)) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
//
//record assertion
//
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gPciRootBridgeIoBBTestStressAssertionGuid031,
L"EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL.SetAttributes - Set Supported attribute status must be EFI_SUCCESS",
L"%a:%d:Status - %r,Set Attributes -%LXh,Supported Attributes -%LXh",
__FILE__,
(UINTN)__LINE__,
Status,
ThisAttribute,
SupportedAttributes
);
//
//the attributes should be really set.
//
if (ThisAttribute & CommonAttributes) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
//
//record assertion
//
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gPciRootBridgeIoBBTestStressAssertionGuid032,
L"EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL.SetAttributes - Set Supported attribute the attributes should be really set.",
L"%a:%d:Attributes before Set -%LXh,Set Attributes -%LXh,Attributes after Set -%LXh,Supported Attributes -%LXh",
__FILE__,
(UINTN)__LINE__,
CurrentAttributes,
ThisAttribute,
CommonAttributes,
SupportedAttributes
);
} else {
//
//unsupported attributes
//
if (Status == EFI_UNSUPPORTED) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
//
//record assertion
//
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gPciRootBridgeIoBBTestStressAssertionGuid033,
L"EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL.SetAttributes - Set UnSupported attribute status must be EFI_UNSUPPORTED",
L"%a:%d:Status - %r,Set Attributes -%LXh,Supported Attributes -%LXh",
__FILE__,
(UINTN)__LINE__,
Status,
ThisAttribute,
SupportedAttributes
);
//
//the attributes should be remain unchanged.
//
if (CurrentAttributes == CommonAttributes) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
//
//record assertion
//
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gPciRootBridgeIoBBTestStressAssertionGuid034,
L"EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL.SetAttributes - Set UnSupported attribute the attributes should remain unchanged",
L"%a:%d:Attributes before Set -%LXh,Set Attributes -%LXh,Attributes after Set -%LXh,Supported Attributes -%LXh",
__FILE__,
(UINTN)__LINE__,
CurrentAttributes,
ThisAttribute,
CommonAttributes,
SupportedAttributes
);
}
}
//
//done successfully
//
return EFI_SUCCESS;
}
//
// TDS 5.2
//
EFI_STATUS
BBTestReadBlocksFunctionAutoTest (
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_BLOCK_IO_PROTOCOL *BlockIo;
EFI_TEST_ASSERTION AssertionType;
UINT32 MediaId;
BOOLEAN RemovableMedia;
BOOLEAN MediaPresent;
BOOLEAN LogicalPartition;
BOOLEAN ReadOnly;
BOOLEAN WriteCaching;
UINT32 BlockSize;
UINT32 IoAlign;
EFI_LBA LastBlock;
UINTN BufferSize;
UINT8 *Buffer;
UINT32 BlockNumber;
UINTN IndexI, IndexJ;
UINTN NewBufferSize;
EFI_LBA NewLba;
UINTN Remainder;
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;
}
BlockIo = (EFI_BLOCK_IO_PROTOCOL *)ClientInterface;
//
// Locate & record DevicePath for further investigation
//
LocateDevicePathFromBlockIo (BlockIo, &DevicePath, StandardLib);
DevicePathStr = DevicePathToStr (DevicePath);
if (DevicePathStr != NULL) {
StandardLib->RecordMessage (
StandardLib,
EFI_VERBOSE_LEVEL_DEFAULT,
L"Current Device: %s",
DevicePathStr
);
Status = gtBS->FreePool (DevicePathStr);
if (EFI_ERROR(Status)) {
StandardLib->RecordAssertion (
StandardLib,
EFI_TEST_ASSERTION_FAILED,
gTestGenericFailureGuid,
L"BS.FreePool - Free device path string",
L"%a:%d:Status - %r",
__FILE__,
__LINE__,
Status
);
return Status;
}
DevicePathStr = NULL;
}
//
// Initialize variable
//
MediaId = BlockIo->Media->MediaId;
RemovableMedia = BlockIo->Media->RemovableMedia;
MediaPresent = BlockIo->Media->MediaPresent;
LogicalPartition = BlockIo->Media->LogicalPartition;
ReadOnly = BlockIo->Media->ReadOnly;
WriteCaching = BlockIo->Media->WriteCaching;
BlockSize = BlockIo->Media->BlockSize;
IoAlign = BlockIo->Media->IoAlign;
LastBlock = BlockIo->Media->LastBlock;
BlockNumber = (UINT32) MINIMUM(LastBlock, MAX_NUMBER_OF_READ_BLOCK_BUFFER);
BufferSize = BlockNumber * BlockSize;
if (BufferSize == 0) {
BufferSize = 512;
}
//
// allocate buffer
//
Status = gtBS->AllocatePool (EfiBootServicesData, BufferSize, &Buffer);
if (EFI_ERROR(Status)) {
StandardLib->RecordAssertion (
StandardLib,
EFI_TEST_ASSERTION_FAILED,
gTestGenericFailureGuid,
L"BS.AllocatePool - Allocate buffer for testing",
L"%a:%d:Status - %r",
__FILE__,
__LINE__,
Status
);
return Status;
}
//
// Assertion Point 5.2.2.1
// ReadBlocks must succeed to read proper data from device with valid parameter
//
if (MediaPresent == TRUE) {
for (IndexI = 1; IndexI < MAX_DIFFERENT_BUFFERSIZE_FOR_TEST; IndexI++) {
//
// prepare test data
// BufferSize will range from BlockSize to MAX_DIFFERENT_BUFFERSIZE_FOR_TEST*BlockSize
//
NewBufferSize = IndexI * BlockSize;
//
//parameter verification on NewBufferSize
//
if (NewBufferSize > BufferSize) {
break;
}
for (IndexJ = 0; IndexJ < 3 * MAX_DIFFERENT_LBA_FOR_TEST; IndexJ++) {
//
// prepare test data
//
if (IndexJ < MAX_DIFFERENT_LBA_FOR_TEST) {
// from 1 to MAX_DIFFERENT_LBA_FOR_TEST
NewLba = IndexJ;
} else if (IndexJ < 2 * MAX_DIFFERENT_LBA_FOR_TEST) {
// from (LastBlock - MAX_DIFFERENT_LBA_FOR_TEST - MAX_DIFFERENT_BUFFERSIZE_FOR_TEST) to (LastBlock - MAX_DIFFERENT_BUFFERSIZE_FOR_TEST)
NewLba = IndexJ + LastBlock - 2 * MAX_DIFFERENT_LBA_FOR_TEST - MAX_DIFFERENT_BUFFERSIZE_FOR_TEST;
} else {
// from (LastBlock/2 - MAX_DIFFERENT_LBA_FOR_TEST/2) to (LastBlock/2 + MAX_DIFFERENT_LBA_FOR_TEST/2)
NewLba = IndexJ - 2 * MAX_DIFFERENT_LBA_FOR_TEST + (DivU64x32 (LastBlock, 2, &Remainder) - MAX_DIFFERENT_LBA_FOR_TEST / 2);
}
//
//parameter verification on NewLba
//
if (NewLba + NewBufferSize / BlockSize > LastBlock + 1) {
continue;
}
//
// Call ReadBlocks with the specified LBA and BufferSize
//
Status = BlockIo->ReadBlocks (
BlockIo,
MediaId,
NewLba,
NewBufferSize,
(VOID*)Buffer
);
if (EFI_ERROR(Status)) {
AssertionType = EFI_TEST_ASSERTION_FAILED;
} else {
AssertionType = EFI_TEST_ASSERTION_PASSED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gBlockIoFunctionTestAssertionGuid003,
L"EFI_BLOCK_IO_PROTOCOL.ReadBlocks - Read Block with proper parameter from valid media",
L"%a:%d:BufferSize=%d, Lba=0x%lx, Status=%r",
__FILE__,
__LINE__,
NewBufferSize,
NewLba,
Status
);
if (EFI_ERROR(Status)) {
continue;
}
}//end of loop of Lba - IndexJ
}//end of loop of BufferSize - IndexI
}
//
// Free resources
//
Status = gtBS->FreePool (Buffer);
if (EFI_ERROR(Status)) {
StandardLib->RecordAssertion (
StandardLib,
EFI_TEST_ASSERTION_FAILED,
gTestGenericFailureGuid,
L"BS.FreePool - Free buffer for testing",
L"%a:%d:Status - %r",
__FILE__,
__LINE__,
Status
);
return Status;
}
return EFI_SUCCESS;
}
//
// TDS 4.3.1
//
EFI_STATUS
BBTestReadKeyStrokeManualTest (
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_SIMPLE_TEXT_IN_PROTOCOL *SimpleIn;
EFI_TEST_ASSERTION AssertionType;
EFI_INPUT_KEY Key;
CHAR16 KeyBuffer[MAX_KEY_BUFFER_SIZE];
EFI_DEVICE_PATH_PROTOCOL *DevicePath;
CHAR16 *DevicePathStr;
UINTN Index;
//
// 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;
}
SimpleIn = (EFI_SIMPLE_TEXT_IN_PROTOCOL *)ClientInterface;
//
// Get Device Path of current Simple_Text_In_Protocol
// And out put device path or device name
//
Status = LocateDevicePathFromSimpleTextIn (SimpleIn, &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/StdErr
//
StandardLib->RecordMessage (
StandardLib,
EFI_VERBOSE_LEVEL_DEFAULT,
L"\r\nCurrent Device: ConsoleSplitter/TxtIn"
);
}
//
// wait for times
//
Print (L"\r\nReadKeyStroke Stress Test Start!\r\n");
WaitTimeOrKey (5);
//
// Assertion Point 4.1.3.2.1
// ReadKeyStroke()
//
Status = SimpleIn->Reset (SimpleIn,TRUE);
if (EFI_ERROR(Status)) {
AssertionType = EFI_TEST_ASSERTION_FAILED;
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gTestGenericFailureGuid,
L"EFI_SIMPLE_TEXT_IN_PROTOCOL.Reset - Reset with ExtendedVeirification as TRUE",
L"%a:%d, Status = %r",
__FILE__,
__LINE__,
Status
);
}
Print (L"\r\nPlease input some displayabed characters in 5 seconds\r\n");
gtBS->Stall (5000000);
//
// Assume user has input some key, go on verification
// Read all key
//
Index=0;
do {
Status = SimpleIn->ReadKeyStroke (SimpleIn, &Key);
if (Status == EFI_SUCCESS) {
KeyBuffer[Index++] = Key.UnicodeChar;
}
} while (Status == EFI_SUCCESS && Index < MAX_KEY_BUFFER_SIZE);
//
// Echo the input keys
//
if (Status != EFI_NOT_READY) {
AssertionType = EFI_TEST_ASSERTION_FAILED;
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gSimpleTextInExtensiveTestAssertionGuid001,
L"EFI_SIMPLE_TEXT_IN_PROTOCOL.ReadKeyStroke - ReadKeyStroke() when no key input",
L"%a:%d, Status = %r, Expected = %r",
__FILE__,
__LINE__,
Status,
EFI_NOT_READY
);
}
KeyBuffer[Index] = 0;
Print (L"The keys input are:%s", KeyBuffer);
//
// Prompt for user judge
//
if (AutoJudge (5,TRUE,L"\r\nEcho correct?\r\n") == TRUE) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gSimpleTextInExtensiveTestAssertionGuid002,
L"EFI_SIMPLE_TEXT_IN_PROTOCOL.ReadKeyStroke - ReadKeyStroke() with key input, user's view",
L"%a:%d",
__FILE__,
__LINE__
);
return EFI_SUCCESS;
}
//
// TDS 5.3
//
EFI_STATUS
BBTestWriteBlocksFunctionAutoTest (
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_BLOCK_IO_PROTOCOL *BlockIo;
UINT32 MediaId;
BOOLEAN RemovableMedia;
BOOLEAN MediaPresent;
BOOLEAN LogicalPartition;
BOOLEAN ReadOnly;
BOOLEAN WriteCaching;
UINT32 BlockSize;
UINT32 IoAlign;
EFI_LBA LastBlock;
UINTN BufferSize;
UINT8 *Buffer;
UINT8 *Buffer2;
UINT8 *Buffer3;
UINT32 BlockNumber;
UINTN IndexI, IndexJ;
UINTN NewBufferSize;
EFI_LBA NewLba;
UINTN Remainder;
EFI_DEVICE_PATH_PROTOCOL *DevicePath;
CHAR16 *DevicePathStr;
EFI_TEST_ASSERTION AssertionTypeRead1;
EFI_TEST_ASSERTION AssertionTypeRead2;
EFI_TEST_ASSERTION AssertionTypeRead3;
EFI_TEST_ASSERTION AssertionTypeWrite1;
EFI_TEST_ASSERTION AssertionTypeWrite2;
EFI_TEST_ASSERTION AssertionTypeComp1;
EFI_TEST_ASSERTION AssertionTypeComp2;
EFI_STATUS StatusRead1;
EFI_STATUS StatusRead2;
EFI_STATUS StatusRead3;
EFI_STATUS StatusWrite1;
EFI_STATUS StatusWrite2;
UINTN CountComp1;
UINTN CountComp2;
//
// 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;
}
BlockIo = (EFI_BLOCK_IO_PROTOCOL *)ClientInterface;
//
// Locate & record DevicePath for further investigation
//
LocateDevicePathFromBlockIo (BlockIo, &DevicePath, StandardLib);
DevicePathStr = DevicePathToStr (DevicePath);
if (DevicePathStr != NULL) {
StandardLib->RecordMessage (
StandardLib,
EFI_VERBOSE_LEVEL_DEFAULT,
L"Current Device: %s",
DevicePathStr
);
Status = gtBS->FreePool (DevicePathStr);
if (EFI_ERROR(Status)) {
StandardLib->RecordAssertion (
StandardLib,
EFI_TEST_ASSERTION_FAILED,
gTestGenericFailureGuid,
L"BS.FreePool - Free device path string",
L"%a:%d:Status - %r",
__FILE__,
__LINE__,
Status
);
return Status;
}
DevicePathStr = NULL;
}
//
// Initialize variable
//
MediaId = BlockIo->Media->MediaId;
RemovableMedia = BlockIo->Media->RemovableMedia;
MediaPresent = BlockIo->Media->MediaPresent;
LogicalPartition = BlockIo->Media->LogicalPartition;
ReadOnly = BlockIo->Media->ReadOnly;
WriteCaching = BlockIo->Media->WriteCaching;
BlockSize = BlockIo->Media->BlockSize;
IoAlign = BlockIo->Media->IoAlign;
LastBlock = BlockIo->Media->LastBlock;
BlockNumber = (UINT32) MINIMUM(LastBlock, MAX_NUMBER_OF_READ_BLOCK_BUFFER);
BufferSize = BlockNumber * BlockSize;
if (BufferSize == 0) {
BufferSize = 512;
}
//
// allocate buffer
//
Status = gtBS->AllocatePool (EfiBootServicesData, BufferSize, &Buffer);
if (EFI_ERROR(Status)) {
StandardLib->RecordAssertion (
StandardLib,
EFI_TEST_ASSERTION_FAILED,
gTestGenericFailureGuid,
L"BS.AllocatePool - Allocate buffer for testing",
L"%a:%d:Status - %r",
__FILE__,
__LINE__,
Status
);
return Status;
}
Status = gtBS->AllocatePool (EfiBootServicesData, BufferSize, &Buffer2);
if (EFI_ERROR(Status)) {
StandardLib->RecordAssertion (
StandardLib,
EFI_TEST_ASSERTION_FAILED,
gTestGenericFailureGuid,
L"BS.AllocatePool - Allocate buffer for testing",
L"%a:%d:Status - %r",
__FILE__,
__LINE__,
Status
);
gtBS->FreePool (Buffer);
return Status;
}
Status = gtBS->AllocatePool (EfiBootServicesData, BufferSize, &Buffer3);
if (EFI_ERROR(Status)) {
StandardLib->RecordAssertion (
StandardLib,
EFI_TEST_ASSERTION_FAILED,
gTestGenericFailureGuid,
L"BS.AllocatePool - Allocate buffer for testing",
L"%a:%d:Status - %r",
__FILE__,
__LINE__,
Status
);
gtBS->FreePool (Buffer);
gtBS->FreePool (Buffer2);
return Status;
}
//
// Assertion Point 5.3.2.1
// ReadBlocks must succeed to read proper data from device with valid parameter
//
if ((MediaPresent == TRUE) && (ReadOnly == FALSE)) {
for (IndexI = 1; IndexI < MAX_DIFFERENT_BUFFERSIZE_FOR_TEST; IndexI++) {
//
// prepare test data
// BufferSize will range from BlockSize to MAX_DIFFERENT_BUFFERSIZE_FOR_TEST*BlockSize
//
NewBufferSize = IndexI * BlockSize;
//
//parameter verification on NewBufferSize
//
if (NewBufferSize > BufferSize) {
break;
}
for (IndexJ = 0; IndexJ < 3 * MAX_DIFFERENT_LBA_FOR_TEST; IndexJ++) {
//
// prepare test data
//
if (IndexJ < MAX_DIFFERENT_LBA_FOR_TEST) {
// from 1 to MAX_DIFFERENT_LBA_FOR_TEST
NewLba = IndexJ;
} else if (IndexJ < 2 * MAX_DIFFERENT_LBA_FOR_TEST) {
// from (LastBlock - MAX_DIFFERENT_LBA_FOR_TEST - MAX_DIFFERENT_BUFFERSIZE_FOR_TEST) to (LastBlock - MAX_DIFFERENT_BUFFERSIZE_FOR_TEST)
NewLba = IndexJ + LastBlock - 2 * MAX_DIFFERENT_LBA_FOR_TEST - MAX_DIFFERENT_BUFFERSIZE_FOR_TEST;
} else {
// from (LastBlock/2 - MAX_DIFFERENT_LBA_FOR_TEST/2) to (LastBlock/2 + MAX_DIFFERENT_LBA_FOR_TEST/2)
NewLba = IndexJ - 2 * MAX_DIFFERENT_LBA_FOR_TEST + (DivU64x32 (LastBlock, 2, &Remainder) - MAX_DIFFERENT_LBA_FOR_TEST / 2);
}
//
//parameter verification on NewLba
//
if (NewLba + NewBufferSize / BlockSize > LastBlock + 1) {
continue;
}
//
// To avoid the LOG information is destroied, the LOG information will
// be recorded after the original data is written again.
//
//
// Call ReadBlocks with the specified LBA and BufferSize
//
StatusRead1 = BlockIo->ReadBlocks (
BlockIo,
MediaId,
NewLba,
NewBufferSize,
(VOID*)Buffer
);
if (EFI_ERROR(StatusRead1)) {
AssertionTypeRead1 = EFI_TEST_ASSERTION_FAILED;
} else {
AssertionTypeRead1 = EFI_TEST_ASSERTION_PASSED;
}
//
// Write specified buffer2 differ from buffer to the device
//
StatusWrite1 = BlockIo->WriteBlocks (
BlockIo,
MediaId,
NewLba,
NewBufferSize,
(VOID*)Buffer2
);
if (EFI_ERROR(StatusWrite1)) {
AssertionTypeWrite1 = EFI_TEST_ASSERTION_FAILED;
} else {
AssertionTypeWrite1 = EFI_TEST_ASSERTION_PASSED;
}
//
// if write-cached, then flush the data to physical device
//
if (WriteCaching) {
BlockIo->FlushBlocks (BlockIo);
}
//
// Read Block with same LBA and BufferSize again and save data into Buffer3
//
StatusRead2 = BlockIo->ReadBlocks (
BlockIo,
MediaId,
NewLba,
NewBufferSize,
(VOID*)Buffer3
);
if (EFI_ERROR(StatusRead2)) {
AssertionTypeRead2 = EFI_TEST_ASSERTION_FAILED;
} else {
AssertionTypeRead2 = EFI_TEST_ASSERTION_PASSED;
}
//
// verification on Write and Read blocks on valid media
//
CountComp1 = VerifyBuffer (Buffer2, Buffer3, NewBufferSize);
if (CountComp1 > 0) {
AssertionTypeComp1 = EFI_TEST_ASSERTION_FAILED;
} else {
AssertionTypeComp1 = EFI_TEST_ASSERTION_PASSED;
}
//
// Write buffer read in the first call of ReadBlocks back to the device
//
StatusWrite2 = BlockIo->WriteBlocks (
BlockIo,
MediaId,
NewLba,
NewBufferSize,
(VOID*)Buffer
);
if (EFI_ERROR(StatusWrite2)) {
AssertionTypeWrite2 = EFI_TEST_ASSERTION_FAILED;
} else {
AssertionTypeWrite2 = EFI_TEST_ASSERTION_PASSED;
}
//
// if write-cached, then flush the data to physical device
//
if (WriteCaching) {
BlockIo->FlushBlocks (BlockIo);
}
//
// Read Block with same LBA and BufferSize again and save data into Buffer3
//
StatusRead3 = BlockIo->ReadBlocks (
BlockIo,
MediaId,
NewLba,
NewBufferSize,
(VOID*)Buffer3
);
if (EFI_ERROR(StatusRead3)) {
AssertionTypeRead3 = EFI_TEST_ASSERTION_FAILED;
} else {
AssertionTypeRead3 = EFI_TEST_ASSERTION_PASSED;
}
//
// verification on first and last call of ReadBlocks
//
CountComp2 = VerifyBuffer (Buffer, Buffer3, NewBufferSize);
if (CountComp2 > 0) {
AssertionTypeComp2 = EFI_TEST_ASSERTION_FAILED;
} else {
AssertionTypeComp2 = EFI_TEST_ASSERTION_PASSED;
}
//
// Record test results
//
StandardLib->RecordAssertion (
StandardLib,
AssertionTypeRead1,
gTestGenericFailureGuid,
L"EFI_BLOCK_IO_PROTOCOL.ReadBlocks - Read Block with proper parameter from valid media",
L"%a:%d:BufferSize=%d, Lba=0x%lx, Status=%r",
__FILE__,
__LINE__,
NewBufferSize,
NewLba,
StatusRead1
);
StandardLib->RecordAssertion (
StandardLib,
AssertionTypeWrite1,
gBlockIoFunctionTestAssertionGuid009,
L"EFI_BLOCK_IO_PROTOCOL.WriteBlocks - Write Block with proper parameter from valid media",
L"%a:%d:BufferSize=%d, Lba=0x%lx, Status=%r",
__FILE__,
__LINE__,
NewBufferSize,
NewLba,
StatusWrite1
);
StandardLib->RecordAssertion (
StandardLib,
AssertionTypeRead2,
gTestGenericFailureGuid,
L"EFI_BLOCK_IO_PROTOCOL.ReadBlocks - Read Block with proper parameter from valid media",
L"%a:%d:BufferSize=%d, Lba=0x%lx, Status=%r",
__FILE__,
__LINE__,
NewBufferSize,
NewLba,
StatusRead2
);
StandardLib->RecordAssertion (
StandardLib,
AssertionTypeComp1,
gBlockIoFunctionTestAssertionGuid012,
L"EFI_BLOCK_IO_PROTOCOL.WriteBlocks - Verification on Write and Read blocks on valid media",
L"%a:%d:BufferSize=%d, Lba=0x%lx, DiffCount=%d",
__FILE__,
__LINE__,
NewBufferSize,
NewLba,
CountComp1
);
StandardLib->RecordAssertion (
StandardLib,
AssertionTypeWrite2,
gBlockIoFunctionTestAssertionGuid013,
L"EFI_BLOCK_IO_PROTOCOL.WriteBlocks - Write Block with proper parameter back to valid media ",
L"%a:%d:BufferSize=%d, Lba=0x%lx, Status=%r",
__FILE__,
__LINE__,
NewBufferSize,
NewLba,
StatusWrite2
);
StandardLib->RecordAssertion (
StandardLib,
AssertionTypeRead3,
gTestGenericFailureGuid,
L"EFI_BLOCK_IO_PROTOCOL.ReadBlocks - Read Block with proper parameter from valid media",
L"%a:%d:BufferSize=%d, Lba=0x%lx, Status=%r",
__FILE__,
__LINE__,
NewBufferSize,
NewLba,
StatusRead3
);
StandardLib->RecordAssertion (
StandardLib,
AssertionTypeComp2,
gBlockIoFunctionTestAssertionGuid016,
L"EFI_BLOCK_IO_PROTOCOL.WriteBlocks - Verification on Write and Read blocks on valid media",
L"%a:%d:BufferSize=%d, Lba=0x%lx, DiffCount=%d",
__FILE__,
__LINE__,
NewBufferSize,
NewLba,
CountComp2
);
}//end of loop of Lba - IndexJ
}//end of loop of BufferSize - IndexI
}
//
// Free resources
//
Status = gtBS->FreePool (Buffer3);
if (EFI_ERROR(Status)) {
StandardLib->RecordAssertion (
StandardLib,
EFI_TEST_ASSERTION_FAILED,
gTestGenericFailureGuid,
L"BS.FreePool - Free buffer for testing",
L"%a:%d:Status - %r",
__FILE__,
__LINE__,
Status
);
return Status;
}
Status = gtBS->FreePool (Buffer2);
if (EFI_ERROR(Status)) {
StandardLib->RecordAssertion (
StandardLib,
EFI_TEST_ASSERTION_FAILED,
gTestGenericFailureGuid,
L"BS.FreePool - Free buffer for testing",
L"%a:%d:Status - %r",
__FILE__,
__LINE__,
Status
);
return Status;
}
Status = gtBS->FreePool (Buffer);
if (EFI_ERROR(Status)) {
StandardLib->RecordAssertion (
StandardLib,
EFI_TEST_ASSERTION_FAILED,
gTestGenericFailureGuid,
L"BS.FreePool - Free buffer for testing",
L"%a:%d:Status - %r",
__FILE__,
__LINE__,
Status
);
return Status;
}
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 5.5
//
EFI_STATUS
BBTestMediaIntegrityManualTest (
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_BLOCK_IO_PROTOCOL *BlockIo;
EFI_TEST_ASSERTION AssertionType;
UINT32 MediaId;
BOOLEAN RemovableMedia;
BOOLEAN MediaPresent;
BOOLEAN LogicalPartition;
BOOLEAN ReadOnly;
BOOLEAN WriteCaching;
UINT32 BlockSize;
UINT32 IoAlign;
EFI_LBA LastBlock;
UINTN BufferSize;
UINT8 *Buffer;
UINT32 BlockNumber;
UINTN Index;
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;
}
BlockIo = (EFI_BLOCK_IO_PROTOCOL *)ClientInterface;
//
// Initialize variable
//
MediaId = BlockIo->Media->MediaId;
RemovableMedia = BlockIo->Media->RemovableMedia;
MediaPresent = BlockIo->Media->MediaPresent;
LogicalPartition = BlockIo->Media->LogicalPartition;
ReadOnly = BlockIo->Media->ReadOnly;
WriteCaching = BlockIo->Media->WriteCaching;
BlockSize = BlockIo->Media->BlockSize;
IoAlign = BlockIo->Media->IoAlign;
LastBlock = BlockIo->Media->LastBlock;
BlockNumber = (UINT32) MINIMUM(LastBlock, MAX_NUMBER_OF_READ_BLOCK_BUFFER);
BufferSize = BlockNumber * BlockSize;
if (BufferSize == 0) {
BufferSize = 512;
}
//
// allocate buffer
//
Status = gtBS->AllocatePool (EfiBootServicesData, BufferSize, &Buffer);
if (EFI_ERROR(Status)) {
StandardLib->RecordAssertion (
StandardLib,
EFI_TEST_ASSERTION_FAILED,
gTestGenericFailureGuid,
L"BS.AllocatePool - Allocate buffer for testing",
L"%a:%d:Status - %r",
__FILE__,
__LINE__,
Status
);
return Status;
}
//
// Locate the Handle that the BlockIo interface is bound to
//
LocateDevicePathFromBlockIo (BlockIo, &DevicePath, StandardLib);
DevicePathStr = DevicePathToStr (DevicePath);
if (DevicePathStr != NULL) {
StandardLib->RecordMessage (
StandardLib,
EFI_VERBOSE_LEVEL_DEFAULT,
L"Current Device: %s",
DevicePathStr
);
Status = gtBS->FreePool (DevicePathStr);
if (EFI_ERROR(Status)) {
StandardLib->RecordAssertion (
StandardLib,
EFI_TEST_ASSERTION_FAILED,
gTestGenericFailureGuid,
L"BS.FreePool - Free device path string",
L"%a:%d:Status - %r",
__FILE__,
__LINE__,
Status
);
goto FreeBuffer;
}
DevicePathStr = NULL;
}
//
// Assertion Point 5.5.2.1
// Media remove of insert of device must affect the MediaPresent field
//
if (RemovableMedia == TRUE) {
//
// Insert -> Remove -> Insert or Remove -> Insert -> Remove
//
for (Index = 0; Index < 2; Index++) {
if (MediaPresent == TRUE) {
Print (L"Remove media in device ");
} else {
Print (L"Insert media into device ");
}
DevicePathStr = DevicePathToStr (DevicePath);
if (DevicePathStr != NULL) {
Print (DevicePathStr);
Status = gtBS->FreePool (DevicePathStr);
if (EFI_ERROR(Status)) {
StandardLib->RecordAssertion (
StandardLib,
EFI_TEST_ASSERTION_FAILED,
gTestGenericFailureGuid,
L"BS.FreePool - Free device path string",
L"%a:%d:Status - %r",
__FILE__,
__LINE__,
Status
);
goto FreeBuffer;
}
DevicePathStr = NULL;
}
if (AutoJudge (50, FALSE, L"\r\nReady?\r\n") != TRUE) {
goto AssertionPoint2;
}
//
// Call ReadBlocks to force re-install device
//
Status = BlockIo->ReadBlocks (
BlockIo,
MediaId,
0,
BlockSize,
(VOID*)Buffer
);
if (EFI_ERROR(Status)) {
//
// No Status check here.
//
}
//
// Begin to re-locate the BlockIo interface according to the DevicePath
//
LocateBlockIoFromDevicePath (&BlockIo, DevicePath, StandardLib);
if (MediaPresent == BlockIo->Media->MediaPresent) {
AssertionType = EFI_TEST_ASSERTION_FAILED;
} else {
AssertionType = EFI_TEST_ASSERTION_PASSED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gBlockIoFunctionTestAssertionGuid017,
L"EFI_BLOCK_IO_PROTOCOL.Media->MediaPresent,Media remove or insert of device must affect the MediaPresent field",
L"%a:%d:Previous MediaPresent=%d, After MediaPresent=%d",
__FILE__,
__LINE__,
MediaPresent,
BlockIo->Media->MediaPresent
);
//
// Restore the envionment
//
MediaPresent = BlockIo->Media->MediaPresent;
}
//
// Initialize variable
//
MediaId = BlockIo->Media->MediaId;
RemovableMedia = BlockIo->Media->RemovableMedia;
MediaPresent = BlockIo->Media->MediaPresent;
LogicalPartition = BlockIo->Media->LogicalPartition;
ReadOnly = BlockIo->Media->ReadOnly;
WriteCaching = BlockIo->Media->WriteCaching;
BlockSize = BlockIo->Media->BlockSize;
IoAlign = BlockIo->Media->IoAlign;
LastBlock = BlockIo->Media->LastBlock;
}
//
// Assertion Point 5.5.2.2
// Media change of device must affect the MediaId field and
// may affect the BlockSize and ReadOnly and Logical Partition field.
//
AssertionPoint2:
if (RemovableMedia == TRUE) {
if (MediaPresent == TRUE) {
Print (L"Change media in device ");
} else {
Print (L"Insert media into device ");
}
DevicePathStr = DevicePathToStr (DevicePath);
if (DevicePathStr != NULL) {
Print (DevicePathStr);
Status = gtBS->FreePool (DevicePathStr);
if (EFI_ERROR(Status)) {
StandardLib->RecordAssertion (
StandardLib,
EFI_TEST_ASSERTION_FAILED,
gTestGenericFailureGuid,
L"BS.FreePool - Free device path string",
L"%a:%d:Status - %r",
__FILE__,
__LINE__,
Status
);
goto FreeBuffer;
}
DevicePathStr = NULL;
}
if (AutoJudge (50, FALSE, L"\r\nReady?\r\n") != TRUE) {
goto FreeBuffer;
}
//
// Call ReadBlocks to force re-install device
//
Status = BlockIo->ReadBlocks (
BlockIo,
MediaId,
0,
BlockSize,
(VOID*)Buffer
);
if (EFI_ERROR(Status)) {
//
// No Status check here.
//
}
//
// Begin to re-locate the BlockIo interface according to the DevicePath
//
LocateBlockIoFromDevicePath (&BlockIo, DevicePath, StandardLib);
//
// MediaID verificatoin
//
if (MediaId == BlockIo->Media->MediaId) {
AssertionType = EFI_TEST_ASSERTION_FAILED;
} else {
AssertionType = EFI_TEST_ASSERTION_PASSED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gBlockIoFunctionTestAssertionGuid019,
L"EFI_BLOCK_IO_PROTOCOL.Media->MediaId,Media remove or insert of device must affect the MediaId field",
L"%a:%d:Previous MediaId=%d, After MediaId=%d",
__FILE__,
__LINE__,
MediaId,
BlockIo->Media->MediaId
);
//
// User's view about the current attribute of the media
//
MediaId = BlockIo->Media->MediaId;
RemovableMedia = BlockIo->Media->RemovableMedia;
MediaPresent = BlockIo->Media->MediaPresent;
LogicalPartition = BlockIo->Media->LogicalPartition;
ReadOnly = BlockIo->Media->ReadOnly;
WriteCaching = BlockIo->Media->WriteCaching;
BlockSize = BlockIo->Media->BlockSize;
IoAlign = BlockIo->Media->IoAlign;
LastBlock = BlockIo->Media->LastBlock;
StandardLib->RecordMessage (
StandardLib,
EFI_VERBOSE_LEVEL_DEFAULT,
L"Current Media data field:\n"
L"MediaId =%d\n"
L"RemovableMedia =%d\n"
L"MediaPresent =%d\n"
L"LogicalPartition=%d\n"
L"ReadOnly =%d\n"
L"WriteCaching =%d\n"
L"BlockSize =%d\n"
L"IoAlign =%d\n"
L"LastBlock =%lx\n",
MediaId,
RemovableMedia,
MediaPresent,
LogicalPartition,
ReadOnly,
WriteCaching,
BlockSize,
IoAlign,
LastBlock
);
//
// Output current media data structure
//
if (AutoJudge (99, TRUE, L"\r\nCorrect?\r\n") != TRUE) {
AssertionType = EFI_TEST_ASSERTION_FAILED;
} else {
AssertionType = EFI_TEST_ASSERTION_PASSED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gBlockIoFunctionTestAssertionGuid020,
L"EFI_BLOCK_IO_PROTOCOL.Media,Media remove or insert of device must affect the MediaId field",
L"%a:%d:As user's select",
__FILE__,
__LINE__
);
//
// Restore environment
//
if (MediaPresent == TRUE) {
Print (L"Change media back in device ");
} else {
Print (L"Remove media from device ");
}
DevicePathStr = DevicePathToStr (DevicePath);
if (DevicePathStr != NULL) {
Print (DevicePathStr);
Status = gtBS->FreePool (DevicePathStr);
if (EFI_ERROR(Status)) {
StandardLib->RecordAssertion (
StandardLib,
EFI_TEST_ASSERTION_FAILED,
gTestGenericFailureGuid,
L"BS.FreePool - Free device path string",
L"%a:%d:Status - %r",
__FILE__,
__LINE__,
Status
);
goto FreeBuffer;
}
DevicePathStr = NULL;
}
if (AutoJudge (50, FALSE, L"\r\nReady?\r\n") != TRUE) {
goto FreeBuffer;
}
//
// Call ReadBlocks to force re-install device
//
Status = BlockIo->ReadBlocks (
BlockIo,
MediaId,
0,
BlockSize,
(VOID*)Buffer
);
if (EFI_ERROR(Status)) {
//
// No Status check here.
//
}
}
FreeBuffer:
//
// Free resources
//
Status = gtBS->FreePool (Buffer);
if (EFI_ERROR(Status)) {
StandardLib->RecordAssertion (
StandardLib,
EFI_TEST_ASSERTION_FAILED,
gTestGenericFailureGuid,
L"BS.FreePool - Free buffer for testing",
L"%a:%d:Status - %r",
__FILE__,
__LINE__,
Status
);
return Status;
}
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.2.2
//
EFI_STATUS
BBTestWaitForKeyConformanceManualTest (
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_SIMPLE_TEXT_IN_PROTOCOL *SimpleIn;
EFI_TEST_ASSERTION AssertionType;
EFI_INPUT_KEY Key;
EFI_DEVICE_PATH_PROTOCOL *DevicePath;
CHAR16 *DevicePathStr;
UINTN WaitIndex;
//
// 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;
}
SimpleIn = (EFI_SIMPLE_TEXT_IN_PROTOCOL *)ClientInterface;
//
// Get Device Path of current Simple_Text_In_Protocol
// And out put device path or device name
//
Status = LocateDevicePathFromSimpleTextIn (SimpleIn, &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/StdErr
//
StandardLib->RecordMessage (
StandardLib,
EFI_VERBOSE_LEVEL_DEFAULT,
L"\r\nCurrent Device: ConsoleSplitter/TxtIn"
);
}
//
// wait for times
//
Print (L"\r\nWaitForKey Conformance Test Start!\r\n");
WaitTimeOrKey (5);
//
// Assertion Point 4.2.2.2.1
// ReadKeyStroke()
//
//
// Call Reset with ExtendedVerification as TRUE
//
Status = SimpleIn->Reset (SimpleIn, TRUE);
if (EFI_ERROR(Status)) {
AssertionType = EFI_TEST_ASSERTION_FAILED;
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gTestGenericFailureGuid,
L"EFI_SIMPLE_TEXT_IN_PROTOCOL.Reset - Reset with ExtendedVeirification as TRUE",
L"%a:%d, Status = %r",
__FILE__,
__LINE__,
Status
);
}
//
// Call CheckEvent() on the WaitForKey event
//
Status = gtBS->CheckEvent (SimpleIn->WaitForKey);
if (Status!=EFI_NOT_READY) {
AssertionType = EFI_TEST_ASSERTION_FAILED;
} else {
AssertionType = EFI_TEST_ASSERTION_PASSED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gSimpleTextInConformanceTestAssertionGuid007,
L"EFI_SIMPLE_TEXT_IN_PROTOCOL.WaitForKey - Event check before key input",
L"%a:%d, Status = %r, Expected = %r",
__FILE__,
__LINE__,
Status,
EFI_NOT_READY
);
//
// Prompt tester to input some character
//
Print (L"Press ONE displayable key! and NO More!");
//
// WaitForKey event
//
Status = gtBS->WaitForEvent (1, &(SimpleIn->WaitForKey), &WaitIndex);
if (EFI_ERROR(Status)) {
AssertionType = EFI_TEST_ASSERTION_FAILED;
} else {
AssertionType = EFI_TEST_ASSERTION_PASSED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gSimpleTextInConformanceTestAssertionGuid008,
L"EFI_SIMPLE_TEXT_IN_PROTOCOL.WaitForKey - Wait for event with key input",
L"%a:%d, Status = %r, Expected = %r",
__FILE__,
__LINE__,
Status,
EFI_SUCCESS
);
Print (L"\r\nThe key(s) input:");
//
// Call ReadKeyStroke repeatedly to receive the character.
//
while (TRUE) {
//
// Call ReadKeyStroke to retrieve the key
//
Status = SimpleIn->ReadKeyStroke (SimpleIn, &Key);
if (EFI_ERROR(Status)) {
break;
}
//
// Output what user input
//
if (Key.ScanCode==0) {
//
// Unicode character
//
APrint ((char*)(&Key.UnicodeChar));
} else {
//
// Scan code character
//
Print (ScanCodeDesc (Key.ScanCode));
}
}
//
// Wait 2 second for user to check the key echoed.
//
gtBS->Stall (2000000);
//
// Call CheckEvent() on the WaitForKey event
//
Status = gtBS->CheckEvent (SimpleIn->WaitForKey);
if (Status!=EFI_NOT_READY) {
AssertionType = EFI_TEST_ASSERTION_FAILED;
} else {
AssertionType = EFI_TEST_ASSERTION_PASSED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gSimpleTextInConformanceTestAssertionGuid010,
L"EFI_SIMPLE_TEXT_IN_PROTOCOL.WaitForKey - Event check after key read stroken",
L"%a:%d, Status = %r, Expected = %r",
__FILE__,
__LINE__,
Status,
EFI_NOT_READY
);
return EFI_SUCCESS;
}
