void RA3FDevSoundTestBase::KickoffTestL()
{
INFO_PRINTF1(_L("__________ Creating DevSound object ___________"));
// Create devsound object
TRAPD(err, iMMFDevSound = CMMFDevSound::NewL());
if (err != KErrNone)
{
ERR_PRINTF2(_L("Could not create DevSound object. Error = %d"), err);
StopTest(err);
return;
}
INFO_PRINTF1(_L("DevSound State: EStateCreated"));
iDevSoundState = EStateCreated;
// Connect RFs
err = iFs.Connect();
if (err != KErrNone)
{
ERR_PRINTF2(_L("Could not connect to Filesystem. Error = %d"), err);
StopTest(err);
return;
}
DoKickoffTestL();
INFO_PRINTF1(_L("DevSound Event: EEventInitialize"));
Fsm(EEventInitialize, KErrNone);
}
void RA3FDevSoundTestBase::BufferToBeEmptied(CMMFBuffer* aBuffer)
{
INFO_PRINTF1(_L("DevSound called BufferToBeEmptied."));
if (!aBuffer)
{
INFO_PRINTF1(_L("BufferToBeEmptied callback received a NULL CMMFBuffer"));
StopTest(KErrGeneral);
return;
}
iBuffer = aBuffer;
if(aBuffer->LastBuffer())
{
if(iDevSoundState == EStatePause)
{
// We need to call CMMFDevSound->Stop() here if last buffer flag set
INFO_PRINTF1(_L("Devsound is in Paused state and CMMFBuffer::LastBuffer is set"));
INFO_PRINTF1(_L("iMMFDevSound->Stop()"));
iMMFDevSound->Stop();
StopTest();
}
else
{
INFO_PRINTF1(_L("***** Unknown behaviour: Last buffer flag set before calling CMMFDevSound->Pause()"));
StopTest(KErrUnknown);
}
}
else
{
INFO_PRINTF1(_L("DevSound Event: EEventBTBE"));
Fsm(EEventBTBE, KErrNone);
}
}
// signal complete
void RTestStepConvertPanic::ConvertComplete(TInt aError)
{
if (aError != KErrServerTerminated)
{
StopTest(aError, EFail);
}
else
{
StopTest(EPass);
}
}
void RA3FDevSoundTestBase::PlayError(TInt aError)
{
INFO_PRINTF1(_L("========== DevSound PlayError() callback =========="));
INFO_PRINTF3(KMsgErrorDevSoundCallback, &KPlayErrorText, aError);
if(iBuffer->LastBuffer() && (aError == KErrUnderflow))
{
INFO_PRINTF1(_L("Playback completed normally"));
StopTest();
}
else
{
INFO_PRINTF1(_L("Playback completed with error"));
StopTest(aError, EFail);
}
}
void RA3FDevSoundTestBase::ToneFinished(TInt aError)
{
INFO_PRINTF1(_L("========== DevSound ToneFinished() callback =========="));
if (aError == KErrUnderflow)
{
INFO_PRINTF2(_L("DevSound called CMMFDevSound::ToneFinished with error = %d as expected"), aError);
StopTest(aError,EPass);
}
else
{
ERR_PRINTF2(_L("DevSound called CMMFDevSound::ToneFinished with error = %d"), aError);
ERR_PRINTF2(_L("Expected error = %d"), KErrUnderflow);
StopTest(aError);
}
}
void RA3FDevSoundTestBase::SampleRateFromTIntToTMMFSampleRate(TInt aSampleRate, TMMFSampleRate &aESampleRate)
{
const TSampleRateToTMMFSampleRate SampleRateLookUp [] =
{
{8000, EMMFSampleRate8000Hz},
{11025, EMMFSampleRate11025Hz},
{16000, EMMFSampleRate16000Hz},
{22050, EMMFSampleRate22050Hz},
{32000, EMMFSampleRate32000Hz},
{44100, EMMFSampleRate44100Hz},
{48000, EMMFSampleRate48000Hz},
{88200, EMMFSampleRate88200Hz},
{96000, EMMFSampleRate96000Hz},
{12000, EMMFSampleRate12000Hz},
{24000, EMMFSampleRate24000Hz},
{64000, EMMFSampleRate64000Hz}
};
const TInt length = sizeof SampleRateLookUp / sizeof *SampleRateLookUp;
for(TInt i = 0; i < length; i++)
{
if(aSampleRate == SampleRateLookUp[i].iTIntSampleRate)
{
aESampleRate = SampleRateLookUp[i].iTMMFSampleRate;
return;
}
}
ERR_PRINTF1(_L("User SampleRate doesn't match any of the specified sample rates"));
StopTest(KErrGeneral);
}
void RA3FDevSoundTestBase::SampleRateFromTUintToString(TUint aSampleRate, TDes& aStringSampleRate)
{
const TSampleRateToString SampleRateLookUp [] =
{
{0x00000001, KEMMFSampleRate8000Hz() },
{0x00000002, KEMMFSampleRate11025Hz()},
{0x00000004, KEMMFSampleRate16000Hz()},
{0x00000008, KEMMFSampleRate22050Hz()},
{0x00000010, KEMMFSampleRate32000Hz()},
{0x00000020, KEMMFSampleRate44100Hz()},
{0x00000040, KEMMFSampleRate48000Hz()},
{0x00000080, KEMMFSampleRate88200Hz()},
{0x00000100, KEMMFSampleRate96000Hz()},
{0x00000200, KEMMFSampleRate12000Hz()},
{0x00000400, KEMMFSampleRate24000Hz()},
{0x00000800, KEMMFSampleRate64000Hz()}
};
const TInt length = sizeof SampleRateLookUp / sizeof *SampleRateLookUp;
for (TInt i =0; i < length; i++)
{
if(aSampleRate == SampleRateLookUp[i].iTUIntSampleRate)
{
aStringSampleRate.Copy(SampleRateLookUp[i].iTPtrSampleRate);
return;
}
}
ERR_PRINTF1(_L("SampleRate doesn't match any of the specified sample rates"));
StopTest(KErrGeneral);
}
/*
*
* main( )
*
*/
void main( void )
{
/* Initialize BSL */
EZDSP5535_init( );
/* Display test ID */
printf( "\nRunning UART Test...\n");
/* Call test function */
TestFail = uart_test( );
/* Check for test fail */
if ( TestFail != 0 )
{
/* Print error message */
printf( " FAIL... error code %d... quitting\n", TestFail );
}
else
{
/* Print pass message */
printf( " PASS\n" );
printf( "\n***ALL Tests Passed***\n" );
}
StopTest();
}
void RA3FDevSoundTestBase::RecordError(TInt aError)
{
INFO_PRINTF2(_L("DevSound called RecordError with error = %d"), aError);
if (aError == KErrUnderflow)
{
StopTest(aError);
}
}
void RAsyncTestStep::DoCallBack()
{
TRAPD(error, KickoffTestL());
if (error!=KErrNone)
{
StopTest(error); // if kickoff fails, we stop here
}
}
int main() {
StartTest("C++",3);
AssertS("a) Thread gestartet ", test_A3_a() );
AssertS("b) Wörter gesendet ", test_A3_b() );
AssertS("c) Auf Thread warten ", test_A3_c() );
StopTest();
return EXIT_SUCCESS;
}
JNIEXPORT jint JNICALL Java_com_xilinx_gui_DriverInfoGenDV_stopTest(JNIEnv *env, jobject obj, jint engine, jint testmode, jint maxsize){
int tmode = ENABLE_LOOPBACK;
if (testmode == 0) // loopback
tmode = ENABLE_LOOPBACK;
else if (testmode == 1) // checker
tmode = ENABLE_PKTCHK;
else if (testmode == 2) // generator
tmode = ENABLE_PKTGEN;
else if (testmode == 3)
tmode = ENABLE_PKTCHK|ENABLE_PKTGEN;
return StopTest(statsfd, engine, tmode, maxsize);
}
// signal complete
void RTestStepConvertAudio::ConvertComplete(TInt aError)
{
if (aError != KErrNone)
{
StopTest(aError);
}
else
{
TBool result = EFalse;
TRAPD(err, result = CheckConversionL());
if (err != KErrNone)
{
INFO_PRINTF2(_L("Could not check the converted file, err = %d"), err);
StopTest(err, EFail);
}
else
{
StopTest(aError, (result ? EPass : EFail));
}
}
}
int main(uint32_t argc, char * argv[])
{
if (argc < 5) {
Usage();
return 0;
}
StartTest(argv[1], StrToIntA(argv[2]), StrToIntA(argv[3]), StrToIntA(argv[4]), StrToIntA(argv[5]));
getchar();
StopTest();
return 0;
}
/** Signals the the sequence has finished. Check to see if the test should now end
*/
void CT_LbsHybridMultipleTest::SequenceFinished()
{
//This sequence is finished
iActiveSequences--;
//Check to see whether any other sequences are active
if(iActiveSequences > 0)
{
return;
}
else
{
//No active sequences, end the test
return StopTest(0);
}
}
void RA3FDevSoundTestBase::BufferToBeFilled(CMMFBuffer* aBuffer)
{
INFO_PRINTF1(_L("========== DevSound BufferToBeFilled() callback =========="));
if (!aBuffer)
{
ERR_PRINTF1(_L("BufferToBeFilled callback received a NULL CMMFBuffer!"));
StopTest(KErrGeneral);
}
else
{
iBuffer = aBuffer;
INFO_PRINTF1(_L("DevSound Event: EEventBTBF"));
Fsm(EEventBTBF, KErrNone);
}
}
void FAutomationTestFramework::StartTestByName( const FString& InTestToRun, const int32 InRoleIndex )
{
if (GIsAutomationTesting)
{
while(!LatentCommands.IsEmpty())
{
TSharedPtr<IAutomationLatentCommand> TempCommand;
LatentCommands.Dequeue(TempCommand);
}
while(!NetworkCommands.IsEmpty())
{
TSharedPtr<IAutomationNetworkCommand> TempCommand;
NetworkCommands.Dequeue(TempCommand);
}
FAutomationTestExecutionInfo TempExecutionInfo;
StopTest(TempExecutionInfo);
}
FString TestName;
FString Params;
if (!InTestToRun.Split(TEXT(" "), &TestName, &Params, ESearchCase::CaseSensitive))
{
TestName = InTestToRun;
}
NetworkRoleIndex = InRoleIndex;
// Ensure there isn't another slow task in progress when trying to run unit tests
if ( !GIsSlowTask && !GIsPlayInEditorWorld )
{
// Ensure the test exists in the framework and is valid to run
if ( ContainsTest( TestName ) )
{
// Make any setting changes that have to occur to support unit testing
PrepForAutomationTests();
InternalStartTest( InTestToRun );
}
else
{
UE_LOG(LogAutomationTest, Error, TEXT("Test %s does not exist and could not be run."), *InTestToRun);
}
}
else
{
UE_LOG(LogAutomationTest, Error, TEXT("Test %s is too slow and could not be run."), *InTestToRun);
}
}
void RA3FDevSoundTestBase::EncodingFromStringToTFourCC(const TDesC& aFourCCString)
{
iFourCCString.Copy(aFourCCString);
if(aFourCCString.Length() <= KTFourCC)
{
while( iFourCCString.Length() < KTFourCC )
{
iFourCCString.Insert(0, _L(" "));
}
iFourCCCode = TFourCC(iFourCCString[3] << 24 | iFourCCString[2] << 16 | iFourCCString[1] << 8 | iFourCCString[0]);
}
else
{
ERR_PRINTF2(KMsgErrorFourccLength,iFourCCString.Length());
StopTest(KErrUnknown);
}
}
void CShowAudioTestDlg::OnClickCancel()
{
if (this->GetSafeHwnd())
{
this->ShowWindow(SW_HIDE);
CComVariant var = L"取消";
m_pSkinEngine->SetSubSkinProp(GetSafeHwnd(),L"btnFront",L"label",var);
var = L"下一步";
m_pSkinEngine->SetSubSkinProp(GetSafeHwnd(),L"btnBack",L"label",var);
var = TRUE;
m_pSkinEngine->SetSubSkinProp(GetSafeHwnd(),L"itemAudioSetStep1Dlg",L"visible",var);
var = FALSE;
m_pSkinEngine->SetSubSkinProp(GetSafeHwnd(),L"itemAudioSetStep2Dlg",L"visible",var);
StopTest();
}
}
void RA3FDevSoundTestBase::ChannelsFromTUintToString(TUint aChannels,TDes& aStringChannels)
{
const TChannelsToString ChannelsLookUp [] =
{
{0x00000001, KEMMFMono() },
{0x00000002, KEMMFStereo()},
};
const TInt length = sizeof ChannelsLookUp / sizeof *ChannelsLookUp;
for (TInt i =0; i < length; i++)
{
if(aChannels == ChannelsLookUp[i].iTUIntChannels)
{
aStringChannels.Copy(ChannelsLookUp[i].iTPtrChannels);
return;
}
}
ERR_PRINTF1(_L("Channels doesn't match any of the specified channels"));
StopTest(KErrGeneral);
}
void CWizSoundSysPage::OnBnClickedButtonTest()
{
if(m_nInputDevice == UNDEFINED)
{
AfxMessageBox(_T("No input device selected"));
return;
}
if(m_nOutputDevice == UNDEFINED)
{
AfxMessageBox(_T("No output device selected"));
return;
}
CString szTest;
if(!m_bTesting)
{
m_bTesting = StartTest();
if(m_bTesting)
{
szTest.LoadString(IDS_STOP);
m_wndTestBtn.SetWindowText(szTest);
TRANSLATE(m_wndTestBtn, IDS_STOP, _T("Stop"));
m_DxButton.EnableWindow(FALSE);
m_WinButton.EnableWindow(FALSE);
m_OutputDriversCombo.EnableWindow(FALSE);
m_InputDriversCombo.EnableWindow(FALSE);
}
}
else
{
StopTest();
szTest.LoadString(IDS_TESTSELECTED);
m_wndTestBtn.SetWindowText(szTest);
TRANSLATE(m_wndTestBtn, IDS_TESTSELECTED, _T("Test selected"));
m_DxButton.EnableWindow(TRUE);
m_WinButton.EnableWindow(TRUE);
m_OutputDriversCombo.EnableWindow(TRUE);
m_InputDriversCombo.EnableWindow(TRUE);
m_bTesting = FALSE;
}
}
EXPORT_C void RAsyncTestStep::StopTest()
{
StopTest(KErrNone);
}
void CWizSoundSysPage::Close()
{
if(m_bTesting)
StopTest();
}
EXPORT_C void RAsyncTestStep::StopTest(TInt aReason)
{
TVerdict resultToUse = (aReason==KErrNone) ? EPass : EFail;
StopTest (aReason, resultToUse);
}
void RAsyncTestStep::HandleError(TInt aError)
{
INFO_PRINTF2(_L("ActiveScheduler::Error(%d)"), aError);
StopTest(aError);
}
/*
*
* CallStopTest
*
*/
void RA3FDevSoundTestBase::CallStopTest(TInt aError)
{
StopTest(aError);
}
/* Called when one of the stub PM's receives a message from the NG
*
* @param aPmId The ID of the PM that received this message
* @param aMessageType The ID of the message type received from the PM
*/
void CT_LbsHybridMultipleTest::OnHandleNGMessage(TUint aPmId, TInt aMessageType)
{
//Get the correct proxy
CLbsTestNgMessageHandler* proxy = LookupProtocolModuleProxy(aPmId);
if (!proxy)
{
INFO_PRINTF2(_L("ERROR: No NG proxy setup for PM%d"), aPmId);
User::Leave(KErrNotFound);
}
TInt cleanupCnt;
TInt sequenceId = KErrNotFound;
//For each of the different message types, find out whether the message type was expected by the
// sequence (if a session Id is sent with the message) or by any sequence (if the session Id is not
// present). Then confirm the message parameters are expected and then move the correct sequence
// onto the next message.
switch(aMessageType)
{
// >> AdviceSystemStatus() [2009]
case ENetMsgGetCurrentCapabilitiesResponse:
{
sequenceId = WasMessageExpectedPmId(aPmId, ENetMsgGetCurrentCapabilitiesResponse);
INFO_PRINTF2(_L("-> AdviceSystemStatus() [2009] Sq: %d"), sequenceId);
if(sequenceId != KErrNotFound)
{
CLbsNetworkProtocolBase::TLbsSystemStatus status;
cleanupCnt = proxy->ProtocolProxy()->GetArgsLC(ENetMsgGetCurrentCapabilitiesResponse, &status);
TESTL(status == CLbsNetworkProtocolBase::ESystemStatusNone);
CleanupStack::PopAndDestroy(cleanupCnt);
}
break;
}
// >> RespondPrivacyRequest() [2000]
case ENetMsgRespondPrivacyRequest:
{
TLbsNetSessionId* getSessionId = NULL;
CLbsNetworkProtocolBase::TLbsPrivacyResponse getPrivacy;
cleanupCnt = proxy->ProtocolProxy()->GetArgsLC(ENetMsgRespondPrivacyRequest, &getSessionId, &getPrivacy);
sequenceId = WasMessageExpectedSessionId(getSessionId->SessionNum(), ENetMsgRespondPrivacyRequest);
INFO_PRINTF3(_L("-> RespondPrivacyRequest(%d) [2000] Sq: %d"), getPrivacy, sequenceId);
if(sequenceId != KErrNotFound)
{
iSequences[sequenceId]->CheckRespondPrivacyRequest(getPrivacy);
}
CleanupStack::PopAndDestroy(cleanupCnt);//getSessionId
break;
}
// >> RequestAssistanceData() [2004]
case ENetMsgRequestAssistanceData:
{
sequenceId = WasMessageExpectedPmId(aPmId, ENetMsgRequestAssistanceData);
//Request Assistance Data is a special case. Depending upon the timing of when the messages
// will be sent/received, it is not possible to predict in advance whether this message will
// always arrive in some of the later sequences. As such, a RequestAssistanceData message can
// arrive and even if it is not expected by any of the sequences, it will not fail the test.
if(sequenceId != KErrNotFound)
{
INFO_PRINTF2(_L("-> RequestAssistanceData() [2004] Sq: %d"), sequenceId);
TLbsAsistanceDataGroup dataGroup;
cleanupCnt = proxy->ProtocolProxy()->GetArgsLC(ENetMsgRequestAssistanceData, &dataGroup);
CleanupStack::PopAndDestroy(cleanupCnt);
}
else
{
//Message was not expected by any sequence. Manually set the Net Proxy off listening
// again, so the sequence can receive the message it expected.
INFO_PRINTF2(_L("-> RequestAssistanceData() [2004] Sq: unknown, PM: %d"), aPmId);
proxy->WaitForResponseL(80 * 1000 * 1000);
//Break out of the function now
return;
}
break;
}
// >> ResponsdLocationRequest() [2001]
case ENetMsgRespondLocationRequest:
{
TLbsNetSessionId* getSessionId = NULL;
getSessionId = NULL;
TInt getReason = KErrNone;
TPositionSatelliteInfo* getPositionInfo = NULL;
cleanupCnt = proxy->ProtocolProxy()->GetArgsLC(ENetMsgRespondLocationRequest, &getSessionId, &getReason, &getPositionInfo);
sequenceId = WasMessageExpectedSessionId(getSessionId->SessionNum(), ENetMsgRespondLocationRequest);
INFO_PRINTF3(_L("-> RespondLocationRequest(%d) [2001] Sq: %d"), getReason, sequenceId);
CleanupStack::PopAndDestroy(cleanupCnt);
break;
}
// >> RequestSelfLocation() [2005]
case ENetMsgRequestSelfLocation:
{
TLbsNetSessionId* sessionId = NULL;
TLbsNetPosRequestOptionsAssistance* opts = NULL;
cleanupCnt = proxy->ProtocolProxy()->GetArgsLC(ENetMsgRequestSelfLocation, &sessionId, &opts);
sequenceId = WasMessageExpectedPmId(aPmId, ENetMsgRequestSelfLocation);
INFO_PRINTF2(_L("-> RequestSelfLocation() [2005] Sq: %d"), sequenceId);
if(sequenceId != KErrNotFound)
{
iSequences[sequenceId]->CheckSelfLocationRequest(sessionId);
}
CleanupStack::PopAndDestroy(cleanupCnt);
break;
}
// >> CancelSelfLocation() [2006]
case ENetMsgCancelSelfLocation:
{
TLbsNetSessionId* sessionId = NULL;
TInt reason = 0;
cleanupCnt = proxy->ProtocolProxy()->GetArgsLC(ENetMsgCancelSelfLocation, &sessionId, &reason);
sequenceId = WasMessageExpectedSessionId(sessionId->SessionNum(), ENetMsgRequestSelfLocation);
INFO_PRINTF2(_L("-> CancelSelfLocation() [2006] Sq: %d"), sequenceId);
CleanupStack::PopAndDestroy(cleanupCnt);
break;
}
// >> RequestTransmitLocation() [2002]
case ENetMsgRequestTransmitLocation:
{
HBufC16* getThirdParty = NULL;
TLbsNetSessionId* getSessionId = NULL;
TInt getPriority(0);
TInt cleanupCnt;
cleanupCnt = proxy->ProtocolProxy()->GetArgsLC(ENetMsgRequestTransmitLocation, &getSessionId, &getThirdParty, &getPriority);
sequenceId = WasMessageExpectedPmId(aPmId, ENetMsgRequestTransmitLocation);
INFO_PRINTF2(_L("-> RequestTransmitLocation() [2002] Sq: %d"), sequenceId);
if(sequenceId != KErrNotFound)
{
iSequences[sequenceId]->CheckRequestTransmitLocation(getSessionId, getPriority, *getThirdParty);
}
CleanupStack::PopAndDestroy(cleanupCnt);
break;
}
// >> CancelTransmitLocation() [2003]
case ENetMsgCancelTransmitLocation:
{
TLbsNetSessionId* sessionId = NULL;
TInt reason = 0;
cleanupCnt = proxy->ProtocolProxy()->GetArgsLC(ENetMsgCancelTransmitLocation, &sessionId, &reason);
sequenceId = WasMessageExpectedSessionId(sessionId->SessionNum(), ENetMsgCancelTransmitLocation);
INFO_PRINTF2(_L("-> CancelTransmitLocation() [2003] Sq: %d"), sequenceId);
CleanupStack::PopAndDestroy(cleanupCnt);
break;
}
// >> RequestNetworkLocation() [2007]
case ENetMsgRequestNetworkLocation:
{
TLbsNetSessionId* sessionId = NULL;
TLbsNetPosRequestOptionsAssistance* opts = NULL;
cleanupCnt = proxy->ProtocolProxy()->GetArgsLC(ENetMsgRequestNetworkLocation, &sessionId, &opts);
sequenceId = WasMessageExpectedPmId(aPmId, ENetMsgRequestNetworkLocation);
INFO_PRINTF2(_L("-> RequestNetworkLocation() [2007] Sq: %d"), sequenceId);
if(sequenceId != KErrNotFound)
{
iSequences[sequenceId]->CheckNetworkLocationRequest(sessionId);
}
break;
}
// >> CancelNetworkLocation [2008]
case ENetMsgCancelNetworkLocation:
{
sequenceId = WasMessageExpectedPmId(aPmId, ENetMsgCancelNetworkLocation);
INFO_PRINTF2(_L("-> CancelNetworkLocation() [2008] Sq: %d"), sequenceId);
//NOTE: Currently no handling implemented for this message type
break;
}
// Timeout occurred waiting for a NG Message
case -1000:
{
INFO_PRINTF2(_L("Error - Timeout occurred waiting for NG message on PM: %d"), aPmId);
break;
}
//Error occurred, not a recognised message. Fail the test.
default:
{
INFO_PRINTF3(_L("Error - Received invalid NG message: %d on PM: %d"), aMessageType, aPmId);
return StopTest(KErrArgument);
}
}
//If the message was expected, continue the test
if(sequenceId != KErrNotFound)
{
iSequences[sequenceId]->SignalCallbackIdleStart();
}
else
{
// when an unexpected message arrives merley ignore and wait for next one!
proxy->WaitForResponseL(80 * 1000 * 1000);
}
}
void CDlgSpeedTest::OnBnClickedCancel()
{
// TODO: 在此添加控件通知处理程序代码
StopTest();
OnCancel();
}
bool FAutomationTestFramework::RunSmokeTests()
{
bool bAllSuccessful = true;
uint32 PreviousRequestedTestFilter = RequestedTestFilter;
//so extra log spam isn't generated
RequestedTestFilter = EAutomationTestFlags::SmokeFilter;
// Skip running on cooked platforms like mobile
//@todo - better determination of whether to run than requires cooked data
// Ensure there isn't another slow task in progress when trying to run unit tests
const bool bRequiresCookedData = FPlatformProperties::RequiresCookedData();
if ((!bRequiresCookedData && !GIsSlowTask && !GIsPlayInEditorWorld && !FPlatformProperties::IsProgram()) || bForceSmokeTests)
{
TArray<FAutomationTestInfo> TestInfo;
GetValidTestNames( TestInfo );
if ( TestInfo.Num() > 0 )
{
double SmokeTestStartTime = FPlatformTime::Seconds();
// Output the results of running the automation tests
TMap<FString, FAutomationTestExecutionInfo> OutExecutionInfoMap;
// Run each valid test
FScopedSlowTask SlowTask(TestInfo.Num());
for ( int TestIndex = 0; TestIndex < TestInfo.Num(); ++TestIndex )
{
SlowTask.EnterProgressFrame(1);
if (TestInfo[TestIndex].GetTestFlags() & EAutomationTestFlags::SmokeFilter )
{
FString TestCommand = TestInfo[TestIndex].GetTestName();
FAutomationTestExecutionInfo& CurExecutionInfo = OutExecutionInfoMap.Add( TestCommand, FAutomationTestExecutionInfo() );
int32 RoleIndex = 0; //always default to "local" role index. Only used for multi-participant tests
StartTestByName( TestCommand, RoleIndex );
const bool CurTestSuccessful = StopTest(CurExecutionInfo);
bAllSuccessful = bAllSuccessful && CurTestSuccessful;
}
}
double EndTime = FPlatformTime::Seconds();
double TimeForTest = static_cast<float>(EndTime - SmokeTestStartTime);
if (TimeForTest > 2.0f)
{
//force a failure if a smoke test takes too long
UE_LOG(LogAutomationTest, Warning, TEXT("Smoke tests took > 2s to run: %.2fs"), (float)TimeForTest);
}
FAutomationTestFramework::DumpAutomationTestExecutionInfo( OutExecutionInfoMap );
}
}
else if( bRequiresCookedData )
{
UE_LOG( LogAutomationTest, Log, TEXT( "Skipping unit tests for the cooked build." ) );
}
else if (!FPlatformProperties::IsProgram())
{
UE_LOG(LogAutomationTest, Error, TEXT("Skipping unit tests.") );
bAllSuccessful = false;
}
//revert to allowing all logs
RequestedTestFilter = PreviousRequestedTestFilter;
return bAllSuccessful;
}
