//
// 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.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 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
//
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 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;
}
