public TestResult Run(ezCMake.CMakeResult cmakeResults, ezBuild.BuildResult buildResults)
{
_Result.Clean();
Console.WriteLine("*** Starting Test ***");
if (!cmakeResults.Success)
{
_Result.Error("Test failed: CMake step failed, aborting!");
return(_Result);
}
Stopwatch sw = new Stopwatch();
sw.Start();
int iFailedTargets = 0;
List <ezCMake.TestTarget> targets = cmakeResults.TestTargets;
foreach (ezCMake.TestTarget target in targets)
{
Console.WriteLine("** Starting Test of target '{0}' **", target.Name);
// Only test targets which compiled successfully.
ezBuild.BuildTargetResult buildTargetResult = buildResults.BuildTargetResults.Find(item => item.Name == target.Name);
TestTargetResult testResult = null;
if (buildTargetResult == null || !buildTargetResult.Success)
{
// Dummy result for non-testable targets.
testResult = new TestTargetResult();
testResult.Name = target.Name;
testResult.NeedsHardwareAccess = target.NeedsHardwareAccess;
testResult.Experimental = target.Experimental;
testResult.ProcessRes = null;
if (buildTargetResult == null)
{
testResult.Error("Target '{0}' has no equivalent build target, test aborted!", testResult.Name);
}
else if (!buildTargetResult.Success)
{
testResult.Error("Target '{0}' was not build successfully, test aborted!", testResult.Name);
}
}
else
{
testResult = RunTest(target);
}
if (!testResult.Success && !testResult.Experimental)
{
iFailedTargets++;
}
_Result.TestTargetResults.Add(testResult);
}
sw.Stop();
_Result.Duration = sw.Elapsed.TotalSeconds;
_Result.Success = iFailedTargets == 0;
if (iFailedTargets > 0)
{
_Result.Error("Test failed: {0} targets failed the test!", iFailedTargets);
}
return(_Result);
}
public BuildResult Run(ezCMake.CMakeResult cmakeResults, bool bClean)
{
_Result.Clean();
Console.WriteLine("*** Starting Build ***");
if (!cmakeResults.Success)
{
_Result.Error("Build failed: CMake step failed, aborting!");
return(_Result);
}
List <ezCMake.BuildTarget> targets = cmakeResults.BuildTargets;
var buildTypes = targets.Select(x => x.BuildType).Distinct();
Dictionary <string, ezBuildTemplate> buildTemplates = new Dictionary <string, ezBuildTemplate>();
foreach (string sType in buildTypes)
{
buildTemplates[sType] = ezBuildTemplateFactory.Create(_Settings, sType);
if (buildTemplates[sType] == null)
{
_Result.Error("Build failed: No build template available for the desired configuration ({0}) and build type ({1})!",
_Settings.Configuration, sType);
return(_Result);
}
}
Stopwatch sw = new Stopwatch();
sw.Start();
if (bClean)
{
Console.WriteLine("** Cleaning Solution **");
foreach (ezBuildTemplate buildTemplate in buildTemplates.Values)
{
if (!buildTemplate.CleanSolution(_Settings.AbsCMakeWorkspace))
{
_Result.Error("Build clean: failed.");
}
}
}
List <string> successfulTargets = new List <string>();
int iFailedTargets = 0;
foreach (ezCMake.BuildTarget target in targets)
{
Console.WriteLine("** Starting Build of target '{0}' **", target.Name);
// Only build targets who's dependencies compiled successfully.
bool bMeetDependencies = !target.Dependencies.Except(successfulTargets).Any();
if (bMeetDependencies)
{
BuildTargetResult targetResult = buildTemplates[target.BuildType].BuildTarget(target, _Settings.AbsCMakeWorkspace);
targetResult.Duration = targetResult.ProcessRes.Duration;
if (targetResult.ProcessRes.ExitCode == 0)
{
successfulTargets.Add(targetResult.Name);
}
else
{
if (!target.Experimental)
{
iFailedTargets++;
}
}
_Result.BuildTargetResults.Add(targetResult);
}
else
{
// Dummy result for non-buildable targets.
BuildTargetResult targetResult = new BuildTargetResult();
targetResult.Name = target.Name;
targetResult.Experimental = target.Experimental;
targetResult.ProcessRes = null;
_Result.BuildTargetResults.Add(targetResult);
}
}
sw.Stop();
_Result.Duration = sw.Elapsed.TotalSeconds;
_Result.Success = iFailedTargets == 0;
if (iFailedTargets > 0)
{
_Result.Error("Build failed: {0} targets failed to build!", iFailedTargets);
}
return(_Result);
}
