//
// 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 3.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_DEBUGPORT_PROTOCOL *DebugPort;
EFI_TEST_ASSERTION AssertionType;
//
// 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;
}
DebugPort = (EFI_DEBUGPORT_PROTOCOL *)ClientInterface;
//
// Assertion Point 3.1.2.1
// Invoke Reset and verify interface correctness within test case.
//
Status = DebugPort->Reset (DebugPort);
if (EFI_ERROR(Status)) {
AssertionType = EFI_TEST_ASSERTION_FAILED;
} else {
AssertionType = EFI_TEST_ASSERTION_PASSED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gDebugPortBBTestFunctionAssertionGuid001,
L"EFI_DEBUGPORT_PROTOCOL.Reset - Invoke Reset and verify interface correctness within test case",
L"%a:%d:Status - %r",
__FILE__,
(UINTN)__LINE__,
Status
);
return EFI_SUCCESS;
}
//
// TDS 4.1
//
EFI_STATUS
BBTestGetNextDeviceConformanceAutoTest (
IN EFI_BB_TEST_PROTOCOL *This,
IN VOID *ClientInterface,
IN EFI_TEST_LEVEL TestLevel,
IN EFI_HANDLE SupportHandle
)
{
EFI_STANDARD_TEST_LIBRARY_PROTOCOL *StandardLib;
EFI_STATUS Status;
EFI_SCSI_PASS_THRU_PROTOCOL *ScsiPassThru;
EFI_TEST_ASSERTION AssertionType;
UINT32 Target;
UINT64 Lun;
UINT32 NewTarget;
UINT64 NewLun;
//
// 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;
}
ScsiPassThru = (EFI_SCSI_PASS_THRU_PROTOCOL *)ClientInterface;
//
// Assertion Point 4.1.2.1
// Call GetNextDevice() with invalid parameter.
//
NewTarget = 0xFFFFFFFF;
//
// Get First Device Target and Lun.
//
Status = ScsiPassThru->GetNextDevice (ScsiPassThru, &NewTarget, &NewLun);
if (EFI_ERROR(Status)) {
StandardLib->RecordAssertion (
StandardLib,
EFI_TEST_ASSERTION_FAILED,
gTestGenericFailureGuid,
L"EFI_SCSI_PASS_THRU_PROTOCOL.GetNextDevice",
L"%a:%d:Status - %r",
__FILE__,
__LINE__,
Status
);
return EFI_UNSUPPORTED;
}
//
// Check point 1, call GetNextDevice with invalid Target.
//
Target = 0xEEEEEEEE;
Lun = NewLun;
Status = ScsiPassThru->GetNextDevice (ScsiPassThru, &Target, &Lun);
if (Status == EFI_INVALID_PARAMETER) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gScsiPassThruBBTestConformanceAssertionGuid002,
L"EFI_SCSI_PASS_THRU_PROTOCOL.GetNextDevice - call GetNextDevice with invalid Target.",
L"%a:%d:Status - %r, Target - %d, Lun - %ld",
__FILE__,
__LINE__,
Status,
Target,
Lun
);
//
// Check point 2, call GetNextDevice with invalid Lun.
//
Target = NewTarget;
Lun = 0xEEEEEEEE;
Status = ScsiPassThru->GetNextDevice (ScsiPassThru, &Target, &Lun);
if (Status == EFI_INVALID_PARAMETER) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gScsiPassThruBBTestConformanceAssertionGuid003,
L"EFI_SCSI_PASS_THRU_PROTOCOL.GetNextDevice - call GetNextDevice with invalid Lun.",
L"%a:%d:Status - %r, Target - %d, Lun - %ld",
__FILE__,
__LINE__,
Status,
Target,
Lun
);
//
// Check point 3, Call GetNextDevice() with Target=0xFFFFFFFF to get the
// first device. Then call it again to get the next device.
// Use the Target and Lun return from the first call to call
// the function.
//
Target = NewTarget;
Lun = NewLun;
//
// Get the second Device Target and Lun.
//
Status = ScsiPassThru->GetNextDevice (ScsiPassThru, &NewTarget, &NewLun);
if (EFI_ERROR(Status)) {
StandardLib->RecordAssertion (
StandardLib,
EFI_TEST_ASSERTION_FAILED,
gTestGenericFailureGuid,
L"EFI_SCSI_PASS_THRU_PROTOCOL.GetNextDevice",
L"%a:%d:Status - %r",
__FILE__,
__LINE__,
Status
);
return EFI_UNSUPPORTED;
}
return EFI_SUCCESS;
}
//
// TDS 4.1.6
//
EFI_STATUS
BBTestStrToFatFunctionAutoTest (
IN EFI_BB_TEST_PROTOCOL *This,
IN VOID *ClientInterface,
IN EFI_TEST_LEVEL TestLevel,
IN EFI_HANDLE SupportHandle
)
{
EFI_STANDARD_TEST_LIBRARY_PROTOCOL *StandardLib;
EFI_STATUS Status;
EFI_UNICODE_COLLATION2_PROTOCOL *UnicodeCollation;
UINTN Index;
UINTN SubIndex;
UINTN FatSize;
EFI_TEST_ASSERTION AssertionType;
//
// Test Data
//
CHAR16 *TestData[] ={
L"longfilename.c",
L"\x40\x50[]-\x20\x30",
L"\x40\x50.\x20\x30",
L"\x40\x50 \x20\x30",
L"\x40\x50\x1234\x20\x30",
L"\x40\x50\x1234\x20\x30",
L"filename.c",
L"longfilename.c"
};
CHAR8 Result[MAX_SIZE_OF_STRING + 1];
CHAR16 UnicodeBuf[MAX_SIZE_OF_STRING + 1];
BOOLEAN IsLongFileName;
//
// 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;
}
UnicodeCollation = (EFI_UNICODE_COLLATION2_PROTOCOL *)ClientInterface;
for (Index = 0; Index < sizeof (TestData) / sizeof (CHAR16*); Index++) {
//
// For each test data, test the StrToFat functionality.
//
for (SubIndex = 0; SubIndex < MAX_SIZE_OF_STRING; SubIndex++) {
Result[SubIndex] = 'x';
}
Result[MAX_SIZE_OF_STRING] = 0;
//
// FatSize is equal to the length of TestData[Index]
//
FatSize = GetStrLen16 (TestData[Index]);
IsLongFileName = UnicodeCollation->StrToFat (
UnicodeCollation,
TestData[Index],
FatSize,
Result
);
if (CheckStrToFat (TestData[Index], FatSize, Result, IsLongFileName) == TRUE &&
IsLongFileName == CheckLongFileName (TestData[Index], FatSize)) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
//
// Change Char8 to Char16 for record log
//
UnicodeCollation->FatToStr (
UnicodeCollation,
FatSize,
Result,
UnicodeBuf
);
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gUnicodeCollationFunctionTestAssertionGuid010,
L"EFI_UNICODE_COLLATION_PROTOCOL.StrToFat - Verification of StrToFat interface",
L"%a:%d: Str='%s', StrSize=%d, Parameter FatSize=%d, Fat='%s', Return Fat Length= %d, LongFileNmae=%d, Expected=%d",
__FILE__,
(UINTN)__LINE__,
TestData[Index],
GetStrLen16 (TestData[Index]),
FatSize,
UnicodeBuf,
GetStrLen8 (Result),
IsLongFileName,
CheckLongFileName (TestData[Index], FatSize)
);
//
// FatSize is larger than the length of TestData[Index]
//
FatSize = GetStrLen16 (TestData[Index]) + 2;
IsLongFileName = UnicodeCollation->StrToFat (
UnicodeCollation,
TestData[Index],
FatSize,
Result
);
if (CheckStrToFat (TestData[Index], FatSize, Result, IsLongFileName) == TRUE &&
IsLongFileName == CheckLongFileName (TestData[Index], FatSize)) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
//
// Change Char8 to Char16 for record log
//
UnicodeCollation->FatToStr (
UnicodeCollation,
FatSize,
Result,
UnicodeBuf
);
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gUnicodeCollationFunctionTestAssertionGuid011,
L"EFI_UNICODE_COLLATION_PROTOCOL.StrToFat - Verification of StrToFat interface",
L"%a:%d: Str='%s', StrSize=%d, Parameter FatSize=%d, Fat='%s', Return Fat Length= %d, LongFileNmae=%d, Expected=%d",
__FILE__,
(UINTN)__LINE__,
TestData[Index],
GetStrLen16 (TestData[Index]),
FatSize,
UnicodeBuf,
GetStrLen8 (Result),
IsLongFileName,
CheckLongFileName (TestData[Index], FatSize)
);
//
// FatSize is smaller than the length of TestData[Index]
//
FatSize = GetStrLen16 (TestData[Index]) - 2;
IsLongFileName = UnicodeCollation->StrToFat (
UnicodeCollation,
TestData[Index],
FatSize,
Result
);
if (CheckStrToFat (TestData[Index], FatSize, Result, IsLongFileName) == TRUE &&
IsLongFileName == CheckLongFileName (TestData[Index], FatSize)) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
//
// Change Char8 to Char16 for record log
//
UnicodeCollation->FatToStr (
UnicodeCollation,
FatSize,
Result,
UnicodeBuf
);
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gUnicodeCollationFunctionTestAssertionGuid012,
L"EFI_UNICODE_COLLATION_PROTOCOL.StrToFat - Verification of StrToFat interface",
L"%a:%d: Str='%s', StrSize=%d, Parameter FatSize=%d, Fat='%s', Return Fat Length= %d, ConversionFail=%d, Expected=%d",
__FILE__,
(UINTN)__LINE__,
TestData[Index],
GetStrLen16 (TestData[Index]),
FatSize,
UnicodeBuf,
GetStrLen8 (Result),
IsLongFileName,
CheckLongFileName (TestData[Index], FatSize)
);
};
return EFI_SUCCESS;
}
//
// TDS 3.3
//
EFI_STATUS
BBTestReadFunctionManualTest (
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_DEBUGPORT_PROTOCOL *DebugPort;
EFI_TEST_ASSERTION AssertionType;
UINTN BufferSize;
CHAR8 Buffer[20];
UINTN WaitIndex;
EFI_INPUT_KEY Key;
//
// 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;
}
DebugPort = (EFI_DEBUGPORT_PROTOCOL *)ClientInterface;
//
// Assertion Point 3.3.2.1
// Call Read() to send data to debug port with enough time.
//
BufferSize = 1;
EfiCommonLibZeroMem ((VOID*)Buffer, sizeof(Buffer));
//
// Wait for the input data.
//
Print (L"Please any key after input data.");
gtBS->WaitForEvent (1, &(gtST->ConIn->WaitForKey), &WaitIndex);
gtST->ConIn->ReadKeyStroke (gtST->ConIn, &Key);
Status = DebugPort->Read (DebugPort, 1000, &BufferSize, (VOID*)Buffer);
if (EFI_ERROR(Status)) {
AssertionType = EFI_TEST_ASSERTION_FAILED;
} else {
AssertionType = EFI_TEST_ASSERTION_PASSED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gDebugPortBBTestFunctionAssertionGuid006,
L"EFI_DEBUGPORT_PROTOCOL.Read - Invoke Read and verify interface correctness with enough time",
L"%a:%d:Status - %r",
__FILE__,
(UINTN)__LINE__,
Status
);
//
// Verify the functionality manually.
//
Print (L"Please verify the input string is %s, right press \"Y\", wrong press \"N\"", Buffer);
//
// Get the input key.
//
while(1)
{
gtBS->WaitForEvent (1, &(gtST->ConIn->WaitForKey), &WaitIndex);
gtST->ConIn->ReadKeyStroke (gtST->ConIn, &Key);
if((Key.UnicodeChar == L'Y') || (Key.UnicodeChar == L'y') || (Key.UnicodeChar == L'N') || (Key.UnicodeChar == L'n')) {
break;
}
else {
Print (L"Please press \"Y\" or \"N\"");
}
}
if ((Key.UnicodeChar == L'N') || (Key.UnicodeChar == L'n')) {
AssertionType = EFI_TEST_ASSERTION_FAILED;
} else {
AssertionType = EFI_TEST_ASSERTION_PASSED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gDebugPortBBTestFunctionAssertionGuid007,
L"EFI_DEBUGPORT_PROTOCOL.Read - Invoke Read and verify its functionality correctness with enough time",
L"%a:%d:Status - %r",
__FILE__,
(UINTN)__LINE__,
Status
);
return EFI_SUCCESS;
}
//
// TDS 4.1.2
//
EFI_STATUS
BBTestMetaiMatchFunctionAutoTest (
IN EFI_BB_TEST_PROTOCOL *This,
IN VOID *ClientInterface,
IN EFI_TEST_LEVEL TestLevel,
IN EFI_HANDLE SupportHandle
)
{
EFI_STANDARD_TEST_LIBRARY_PROTOCOL *StandardLib;
EFI_STATUS Status;
EFI_UNICODE_COLLATION2_PROTOCOL *UnicodeCollation;
UINTN Index;
BOOLEAN Result;
EFI_TEST_ASSERTION AssertionType;
//
// Test Data
//
METAIMATCH_TEST_DATA_FIELD TestData[] ={
{L"", L"\x30\x50zz\x40\x20", FALSE},
{L"\x30\x50*\x40\x20", L"", FALSE},
{L"", L"", TRUE},
{L"\x30\x50*\x40\x20", L"\x30\x50zz\x40\x20", TRUE},
{L"\x30\x50*\x40\x20", L"\x30\x50\x30\x20", FALSE},
{L"\x30\x50?\x40\x20", L"\x30\x50H\x40\x20", TRUE},
{L"\x30\x50?\x40\x20", L"\x30\x50\x40\x20", FALSE},
{L"\x30\x50[abcdzyxw!)(@#*]\x40\x20", L"\x30\x50Z\x40\x20", TRUE},
{L"\x30\x50[abcdZyxw!)(@#*]\x40\x20", L"\x30\x50Z\x40\x20", TRUE},
{L"\x30\x50[abcdZyxw!)(@#*]\x40\x20", L"\x30\x50z\x40\x20", TRUE},
{L"\x30\x50[abcdzyxw!)(@#*]\x40\x20", L"\x30\x50z\x40\x20", TRUE},
{L"\x30\x50[abcdzyxw!)(@#*]\x40\x20", L"\x30\x50W\x40\x20", TRUE},
{L"\x30\x50[abcdzyxw!)(@#*]\x40\x20", L"\x30\x50w\x40\x20", TRUE},
{L"\x30\x50[abcdzyxw!)(@#*]\x40\x20", L"\x30\x50@\x40\x20", TRUE},
{L"\x30\x50[abcdzyxw!)(@#*]\x40\x20", L"\x30\x50*\x40\x20", TRUE},
{L"\x30\x50[abcdzyxw!)(@#*?]\x40\x20", L"\x30\x50?\x40\x20", TRUE},
{L"\x30\x50[abcdzyxw!)(@#*]\x40\x20", L"\x30\x50g\x40\x20", FALSE},
{L"\x30\x50[abcdzyxw!)(@#*]\x40\x20", L"\x30\x50q\x40\x20", FALSE},
{L"\x30\x50[abcdzyxw!)(@#*]\x40\x20", L"\x30\x50W\x40\x20", TRUE},
//
// Index = 19
//
{L"[a-z]", L"b", TRUE},
{L"[a-z]", L"B", TRUE},
{L"[bcd]", L"B", TRUE},
{L"\x30\x50[R-Z]\x40\x20", L"\x30\x50r\x40\x20", TRUE},
{L"\x30\x50[R-Z]\x40\x20", L"\x30\x50R\x40\x20", TRUE},
{L"\x30\x50[R-Z]\x40\x20", L"\x30\x50Z\x40\x20", TRUE},
{L"\x30\x50[R-Z]\x40\x20", L"\x30\x50z\x40\x20", TRUE},
{L"\x30\x50[R-Z]\x40\x20", L"\x30\x50Y\x40\x20", TRUE},
{L"\x30\x50[R-Z]\x40\x20", L"\x30\x50s\x40\x20", TRUE},
{L"\x30\x50[R-Z]\x40\x20", L"\x30\x50k\x40\x20", FALSE},
{L"\x30\x50[R-Z]\x40\x20", L"\x30\x50K\x40\x20", FALSE},
//
// Index = 30
//
{L"\x30\x50[\x20-\x25]\x40\x20", L"\x30\x50\x20\x40\x20", TRUE},
{L"\x30\x50[\x20-\x25]\x40\x20", L"\x30\x50\x25\x40\x20", TRUE},
{L"\x30\x50[\x20-\x25]\x40\x20", L"\x30\x50\x22\x40\x20", TRUE},
{L"\x30\x50[\x20-\x25]\x40\x20", L"\x30\x50\x10\x40\x20", FALSE},
};
//
// 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;
}
UnicodeCollation = (EFI_UNICODE_COLLATION2_PROTOCOL *)ClientInterface;
for (Index = 0; Index < sizeof (TestData) / sizeof (METAIMATCH_TEST_DATA_FIELD); Index ++) {
//
// For each test data, test the MetaiMatch functionality.
//
Result = UnicodeCollation->MetaiMatch (
UnicodeCollation,
TestData[Index].String,
TestData[Index].Pattern
);
if (Result == TestData[Index].Result) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gUnicodeCollationFunctionTestAssertionGuid002,
L"EFI_UNICODE_COLLATION_PROTOCOL.MetaiMatch - Verification of MetaiMatch interface",
L"%a:%d: Index = %d, String='%s', Pattern='%s', Result=%d, Expected Result=%d",
__FILE__,
(UINTN)__LINE__,
Index,
TestData[Index].String,
TestData[Index].Pattern,
Result,
TestData[Index].Result
);
};
return EFI_SUCCESS;
}
//
// TDS 4.1.5
//
EFI_STATUS
BBTestFatToStrFunctionAutoTest (
IN EFI_BB_TEST_PROTOCOL *This,
IN VOID *ClientInterface,
IN EFI_TEST_LEVEL TestLevel,
IN EFI_HANDLE SupportHandle
)
{
EFI_STANDARD_TEST_LIBRARY_PROTOCOL *StandardLib;
EFI_STATUS Status;
EFI_UNICODE_COLLATION2_PROTOCOL *UnicodeCollation;
UINTN Index;
UINTN FatSize;
EFI_TEST_ASSERTION AssertionType;
//
// Test Data
//
CHAR8 *TestData[] ={
"filename.c",
"longfilename.c",
"\x10\x11\x20\x22\x50\x51\x61\x62",
};
CHAR16 Result[MAX_SIZE_OF_STRING + 1];
//
// 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;
}
UnicodeCollation = (EFI_UNICODE_COLLATION2_PROTOCOL *)ClientInterface;
for (Index = 0; Index < sizeof (TestData) / sizeof (CHAR8*); Index++) {
//
// For each test data, test the FatToStr functionality.
//
//
// FatSize reflect length of TestData[Index] correctly
//
FatSize = GetStrLen8 (TestData[Index]);
UnicodeCollation->FatToStr (
UnicodeCollation,
FatSize,
TestData[Index],
Result
);
if (CheckFatToStr (TestData[Index], FatSize, Result) == TRUE) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gUnicodeCollationFunctionTestAssertionGuid007,
L"EFI_UNICODE_COLLATION_PROTOCOL.FatToStr - Verification of FatToStr interface",
L"%a:%d: Fat='%s', FatToStr='%s', FatSize=%d, StrSize=%d",
__FILE__,
(UINTN)__LINE__,
TestData[Index],
Result,
FatSize,
GetStrLen16 (Result)
);
//
// FatSize is larger then length of TestData[Index]
//
FatSize = GetStrLen8 (TestData[Index]) + 2;
if (FatSize >= 0 || FatSize <= MAX_SIZE_OF_STRING) {
UnicodeCollation->FatToStr (
UnicodeCollation,
FatSize,
TestData[Index],
Result
);
if (CheckFatToStr (TestData[Index], FatSize, Result) == TRUE) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gUnicodeCollationFunctionTestAssertionGuid008,
L"EFI_UNICODE_COLLATION_PROTOCOL.FatToStr - Verification of FatToStr interface",
L"%a:%d: Fat='%s', FatToStr='%s', FatSize=%d, StrSize=%d",
__FILE__,
(UINTN)__LINE__,
TestData[Index],
Result,
FatSize,
GetStrLen16 (Result)
);
}
//
// FatSize is less then length of TestData[Index]
//
FatSize = GetStrLen8 (TestData[Index]) - 2;
if (FatSize >= 0 || FatSize <= MAX_SIZE_OF_STRING) {
UnicodeCollation->FatToStr (
UnicodeCollation,
FatSize,
TestData[Index],
Result
);
if (CheckFatToStr (TestData[Index], FatSize, Result) == TRUE) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gUnicodeCollationFunctionTestAssertionGuid009,
L"EFI_UNICODE_COLLATION_PROTOCOL.FatToStr - Verification of FatToStr interface",
L"%a:%d: Fat='%s', FatToStr='%s', FatSize=%d, StrSize=%d",
__FILE__,
(UINTN)__LINE__,
TestData[Index],
Result,
FatSize,
GetStrLen16 (Result)
);
}
};
return EFI_SUCCESS;
}
//
// TDS 4.1
//
EFI_STATUS
BBTestCreateThunkConformanceTest (
IN EFI_BB_TEST_PROTOCOL *This,
IN VOID *ClientInterface,
IN EFI_TEST_LEVEL TestLevel,
IN EFI_HANDLE SupportHandle
)
{
EFI_STANDARD_TEST_LIBRARY_PROTOCOL *StandardLib;
EFI_STATUS Status;
EFI_TEST_ASSERTION AssertionType;
EFI_EBC_PROTOCOL *EbcInterface;
VOID *EbcEntryPoint;
EFI_IMAGE_ENTRY_POINT ThunkEntryPoint;
//
// Verify whether it is one of IHV interfaces
//
if (! IsIhvInterface (ClientInterface, SupportHandle)) {
return EFI_UNSUPPORTED;
}
//
// Get the Standard Library Interface
//
Status = gtBS->HandleProtocol (
SupportHandle,
&gEfiStandardTestLibraryGuid,
&StandardLib
);
if (EFI_ERROR(Status)) {
return Status;
}
//
// Get the EFI_EBC_PROTOCOL Protocol interface to be tested
//
EbcInterface = (EFI_EBC_PROTOCOL *)ClientInterface;
//
// Register a callback for flushing the instruction cache so that created
// thunks can be flushed.
//
Status = EbcInterface->RegisterICacheFlush (EbcInterface, FlushICache);
if (EFI_ERROR(Status)) {
StandardLib->RecordAssertion (
StandardLib,
EFI_TEST_ASSERTION_FAILED,
gTestGenericFailureGuid,
L"EFI_EBC_PROTOCOL.RegisterICacheFlush - Can't register callback function",
L"%a:%d:Status - %r",
__FILE__,
__LINE__,
Status
);
return Status;
}
//
// Load Ebc Driver
//
Status = LoadEbcDriver (&EbcEntryPoint);
if (EFI_ERROR(Status)) {
StandardLib->RecordAssertion (
StandardLib,
EFI_TEST_ASSERTION_WARNING,
gTestGenericFailureGuid,
L"LoadEbcDriver - Can't load Ebc Driver and get the entry point",
L"%a:%d:Status - %r",
__FILE__,
__LINE__,
Status
);
UnloadEbcDriver();
return Status;
}
//
// 4.1.2.1 Call CreateThunk() with Invalid Parameters
//
Status = EbcInterface->CreateThunk (
EbcInterface,
gDummyImageHandle,
(VOID *)((UINTN)EbcEntryPoint+1), // invalid
(VOID **)&ThunkEntryPoint
);
if (Status == EFI_INVALID_PARAMETER) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gEbcBBTestConformanceAssertionGuid001,
L"EFI_EBC_PROTOCOL.CreateThunk - Call CreateThunk() with Invalid Parameters",
L"%a:%d:Status - %r",
__FILE__,
__LINE__,
Status
);
UnloadEbcDriver();
return EFI_SUCCESS;
}
//
// TDS 3.4.2
//
EFI_STATUS
DevicePathUtilitiesAppendDeviceNodeConformanceTest (
IN EFI_BB_TEST_PROTOCOL *This,
IN VOID *ClientInterface,
IN EFI_TEST_LEVEL TestLevel,
IN EFI_HANDLE SupportHandle
)
{
EFI_STANDARD_TEST_LIBRARY_PROTOCOL *StandardLib;
EFI_STATUS Status;
EFI_DEVICE_PATH_UTILITIES_PROTOCOL *DevicePathUtilities;
EFI_TEST_ASSERTION AssertionType;
EFI_DEVICE_PATH_PROTOCOL *pDevicePath1;
EFI_DEVICE_PATH_PROTOCOL *pDevicePath2;
EFI_DEVICE_PATH_PROTOCOL *pDevicePath3;
EFI_DEVICE_PATH_PROTOCOL *pDevicePath4;
//
// Get the Standard Library Interface
//
Status = gtBS->HandleProtocol (
SupportHandle,
&gEfiStandardTestLibraryGuid,
&StandardLib
);
if (EFI_ERROR (Status)) {
return Status;
}
DevicePathUtilities = (EFI_DEVICE_PATH_UTILITIES_PROTOCOL *) ClientInterface;
//
// TDS 3.4.2.2.1
//
pDevicePath1 = (EFI_DEVICE_PATH *) AllocatePool (END_DEVICE_PATH_LENGTH);
if (pDevicePath1 == NULL) {
return EFI_OUT_OF_RESOURCES;
}
SetDevicePathEndNode (pDevicePath1);
pDevicePath2 = DevicePathUtilities->CreateDeviceNode (PCIRootNodeType, PCIRootNodeSubType, PCIRootNodeLength);
pDevicePath4 = DevicePathUtilities->AppendDeviceNode (pDevicePath1, pDevicePath2);
pDevicePath3 = DevicePathUtilities->AppendDeviceNode (NULL, pDevicePath2);
if ((pDevicePath3 != NULL) && (EfiCompareMem(pDevicePath3, pDevicePath4, DevicePathUtilities->GetDevicePathSize (pDevicePath3)) == 0)) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
if (pDevicePath3 != NULL) {
FreePool (pDevicePath3);
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gDevicePathUtilitiesBBTestFunctionAssertionGuid054,
L"EFI_DEVICE_PATH_UTILITIES_PROTOCOL - AppendDeviceNode should return a copy of DeviceNode if DevicePath is NULL",
L"%a:%d",
__FILE__,
(UINTN)__LINE__
);
//
// TDS 3.4.2.2.2
//
pDevicePath3 = DevicePathUtilities->AppendDeviceNode (pDevicePath4, NULL);
if ((pDevicePath3 != NULL) && (EfiCompareMem(pDevicePath3, pDevicePath4, DevicePathUtilities->GetDevicePathSize (pDevicePath3)) == 0)) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
if (pDevicePath2 != NULL) {
FreePool(pDevicePath2);
}
if (pDevicePath3 != NULL) {
FreePool(pDevicePath3);
}
if (pDevicePath4 != NULL) {
FreePool(pDevicePath4);
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gDevicePathUtilitiesBBTestFunctionAssertionGuid055,
L"EFI_DEVICE_PATH_UTILITIES_PROTOCOL - AppendDeviceNode should return a copy of DevicePath if DeviceNode is NULL",
L"%a:%d",
__FILE__,
(UINTN)__LINE__
);
pDevicePath3 = DevicePathUtilities->AppendDeviceNode (NULL, NULL);
if ((pDevicePath3 != NULL) && (EfiCompareMem(pDevicePath3, pDevicePath1, DevicePathUtilities->GetDevicePathSize (pDevicePath3)) == 0)) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
FreePool(pDevicePath1);
if (pDevicePath3 != NULL) {
FreePool(pDevicePath3);
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gDevicePathUtilitiesBBTestFunctionAssertionGuid069,
L"EFI_DEVICE_PATH_UTILITIES_PROTOCOL - AppendDeviceNode should return end-of-device-path device node if both DevicePath and DeviceNode are NULL",
L"%a:%d",
__FILE__,
(UINTN)__LINE__
);
return EFI_SUCCESS;
}
//
// 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 3.1
//
EFI_STATUS
BBTestCreateThunkBasicTest (
IN EFI_BB_TEST_PROTOCOL *This,
IN VOID *ClientInterface,
IN EFI_TEST_LEVEL TestLevel,
IN EFI_HANDLE SupportHandle
)
{
EFI_STANDARD_TEST_LIBRARY_PROTOCOL *StandardLib;
EFI_STATUS Status;
EFI_TEST_ASSERTION AssertionType;
EFI_EBC_PROTOCOL *EbcInterface;
VOID *EbcEntryPoint;
EFI_IMAGE_ENTRY_POINT ThunkEntryPoint;
VOID *EbcDriverInterface;
//
// Get the Standard Library Interface
//
Status = gtBS->HandleProtocol (
SupportHandle,
&gEfiStandardTestLibraryGuid,
&StandardLib
);
if (EFI_ERROR(Status)) {
return Status;
}
//
// Get the EFI_EBC_PROTOCOL Protocol interface to be tested
//
EbcInterface = (EFI_EBC_PROTOCOL *)ClientInterface;
//
// Register a callback for flushing the instruction cache so that created
// thunks can be flushed.
//
Status = EbcInterface->RegisterICacheFlush (EbcInterface, FlushICache);
if (EFI_ERROR(Status)) {
StandardLib->RecordAssertion (
StandardLib,
EFI_TEST_ASSERTION_FAILED,
gTestGenericFailureGuid,
L"EFI_EBC_PROTOCOL.RegisterICacheFlush - Can't register callback function",
L"%a:%d:Status - %r",
__FILE__,
__LINE__,
Status
);
return Status;
}
//
// 3.1.2.1 CreateThunk() Basic Functionality
//
//
// Load Ebc Driver
//
Status = LoadEbcDriver (&EbcEntryPoint);
if (EFI_ERROR(Status)) {
StandardLib->RecordAssertion (
StandardLib,
EFI_TEST_ASSERTION_WARNING,
gTestGenericFailureGuid,
L"LoadEbcDriver - Can't load Ebc Driver and get the entry point",
L"%a:%d:Status - %r",
__FILE__,
__LINE__,
Status
);
UnloadEbcDriver();
return Status;
}
//
// Create a thunk for the image's entry point. This will be the new
// entry point for the image.
//
Status = EbcInterface->CreateThunk (
EbcInterface,
gDummyImageHandle,
EbcEntryPoint,
(VOID **)&ThunkEntryPoint
);
if (Status == EFI_SUCCESS) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gEbcBBTestFunctionAssertionGuid001,
L"EFI_EBC_PROTOCOL.CreateThunk - Call CreateThunk to create ebc thunk",
L"%a:%d:Status - %r",
__FILE__,
__LINE__,
Status
);
if (Status == EFI_SUCCESS) {
ThunkEntryPoint (gDummyImageHandle, gtST);
Status = gtBS->HandleProtocol (
gDummyImageHandle,
&gEfiEbcDriverProtocolGuid,
&EbcDriverInterface
);
if (Status == EFI_SUCCESS) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gEbcBBTestFunctionAssertionGuid002,
L"EFI_EBC_PROTOCOL.CreateThunk - Ebc entry point invoked",
L"%a:%d:Status - %r",
__FILE__,
__LINE__,
Status
);
Status = EbcInterface->UnloadImage (EbcInterface, gDummyImageHandle);
if (EFI_ERROR(Status)) {
StandardLib->RecordAssertion (
StandardLib,
EFI_TEST_ASSERTION_FAILED,
gTestGenericFailureGuid,
L"EFI_EBC_PROTOCOL.UnloadImage - Can't unload the ebc thunk",
L"%a:%d:Status - %r",
__FILE__,
__LINE__,
Status
);
UnloadEbcDriver();
return Status;
}
}
UnloadEbcDriver();
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.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 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;
}
EFI_STATUS
BBTestFpuControlWordTest (
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;
UINT16 FpuCw;
EFI_TEST_ASSERTION AssertionType;
//
// Get the Standard Library Interface
//
Status = gtBS->HandleProtocol (
SupportHandle,
&gEfiStandardTestLibraryGuid,
&StandardLib
);
if (EFI_ERROR (Status)) {
return Status;
}
//
// record assertion for the returned FPU control word.
//
Status = GetFpuControlWord(&FpuCw);
if (EFI_ERROR(Status)) {
StandardLib->RecordAssertion (
StandardLib,
EFI_TEST_ASSERTION_FAILED,
gTestGenericFailureGuid,
L"Execution Mode - Could NOT get FPU control word",
L"%a:%d:Status - %r",
__FILE__,
__LINE__,
Status
);
return Status;
}
if ((sizeof(UINTN) == 4 && FpuCw == FPU_CONTROL_WORD_VALUE_IA32) ||
(sizeof(UINTN) == 8 && FpuCw == FPU_CONTROL_WORD_VALUE_X64)) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gBasicTestAssertionGuid001,
L"EFI_EXE_MODE - Get FPU control word",
L"%a:%d:FPU control word got %x",
__FILE__,
__LINE__,
FpuCw
);
return EFI_SUCCESS;
}
//
// TDS 3.4.3
//
EFI_STATUS
DevicePathUtilitiesAppendDevicePathConformanceTest (
IN EFI_BB_TEST_PROTOCOL *This,
IN VOID *ClientInterface,
IN EFI_TEST_LEVEL TestLevel,
IN EFI_HANDLE SupportHandle
)
{
EFI_STANDARD_TEST_LIBRARY_PROTOCOL *StandardLib;
EFI_STATUS Status;
EFI_DEVICE_PATH_UTILITIES_PROTOCOL *DevicePathUtilities;
EFI_TEST_ASSERTION AssertionType;
EFI_DEVICE_PATH_PROTOCOL *pDevicePath1;
EFI_DEVICE_PATH_PROTOCOL *pDevicePath2;
EFI_DEVICE_PATH_PROTOCOL *pDevicePath3;
EFI_DEVICE_PATH_PROTOCOL *pDevicePath4;
UINTN DevicePathLen1;
UINTN DevicePathLen2;
UINTN DevicePathLen3;
//
// Get the Standard Library Interface
//
Status = gtBS->HandleProtocol (
SupportHandle,
&gEfiStandardTestLibraryGuid,
&StandardLib
);
if (EFI_ERROR (Status)) {
return Status;
}
DevicePathUtilities = (EFI_DEVICE_PATH_UTILITIES_PROTOCOL *) ClientInterface;
//
// TDS 3.4.3.2.1
//
pDevicePath1 = (EFI_DEVICE_PATH *) AllocatePool (END_DEVICE_PATH_LENGTH);
SetDevicePathEndNode (pDevicePath1);
pDevicePath3 = DevicePathUtilities->CreateDeviceNode (USBNodeType, USBNodeSubType, USBNodeLength);
pDevicePath4 = DevicePathUtilities->AppendDeviceNode (pDevicePath1, pDevicePath3);
FreePool (pDevicePath1);
FreePool (pDevicePath3);
DevicePathLen2 = DevicePathUtilities->GetDevicePathSize (pDevicePath4);
pDevicePath1 = DevicePathUtilities->AppendDevicePath (NULL, pDevicePath4);
FreePool (pDevicePath4);
DevicePathLen3 = DevicePathUtilities->GetDevicePathSize (pDevicePath1);
FreePool (pDevicePath1);
if (DevicePathLen2 == DevicePathLen3) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gDevicePathUtilitiesBBTestFunctionAssertionGuid059,
L"EFI_DEVICE_PATH_UTILITIES_PROTOCOL - AppendDevicePath should ignore Src1 when it is set NULL",
L"%a:%d:Status - %r",
__FILE__,
(UINTN)__LINE__
);
//
// TDS 3.4.3.2.2
//
pDevicePath1 = (EFI_DEVICE_PATH *) AllocatePool (END_DEVICE_PATH_LENGTH);
if (pDevicePath1 == NULL) {
return EFI_OUT_OF_RESOURCES;
}
SetDevicePathEndNode (pDevicePath1);
DevicePathLen1 = DevicePathUtilities->GetDevicePathSize (pDevicePath1);
pDevicePath2 = DevicePathUtilities->CreateDeviceNode (PCIRootNodeType, PCIRootNodeSubType, PCIRootNodeLength);
pDevicePath3 = DevicePathUtilities->AppendDeviceNode (pDevicePath1, pDevicePath2);
FreePool (pDevicePath1);
FreePool (pDevicePath2);
pDevicePath1 = DevicePathUtilities->CreateDeviceNode (PCINodeType, PCINodeSubType, PCINodeLength);
pDevicePath2 = DevicePathUtilities->AppendDeviceNode (pDevicePath3, pDevicePath1);
FreePool (pDevicePath3);
FreePool (pDevicePath1);
DevicePathLen1 = DevicePathUtilities->GetDevicePathSize (pDevicePath2);
pDevicePath1 = DevicePathUtilities->AppendDevicePath (pDevicePath2, NULL);
FreePool (pDevicePath2);
DevicePathLen3 = DevicePathUtilities->GetDevicePathSize (pDevicePath1);
FreePool (pDevicePath1);
if (DevicePathLen1 == DevicePathLen3) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gDevicePathUtilitiesBBTestFunctionAssertionGuid060,
L"EFI_DEVICE_PATH_UTILITIES_PROTOCOL - AppendDevicePath should ignore Src2 when it is set NULL",
L"%a:%d:Status - %r",
__FILE__,
(UINTN)__LINE__
);
pDevicePath1 = DevicePathUtilities->AppendDevicePath (NULL, NULL);
if ((pDevicePath1 != NULL) && (IsDevicePathEnd(pDevicePath1))) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gDevicePathUtilitiesBBTestFunctionAssertionGuid068,
L"EFI_DEVICE_PATH_UTILITIES_PROTOCOL - AppendDevicePath should return end-of-device-path if both Src1 and Src2 are NULL",
L"%a:%d",
__FILE__,
(UINTN)__LINE__
);
return EFI_SUCCESS;
}
EFI_STATUS
PlatformSpecificElementsBbTest (
IN EFI_BB_TEST_PROTOCOL *This,
IN VOID *ClientInterface,
IN EFI_TEST_LEVEL TestLevel,
IN EFI_HANDLE SupportHandle
)
/*++
Routine Description:
Check the platform specific elements, which defined in the EFI spec 1.10,
section 2.6.2.
--*/
{
EFI_STATUS Status;
EFI_STANDARD_TEST_LIBRARY_PROTOCOL *StandardLib;
EFI_TEST_PROFILE_LIBRARY_PROTOCOL *ProfileLib;
EFI_INI_FILE_HANDLE IniFile;
//
// Locate the standard test library protocol
//
Status = gtBS->HandleProtocol (
SupportHandle,
&gEfiStandardTestLibraryGuid,
&StandardLib
);
if (EFI_ERROR (Status)) {
return Status;
}
//
// Locate the test profile library protocol
//
Status = gtBS->HandleProtocol (
SupportHandle,
&gEfiTestProfileLibraryGuid,
&ProfileLib
);
if (EFI_ERROR (Status)) {
return Status;
}
//
// Open the INI file
//
Status = OpenIniFile (
ProfileLib,
EFI_COMPLIANT_BB_TEST_INI_PATH,
EFI_COMPLIANT_BB_TEST_INI_FILE,
&IniFile
);
if (EFI_ERROR (Status)) {
StandardLib->RecordAssertion (
StandardLib,
EFI_TEST_ASSERTION_WARNING,
gTestGenericFailureGuid,
L"EFI Compliant - Cannot open INI file",
L"%a:%d",
__FILE__,
(UINTN)__LINE__
);
return Status;
}
//
// Check the console protocols
//
CheckConsoleProtocols (StandardLib, IniFile);
//
// Check the graphical console protocols
//
CheckGraphicalConsoleProtocols (StandardLib, IniFile);
//
// Check the pointer protocols
//
CheckPointerProtocols (StandardLib, IniFile);
//
// Check the boot from disk protocols
//
CheckBootFromDiskProtocols (StandardLib, IniFile);
//
// Check the boot from network protocols
//
CheckBootFromNetworkProtocols (StandardLib, IniFile);
//
// Check the UART support protocols
//
CheckUartProtocols (StandardLib, IniFile);
//
// Check the PCI support protocols
//
CheckPciProtocols (StandardLib, IniFile);
//
// Check the USB support protocols
//
CheckUsbProtocols (StandardLib, IniFile);
//
// Check the SCSI support protocols
//
CheckScsiProtocols (StandardLib, IniFile);
//
// Check the Debug support protocols
//
CheckDebugProtocols (StandardLib, IniFile);
//
// Check the driver override protocols
//
CheckDriverOverrideProtocols (StandardLib, IniFile);
//
// Close the INI file
//
CloseIniFile (ProfileLib, IniFile);
//
// Done
//
return EFI_SUCCESS;
}
//
// TDS 3.4.4
//
EFI_STATUS
DevicePathUtilitiesAppendDevicePathInstanceConformanceTest (
IN EFI_BB_TEST_PROTOCOL *This,
IN VOID *ClientInterface,
IN EFI_TEST_LEVEL TestLevel,
IN EFI_HANDLE SupportHandle
)
{
EFI_STANDARD_TEST_LIBRARY_PROTOCOL *StandardLib;
EFI_STATUS Status;
EFI_DEVICE_PATH_UTILITIES_PROTOCOL *DevicePathUtilities;
EFI_TEST_ASSERTION AssertionType;
EFI_DEVICE_PATH_PROTOCOL *pDevicePath1;
EFI_DEVICE_PATH_PROTOCOL *pDevicePath2;
EFI_DEVICE_PATH_PROTOCOL *pDevicePath3;
//
// Get the Standard Library Interface
//
Status = gtBS->HandleProtocol (
SupportHandle,
&gEfiStandardTestLibraryGuid,
&StandardLib
);
if (EFI_ERROR (Status)) {
return Status;
}
DevicePathUtilities = (EFI_DEVICE_PATH_UTILITIES_PROTOCOL *) ClientInterface;
//
// TDS 3.4.4.2.1
//
pDevicePath1 = (EFI_DEVICE_PATH *) AllocatePool (END_DEVICE_PATH_LENGTH);
if (pDevicePath1 == NULL) {
return EFI_OUT_OF_RESOURCES;
}
SetDevicePathEndNode (pDevicePath1);
pDevicePath2 = DevicePathUtilities->CreateDeviceNode (PCIRootNodeType, PCIRootNodeSubType, PCIRootNodeLength);
pDevicePath3 = DevicePathUtilities->AppendDeviceNode (pDevicePath1, pDevicePath2);
FreePool (pDevicePath1);
FreePool (pDevicePath2);
pDevicePath1 = DevicePathUtilities->CreateDeviceNode (PCINodeType, PCINodeSubType, PCINodeLength);
pDevicePath2 = DevicePathUtilities->AppendDeviceNode (pDevicePath3, pDevicePath1);
FreePool (pDevicePath3);
FreePool (pDevicePath1);
pDevicePath1 = DevicePathUtilities->AppendDevicePathInstance (pDevicePath2, NULL);
FreePool (pDevicePath2);
if (pDevicePath1 == NULL) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gDevicePathUtilitiesBBTestFunctionAssertionGuid062,
L"EFI_DEVICE_PATH_UTILITIES_PROTOCOL - AppendDevicePathInstance should not succeed with DevicePathInstance set to be NULL",
L"%a:%d:Status - %r",
__FILE__,
(UINTN)__LINE__
);
return EFI_SUCCESS;
}
//
// TDS 4.1.4
//
EFI_STATUS
BBTestStrUprFunctionAutoTest (
IN EFI_BB_TEST_PROTOCOL *This,
IN VOID *ClientInterface,
IN EFI_TEST_LEVEL TestLevel,
IN EFI_HANDLE SupportHandle
)
{
EFI_STANDARD_TEST_LIBRARY_PROTOCOL *StandardLib;
EFI_STATUS Status;
EFI_UNICODE_COLLATION2_PROTOCOL *UnicodeCollation;
UINTN Index;
EFI_TEST_ASSERTION AssertionType;
//
// Test Data
//
CHAR16 *TestData[] ={
L"\x21\x22\x31\x32\x41\x42\x43\x44\x45\x46\x47\x48\x49\x4A\x4B\x4C\x4D\x4E\x4F\x50\x51\x52\x53\x54\x55\x56\x57\x58\x59\x5Ax61\x62\x7D\x7E",
L"\x30\x50[abcdzyxw!)(@#*]\x40\x20\x30\x50\ab\x40\x20",
L"\x30\x50[A-D]\x40\x20\x30\x50f\x40\x20",
L""
};
CHAR16 TestDataSav[MAX_SIZE_OF_STRING + 1];
//
// 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;
}
UnicodeCollation = (EFI_UNICODE_COLLATION2_PROTOCOL *)ClientInterface;
for (Index = 0; Index < sizeof (TestData) / sizeof (CHAR16*); Index++) {
//
// Backup current test data
//
CopyUnicodeString (TestDataSav, TestData[Index]);
//
// For each test data, test the StrUpr functionality.
//
UnicodeCollation->StrUpr (UnicodeCollation, TestData[Index]);
if (CheckStrUpr (TestDataSav, TestData[Index])) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gUnicodeCollationFunctionTestAssertionGuid005,
L"EFI_UNICODE_COLLATION_PROTOCOL.StrUpr - Verification of StrUpr interface",
L"%a:%d: Original=%s-- ToUpper=%s",
__FILE__,
(UINTN)__LINE__,
TestDataSav,
TestData[Index]
);
CopyUnicodeString (TestDataSav, TestData[Index]);
UnicodeCollation->StrLwr (UnicodeCollation, TestData[Index]);
UnicodeCollation->StrUpr (UnicodeCollation, TestData[Index]);
if (CheckStrEql (TestDataSav, TestData[Index])) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gUnicodeCollationFunctionTestAssertionGuid006,
L"EFI_UNICODE_COLLATION_PROTOCOL.StrUpr - Verification of StrUpr interface",
L"%a:%d: Original=%s -- ToUpper=%s",
__FILE__,
(UINTN)__LINE__,
TestDataSav,
TestData[Index]
);
};
return EFI_SUCCESS;
}
//
//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.1.1
//
EFI_STATUS
BBTestStriCollFunctionAutoTest (
IN EFI_BB_TEST_PROTOCOL *This,
IN VOID *ClientInterface,
IN EFI_TEST_LEVEL TestLevel,
IN EFI_HANDLE SupportHandle
)
{
EFI_STANDARD_TEST_LIBRARY_PROTOCOL *StandardLib;
EFI_STATUS Status;
EFI_UNICODE_COLLATION2_PROTOCOL *UnicodeCollation;
UINTN Index;
INTN Result;
EFI_TEST_ASSERTION AssertionType;
//
// Test Data
//
STRICOLL_TEST_DATA_FIELD TestData[] ={
{
L"",
L"",
STRING_COMPARE_EQUAL
},
{
L"\x01\x02\x11\x12\x21\x22\x31\x32\x41\x42\x43\x44\x45\x46\x47\x48\x49\x4A\x4B\x4C\x4D\x4E\x4F\x50\x51\x52\x53\x54\x55\x56\x57\x58\x59\x5Ax61\x62\x7D\x7E",
L"\x01\x02\x11\x12\x21\x22\x31\x32\x61\x62\x63\x64\x65\x66\x67\x68\x69\x6A\x6B\x6C\x6D\x6E\x6F\x70\x71\x72\x73\x74\x75\x76\x77\x78\x79\x7Ax61\x62\x7D\x7E",
STRING_COMPARE_EQUAL
},
{
L"\x01\x02\x11\x12\x21\x22\x31\x32\x61\x62\x63\x64\x65\x66\x67\x68\x69\x6A\x6B\x6C\x6D\x6E\x6F\x70\x71\x72\x73\x74\x75\x76\x77\x78\x79\x7Ax61\x62\x7D\x7E",
L"\x01\x02\x11\x12\x21\x22\x31\x32\x41\x42\x43\x44\x45\x46\x47\x48\x49\x4A\x4B\x4C\x4D\x4E\x4F\x50\x51\x52\x53\x54\x55\x56\x57\x58\x59\x5Ax61\x62\x7D\x7E",
STRING_COMPARE_EQUAL
},
{
L"\x01\x02\x11\x12\x21\x22\x31\x32\x41\x42\x43\x44\x45\x46\x47\x48\x49\x4A\x4B\x4C\x4D\x4E\x4F\x50\x51\x52\x53\x54\x55\x56\x57\x58\x59\x5A\x61\x62\x7D\x7E",
L"\x01\x02\x11\x12\x21\x22\x31\x32\x41\x42\x43\x44\x45\x46\x47\x48\x49\x4A\x4B\x4C\x4D\x4E\x4F\x50\x51\x52\x53\x54\x55\x56\x57\x58\x59\x5A\x61\x62\x7D\x7D",
STRING_COMPARE_MORE
},
{
L"\x01\x02\x11\x12\x21\x22\x31\x32\x41\x42\x43\x44\x45\x46\x47\x48\x49\x4A\x4B\x4C\x4D\x4E\x4F\x50\x51\x52\x53\x54\x55\x56\x57\x58\x59\x5A\x61\x62\x7D\x7E",
L"\x01\x02\x11\x12\x21\x22\x31\x32\x41\x42\x43\x44\x45\x46\x47\x48\x49\x4A\x4B\x4C\x4D\x4E\x4F\x50\x51\x52\x53\x54\x55\x56\x57\x58\x59\x5A\x61\x62\x7D\x7F",
STRING_COMPARE_LESS
},
{
L"\x01",
L"",
STRING_COMPARE_MORE
},
{
L"",
L"\x01\x02",
STRING_COMPARE_LESS
},
};
//
// 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;
}
UnicodeCollation = (EFI_UNICODE_COLLATION2_PROTOCOL *)ClientInterface;
for (Index = 0; Index < sizeof (TestData) / sizeof (STRICOLL_TEST_DATA_FIELD); Index++) {
//
// For each test data, test the StriColl functionality.
//
Result = UnicodeCollation->StriColl (
UnicodeCollation,
TestData[Index].S1,
TestData[Index].S2
);
if (((Result < 0) && (TestData[Index].Result < 0)) ||
((Result == 0) && (TestData[Index].Result == 0)) ||
((Result > 0) && (TestData[Index].Result > 0))) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gUnicodeCollationFunctionTestAssertionGuid001,
L"EFI_UNICODE_COLLATION_PROTOCOL.StriColl - Verification of StriColl interface",
L"%a:%d: S1='%s', S2='%s', Result=%d",
__FILE__,
(UINTN)__LINE__,
TestData[Index].S1,
TestData[Index].S2,
Result
);
};
return EFI_SUCCESS;
}
//
//TDS 4.3.2
//
EFI_STATUS
GetAndSetBarAttributes_Stress (
IN EFI_BB_TEST_PROTOCOL *This,
IN VOID *ClientInterface,
IN EFI_TEST_LEVEL TestLevel,
IN EFI_HANDLE SupportHandle
)
{
EFI_STATUS Status;
PCI_IO_PROTOCOL_DEVICE *PciIoDevice;
EFI_PCI_IO_PROTOCOL *PciIo;
EFI_STANDARD_TEST_LIBRARY_PROTOCOL *StandardLib;
EFI_TEST_ASSERTION AssertionType;
UINTN Index;
UINTN SubIndex;
UINT8 BarIndex;
UINT64 DevSupportedAttributes;
UINT64 BarOriginalAttributes;
UINT64 AddressOffset;
UINT64 AddressLength;
VOID *Resources;
UINTN PciIoAttributesNumber;
UINT64 ThisAttribute;
//
//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;
}
//
//get PciIoDevice struct pointer.
//
PciIoDevice = NULL;
PciIoDevice = GetPciIoDevice (PciIo);
if (PciIoDevice == NULL) {
return EFI_ABORTED;
}
InitializeCaseEnvironment ();
//
//print the device path of pci device.
//
Status = PrintPciIoDevice (PciIoDevice->DevicePath);
if (EFI_ERROR(Status)) {
return Status;
}
Status = PciIo->Attributes (
PciIo,
EfiPciIoAttributeOperationSupported,
0,
&DevSupportedAttributes
);
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_IO_PROTOCOL.Attributes - return status must be EFI_SUCCESS.",
L"%a:%d:Status - %r",
__FILE__,
__LINE__,
Status
);
for (Index = 0; Index < REGNUM; Index++) {
BarIndex = (UINT8)Index;
Resources = 0;
Status = PciIo->GetBarAttributes (
PciIo,
BarIndex,
&BarOriginalAttributes,
&Resources
);
if (!EFI_ERROR(Status)) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
//
//record assertion
//
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gPciIoBBTestStressAssertionGuid019,
L"EFI_PCI_IO_PROTOCOL.GetBarAttributes - return status must be EFI_SUCCESS.",
L"%a:%d:Status - %r, BarIndex - %d",
__FILE__,
__LINE__,
Status,
BarIndex
);
if (IsValidResourceDescrptor (Resources)) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
//
//record assertion
//
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gPciIoBBTestStressAssertionGuid020,
L"EFI_PCI_IO_PROTOCOL.GetBarAttributes - the Resource Descriptor List must be valid",
L"%a:%d",
__FILE__,
__LINE__
);
//
//free the resources if necessory.
//
if (Status == EFI_SUCCESS) {
gtBS->FreePool (Resources);
}
//
//the attribute supported by this bar must be in the device supported attributes range.
//
if ((BarOriginalAttributes & DevSupportedAttributes) == BarOriginalAttributes) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
//
//record assertion
//
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gPciIoBBTestStressAssertionGuid021,
L"EFI_PCI_IO_PROTOCOL.GetBarAttributes - Bar supported attributes must in the range of Device supproted attributes",
L"%a:%d:Bar Supported - %lXh, Dev Supported - %lXh",
__FILE__,
__LINE__,
BarOriginalAttributes,
DevSupportedAttributes
);
//
//Invalid bar then continue;
//
if (!PciIoDevice->BarHasEffect[BarIndex]) {
continue;
}
AddressOffset = 0;
AddressLength = PciIoDevice->BarLength[BarIndex];
PciIoAttributesNumber = 19;
//
//for each attributes call SetBarAttributes
//
for (SubIndex = 0; SubIndex < PciIoAttributesNumber; SubIndex++) {
ThisAttribute = 1 << SubIndex;
Status = PciIo->SetBarAttributes (
PciIo,
ThisAttribute,
BarIndex,
&AddressOffset,
&AddressLength
);
if ((ThisAttribute & BarOriginalAttributes) == ThisAttribute) {
if (!EFI_ERROR(Status)) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
//
//record assertion
//
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gPciIoBBTestStressAssertionGuid022,
L"EFI_PCI_IO_PROTOCOL.SetBarAttributes - Set Bar supported attributes return Staus Must be EFI_SUCCESS",
L"%a:%d:Set Attribute - %lXh, Supported Attributes - %lXh",
__FILE__,
__LINE__,
ThisAttribute,
BarOriginalAttributes
);
} else {
//
//Unsupported attributes
//
if (Status == EFI_UNSUPPORTED) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
//
//record assertion
//
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gPciIoBBTestStressAssertionGuid023,
L"EFI_PCI_IO_PROTOCOL.SetBarAttributes - Set Unsupported attributes status must be EFI_UNSUPPORTED.",
L"%a:%d:Set Attribute - %lXh, Supported Attributes - %lXh",
__FILE__,
__LINE__,
ThisAttribute,
BarOriginalAttributes
);
}
}
}
//
//done successfully
//
return EFI_SUCCESS;
}
//
// TDS 3.5
//
EFI_STATUS
BBTestInvalidateInstructionCacheFunctionAutoTest (
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_DEBUG_SUPPORT_PROTOCOL *DebugSupport;
EFI_TEST_ASSERTION AssertionType;
UINT64 Start;
UINT64 Length;
UINTN MaxProcessorIndex;
UINTN ProcessorIndex;
//
// 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;
}
DebugSupport = (EFI_DEBUG_SUPPORT_PROTOCOL *)ClientInterface;
if (DebugSupport->Isa != PlatformIsa) {
return EFI_SUCCESS;
}
Status = DebugSupport->GetMaximumProcessorIndex (DebugSupport, &MaxProcessorIndex);
if (EFI_ERROR(Status)) {
StandardLib->RecordAssertion (
StandardLib,
EFI_TEST_ASSERTION_FAILED,
gTestGenericFailureGuid,
L"EFI_DEBUG_SUPPORT_PROTOCOL.GetMaximumProcessorIndex",
L"%a:%d:Status - %r",
__FILE__,
__LINE__,
Status
);
return Status;
}
for (ProcessorIndex = 0; ProcessorIndex < MaxProcessorIndex; ProcessorIndex++) {
//
// Assertion Point 3.5.2.1
// Invoke InvalidateInstructionCache and verify interface correctness.
//
// The Physical base of the memory range to be invalidated.
Start = 0x0;
// The minimum number of bytes in the processor's instruction cache to be invalidated.
Length = 0x0;
Status = DebugSupport->InvalidateInstructionCache (DebugSupport, ProcessorIndex, (VOID*)&Start, Length);
if (EFI_ERROR(Status)) {
AssertionType = EFI_TEST_ASSERTION_FAILED;
} else {
AssertionType = EFI_TEST_ASSERTION_PASSED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gDebugSupportBBTestFunctionAssertionGuid015,
L"EFI_DEBUG_SUPPORT_PROTOCOL.InvalidateInstructionCache - Invoke this function and verify interface correctness",
L"%a:%d:Status - %r",
__FILE__,
__LINE__,
Status
);
}
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 3.4
//
EFI_STATUS
BBTestPollFunctionManualTest (
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_DEBUGPORT_PROTOCOL *DebugPort;
EFI_TEST_ASSERTION AssertionType;
UINTN WaitIndex;
EFI_INPUT_KEY Key;
//
// 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;
}
DebugPort = (EFI_DEBUGPORT_PROTOCOL *)ClientInterface;
//
// Assertion Point 3.4.2.1
// Call Poll() to check the debug port with data.
//
//
// Wait for the input data.
//
Print (L"\nPress any key after input data.");
gtBS->WaitForEvent (1, &(gtST->ConIn->WaitForKey), &WaitIndex);
gtST->ConIn->ReadKeyStroke (gtST->ConIn, &Key);
Status = DebugPort->Poll (DebugPort);
if (EFI_ERROR(Status)) {
AssertionType = EFI_TEST_ASSERTION_FAILED;
} else {
AssertionType = EFI_TEST_ASSERTION_PASSED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gDebugPortBBTestFunctionAssertionGuid010,
L"EFI_DEBUGPORT_PROTOCOL.Poll - Call Poll() to check the debug port with data",
L"%a:%d:Status - %r",
__FILE__,
(UINTN)__LINE__,
Status
);
//
// Assertion Point 3.4.2.2
// Call Poll() to check the debug port without data.
//
// Call Reset() to clean the data of the debug port.
Status = DebugPort->Reset (DebugPort);
if (EFI_ERROR(Status)) {
return Status;
}
Status = DebugPort->Poll (DebugPort);
if (Status == EFI_NOT_READY) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gDebugPortBBTestFunctionAssertionGuid011,
L"EFI_DEBUGPORT_PROTOCOL.Poll - Call Poll() to check the debug port without data",
L"%a:%d:Status - %r",
__FILE__,
(UINTN)__LINE__,
Status
);
return EFI_SUCCESS;
}
EFI_STATUS
BBTestQueryCapsuleCapabilitiesConformanceTest (
IN EFI_BB_TEST_PROTOCOL *This,
IN VOID *ClientInterface,
IN EFI_TEST_LEVEL TestLevel,
IN EFI_HANDLE SupportHandle
)
{
EFI_STATUS Status;
EFI_STANDARD_TEST_LIBRARY_PROTOCOL *StandardLib;
EFI_TEST_ASSERTION AssertionType;
UINT8 *AllocatedBuffer;
EFI_CAPSULE_HEADER *CapsuleHeaderArray[2];
EFI_RESET_TYPE ResetType;
//
// Get the Standard Library Interface
//
Status = gtBS->HandleProtocol (
SupportHandle,
&gEfiStandardTestLibraryGuid,
&StandardLib
);
if (EFI_ERROR(Status)) {
return Status;
}
if (FALSE == CheckBBTestCanRunAndRecordAssertion(
StandardLib,
L"RT.QueryCapsuleCapabilities_Conf - QueryCapsuleCapabilities_Conf it's not Supported in EFI",
__FILE__,
(UINTN)__LINE__
)) {
return EFI_SUCCESS;
}
AllocatedBuffer = (UINT8 *)AllocatePool (sizeof(EFI_CAPSULE_HEADER));
if (AllocatedBuffer == NULL) {
StandardLib->RecordAssertion (
StandardLib,
EFI_TEST_ASSERTION_FAILED,
gTestGenericFailureGuid,
L"RT.QueryCapsuleCapabilities_Conf - Allocate zero pool for EFI_CAPSULE_HEADER",
L"%a:%d,Status - %r",
__FILE__,
(UINTN)__LINE__,
Status
);
return Status;
}
CapsuleHeaderArray[0] = (EFI_CAPSULE_HEADER *) (UINTN)AllocatedBuffer;
CapsuleHeaderArray[0]->CapsuleGuid = mEfiCapsuleHeaderGuid;
CapsuleHeaderArray[0]->HeaderSize = sizeof(EFI_CAPSULE_HEADER);
CapsuleHeaderArray[0]->CapsuleImageSize = sizeof(EFI_CAPSULE_HEADER);
CapsuleHeaderArray[1] = NULL;
// When the flag is CAPSULE_FLAGS_POPULATE_SYSTEM_TABLE and CAPSULE_FLAGS_PERSIST_ACROSS_RESET, platform will ignore the CapsuleGuid
CapsuleHeaderArray[0]->Flags = CAPSULE_FLAGS_PERSIST_ACROSS_RESET | CAPSULE_FLAGS_POPULATE_SYSTEM_TABLE;
Status = gtRT->QueryCapsuleCapabilities(
CapsuleHeaderArray,
1,
NULL, //invalid
&ResetType);
if ((Status == EFI_INVALID_PARAMETER) || (Status == EFI_UNSUPPORTED)) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gMiscRuntimeServicesBBTestConformanceAssertionGuid004,
L"RT.QueryCapsuleCapabilities - invoke QueryCapsuleCapabilities with invalid MaxiumCapsuleSize",
L"%a:%d:Status - %r",
__FILE__,
(UINTN)__LINE__,
Status
);
FreePool (AllocatedBuffer);
return EFI_SUCCESS;
}
//
// TDS 4.2
//
EFI_STATUS
BBTestBuildDevicePathConformanceAutoTest (
IN EFI_BB_TEST_PROTOCOL *This,
IN VOID *ClientInterface,
IN EFI_TEST_LEVEL TestLevel,
IN EFI_HANDLE SupportHandle
)
{
EFI_STANDARD_TEST_LIBRARY_PROTOCOL *StandardLib;
EFI_STATUS Status;
EFI_SCSI_PASS_THRU_PROTOCOL *ScsiPassThru;
EFI_TEST_ASSERTION AssertionType;
UINT32 Target;
UINT64 Lun;
UINT32 NewTarget;
UINT64 NewLun;
EFI_DEVICE_PATH_PROTOCOL *DevicePath;
//
// 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;
}
ScsiPassThru = (EFI_SCSI_PASS_THRU_PROTOCOL *)ClientInterface;
//
// Assertion Point 4.2.2.1
// Call BuildDevicePath() with invalid Target and invalid Lun.
//
Status = GetScsiDevice (ScsiPassThru, &NewTarget, &NewLun);
if (EFI_ERROR(Status)) {
StandardLib->RecordAssertion (
StandardLib,
EFI_TEST_ASSERTION_FAILED,
gTestGenericFailureGuid,
L"Can't Get any Scsi Device",
L"%a:%d:Status - %r",
__FILE__,
__LINE__,
Status
);
return EFI_UNSUPPORTED;
}
//
// Check point 1, call BuildDevicePath with invalid Target.
//
Target = 0xEEEEEEEE;
Lun = NewLun;
Status = ScsiPassThru->BuildDevicePath (ScsiPassThru, Target, Lun, &DevicePath);
if (Status == EFI_NOT_FOUND) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gScsiPassThruBBTestConformanceAssertionGuid004,
L"EFI_SCSI_PASS_THRU_PROTOCOL.BuildDevicePath - call BuildDevicePath with invalid Target.",
L"%a:%d:Status - %r, Target - %d, Lun - %ld",
__FILE__,
__LINE__,
Status,
Target,
Lun
);
//
// Check point 2, call BuildDevicePath with invalid Lun.
//
Target = NewTarget;
Lun = 0xEEEEEEEE;
Status = ScsiPassThru->BuildDevicePath (ScsiPassThru, Target, Lun, &DevicePath);
if (Status == EFI_NOT_FOUND) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gScsiPassThruBBTestConformanceAssertionGuid005,
L"EFI_SCSI_PASS_THRU_PROTOCOL.BuildDevicePath - call BuildDevicePath with invalid Lun.",
L"%a:%d:Status - %r, Target - %d, Lun - %ld",
__FILE__,
__LINE__,
Status,
Target,
Lun
);
//
// Assertion Point 4.2.2.2
// Call BuildDevicePath() with NULL DevicePath.
//
Target = NewTarget;
Lun = NewLun;
Status = ScsiPassThru->BuildDevicePath (ScsiPassThru, Target, Lun, NULL);
if (Status == EFI_INVALID_PARAMETER) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gScsiPassThruBBTestConformanceAssertionGuid006,
L"EFI_SCSI_PASS_THRU_PROTOCOL.BuildDevicePath - call BuildDevicePath with NULL DevicePath.",
L"%a:%d:Status - %r, Target - %d, Lun - %d",
__FILE__,
__LINE__,
Status,
Target,
Lun
);
return EFI_SUCCESS;
}
EFI_STATUS
BBTestUpdateCapsuleConformanceTest (
IN EFI_BB_TEST_PROTOCOL *This,
IN VOID *ClientInterface,
IN EFI_TEST_LEVEL TestLevel,
IN EFI_HANDLE SupportHandle
)
{
EFI_STATUS Status;
EFI_STANDARD_TEST_LIBRARY_PROTOCOL *StandardLib;
EFI_TEST_ASSERTION AssertionType;
UINT8 *AllocatedBuffer;
EFI_CAPSULE_HEADER *CapsuleHeaderArray[2];
//
// Get the Standard Library Interface
//
Status = gtBS->HandleProtocol (
SupportHandle,
&gEfiStandardTestLibraryGuid,
&StandardLib
);
if (EFI_ERROR(Status)) {
return Status;
}
if (FALSE == CheckBBTestCanRunAndRecordAssertion (
StandardLib,
L"RT.UpdateCapsule_Conf- UpdateCapsule_Conf it's not Supported in EFI",
__FILE__,
(UINTN)__LINE__
)) {
return EFI_SUCCESS;
}
AllocatedBuffer = (UINT8 *)AllocatePool (sizeof(EFI_CAPSULE_HEADER));
if (EFI_ERROR(Status)) {
StandardLib->RecordAssertion (
StandardLib,
EFI_TEST_ASSERTION_FAILED,
gTestGenericFailureGuid,
L"RT.UpdateCapsule_conf - Allocate pages for EFI_CAPSULE_HEADER",
L"%a:%d,Status - %r",
__FILE__,
(UINTN)__LINE__,
Status
);
return Status;
}
CapsuleHeaderArray[0] = (EFI_CAPSULE_HEADER *) (UINTN)AllocatedBuffer;
CapsuleHeaderArray[0]->CapsuleGuid = mEfiCapsuleHeaderGuid;
CapsuleHeaderArray[0]->HeaderSize = sizeof(EFI_CAPSULE_HEADER);
CapsuleHeaderArray[0]->CapsuleImageSize = sizeof(EFI_CAPSULE_HEADER);
CapsuleHeaderArray[1] = NULL;
CapsuleHeaderArray[0]->Flags = CAPSULE_FLAGS_PERSIST_ACROSS_RESET;
// When CapsuleCount is 0, the return status code should be EFI_INVALID_PARAMETER
Status = gtRT->UpdateCapsule(
CapsuleHeaderArray,
0, // invaild
(EFI_PHYSICAL_ADDRESS ) 0
);
if (Status == EFI_INVALID_PARAMETER) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gMiscRuntimeServicesBBTestConformanceAssertionGuid001,
L"RT.UpdateCapsule - invoke UpdateCapsule with invalid CapsuleCount - 0",
L"%a:%d:Status - %r",
__FILE__,
__LINE__,
Status
);
//
// when the flag is CAPSULE_FLAGS_PERSIST_ACROSS_RESET, ScatterGatherList can't be NULL.
//
CapsuleHeaderArray[0] = (EFI_CAPSULE_HEADER *) (UINTN)AllocatedBuffer;
CapsuleHeaderArray[0]->CapsuleGuid = mEfiCapsuleHeaderGuid;
CapsuleHeaderArray[0]->HeaderSize = sizeof(EFI_CAPSULE_HEADER);
CapsuleHeaderArray[0]->CapsuleImageSize = sizeof(EFI_CAPSULE_HEADER);
CapsuleHeaderArray[1] = NULL;
CapsuleHeaderArray[0]->Flags = CAPSULE_FLAGS_PERSIST_ACROSS_RESET | CAPSULE_FLAGS_POPULATE_SYSTEM_TABLE;
Status = gtRT->UpdateCapsule(
CapsuleHeaderArray,
1,
(EFI_PHYSICAL_ADDRESS ) 0
);
if (Status == EFI_INVALID_PARAMETER) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gMiscRuntimeServicesBBTestConformanceAssertionGuid002,
L"RT.UpdateCapsule - invoke UpdateCapsule with invalid ScatterGatherList",
L"%a:%d:Status - %r",
__FILE__,
__LINE__,
Status
);
//
// A capsule which has the CAPSULE_FLAGS_POPULATE_SYSTEM_TABLE flag must have
// CAPSULE_FLAGS_PERSIST_ACROSS_RESET set in its header as well.
//
CapsuleHeaderArray[0] = (EFI_CAPSULE_HEADER *) (UINTN)AllocatedBuffer;
CapsuleHeaderArray[0]->CapsuleGuid = mEfiCapsuleHeaderGuid;
CapsuleHeaderArray[0]->HeaderSize = sizeof(EFI_CAPSULE_HEADER);
CapsuleHeaderArray[0]->CapsuleImageSize = sizeof(EFI_CAPSULE_HEADER);
CapsuleHeaderArray[1] = NULL;
CapsuleHeaderArray[0]->Flags = CAPSULE_FLAGS_POPULATE_SYSTEM_TABLE;
Status = gtRT->UpdateCapsule(
CapsuleHeaderArray,
1,
(EFI_PHYSICAL_ADDRESS ) 0
);
if (Status == EFI_INVALID_PARAMETER) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gMiscRuntimeServicesBBTestConformanceAssertionGuid003,
L"RT.UpdateCapsule - invoke UpdateCapsule with invalid Flags",
L"%a:%d:Status - %r",
__FILE__,
(UINTN)__LINE__,
Status
);
//
// A capsule which has the CAPSULE_FLAGS_INITIATE_RESET Flag must have
// CAPSULE_FLAGS_PERSIST_ACROSS_RESET set in its header as well.
//
CapsuleHeaderArray[0] = (EFI_CAPSULE_HEADER *) (UINTN)AllocatedBuffer;
CapsuleHeaderArray[0]->CapsuleGuid = mEfiCapsuleHeaderGuid;
CapsuleHeaderArray[0]->HeaderSize = sizeof(EFI_CAPSULE_HEADER);
CapsuleHeaderArray[0]->CapsuleImageSize = sizeof(EFI_CAPSULE_HEADER);
CapsuleHeaderArray[1] = NULL;
CapsuleHeaderArray[0]->Flags = CAPSULE_FLAGS_INITIATE_RESET;
Status = gtRT->UpdateCapsule(
CapsuleHeaderArray,
1,
(EFI_PHYSICAL_ADDRESS ) 0
);
if (Status == EFI_INVALID_PARAMETER) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gMiscRuntimeServicesBBTestConformanceAssertionGuid005,
L"RT.UpdateCapsule - invoke UpdateCapsule with invalid Flags",
L"%a:%d:Status - %r",
__FILE__,
(UINTN)__LINE__,
Status
);
FreePool(AllocatedBuffer);
return EFI_SUCCESS;
}
//
// TDS 4.3
//
EFI_STATUS
BBTestGetTargetLunConformanceAutoTest (
IN EFI_BB_TEST_PROTOCOL *This,
IN VOID *ClientInterface,
IN EFI_TEST_LEVEL TestLevel,
IN EFI_HANDLE SupportHandle
)
{
EFI_STANDARD_TEST_LIBRARY_PROTOCOL *StandardLib;
EFI_STATUS Status;
EFI_SCSI_PASS_THRU_PROTOCOL *ScsiPassThru;
EFI_TEST_ASSERTION AssertionType;
UINT32 Target;
UINT64 Lun;
EFI_DEVICE_PATH_PROTOCOL *DevicePath;
//
// 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;
}
ScsiPassThru = (EFI_SCSI_PASS_THRU_PROTOCOL *)ClientInterface;
//
// Assertion Point 4.3.2.1
// Call GetTargetLun()with NULL DevicePath, NULL Target and NULL Lun.
//
Status = GetScsiDevice (ScsiPassThru, &Target, &Lun);
if (EFI_ERROR(Status)) {
StandardLib->RecordAssertion (
StandardLib,
EFI_TEST_ASSERTION_FAILED,
gTestGenericFailureGuid,
L"Can't Get any Scsi Device",
L"%a:%d:Status - %r",
__FILE__,
__LINE__,
Status
);
return EFI_UNSUPPORTED;
}
//
// Get the valid Device Path Node.
//
Status = ScsiPassThru->BuildDevicePath (ScsiPassThru, Target, Lun, &DevicePath);
if (EFI_ERROR(Status)) {
StandardLib->RecordAssertion (
StandardLib,
EFI_TEST_ASSERTION_FAILED,
gTestGenericFailureGuid,
L"EFI_SCSI_PASS_THRU_PROTOCOL.BuildDevicePath",
L"%a:%d:Status - %r, Target - %d, Lun - %ld",
__FILE__,
__LINE__,
Status,
Target,
Lun
);
return EFI_UNSUPPORTED;
}
//
// Check Point 1. NULL Device Path.
//
Status = ScsiPassThru->GetTargetLun (ScsiPassThru, NULL, &Target, &Lun);
if (Status == EFI_INVALID_PARAMETER) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gScsiPassThruBBTestConformanceAssertionGuid007,
L"EFI_SCSI_PASS_THRU_PROTOCOL.GetTargetLun - Invoke GetTargetLun() with NULL Device Path",
L"%a:%d:Status - %r",
__FILE__,
__LINE__,
Status
);
//
// Check Point 2. NULL Target.
//
Status = ScsiPassThru->GetTargetLun (ScsiPassThru, DevicePath, NULL, &Lun);
if (Status == EFI_INVALID_PARAMETER) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gScsiPassThruBBTestConformanceAssertionGuid008,
L"EFI_SCSI_PASS_THRU_PROTOCOL.GetTargetLun - Invoke GetTargetLun() with NULL Target",
L"%a:%d:Status - %r",
__FILE__,
__LINE__,
Status
);
//
// Check Point 3. NULL Lun.
//
Status = ScsiPassThru->GetTargetLun (ScsiPassThru, DevicePath, &Target, NULL);
if (Status == EFI_INVALID_PARAMETER) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gScsiPassThruBBTestConformanceAssertionGuid009,
L"EFI_SCSI_PASS_THRU_PROTOCOL.GetTargetLun - Invoke GetTargetLun() with NULL Lun",
L"%a:%d:Status - %r",
__FILE__,
__LINE__,
Status
);
//
// Assertion Point 4.3.2.2
// Call GetTargetLun()with unsupported DevicePath.
//
//
// Set the Device Path to Non Scsi Device Path.
//
DevicePath->Type = 5;
DevicePath->SubType = 1;
Status = ScsiPassThru->GetTargetLun (ScsiPassThru, DevicePath, &Target, &Lun);
if (Status == EFI_UNSUPPORTED) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
//Free the DevicePath.
gtBS->FreePool (DevicePath);
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gScsiPassThruBBTestConformanceAssertionGuid010,
L"EFI_SCSI_PASS_THRU_PROTOCOL.GetTargetLun - Invoke GetTargetLun() with unsupported Device Path",
L"%a:%d:Status - %r",
__FILE__,
__LINE__,
Status
);
return EFI_SUCCESS;
}
//
// TDS 5.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_BLOCK_IO_PROTOCOL *BlockIo;
EFI_TEST_ASSERTION AssertionType;
//
// 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;
//
// Assertion Point 5.1.2.1
// Reset must succeed to reset the block device hardware with extended verification
//
Status = BlockIo->Reset (BlockIo, TRUE);
if (EFI_ERROR(Status)) {
AssertionType = EFI_TEST_ASSERTION_FAILED;
} else {
AssertionType = EFI_TEST_ASSERTION_PASSED;
}
//
// Sometimes the file system will be destroied from this point. Just add a
// stall to avoid it. (Need investigation, I don't know it is useful or not!)
//
Print (L"Wait 5 seconds for the block device resetting...");
gtBS->Stall (5000000);
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gBlockIoFunctionTestAssertionGuid001,
L"EFI_BLOCK_IO_PROTOCOL.Reset - Reset the block device with extended verification",
L"%a:%d:Status=%r",
__FILE__,
__LINE__,
Status
);
//
// Assertion Point 5.1.2.2
// Reset must succeed to reset the block device hardware without extended verification
//
Status = BlockIo->Reset (BlockIo, FALSE);
if (EFI_ERROR(Status)) {
AssertionType = EFI_TEST_ASSERTION_FAILED;
} else {
AssertionType = EFI_TEST_ASSERTION_PASSED;
}
//
// Sometimes the file system will be destroied from this point. Just add a
// stall to avoid it. (Need investigation, I don't know it is useful or not!)
//
Print (L"Wait 5 seconds for the block device resetting...");
gtBS->Stall (5000000);
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gBlockIoFunctionTestAssertionGuid002,
L"EFI_BLOCK_IO_PROTOCOL.Reset - Reset the block device without extended verification",
L"%a:%d:Status=%r",
__FILE__,
__LINE__,
Status
);
return EFI_SUCCESS;
}
