/**
* TDS 5.1 - Entry point for GetVariable() and SetVariable() 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
MultipleStressTest (
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;
//
// Get test support library interfaces
//
Status = GetTestSupportLibrary (
SupportHandle,
&StandardLib,
&RecoveryLib,
&LoggingLib
);
if (EFI_ERROR(Status)) {
return Status;
}
RT = (EFI_RUNTIME_SERVICES *)ClientInterface;
//
// Stress test for GetVariable
//
Status = MultipleStressTestSub1 (RT, StandardLib, LoggingLib);
//
// Stress test for GetNextVariableName
//
Status = MultipleStressTestSub2 (RT, StandardLib, LoggingLib);
//
// Stress test for SetVariable
//
Status = MultipleStressTestSub3 (RT, StandardLib, LoggingLib);
//
// Done
//
return EFI_SUCCESS;
}
/**
* 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.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 4.1.1
//
EFI_STATUS
GetInfo_Func (
IN EFI_BB_TEST_PROTOCOL *This,
IN VOID *ClientInterface,
IN EFI_TEST_LEVEL TestLevel,
IN EFI_HANDLE SupportHandle
)
{
EFI_STATUS Status;
EFI_DECOMPRESS_PROTOCOL *Decompress;
EFI_STANDARD_TEST_LIBRARY_PROTOCOL *StandardLib;
EFI_TEST_PROFILE_LIBRARY_PROTOCOL *ProfileLib;
UINT32 UncompressedFileSize;
UINT32 CompressedFileSize;
UINT32 DestinationSize;
UINT32 SecondTimeSize;
UINT32 ScratchSize;
UINT32 ScratchSizeOrg;
UINTN Index;
VOID *Buffer;
UINTN BufferSize;
EFI_TEST_ASSERTION AssertionType;
EFI_INI_FILE_HANDLE FileHandle;
EFI_FILE_HANDLE CompressedFHandle;
UINTN MaxOrder;
CHAR16 *FileName;
//
//get tested interface.
//
Decompress = (EFI_DECOMPRESS_PROTOCOL *)ClientInterface;
//
// Get the test Supported Library Interface
//
Status = GetTestSupportLibrary (
SupportHandle,
&StandardLib,
&ProfileLib
);
if (EFI_ERROR(Status)) {
return Status;
}
//
// Get the system device path and file path
//
Status = GetSystemData (ProfileLib);
if (EFI_ERROR(Status)) {
return Status;
}
//
//open the ini file.
//
Status = OpenTestIniFile (ProfileLib, &FileHandle);
if (EFI_ERROR(Status)) {
StandardLib->RecordAssertion (
StandardLib,
EFI_TEST_ASSERTION_WARNING,
gTestGenericFailureGuid,
L"EFI_DECOMPRESS_PROTOCOL.GetInfo() -no item found for this test case.",
L"%a:%d:Status - %r",
__FILE__,
__LINE__,
Status
);
return Status;
}
//
//we initialize this variable because it was taken as UINT32 type, in fact it
//is UINT64 value in ipf platform.
//
MaxOrder = 0;
Status = FileHandle->GetOrderNum (
FileHandle,
SECTION_NAME_GETINFO_BASIC_TEST,
(UINT32 *)&MaxOrder
);
if (EFI_ERROR(Status)) {
StandardLib->RecordAssertion (
StandardLib,
EFI_TEST_ASSERTION_WARNING,
gTestGenericFailureGuid,
L"EFI_DECOMPRESS_PROTOCOL.GetInfo() -no item found for this test case",
L"%a:%d:Status - %r",
__FILE__,
__LINE__,
Status
);
CloseTestIniFile (ProfileLib, FileHandle);
return Status;
}
for (Index = 0; Index < MaxOrder; Index++) {
//
//get compressed FileName and Uncompressed File Size.
//
Status = GetUncompressedFileSize (
FileHandle,
SECTION_NAME_GETINFO_BASIC_TEST,
Index,
&UncompressedFileSize
);
if (EFI_ERROR(Status)) {
continue;
}
Status = GetCompressedFileName (
FileHandle,
SECTION_NAME_GETINFO_BASIC_TEST,
Index,
&FileName
);
if (EFI_ERROR(Status)) {
continue;
}
//
//read the Compressed file into memory.
//
Status = OpenFileAndGetSize (
FileName,
&CompressedFHandle,
&CompressedFileSize
);
if (EFI_ERROR(Status)) {
Print (L"Can not open the File :%s\r\n", FileName);
gtBS->FreePool (FileName);
continue;
}
gtBS->FreePool (FileName);
Buffer = AllocatePool (CompressedFileSize);
if (Buffer == NULL) {
CompressedFHandle->Close (CompressedFHandle);
Print (L"Can not allocate %xh buffer.\r\n", CompressedFileSize);
continue;
}
BufferSize = CompressedFileSize;
Status = CompressedFHandle->Read (
CompressedFHandle,
&BufferSize,
Buffer
);
if (EFI_ERROR(Status)) {
CompressedFHandle->Close (CompressedFHandle);
Print (L"File Read Error Status %r\r\n", Status);
gtBS->FreePool (Buffer);
continue;
}
//
//now verify the check points.
//
Status = Decompress->GetInfo (
Decompress,
Buffer,
CompressedFileSize,
&DestinationSize,
&ScratchSize
);
if (Status == EFI_SUCCESS) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
//
//record assertion
//
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gDecompressBBTestFunctionAssertionGuid001,
L"EFI_DECOMPRESS_PROTOCOL.GetInfo() - return Status should be EFI_SUCCESS",
L"%a:%d:Status - %r",
__FILE__,
__LINE__,
Status
);
if (DestinationSize == UncompressedFileSize) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
//
//record assertion
//
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gDecompressBBTestFunctionAssertionGuid002,
L"EFI_DECOMPRESS_PROTOCOL.GetInfo() - the Destination Size should be equal with the Uncompressed File Size",
L"%a:%d:Destination Size - %d, Uncompressed File Size - %d",
__FILE__,
__LINE__,
(UINT32)DestinationSize,
(UINT32)UncompressedFileSize
);
//
//call GetInfo again see if the returned value is the same.
//
ScratchSizeOrg = ScratchSize;
Status = Decompress->GetInfo (
Decompress,
Buffer,
CompressedFileSize,
&SecondTimeSize,
&ScratchSize
);
if (Status == EFI_SUCCESS) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
//
//record assertion
//
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gDecompressBBTestFunctionAssertionGuid003,
L"EFI_DECOMPRESS_PROTOCOL.GetInfo() - call the second time, return Status should be EFI_SUCCESS",
L"%a:%d:Status - %r",
__FILE__,
__LINE__,
Status
);
if (SecondTimeSize == DestinationSize) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
//
//record assertion
//
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gDecompressBBTestFunctionAssertionGuid004,
L"EFI_DECOMPRESS_PROTOCOL.GetInfo() - two time returned Destination size must be equal",
L"%a:%d:First Time - %08x, Second Time- %08x",
__FILE__,
__LINE__,
DestinationSize,
SecondTimeSize
);
if (ScratchSize == ScratchSizeOrg) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
//
//record assertion
//
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gDecompressBBTestFunctionAssertionGuid005,
L"EFI_DECOMPRESS_PROTOCOL.GetInfo() - two time returned Scratch size must be equal",
L"%a:%d:First Time - %08x, Second Time- %08x",
__FILE__,
__LINE__,
ScratchSizeOrg,
ScratchSize
);
//
//free the resources
//
gtBS->FreePool (Buffer);
CompressedFHandle->Close (CompressedFHandle);
}
CloseTestIniFile (ProfileLib, FileHandle);
//
//done successfully
//
return EFI_SUCCESS;
}
//
//TDS 4.1.2
//
EFI_STATUS
Decompress_Func (
IN EFI_BB_TEST_PROTOCOL *This,
IN VOID *ClientInterface,
IN EFI_TEST_LEVEL TestLevel,
IN EFI_HANDLE SupportHandle
)
{
EFI_STATUS Status;
EFI_DECOMPRESS_PROTOCOL *Decompress;
EFI_STANDARD_TEST_LIBRARY_PROTOCOL *StandardLib;
EFI_TEST_PROFILE_LIBRARY_PROTOCOL *ProfileLib;
UINT32 UncompressedFileSize;
UINT32 CompressedFileSize;
UINT32 DestinationSize;
UINT32 ScratchSize;
UINTN Index;
UINTN SubIndex;
VOID *CompressedFileBuffer;
VOID *UncompressedFileBuffer;
UINT8 *DecompressBuffer;
VOID *ScratchBuffer;
UINTN BufferSize;
EFI_TEST_ASSERTION AssertionType;
EFI_INI_FILE_HANDLE FileHandle;
EFI_FILE_HANDLE CompressedFHandle;
EFI_FILE_HANDLE UncompressedFHandle;
UINTN MaxOrder;
CHAR16 *CompressedFileName;
CHAR16 *UncompressedFileName;
//
//get tested interface.
//
Decompress = (EFI_DECOMPRESS_PROTOCOL *)ClientInterface;
//
// Get the test Supported Library Interface
//
Status = GetTestSupportLibrary (
SupportHandle,
&StandardLib,
&ProfileLib
);
if (EFI_ERROR(Status)) {
return Status;
}
//
// Get the system device path and file path
//
Status = GetSystemData (ProfileLib);
if (EFI_ERROR(Status)) {
return Status;
}
//
//open the ini file.
//
Status = OpenTestIniFile (ProfileLib, &FileHandle);
if (EFI_ERROR(Status)) {
StandardLib->RecordAssertion (
StandardLib,
EFI_TEST_ASSERTION_WARNING,
gTestGenericFailureGuid,
L"EFI_DECOMPRESS_PROTOCOL.Decompress() -not found the profile.",
L"%a:%d:Status - %r",
__FILE__,
__LINE__,
Status
);
return Status;
}
//
//we initialize this variable because it was taken as UINT32 type, in fact it
//is UINT64 value in ipf platform.
//
MaxOrder = 0;
Status = FileHandle->GetOrderNum (
FileHandle,
SECTION_NAME_DECOMPRESS_BASIC_TEST,
(UINT32 *)&MaxOrder
);
if (EFI_ERROR(Status)) {
CloseTestIniFile (ProfileLib, FileHandle);
StandardLib->RecordAssertion (
StandardLib,
EFI_TEST_ASSERTION_WARNING,
gTestGenericFailureGuid,
L"EFI_DECOMPRESS_PROTOCOL.Decompress() -no item found for this test case.",
L"%a:%d:Status - %r",
__FILE__,
__LINE__,
Status
);
return Status;
}
for (Index = 0; Index < MaxOrder; Index++) {
CompressedFileBuffer = NULL;
UncompressedFileBuffer = NULL;
DecompressBuffer = NULL;
ScratchBuffer = NULL;
//
//get compressed FileName and file size.
//
Status = GetCompressedFileName (
FileHandle,
SECTION_NAME_DECOMPRESS_BASIC_TEST,
Index,
&CompressedFileName
);
if (EFI_ERROR(Status)) {
Print (L"Get CompressedFileName Error\r\n");
continue;
}
Status = GetUncompressedFileName (
FileHandle,
SECTION_NAME_DECOMPRESS_BASIC_TEST,
Index,
&UncompressedFileName
);
if (EFI_ERROR(Status)) {
gtBS->FreePool (CompressedFileName);
Print (L"Get UncompressedFileName Error\r\n");
continue;
}
//
//Open the Compressed file and get file size.
//
Status = OpenFileAndGetSize (
CompressedFileName,
&CompressedFHandle,
&CompressedFileSize
);
if (EFI_ERROR(Status)) {
Print (L"Can not open the File :%s\r\n", CompressedFileName);
gtBS->FreePool (CompressedFileName);
gtBS->FreePool (UncompressedFileName);
continue;
}
gtBS->FreePool (CompressedFileName);
//
//Open the Uncompressed file and get file size.
//
Status = OpenFileAndGetSize (
UncompressedFileName,
&UncompressedFHandle,
&UncompressedFileSize
);
if (EFI_ERROR(Status)) {
Print (L"Can not open the File :%s\r\n", UncompressedFileName);
CompressedFHandle->Close (CompressedFHandle);
gtBS->FreePool (UncompressedFileName);
continue;
}
gtBS->FreePool (UncompressedFileName);
//
//then read the Compressed File into memory.
//
CompressedFileBuffer = AllocatePool (CompressedFileSize);
if (CompressedFileBuffer == NULL) {
CompressedFHandle->Close (CompressedFHandle);
UncompressedFHandle->Close (UncompressedFHandle);
Print (L"Can not allocate %xh buffer.\r\n", CompressedFileSize);
continue;
}
BufferSize = CompressedFileSize;
Status = CompressedFHandle->Read (
CompressedFHandle,
&BufferSize,
CompressedFileBuffer
);
CompressedFHandle->Close (CompressedFHandle);
if (EFI_ERROR(Status)) {
UncompressedFHandle->Close (UncompressedFHandle);
Print (L"File Read Error Status %r\r\n", Status);
gtBS->FreePool (CompressedFileBuffer);
continue;
}
if (UncompressedFileSize == 0) {
UncompressedFHandle->Close (UncompressedFHandle);
Status = Decompress->GetInfo (
Decompress,
CompressedFileBuffer,
CompressedFileSize,
&DestinationSize,
&ScratchSize
);
if (Status == EFI_SUCCESS) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gTestGenericFailureGuid,
L"EFI_DECOMPRESS_PROTOCOL.GetInfo() - return Status Should be EFI_SUCCESS",
L"%a:%d:Status - %r",
__FILE__,
__LINE__,
Status
);
if (DestinationSize == 0) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gTestGenericFailureGuid,
L"EFI_DECOMPRESS_PROTOCOL.GetInfo() - the Destination Size should be equal with the Uncompressed File Size",
L"%a:%d:destination Size - %d, Uncompressed File Size - %d",
__FILE__,
__LINE__,
(UINT32)DestinationSize,
(UINT32)UncompressedFileSize
);
//
// Fill the buffer with 0x00, and check whether the buffer is changed later
//
DecompressBuffer = AllocateZeroPool (128);
if (DecompressBuffer == NULL) {
gtBS->FreePool (CompressedFileBuffer);
Print (L"Can not allocate %xh buffer.\r\n", 128);
continue;
}
ScratchBuffer = AllocatePool (ScratchSize);
if (ScratchBuffer == NULL) {
gtBS->FreePool (CompressedFileBuffer);
gtBS->FreePool (DecompressBuffer);
Print (L"Can not allocate %xh buffer.\r\n", ScratchSize);
continue;
}
Status = Decompress->Decompress (
Decompress,
CompressedFileBuffer,
CompressedFileSize,
DecompressBuffer,
DestinationSize,
ScratchBuffer,
ScratchSize
);
if (!EFI_ERROR(Status)) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
//
//record assertion
//
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gDecompressBBTestFunctionAssertionGuid007,
L"EFI_DECOMPRESS_PROTOCOL.Decompess() - decompress zero file, return Status should be EFI_SUCCESS",
L"%a:%d:Status - %r",
__FILE__,
__LINE__,
Status
);
AssertionType = EFI_TEST_ASSERTION_PASSED;
//
// Check whether the buffer is changed
//
for (SubIndex = 0; SubIndex < 128; SubIndex++) {
if (DecompressBuffer[SubIndex] != (UINT8)0x00) {
AssertionType = EFI_TEST_ASSERTION_FAILED;
break;
}
}
SubIndex = (SubIndex < 127) ? SubIndex : 127;
//
//record assertion
//
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gDecompressBBTestFunctionAssertionGuid008,
L"EFI_DECOMPRESS_PROTOCOL.Decompess() - Decompressed zero length file, the buffer should not be modified",
L"%a:%d:buffer - 0x%02x, expected - 0x00",
__FILE__,
__LINE__,
DecompressBuffer[SubIndex]
);
//
// Fill the buffer with 0xff, and check whether the buffer is changed later
//
for (SubIndex = 0; SubIndex < 128; SubIndex++) {
DecompressBuffer[SubIndex] = (UINT8)0xff;
}
Status = Decompress->Decompress (
Decompress,
CompressedFileBuffer,
CompressedFileSize,
DecompressBuffer,
DestinationSize,
ScratchBuffer,
ScratchSize
);
if (!EFI_ERROR(Status)) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
//
//record assertion
//
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gDecompressBBTestFunctionAssertionGuid007,
L"EFI_DECOMPRESS_PROTOCOL.Decompess() - decompress zero file, return Status should be EFI_SUCCESS",
L"%a:%d:Status - %r",
__FILE__,
__LINE__,
Status
);
AssertionType = EFI_TEST_ASSERTION_PASSED;
//
// Check whether the buffer is changed
//
for (SubIndex = 0; SubIndex < 128; SubIndex++) {
if (DecompressBuffer[SubIndex] != (UINT8)0xff) {
AssertionType = EFI_TEST_ASSERTION_FAILED;
break;
}
}
SubIndex = (SubIndex < 127) ? SubIndex : 127;
//
//record assertion
//
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gDecompressBBTestFunctionAssertionGuid008,
L"EFI_DECOMPRESS_PROTOCOL.Decompess() - Decompressed zero length file, the buffer should not be modified",
L"%a:%d:buffer - 0x%02x, expected - 0xff",
__FILE__,
__LINE__,
DecompressBuffer[SubIndex]
);
//
//free the resources.
//
gtBS->FreePool (CompressedFileBuffer);
gtBS->FreePool (DecompressBuffer);
gtBS->FreePool (ScratchBuffer);
continue;
}
//
//the Uncompressed file is not null so read it into memory.
//
UncompressedFileBuffer = AllocatePool (UncompressedFileSize);
if (UncompressedFileBuffer == NULL) {
UncompressedFHandle->Close (UncompressedFHandle);
gtBS->FreePool (CompressedFileBuffer);
Print (L"Can not alloate %xh buffer.\r\n", UncompressedFileSize);
continue;
}
BufferSize = UncompressedFileSize;
Status = UncompressedFHandle->Read (
UncompressedFHandle,
&BufferSize,
UncompressedFileBuffer
);
UncompressedFHandle->Close (UncompressedFHandle);
if (EFI_ERROR(Status)) {
gtBS->FreePool (CompressedFileBuffer);
gtBS->FreePool (UncompressedFileBuffer);
Print (L"File Read Error Status %r\r\n", Status);
continue;
}
//
//now verify the check points.
//
Status = Decompress->GetInfo (
Decompress,
CompressedFileBuffer,
CompressedFileSize,
&DestinationSize,
&ScratchSize
);
if (Status == EFI_SUCCESS) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gTestGenericFailureGuid,
L"EFI_DECOMPRESS_PROTOCOL.GetInfo() - return Status should be EFI_SUCCESS",
L"%a:%d:Status - %r",
__FILE__,
__LINE__,
Status
);
if (DestinationSize == UncompressedFileSize) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gTestGenericFailureGuid,
L"EFI_DECOMPRESS_PROTOCOL.GetInfo() - the Destination Size should be equal with the Uncompressed File Size",
L"%a:%d:destination Size - %d, Uncompressed File Size - %d",
__FILE__,
__LINE__,
(UINT32)DestinationSize,
(UINT32)UncompressedFileSize
);
//
//allocate Decompess buffer and Decompress the compessed data.
//
DecompressBuffer = AllocatePool (DestinationSize);
if (DecompressBuffer == NULL) {
gtBS->FreePool (CompressedFileBuffer);
gtBS->FreePool (UncompressedFileBuffer);
Print (L"Can not allocate %xh buffer.\r\n", DestinationSize);
continue;
}
ScratchBuffer = AllocatePool (ScratchSize);
if (ScratchBuffer == NULL) {
gtBS->FreePool (CompressedFileBuffer);
gtBS->FreePool (UncompressedFileBuffer);
gtBS->FreePool (DecompressBuffer);
Print (L"Can not allocate %xh buffer.\r\n", ScratchSize);
continue;
}
Status = Decompress->Decompress (
Decompress,
CompressedFileBuffer,
CompressedFileSize,
DecompressBuffer,
DestinationSize,
ScratchBuffer,
ScratchSize
);
if (!EFI_ERROR(Status)) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
//
//record assertion
//
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gDecompressBBTestFunctionAssertionGuid009,
L"EFI_DECOMPRESS_PROTOCOL.Decompess() - decompress unzero file, return Status should be EFI_SUCCESS",
L"%a:%d:Status - %r",
__FILE__,
__LINE__,
Status
);
if (CompareMem (DecompressBuffer,
UncompressedFileBuffer, UncompressedFileSize) == 0) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
//
//record assertion
//
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gDecompressBBTestFunctionAssertionGuid010,
L"EFI_DECOMPRESS_PROTOCOL.Decompess() - Decompressed data should be equal with Uncompressed data",
L"%a:%d",
__FILE__,
__LINE__
);
//
//free the resources
//
gtBS->FreePool (CompressedFileBuffer);
gtBS->FreePool (UncompressedFileBuffer);
gtBS->FreePool (DecompressBuffer);
gtBS->FreePool (ScratchBuffer);
}
CloseTestIniFile (ProfileLib, FileHandle);
//
//done successfully
//
return EFI_SUCCESS;
}
