private static void CommandDependenciesCommon(Logger logger, Command command1, Command command2, ResultStatus expectedStatus1, ResultStatus expectedStatus2, bool cancelled = false)
{
var builder = Utils.CreateBuilder(false);
var step2 = builder.Root.Add(command2);
var step1 = builder.Root.Add(command1);
BuildStep.LinkBuildSteps(step1, step2);
if (cancelled)
{
var cancelThread = new Thread(() =>
{
Thread.Sleep(1000);
logger.Warning("Cancelling build!");
builder.CancelBuild();
});
cancelThread.Start();
}
builder.Run(Builder.Mode.Build);
Assert.That(step1.Status, Is.EqualTo(expectedStatus1));
Assert.That(step2.Status, Is.EqualTo(expectedStatus2));
}
public void TestSpawnCommandOutput()
{
Utils.CleanContext();
Utils.GenerateSourceFile("input1", "{05D6BCFA-B1FE-4AD1-920F-0352A6DEC02D}");
Utils.GenerateSourceFile("input2", "{B9D01D6C-4048-4814-A2DF-9D317A492B10}");
var builder = Utils.CreateBuilder();
var command = new InputOutputCommand {
Delay = 100, Source = new ObjectUrl(UrlType.File, Utils.GetSourcePath("input1")), OutputUrl = "/db/url1"
};
command.CommandsToSpawn.Add(new InputOutputCommand {
Delay = 100, Source = new ObjectUrl(UrlType.File, Utils.GetSourcePath("input2")), OutputUrl = "/db/url2"
});
CommandBuildStep step = builder.Root.Add(command);
builder.Run(Builder.Mode.Build);
builder.WriteIndexFile(false);
Assert.That(step.SpawnedSteps.Count(), Is.EqualTo(1));
var indexMap = AssetIndexMap.Load();
indexMap.UseTransaction = true;
indexMap.LoadNewValues();
ObjectId outputId;
bool objectIdFound = indexMap.TryGetValue("/db/url2", out outputId);
Assert.IsTrue(objectIdFound);
Assert.That(step.SpawnedSteps.First().Result.OutputObjects[new ObjectUrl(UrlType.Internal, "/db/url2")], Is.EqualTo(outputId));
}
private static void ExecuteSpawnAndAwaitCommands(ResultStatus expectedResult)
{
var builder = Utils.CreateBuilder();
var commands = new List <Command>();
for (int i = 0; i < 10; ++i)
{
commands.Add(new SpawnAndAwaitCommand());
}
var steps = builder.Root.Add(commands);
builder.Run(Builder.Mode.Build);
foreach (var step in steps)
{
Assert.That(step.Status, Is.EqualTo(expectedResult));
Assert.That(step.Result.SpawnedCommands.Count(), Is.EqualTo(10));
Assert.That(step.SpawnedSteps.Count(), Is.EqualTo(10));
foreach (BuildStep childStep in step.SpawnedSteps)
{
Assert.That(childStep.Status, Is.EqualTo(expectedResult));
}
}
}
public void TestUseBuildCacheOutput()
{
Utils.CleanContext();
Utils.GenerateSourceFile("input1", "{32E4EDF4-E8AA-4D13-B111-9BD8AA2A8B07}");
var builder1 = Utils.CreateBuilder(false);
builder1.Root.Add(new InputOutputCommand {
Delay = 100, Source = new ObjectUrl(UrlType.File, Utils.GetSourcePath("input1")), OutputUrl = "/db/url1"
});
builder1.Run(Builder.Mode.Build);
var builder2 = Utils.CreateBuilder(true);
CommandBuildStep step = builder2.Root.Add(new InputOutputCommand {
Delay = 100, Source = new ObjectUrl(UrlType.File, Utils.GetSourcePath("input1")), OutputUrl = "/db/url1"
});
builder2.Run(Builder.Mode.Build);
builder2.WriteIndexFile(false);
Assert.That(step.Status, Is.EqualTo(ResultStatus.NotTriggeredWasSuccessful));
Assert.IsTrue(step.Result.OutputObjects.Keys.Contains(new ObjectUrl(UrlType.ContentLink, "/db/url1")));
var indexMap = AssetIndexMap.Load(VirtualFileSystem.ApplicationDatabaseIndexPath);
indexMap.UseTransaction = true;
indexMap.LoadNewValues();
ObjectId outputId;
bool objectIdFound = indexMap.TryGetValue("/db/url1", out outputId);
Assert.IsTrue(objectIdFound);
Assert.That(step.Result.OutputObjects[new ObjectUrl(UrlType.ContentLink, "/db/url1")], Is.EqualTo(outputId));
}
public void TestMultipleDependencies()
{
Utils.CleanContext();
var builder = Utils.CreateBuilder(false);
var firstStep = builder.Root.Add(new DummyBlockingCommand {
Delay = 100
});
var parentStep = builder.Root.Add(new DummyBlockingCommand {
Delay = 100
});
var step1 = builder.Root.Add(new DummyBlockingCommand {
Delay = 100
});
var step2 = builder.Root.Add(new DummyBlockingCommand {
Delay = 200
});
var finalStep = builder.Root.Add(new DummyBlockingCommand {
Delay = 100
});
BuildStep.LinkBuildSteps(firstStep, parentStep);
BuildStep.LinkBuildSteps(parentStep, step1);
BuildStep.LinkBuildSteps(parentStep, step2);
BuildStep.LinkBuildSteps(step1, finalStep);
BuildStep.LinkBuildSteps(step2, finalStep);
builder.Run(Builder.Mode.Build);
Assert.That(firstStep.Status, Is.EqualTo(ResultStatus.Successful));
Assert.That(parentStep.Status, Is.EqualTo(ResultStatus.Successful));
Assert.That(step1.Status, Is.EqualTo(ResultStatus.Successful));
Assert.That(step2.Status, Is.EqualTo(ResultStatus.Successful));
Assert.That(finalStep.Status, Is.EqualTo(ResultStatus.Successful));
}
public void TestCancelCallback()
{
Logger logger = Utils.CleanContext();
var builder = Utils.CreateBuilder(false);
var commands = new List <Command>();
for (var i = 0; i < 10; ++i)
{
commands.Add(new BlockedCommand());
}
IEnumerable <BuildStep> steps = builder.Root.Add(commands);
var cancelThread = new Thread(() =>
{
Thread.Sleep(1000);
logger.Warning("Cancelling build!");
builder.CancelBuild();
});
cancelThread.Start();
builder.Run(Builder.Mode.Build);
foreach (BuildStep step in steps)
{
Assert.That(step.Status, Is.EqualTo(ResultStatus.Cancelled));
}
}
public void TestConcurrencyReadWriteAccess()
{
Utils.CleanContext();
Utils.GenerateSourceFile("input1", "{99D73F8B-587A-4869-97AE-4A7185D88AC9}");
var inputDep = new ObjectUrl(UrlType.File, Utils.GetSourcePath("input1"));
var builder = Utils.CreateBuilder(false);
CommandBuildStep step = builder.Root.Add(new InputOutputTestCommand {
Delay = 100, Source = new ObjectUrl(UrlType.File, Utils.GetSourcePath("input1")), OutputUrl = "/db/url1", InputDependencies = { inputDep }
});
CommandBuildStep concurrencyStep1 = builder.Root.Add(new InputOutputTestCommand {
Delay = 100, Source = new ObjectUrl(UrlType.Content, "/db/url1"), OutputUrl = "/db/url1", InputDependencies = { inputDep }
});
CommandBuildStep concurrencyStep2 = builder.Root.Add(new InputOutputTestCommand {
Delay = 150, Source = new ObjectUrl(UrlType.Content, "/db/url1"), OutputUrl = "/db/url2", InputDependencies = { inputDep }
});
BuildStep.LinkBuildSteps(step, concurrencyStep1);
BuildStep.LinkBuildSteps(step, concurrencyStep2);
builder.Run(Builder.Mode.Build);
var logger = (LoggerResult)builder.Logger;
Assert.That(logger.Messages.Any(x => x.Text.Contains("Command InputOutputTestCommand /db/url1 > /db/url1 is writing /db/url1 while command InputOutputTestCommand /db/url1 > /db/url2 is reading it")));
}
public void TestCancellationToken()
{
Logger logger = Utils.CleanContext();
var builder = Utils.CreateBuilder();
var commands = new List <Command>();
for (var i = 0; i < 8; ++i)
{
commands.Add(new DummyBlockingCommand {
Delay = 1000000
});
}
for (var i = 0; i < 8; ++i)
{
commands.Add(new DummyAwaitingCommand {
Delay = 1000000
});
}
IEnumerable <BuildStep> steps = builder.Root.Add(commands);
var cancelThread = new Thread(() =>
{
Thread.Sleep(1000);
logger.Warning("Cancelling build!");
builder.CancelBuild();
});
cancelThread.Start();
builder.Run(Builder.Mode.Build);
foreach (BuildStep step in steps)
{
Assert.That(step.Status, Is.EqualTo(ResultStatus.Cancelled));
}
}
public void TestSpawnCommandOutput()
{
Utils.CleanContext();
Utils.GenerateSourceFile("input1", "{05D6BCFA-B1FE-4AD1-920F-0352A6DEC02D}");
Utils.GenerateSourceFile("input2", "{B9D01D6C-4048-4814-A2DF-9D317A492B10}");
var builder = Utils.CreateBuilder(true);
var command = new InputOutputTestCommand {
Delay = 100, Source = new ObjectUrl(UrlType.File, Utils.GetSourcePath("input1")), OutputUrl = "/db/url1"
};
command.CommandsToSpawn.Add(new InputOutputTestCommand {
Delay = 100, Source = new ObjectUrl(UrlType.File, Utils.GetSourcePath("input2")), OutputUrl = "/db/url2"
});
CommandBuildStep step = builder.Root.Add(command);
builder.Run(Builder.Mode.Build);
builder.WriteIndexFile(false);
var indexMap = ContentIndexMap.Load(VirtualFileSystem.ApplicationDatabaseIndexPath);
indexMap.UseTransaction = true;
indexMap.LoadNewValues();
ObjectId outputId;
bool objectIdFound = indexMap.TryGetValue("/db/url2", out outputId);
Assert.IsTrue(objectIdFound);
}
public void TestSameCommandParallelExecution()
{
Utils.CleanContext();
var builder = Utils.CreateBuilder(false);
var commands = new List<Command>();
for (int i = 0; i < 100; ++i)
{
TestCommand.ResetCounter();
commands.Add(new DummyBlockingCommand { Delay = 100 });
}
IEnumerable<BuildStep> steps = builder.Root.Add(commands);
builder.Run(Builder.Mode.Build);
int successful = 0;
int notTriggeredWasSuccessful = 0;
foreach (BuildStep step in steps)
{
if (step.Status == ResultStatus.Successful)
++successful;
if (step.Status == ResultStatus.NotTriggeredWasSuccessful)
++notTriggeredWasSuccessful;
}
Assert.That(successful, Is.EqualTo(1));
Assert.That(notTriggeredWasSuccessful, Is.EqualTo(commands.Count - 1));
}
public void TestCancelPrerequisites()
{
Logger logger = Utils.CleanContext();
var builder = Utils.CreateBuilder(false);
var steps1 = new List <BuildStep>();
var steps2 = new List <BuildStep>();
var steps3 = new List <BuildStep>();
for (var i = 0; i < 4; ++i)
{
BuildStep parentStep = builder.Root.Add(new DummyBlockingCommand {
Delay = 10
});
steps1.Add(parentStep);
for (var j = 0; j < 4; ++j)
{
BuildStep step = builder.Root.Add(new DummyBlockingCommand {
Delay = 1000000
});
BuildStep.LinkBuildSteps(parentStep, step);
steps2.Add(step);
for (var k = 0; k < 4; ++k)
{
BuildStep childStep = builder.Root.Add(new DummyBlockingCommand {
Delay = 1000000
});
BuildStep.LinkBuildSteps(step, childStep);
steps3.Add(childStep);
}
}
}
var cancelThread = new Thread(() =>
{
Thread.Sleep(1000);
logger.Warning("Cancelling build!");
builder.CancelBuild();
});
cancelThread.Start();
builder.Run(Builder.Mode.Build);
foreach (BuildStep step in steps1)
{
Assert.That(step.Status, Is.EqualTo(ResultStatus.Successful));
}
foreach (BuildStep step in steps2)
{
Assert.That(step.Status, Is.EqualTo(ResultStatus.Cancelled));
}
foreach (BuildStep step in steps3)
{
Assert.That(step.Status, Is.EqualTo(ResultStatus.NotTriggeredPrerequisiteFailed));
}
}
private static void ExecuteSimpleBuilder(ResultStatus expectedResult)
{
var builder = Utils.CreateBuilder(false);
var commands = new List<Command>();
for (int i = 0; i < 10; ++i)
commands.Add(new DummyBlockingCommand { Delay = 100 });
IEnumerable<BuildStep> steps = builder.Root.Add(commands);
builder.Run(Builder.Mode.Build);
foreach (BuildStep step in steps)
Assert.That(step.Status, Is.EqualTo(expectedResult));
}
public void TestBlockingCommands()
{
Utils.CleanContext();
var builder = Utils.CreateBuilder(false);
var commands = new List<Command>();
for (int i = 0; i < 100; ++i)
commands.Add(new DummyBlockingCommand { Delay = 100 });
IEnumerable<BuildStep> steps = builder.Root.Add(commands);
builder.Run(Builder.Mode.Build);
foreach (BuildStep step in steps)
Assert.That(step.Status, Is.EqualTo(ResultStatus.Successful));
}
public void TestBuilder()
{
Utils.CleanContext();
if (File.Exists(QueryMetadataProvider.DefaultDatabaseFilename))
{
File.Delete(QueryMetadataProvider.DefaultDatabaseFilename);
}
using (var provider = new QueryMetadataProvider())
{
const string TestStringKeyName = "TestString";
const string TestFloatKeyName = "TestFloat";
var testStringKey = new MetadataKey(TestStringKeyName, MetadataKey.DatabaseType.String);
var testFloatKey = new MetadataKey(TestFloatKeyName, MetadataKey.DatabaseType.Float);
// Create database
bool result = provider.Create(QueryMetadataProvider.DefaultDatabaseFilename);
Assert.True(result);
// Add a key and retrieve it
provider.AddKey(testStringKey);
provider.AddKey(testFloatKey);
provider.Write(new ObjectMetadata("/assets/${PathVariable}/url1", testStringKey, "Test1"));
provider.Write(new ObjectMetadata("/assets/${PathVariable}/url2", testStringKey, "Test2"));
provider.Write(new ObjectMetadata("/assets/${PathVariable}/url3", testFloatKey, 42.69f));
}
var builder = Utils.CreateBuilder();
var commands = new List <Command>();
builder.MetadataDatabaseDirectory = "./";
builder.InitialVariables.Add("PathVariable".ToUpperInvariant(), "path/via/variable");
commands.Add(new EchoCommand("/assets/${PathVariable}/url1", "Metadata TestString: (${Metadata:TestString})"));
commands.Add(new EchoCommand("/assets/${PathVariable}/url2", "Metadata TestString: (${Metadata:TestString})"));
commands.Add(new EchoCommand("/assets/${PathVariable}/url3", "Metadata TestFloat: (${Metadata:TestFloat})"));
commands.Add(new EchoCommand("/assets/${PathVariable}/url4", "Non existing metadata: (${Metadata:NonExisting})"));
builder.Root.Add(commands);
builder.Run(Builder.Mode.Build);
Assert.That(((EchoCommand)commands[0]).Echo, Is.EqualTo("Metadata TestString: (Test1)"));
Assert.That(((EchoCommand)commands[1]).Echo, Is.EqualTo("Metadata TestString: (Test2)"));
Assert.That(((EchoCommand)commands[2]).Echo, Is.EqualTo("Metadata TestFloat: (" + 42.69f + ")"));
Assert.That(((EchoCommand)commands[3]).Echo, Is.EqualTo("Non existing metadata: ()"));
}
void CommonSingleOutput(bool executeRemotely)
{
var builder = Utils.CreateBuilder();
CommandBuildStep step = builder.Root.Add(new InputOutputCommand {
Delay = 100, Source = new ObjectUrl(UrlType.File, Utils.GetSourcePath("input1")), OutputUrl = "/db/url1", ExecuteRemotely = executeRemotely
});
builder.Run(Builder.Mode.Build);
builder.WriteIndexFile(false);
Assert.Contains(new ObjectUrl(UrlType.Internal, "/db/url1"), step.Result.OutputObjects.Keys);
var indexMap = AssetIndexMap.Load();
indexMap.UseTransaction = true;
indexMap.LoadNewValues();
ObjectId outputId;
bool objectIdFound = indexMap.TryGetValue("/db/url1", out outputId);
Assert.IsTrue(objectIdFound);
Assert.That(step.Result.OutputObjects[new ObjectUrl(UrlType.Internal, "/db/url1")], Is.EqualTo(outputId));
}
