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