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)); }