/**
* TDS 5.2 - Entry point for Variable Overflow Stress Test.
* @param This A pointer to the EFI_BB_TEST_PROTOCOL instance.
* @param ClientInterface A pointer to the interface to be tested.
* @param TestLevel Test "thoroughness" control.
* @param SupportHandle A handle containing support protocols.
* @return EFI_SUCCESS Successfully.
* @return Other value Something failed.
*/
EFI_STATUS
OverflowStressTest (
IN EFI_BB_TEST_PROTOCOL *This,
IN VOID *ClientInterface,
IN EFI_TEST_LEVEL TestLevel,
IN EFI_HANDLE SupportHandle
)
{
EFI_STATUS Status;
EFI_RUNTIME_SERVICES *RT;
EFI_STANDARD_TEST_LIBRARY_PROTOCOL *StandardLib;
EFI_TEST_RECOVERY_LIBRARY_PROTOCOL *RecoveryLib;
EFI_TEST_LOGGING_LIBRARY_PROTOCOL *LoggingLib;
UINTN RecoveryDataSize;
UINT8 *RecoveryData;
//
// Get test support library interfaces
//
Status = GetTestSupportLibrary (
SupportHandle,
&StandardLib,
&RecoveryLib,
&LoggingLib
);
if (EFI_ERROR(Status)) {
return Status;
}
RT = (EFI_RUNTIME_SERVICES *)ClientInterface;
//
// 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 2:
goto step2;
default:
goto step3;
}
}
//
// Reclaim test with system reset
//
step2:
Status = OverflowStressTestSub1 (RT, StandardLib, RecoveryLib, LoggingLib);
//
// Free resources
//
step3:
gtBS->FreePool (RecoveryData);
//
// Done
//
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 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 5.2
//
EFI_STATUS
BBTestResetSystemManualStressTest (
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;
UINT32 RepeatTimes;
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;
RepeatTimes = ResetData->RepeatTimes;
AssertionType = EFI_TEST_ASSERTION_PASSED;
goto ManualStressTestStep2;
}
} else {
return EFI_LOAD_ERROR;
}
for (Index = 0; Index < TPL_ARRAY_SIZE; Index++) {
//
// 5.2.2.1 Stress test for ResetSystem when ResetType is EfiResetShutdown
//
for (RepeatTimes = 0; RepeatTimes < MAX_REPEAT_TIMES; RepeatTimes++) {
ResetData->Step = 1;
ResetData->TplIndex = Index;
ResetData->RepeatTimes = RepeatTimes;
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 shut down (or cold reset) after 1 second...");
gtBS->Stall (1000000);
OldTpl = gtBS->RaiseTPL (TplArray[Index]);
gtRT->ResetSystem (
EfiResetShutdown,
EFI_SUCCESS,
0,
NULL
);
gtBS->RestoreTPL (OldTpl);
AssertionType = EFI_TEST_ASSERTION_FAILED;
ManualStressTestStep2:
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gMiscRuntimeServicesCombinationTestAssertionGuid007,
L"RT.ResetSystem - Stress EfiResetShutdown",
L"%a:%d:Status - %r, TPL - %d, Times - %d",
__FILE__,
__LINE__,
Status,
TplArray[Index],
RepeatTimes
);
}
}
return EFI_SUCCESS;
}
//
// TDS 5.5
//
EFI_STATUS
BBTestGetNextMonotonicCountStressTest (
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;
UINT64 RepeatTimes;
EFI_TPL OldTpl;
UINT64 Count;
UINT64 OldCount;
UINT8 ResetBuffer[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,
ResetBuffer
);
ResetData = (RESET_DATA *)&ResetBuffer;
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;
OldCount = ResetData->Count;
goto StressTestStep2;
}
} else {
return EFI_LOAD_ERROR;
}
for (Index = 0; Index < TPL_ARRAY_SIZE; Index++) {
//
// 5.5.2.1 Stress test for GetNextMonotonicCount.
//
OldTpl = gtBS->RaiseTPL (TplArray[Index]);
Status = gtBS->GetNextMonotonicCount (
&OldCount
);
gtBS->RestoreTPL (OldTpl);
if (Status == EFI_SUCCESS) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gMiscBootServicesCombinationTestAssertionGuid007,
L"BS.GetNextMonotonicCount - get current count",
L"%a:%d:Status - %r, TPL - %d",
__FILE__,
__LINE__,
Status,
TplArray[Index]
);
for (RepeatTimes = 0; RepeatTimes < MAX_REPEAT_TIMES; RepeatTimes++) {
OldTpl = gtBS->RaiseTPL (TplArray[Index]);
Status = gtBS->GetNextMonotonicCount (
&Count
);
gtBS->RestoreTPL (OldTpl);
if (Status == EFI_SUCCESS) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gMiscBootServicesCombinationTestAssertionGuid008,
L"BS.GetNextMonotonicCount - get next count",
L"%a:%d:Status - %r, TPL - %d, Times - %d",
__FILE__,
__LINE__,
Status,
TplArray[Index],
RepeatTimes
);
if (Count == OldCount + 1) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gMiscBootServicesCombinationTestAssertionGuid009,
L"BS.GetNextMonotonicCount - Count == OldCount + 1",
L"%a:%d:Status - %r, TPL - %d, Count - %lx, OldCount - %lx, Times - %d",
__FILE__,
__LINE__,
Status,
TplArray[Index],
Count,
OldCount,
RepeatTimes
);
OldCount = Count;
}
//
// save the high 32 bit and reset system
//
ResetData->Step = 1;
ResetData->TplIndex = Index;
ResetData->Count = OldCount;
Status = RecoveryLib->WriteResetRecord (
RecoveryLib,
sizeof (RESET_DATA),
ResetBuffer
);
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);
gtRT->ResetSystem (EfiResetCold, EFI_SUCCESS, 0, NULL);
StressTestStep2:
OldTpl = gtBS->RaiseTPL (TplArray[Index]);
Status = gtBS->GetNextMonotonicCount (
&Count
);
gtBS->RestoreTPL (OldTpl);
if (Status == EFI_SUCCESS) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gMiscBootServicesCombinationTestAssertionGuid010,
L"BS.GetNextMonotonicCount - get count after reset",
L"%a:%d:Status - %r, TPL - %d",
__FILE__,
__LINE__,
Status,
TplArray[Index]
);
if (RShiftU64 (Count, 32) == RShiftU64 (OldCount, 32) + 1) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gMiscBootServicesCombinationTestAssertionGuid012,
L"BS.GetNextMonotonicCount - high 32 bit increase by 1",
L"%a:%d:OldCount - %lx, Count - %lx, TPL - %d",
__FILE__,
__LINE__,
OldCount,
Count,
TplArray[Index]
);
}
return EFI_SUCCESS;
}
