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