自学教程：C++ ADD_LATENT_AUTOMATION_COMMAND函数代码示例

bool FAllUnitTestsTest::RunTest(const FString& Parameters){	ADD_LATENT_AUTOMATION_COMMAND(FAutomationConsoleCommand(FString::Printf(TEXT("UnitTest %s"), *Parameters)));	ADD_LATENT_AUTOMATION_COMMAND(FNUTWaitForUnitTests());	return true;}

bool FRevertTest::RunTest(const FString& Parameters){	// parameter is the provider we want to use followed by the filename	const FString Delimiter(TEXT(" "));	TArray<FString> ParamArray;	Parameters.ParseIntoArray(&ParamArray, *Delimiter, true);	ensure(ParamArray.Num() == 2);	ADD_LATENT_AUTOMATION_COMMAND(FSetProviderLatentCommand(FName(*ParamArray[0])));	ADD_LATENT_AUTOMATION_COMMAND(FConnectLatentCommand(FAsyncCommandHelper()));	struct Local	{		static void AddDepedentCommands(const FString& InParameter)		{			ADD_LATENT_AUTOMATION_COMMAND(FMarkForAddLatentCommand(FAsyncCommandHelper(InParameter)));			ADD_LATENT_AUTOMATION_COMMAND(FRevertLatentCommand(FAsyncCommandHelper(InParameter)));			ADD_LATENT_AUTOMATION_COMMAND(FDeletePackageLatentCommand(InParameter));		}	};	ADD_LATENT_AUTOMATION_COMMAND(FCreatePackageLatentCommand(FLatentCommandChain(ParamArray[1], FAddLatentCommands::CreateStatic(&Local::AddDepedentCommands))))	return true;}

/**  * Execute the loading of each map and performance captures * * @param Parameters - Should specify which map name to load * @return	TRUE if the test was successful, FALSE otherwise */bool FLoadAllMapsInGameTest::RunTest(const FString& Parameters){	FString MapName = Parameters;	//Open the map	GEngine->Exec(GetSimpleEngineAutomationTestGameWorld(GetTestFlags()), *FString::Printf(TEXT("Open %s"), *MapName));	if( FAutomationTestFramework::GetInstance().IsScreenshotAllowed() )	{		//Generate the screen shot name and path		FString ScreenshotFileName;		const FString TestName = FString::Printf(TEXT("LoadAllMaps_Game/%s"), *FPaths::GetBaseFilename(MapName));		AutomationCommon::GetScreenshotPath(TestName, ScreenshotFileName, true);		//Give the map some time to load		ADD_LATENT_AUTOMATION_COMMAND(FEngineWaitLatentCommand(1.5f));		//Take the screen shot		ADD_LATENT_AUTOMATION_COMMAND(FTakeViewportScreenshotCommand(ScreenshotFileName));		//Give the screen shot a chance to capture the scene		ADD_LATENT_AUTOMATION_COMMAND(FEngineWaitLatentCommand(0.5f));	}	//Kick off any Automation matinees that are in this map	ADD_LATENT_AUTOMATION_COMMAND(FEnqueuePerformanceCaptureCommands());	return true;}

bool FSteamLeaderBoardTest::RunTest(const FString& Parameters){	ADD_LATENT_AUTOMATION_COMMAND(FEngineWaitLatentCommand(3.0));	ADD_LATENT_AUTOMATION_COMMAND(FExecStringLatentCommand(TEXT("online sub=steam test leaderboards")));	return true;}

void FOpenAllAssetTests(OpenAssetParameters& AssetList){	ADD_LATENT_AUTOMATION_COMMAND(FWaitLatentCommand(0.5f));	ADD_LATENT_AUTOMATION_COMMAND(FOpenAllofAssetTypeCommand(AssetList));	ADD_LATENT_AUTOMATION_COMMAND(FWaitLatentCommand(0.5f));	ADD_LATENT_AUTOMATION_COMMAND(FCloseAllAssetEditorsCommand());}

bool FMatineePerformanceCaptureCommand::Update(){	//for every matinee actor in the level	for (TObjectIterator<AMatineeActor> It; It; ++It)	{		AMatineeActor* MatineeActor = *It;		FString MatineeFOOName = MatineeActor->GetName();		if (MatineeActor->GetName().Equals(MatineeName,ESearchCase::IgnoreCase))		{				//add latent action to execute this matinee			ADD_LATENT_AUTOMATION_COMMAND(FPlayMatineeLatentCommand(MatineeActor));			//Run the Stat FPS Chart command			ADD_LATENT_AUTOMATION_COMMAND(FExecWorldStringLatentCommand(TEXT("StartFPSChart")));			//add action to wait until matinee is complete			ADD_LATENT_AUTOMATION_COMMAND(FWaitForMatineeToCompleteLatentCommand(MatineeActor));			//Stop the Stat FPS Chart command			ADD_LATENT_AUTOMATION_COMMAND(FExecWorldStringLatentCommand(TEXT("StopFPSChart")));		}		else		{			UE_LOG(LogEngineAutomationLatentCommand, Log, TEXT("'%s' is not the matinee name that is being searched for."), *MatineeActor->GetName())		}	}	return true;}

bool FConnectTest::RunTest(const FString& Parameters){	// parameter is the provider we want to use	ADD_LATENT_AUTOMATION_COMMAND(FSetProviderLatentCommand(FName(*Parameters)));	ADD_LATENT_AUTOMATION_COMMAND(FConnectLatentCommand(FAsyncCommandHelper()));	return true;}

bool FStartFTestsOnMap::Update(){	//should really be wait until the map is properly loaded....in PIE or gameplay....	//ADD_LATENT_AUTOMATION_COMMAND(FWaitLatentCommand(10.f));	ADD_LATENT_AUTOMATION_COMMAND(FTriggerFTests);	ADD_LATENT_AUTOMATION_COMMAND(FWaitForFTestsToFinish);			return true;}

bool FGetRevisionTest::RunTest(const FString& Parameters){	// parameter is the provider we want to use followed by the filename	const FString Delimiter(TEXT(" "));	TArray<FString> ParamArray;	Parameters.ParseIntoArray(ParamArray, *Delimiter, true);	ensure(ParamArray.Num() == 2);	ADD_LATENT_AUTOMATION_COMMAND(FSetProviderLatentCommand(FName(*ParamArray[0])));	ADD_LATENT_AUTOMATION_COMMAND(FConnectLatentCommand(SourceControlAutomationCommon::FAsyncCommandHelper()));	ADD_LATENT_AUTOMATION_COMMAND(FUpdateStatusLatentCommand(SourceControlAutomationCommon::FAsyncCommandHelper(ParamArray[1])));	ADD_LATENT_AUTOMATION_COMMAND(FGetRevisionLatentCommand(ParamArray[1]));	return true;}

void PlayFabApiTest_GetUserData::OnSuccess(const PlayFab::ClientModels::FGetUserDataResult& Result){    int actualValue = -1;    FDateTime updateTime;    const PlayFab::ClientModels::FUserDataRecord* target = Result.Data.Find(TEST_DATA_KEY_1);    if (target != NULL)    {        actualValue = FCString::Atoi(*(target->Value));        updateTime = target->LastUpdated;    }    if (expectedValue != -1 && expectedValue != actualValue)    {        // If I know what value I'm expecting, and I did not get it, log an error        UE_LOG(LogTemp, Error, TEXT("GetUserData: Update value did not match new value %d!=%d"), expectedValue, actualValue);    }    else if (expectedValue != -1 && expectedValue == actualValue)    {        // If I know what value I'm expecting, and I got it, test passed, exit        CheckTimestamp(target->LastUpdated); // If the value was updated correctly, check the timestamp        UE_LOG(LogTemp, Log, TEXT("GetUserData Success"));    }    else if (expectedValue == -1)    {        // If I don't know what value I was expecting, Call Update with (actualValue + 1)        actualValue = (actualValue + 1) % 100;        ADD_LATENT_AUTOMATION_COMMAND(PlayFabApiTest_UpdateUserData(TEST_DATA_KEY_1, TEST_DATA_KEY_2, actualValue));    }}

bool FOpenActualAssetEditors(const FString& Parameters){	//start with all editors closed	FAssetEditorManager::Get().CloseAllAssetEditors();	// below is all latent action, so before sending there, verify the asset exists	UObject* Object = StaticLoadObject(UObject::StaticClass(), NULL, *Parameters);	if (!Object)	{		UE_LOG(LogEditorAutomationTests, Error, TEXT("Failed to find object: %s."), *Parameters);		return false;	}	ADD_LATENT_AUTOMATION_COMMAND(FOpenEditorForAssetCommand(*Parameters));	ADD_LATENT_AUTOMATION_COMMAND(FWaitLatentCommand(0.5f));	ADD_LATENT_AUTOMATION_COMMAND(FCloseAllAssetEditorsCommand());	return true;}

bool FIdenitiyInterfacetFunctionalLoginLogoutTest::RunTest( const FString& Parameters ){	// Get the user info that is used for logging in and out of the subsystem.	FString Username = TEXT( "" );	FString Password = TEXT( "" );	if ( !OSSUtilsTestHelper::GetUserInfo( Username, Password ) ) return false;	// Two identity structs are created because the test function will delete the object after each run.	FTestIdentityInterfaceStruct LoginTestStruct( Username, Password, TEXT( "epic" ), Parameters );	FTestIdentityInterfaceStruct LogoutTestStruct( Username, Password, TEXT("epic"), Parameters );	LogoutTestStruct.bIsLogoutTest = true;	/* The first latent command will run the login test.*/	ADD_LATENT_AUTOMATION_COMMAND( FTestIdentityInterfaceLoginOut( LoginTestStruct ) );	/* This second latent command will run the logout test.*/	ADD_LATENT_AUTOMATION_COMMAND( FTestIdentityInterfaceLoginOut( LogoutTestStruct ) );	return true;}

/**  * Execute the loading of one map to verify screen captures and performance captures work * * @param Parameters - Unused for this test * @return	TRUE if the test was successful, FALSE otherwise */bool FPerformanceCaptureTest::RunTest(const FString& Parameters){	UAutomationTestSettings const* AutomationTestSettings = GetDefault<UAutomationTestSettings>();	check(AutomationTestSettings);	FString MapName = AutomationTestSettings->AutomationTestmap.FilePath;	GEngine->Exec(GetSimpleEngineAutomationTestGameWorld(GetTestFlags()), *FString::Printf(TEXT("Open %s"), *MapName));	ADD_LATENT_AUTOMATION_COMMAND(FEnqueuePerformanceCaptureCommands());	return true;}

/**  * Execute the loading of each map and performance captures * * @param Parameters - Should specify which map name to load * @return	TRUE if the test was successful, FALSE otherwise */bool FClientFunctionalTestingMapsBase::RunTest(const FString& Parameters){	FString MapName = Parameters;	bool bCanProceed = AutomationOpenMap(MapName);	if (bCanProceed)	{		ADD_LATENT_AUTOMATION_COMMAND(FStartFTestsOnMap());		return true;	}	UE_LOG(LogFunctionalTesting, Error, TEXT("Failed to start the %s map (possibly due to BP compilation issues)"), *MapName);	return false;}

/**  * Launch the external tool as a process and wait for it to complete * * @param Parameters - The command to launch the external tool * @return	TRUE if the test was successful, FALSE otherwise */bool FRunExternalToolTest::RunTest(const FString& Parameters){	TArray<FString> Commands;	Parameters.ParseIntoArray(&Commands,TEXT(";"),false);	if( Commands.Num() != 3 )	{		UE_LOG(LogBaseAutomationTests, Error, TEXT("ERROR Parsing commands for external tool: %s"),*Parameters);		return false;	}	const FString& Executable       = Commands[0];	const FString& Options          = Commands[1];	const FString& WorkingDirectory = Commands[2];	//Create the pipes that we can use to read the output of the process	ExternalProcessHelper::ExternalProcessInfo ProcessInfo;	if (!FPlatformProcess::CreatePipe(ProcessInfo.ReadPipe, ProcessInfo.WritePipe))	{		return false;	}		//Create the new process	ProcessInfo.ProcessHandle = FPlatformProcess::CreateProc(*Executable,															*Options,															true,															false,															false,															NULL,															0,															WorkingDirectory.Len() > 0 ? *WorkingDirectory : NULL,															ProcessInfo.WritePipe);	//Check that we got a valid process handle	if( ProcessInfo.ProcessHandle.IsValid() )	{		ADD_LATENT_AUTOMATION_COMMAND(FWaitForProcessToCompleteLatentCommand(ProcessInfo));	}	else	{		UE_LOG(LogBaseAutomationTests, Error, TEXT("Failed to launch executable (%s) for external tool %s"),*Executable, *Parameters);		FPlatformProcess::ClosePipe(ProcessInfo.ReadPipe, ProcessInfo.WritePipe);		return false;	}	return true;}