UnrealEngineUWP/Engine/Source/Programs/UnrealBuildTool/Configuration/TestTargetRules.cs

// Copyright Epic Games, Inc. All Rights Reserved.

using EpicGames.Core;
using System;
using System.IO;
using System.Reflection;
using System.Runtime.Serialization;
using UnrealBuildBase;

namespace UnrealBuildTool
{
	/// <summary>
	/// TargetRules extension for low level tests.
	/// </summary>
	public class TestTargetRules : TargetRules
	{
		/// <summary>
		/// Keeps track if low level tests executable must build with the Editor.
		/// </summary>
		internal static bool bTestsRequireEditor = false;

		/// <summary>
		/// Keeps track if low level tests executable must build with the Engine.
		/// </summary>
		internal static bool bTestsRequireEngine = false;

		/// <summary>
		/// Keeps track if low level tests executable must build with the ApplicationCore.
		/// </summary>
		internal static bool bTestsRequireApplicationCore = false;

		/// <summary>
		/// Keeps track if low level tests executable must build with the CoreUObject.
		/// </summary>
		internal static bool bTestsRequireCoreUObject = false;

		/// <summary>
		/// Keep track of low level test runner module instance.
		/// </summary>
		internal static ModuleRules? LowLevelTestsRunnerModule;

		/// <summary>
		/// Associated tested target of this test target, if defined.
		/// </summary>
		protected TargetRules? TestedTarget { get; private set; }

		/// <summary>
		/// Test target override for bCompileAgainstApplicationCore.
		/// It is set to true if there is any reference to ApplicationCore in the dependency graph.
		/// </summary>
		public override bool bCompileAgainstApplicationCore
		{
			get { return bTestsRequireApplicationCore; }
			set { bTestsRequireApplicationCore = value; }
		}

		/// <summary>
		/// If set to true, it will not compile against ApplicationCore even if "ApplicationCore" is in the dependency graph.
		/// </summary>
		public static bool bNeverCompileAgainstApplicationCore = false;

		/// <summary>
		/// Test target override for bCompileAgainstCoreUObject.
		/// It is set to true if there is any reference to CoreUObject in the dependency graph.
		/// </summary>
		public override bool bCompileAgainstCoreUObject
		{
			get { return bTestsRequireCoreUObject; }
			set { bTestsRequireCoreUObject = value; }
		}

		/// <summary>
		/// If set to true, it will not compile against CoreUObject even if "CoreUObject" is in the dependency graph.
		/// </summary>
		public static bool bNeverCompileAgainstCoreUObject = false;

		/// <summary>
		/// Test target override for bCompileAgainstEngine.
		/// It is set to true if there is any reference to Engine in the dependency graph.
		/// </summary>
		public override bool bCompileAgainstEngine
		{
			get { return bTestsRequireEngine; }
			set { bTestsRequireEngine = value; }
		}

		/// <summary>
		/// If set to true, it will not compile against engine even if "Engine" is in the dependency graph.
		/// </summary>
		public static bool bNeverCompileAgainstEngine = false;

		/// <summary>
		/// Test target override for bCompileAgainstEditor.
		/// It is set to true if there is any reference to UnrealEd in the dependency graph.
		/// </summary>
		public override bool bCompileAgainstEditor
		{
			get { return bTestsRequireEditor; }
			set { bTestsRequireEditor = value; }
		}

		/// <summary>
		/// If set to true, it will not compile against editor even if "UnrealEd" is in the dependency graph.
		/// </summary>
		public static bool bNeverCompileAgainstEditor = false;

		/// <summary>
		/// Whether to stub the platform file.
		/// </summary>
		public bool bUsePlatformFileStub
		{ 
			get { return bUsePlatformFileStubPrivate; }
			set
			{
				bUsePlatformFileStubPrivate = value;
				GlobalDefinitions.Remove("UE_LLT_USE_PLATFORM_FILE_STUB=0");
				GlobalDefinitions.Remove("UE_LLT_USE_PLATFORM_FILE_STUB=1");
				GlobalDefinitions.Add($"UE_LLT_USE_PLATFORM_FILE_STUB={Convert.ToInt32(bUsePlatformFileStubPrivate)}");
			}
		}
		private bool bUsePlatformFileStubPrivate = false;

		/// <summary>
		/// Whether to mock engine default instances for materials, AI controller etc.
		/// </summary>
		public bool bMockEngineDefaults
		{
			get { return bMockEngineDefaultsPrivate; }
			set
			{
				bMockEngineDefaultsPrivate = value;
				GlobalDefinitions.Remove("UE_LLT_WITH_MOCK_ENGINE_DEFAULTS=0");
				GlobalDefinitions.Remove("UE_LLT_WITH_MOCK_ENGINE_DEFAULTS=1");
				GlobalDefinitions.Add($"UE_LLT_WITH_MOCK_ENGINE_DEFAULTS={Convert.ToInt32(bMockEngineDefaultsPrivate)}");
			}
		}
		private bool bMockEngineDefaultsPrivate = false;

		/// <summary>
		/// Constructor that explicit targets can inherit from.
		/// </summary>
		/// <param name="Target"></param>
		public TestTargetRules(TargetInfo Target) : base(Target)
		{
			SetupCommonProperties(Target);

			ExeBinariesSubFolder = LaunchModuleName = Name + (ExplicitTestsTarget ? string.Empty : "Tests");

			if (ExplicitTestsTarget)
			{
				bBuildInSolutionByDefault = true;
				SolutionDirectory = "Programs/LowLevelTests";

				// Default to true for explicit targets to reduce compilation times.
				// Selective module compilation will automatically detect if Engine is required based on Engine include files in tests.
				bNeverCompileAgainstEngine = true;
			}

			if (Target.Platform == UnrealTargetPlatform.Win64)
			{
				string OutputName = "$(TargetName)";
				if(Target.Configuration != UndecoratedConfiguration)
				{
					OutputName = OutputName + "-" + Target.Platform + "-" + Target.Configuration;
				}
				if (File != null)
				{
					string OutputDirectory = UEBuildTarget.GetOutputDirectoryForExecutable(Unreal.EngineDirectory, File).FullName;
					string OutputFileName = $"{OutputDirectory}\\Binaries\\{Target.Platform}\\{ExeBinariesSubFolder}\\{OutputName}.exe.is_unreal_test";
					PostBuildSteps.Add("echo > " + OutputFileName);
				}
			}
		}

		/// <summary>
		/// Constructs a valid TestTargetRules instance from an existent TargetRules instance.
		/// </summary>
		public static TestTargetRules Create(TargetRules Rules, TargetInfo TargetInfo)
		{
			Type TestTargetRulesType = typeof(TestTargetRules);
			TestTargetRules TestRules = (TestTargetRules)FormatterServices.GetUninitializedObject(TestTargetRulesType);

			// Initialize the logger before calling the constructor
			TestRules.Logger = Rules.Logger;

			ConstructorInfo? Constructor = TestTargetRulesType.GetConstructor(new Type[] { typeof(TargetRules), typeof(TargetInfo) });
			if (Constructor == null)
			{
				throw new BuildException("No constructor found on {0} which takes first argument of type TargetRules and second of type TargetInfo.", TestTargetRulesType.Name);
			}

			try
			{
				Constructor.Invoke(TestRules, new object[] { Rules, TargetInfo });
			}
			catch (Exception Ex)
			{
				throw new BuildException(Ex, "Unable to instantiate instance of '{0}' object type from compiled assembly '{1}'.  Unreal Build Tool creates an instance of your module's 'Rules' object in order to find out about your module's requirements.  The CLR exception details may provide more information:  {2}", TestTargetRulesType.Name, Path.GetFileNameWithoutExtension(TestTargetRulesType.Assembly?.Location), Ex.ToString());
			}

			return TestRules;
		}

		/// <summary>
		/// Constructor for TestTargetRules based on existing target.
		/// TestTargetRules is setup as a program and is linked monolithically.
		/// It removes a lot of default compilation behavior in order to produce a minimal test environment.
		/// </summary>
		public TestTargetRules(TargetRules TestedTarget, TargetInfo Target) : base(Target)
		{
			if (TestedTarget is TestTargetRules)
			{
				throw new BuildException("TestedTarget can't be of type TestTargetRules.");
			}

			this.TestedTarget = TestedTarget;

			TargetFiles = TestedTarget.TargetFiles;

			ExeBinariesSubFolder = Name = TestedTarget.Name + "Tests";
			TargetSourceFile = File = TestedTarget.File;
			if (TestedTarget.LaunchModuleName != null)
			{
				LaunchModuleName = TestedTarget.LaunchModuleName + "Tests";
			}

			ManifestFileNames = TestedTarget.ManifestFileNames;

			WindowsPlatform = TestedTarget.WindowsPlatform;

			SetupCommonProperties(Target);
		}

		private void SetupCommonProperties(TargetInfo Target)
		{
			IncludeOrderVersion = EngineIncludeOrderVersion.Latest;

			bIsTestTargetOverride = true;

			VSTestRunSettingsFile = FileReference.Combine(Unreal.EngineDirectory, "Source", "Programs", "LowLevelTests", "vstest.runsettings");

			DefaultBuildSettings = BuildSettingsVersion.Latest;

			Type = TargetType.Program;
			LinkType = TargetLinkType.Monolithic;

			bBuildInSolutionByDefault = false;

			bDeployAfterCompile = Target.Platform != UnrealTargetPlatform.Android;
			bIsBuildingConsoleApplication = true;

			// Disabling default true flags that aren't necessary for tests

			// Lean and Mean mode
			bBuildDeveloperTools = false;

			// No localization
			bCompileICU = false;

			// No need for shaders by default
			bForceBuildShaderFormats = false;

			// Do not compile against the engine, editor etc
			bCompileAgainstEngine = false;
			bCompileAgainstEditor = false;
			bCompileAgainstCoreUObject = false;
			bCompileAgainstApplicationCore = false;
			bCompileCEF3 = false;

			// No mixing with Functional Test framework
			bForceDisableAutomationTests = true;

			bDebugBuildsActuallyUseDebugCRT = true;

			// Allow logging in shipping
			bUseLoggingInShipping = true;

			// Allow exception handling
			bForceEnableExceptions = true;

			bBuildWithEditorOnlyData = false;
			bBuildRequiresCookedData = true;
			bBuildDeveloperTools = false;

			// Disable malloc profiling in tests
			bUseMallocProfiler = false;

			// Useful for debugging test failures
			if (Target.Configuration == UnrealTargetConfiguration.Debug)
			{
				bDebugBuildsActuallyUseDebugCRT = true;
			}

			if (!ExplicitTestsTarget && TestedTarget != null)
			{
				GlobalDefinitions.AddRange(TestedTarget.GlobalDefinitions);
			}

			GlobalDefinitions.Add("STATS=0");
			GlobalDefinitions.Add("TEST_FOR_VALID_FILE_SYSTEM_MEMORY=0");
			
			// LLT Globals
			GlobalDefinitions.Add("UE_LLT_USE_PLATFORM_FILE_STUB=0");
			GlobalDefinitions.Add("UE_LLT_WITH_MOCK_ENGINE_DEFAULTS=0");

			// Platform specific setup
			if (Target.Platform == UnrealTargetPlatform.Android)
			{
				UndecoratedConfiguration = Target.Configuration;

				GlobalDefinitions.Add("USE_ANDROID_INPUT=0");
				GlobalDefinitions.Add("USE_ANDROID_OPENGL=0");
				GlobalDefinitions.Add("USE_ANDROID_LAUNCH=0");
				GlobalDefinitions.Add("USE_ANDROID_JNI=0");
			}
			else if (Target.Platform == UnrealTargetPlatform.IOS) // TODO: this doesn't compile
			{
				GlobalDefinitions.Add("HAS_METAL=0");

				bIsBuildingConsoleApplication = false;
				// Required for IOS, but needs to fix compilation errors
				bCompileAgainstApplicationCore = true;

			}
		}
	}
}