public static void GetCyclePaths_GivenEmptyTables_ReturnsEmptyCollection() { var cycleDetector = new CycleDetector(); var result = cycleDetector.GetCyclePaths(Array.Empty <IRelationalDatabaseTable>()); Assert.That(result, Is.Empty); }
public void DisconnectedGraphCycleIsDetected() { var graph = new[] { new GraphVertex <int> { Value = 1, }, new GraphVertex <int> { Value = 2, AdjacentVertices = new System.Collections.Generic.List <int> { 2 } }, new GraphVertex <int> { Value = 2, AdjacentVertices = new System.Collections.Generic.List <int> { 1 } }, }; Assert.True(CycleDetector.IsCyclic(graph)); }
public void TestFindAnyCycleFromManyCycles() { using (var env = new TestEnvironment()) { env.CreateRepo("A", new Dictionary <string, DepsContent> { { "full-build", new DepsContent(null, new List <Dep> { new Dep("B"), new Dep("C") }) } }); env.CreateRepo("B", new Dictionary <string, DepsContent> { { "full-build", new DepsContent(null, new List <Dep> { new Dep("D") }) } }); env.CreateRepo("C", new Dictionary <string, DepsContent> { { "full-build", new DepsContent(null, new List <Dep> { new Dep("D") }) } }); env.CreateRepo("D", new Dictionary <string, DepsContent> { { "full-build", new DepsContent(null, new List <Dep> { new Dep("A") }) } }); Helper.SetWorkspace(env.RemoteWorkspace); var cycle = CycleDetector.TryFindCycle("A"); Assert.IsNotNull(cycle); } }
private ILookup <ISourceFile, ISourceFile> ReportFailuresForCycles() { var sourceFileGraph = this.sourceFilesByUri.Values .SelectMany(sourceFile => GetModuleDeclarations(sourceFile) .Where(this.sourceFilesByModuleDeclaration.ContainsKey) .Select(moduleDeclaration => this.sourceFilesByModuleDeclaration[moduleDeclaration]) .Distinct() .Select(referencedFile => (sourceFile, referencedFile))) .ToLookup(x => x.sourceFile, x => x.referencedFile); var cycles = CycleDetector <ISourceFile> .FindCycles(sourceFileGraph); foreach (var(moduleDeclaration, moduleSourceFile) in sourceFilesByModuleDeclaration) { if (cycles.TryGetValue(moduleSourceFile, out var cycle)) { if (cycle.Length == 1) { errorBuildersByModuleDeclaration[moduleDeclaration] = x => x.CyclicModuleSelfReference(); } else { errorBuildersByModuleDeclaration[moduleDeclaration] = x => x.CyclicModule(cycle.Select(x => x.FileUri.LocalPath)); } } } return(sourceFileGraph); }
public void TestCycleWithTwoWays() { using (var env = new TestEnvironment()) { env.CreateRepo("A", new Dictionary <string, DepsData> { { "full-build", new DepsData(null, new List <Dep> { new Dep("B"), new Dep("C") }) } }); env.CreateRepo("C", new Dictionary <string, DepsData> { { "full-build", new DepsData(null, new List <Dep> { new Dep("D") }) } }); env.CreateRepo("D", new Dictionary <string, DepsData> { { "full-build", new DepsData(null, new List <Dep> { new Dep("C") }) } }); Helper.SetWorkspace(env.RemoteWorkspace); var cycle = CycleDetector.TryFindCycle("A"); Assert.AreEqual(new[] { "A/full-build", "C/full-build", "D/full-build", "C/full-build" }, cycle.ToArray()); } }
public void TestNoCycleInDirectedGraph() { using (var env = new TestEnvironment()) { env.CreateRepo("A", new Dictionary <string, DepsData> { { "full-build", new DepsData(null, new List <Dep> { new Dep("B"), new Dep("C") }) } }); env.CreateRepo("B", new Dictionary <string, DepsData> { { "full-build", new DepsData(null, new List <Dep> { new Dep("D") }) } }); env.CreateRepo("C", new Dictionary <string, DepsData> { { "full-build", new DepsData(null, new List <Dep> { new Dep("D") }) } }); env.CreateRepo("D", new Dictionary <string, DepsData> { { "full-build", new DepsData(null, new List <Dep>()) } }); Helper.SetWorkspace(env.RemoteWorkspace); var cycle = CycleDetector.TryFindCycle("A"); Assert.IsNull(cycle); } }
private ImmutableDictionary <DeclaredSymbol, ImmutableArray <DeclaredSymbol> > FindCycles() { var symbolGraph = declarationAccessDict .SelectMany(kvp => kvp.Value.Select(x => bindings[x]).OfType <DeclaredSymbol>().Select(x => (kvp.Key, x))) .ToLookup(x => x.Item1, x => x.Item2); return(CycleDetector <DeclaredSymbol> .FindCycles(symbolGraph)); }
public void ExampleHistoryRepeatItselfTest(string fileName, long expectedSteps) { var exampleLoader = new AlternateExampleLoader(fileName); var cycleDetector = new CycleDetector(exampleLoader.MoonsPositions); var cycleSteps = cycleDetector.FindCycleSteps(); Assert.Equal(expectedSteps, cycleSteps); }
private void CheckCycle() { var diGraph = DiGraph <string> .GetDiGraph(Model.NodesSource.Cast <NodeModel>(), Model.LinksSource.Cast <LinkModel>()); var algorithm = new CycleDetector <string>(); var HasCycle = algorithm.HasCycle(diGraph); MessageBox.Show(HasCycle.ToString()); }
public void DoesNotThrowWhenThereAreNoCycles() { var mockContainer = new Mock <IContainer>(); mockContainer.Setup(x => x.GetDependencies(typeof(A))) .Returns(new[] { typeof(B) }); mockContainer.Setup(x => x.GetDependencies(typeof(B))) .Returns(new[] { typeof(C) }); CycleDetector.CheckForCycles(typeof(A), mockContainer.Object); }
public GetCommand() : base( new CommandSettings { LogPerfix = "GET", LogFileName = "get", MeasureElapsedTime = true, Location = CommandSettings.CommandLocation.WorkspaceDirectory }) { cycleDetector = new CycleDetector(); }
/// <summary> /// Analyses database tables. Reports messages when a set of foreign key relationships forms a cycle. /// </summary> /// <param name="tables">A set of database tables.</param> /// <param name="cancellationToken">A cancellation token used to interrupt analysis.</param> /// <returns>A set of linting messages used for reporting. An empty set indicates no issues discovered.</returns> /// <exception cref="ArgumentNullException"><paramref name="tables"/> is <c>null</c>.</exception> public IAsyncEnumerable <IRuleMessage> AnalyseTables(IEnumerable <IRelationalDatabaseTable> tables, CancellationToken cancellationToken = default) { if (tables == null) { throw new ArgumentNullException(nameof(tables)); } var cycleDetector = new CycleDetector(); var cycles = cycleDetector.GetCyclePaths(tables.ToList()); return(cycles.Select(BuildMessage).ToAsyncEnumerable()); }
public void Calculate_cykl() { var odbiorcy = new List <InputData>() { new InputData(0, InputType.Odbiorca, 10, 30), new InputData(1, InputType.Odbiorca, 28, 25), new InputData(2, InputType.Odbiorca, 27, 30), new InputData(3, InputType.Odbiorca, 50, null, true) }; var dostawcy = new List <InputData>() { new InputData(0, InputType.Dostawca, 20, 10), new InputData(1, InputType.Dostawca, 30, 12), new InputData(2, InputType.Odbiorca, 65, null, true) }; var datagrid = Utility.CreateEmptyCellGrid(dostawcy.Count, odbiorcy.Count); datagrid[0][0].KosztyJednostkowe = 8; datagrid[0][1].KosztyJednostkowe = 14; datagrid[0][2].KosztyJednostkowe = 17; datagrid[1][0].KosztyJednostkowe = 12; datagrid[1][1].KosztyJednostkowe = 9; datagrid[1][2].KosztyJednostkowe = 19; datagrid[0][3].IsVirtual = true; datagrid[1][3].IsVirtual = true; datagrid[2][3].IsVirtual = true; datagrid[2][0].IsVirtual = true; datagrid[2][1].IsVirtual = true; datagrid[2][2].IsVirtual = true; var iteracja = new IterationProfit(datagrid, JobType.Profit, 1); iteracja.CalculateZysk(dostawcy, odbiorcy); iteracja.CalculatePrzydzial(dostawcy, odbiorcy); iteracja.CalculateWspolczynnikiAlfaAndBeta(); iteracja.CalculateDeltyNiebazowe(); var cycleDetector = new CycleDetector(iteracja.DataGrid, CycleBaseType.Maximizing).Detect(); var points = cycleDetector.WyznaczonyCykl.ToPointsList(); var expectedPoints = new string[] { "13", "12", "22", "23" }.ToList(); Assert.IsTrue(expectedPoints.Contains(points[0].Id)); Assert.IsTrue(expectedPoints.Contains(points[1].Id)); Assert.IsTrue(expectedPoints.Contains(points[2].Id)); Assert.IsTrue(expectedPoints.Contains(points[3].Id)); Assert.AreEqual(2, cycleDetector.FindPrzydzialDoOptymalizacji()); }
public void ThrowsExceptionWhenCycleExists() { var mockContainer = new Mock <IContainer>(); mockContainer.Setup(x => x.GetDependencies(typeof(A))) .Returns(new[] { typeof(B) }); mockContainer.Setup(x => x.GetDependencies(typeof(B))) .Returns(new[] { typeof(C) }); mockContainer.Setup(x => x.GetDependencies(typeof(C))) .Returns(new[] { typeof(A) }); CycleDetector.CheckForCycles(typeof(A), mockContainer.Object); }
public async Task RenderAsync(CancellationToken cancellationToken = default) { if (!ExportDirectory.Exists) { ExportDirectory.Create(); } var cycleDetector = new CycleDetector(); var cycles = cycleDetector.GetCyclePaths(Tables); var hasCycles = cycles.Count > 0; // TODO acutlly use the canellation tokens here await ExportInsertionOrderAsync(hasCycles, cancellationToken).ConfigureAwait(false); await ExportDeletionOrderAsync(hasCycles, cancellationToken).ConfigureAwait(false); }
public void CycleIsNotDetectedForNonCycledGraph() { var graph = new[] { new GraphVertex <int> { Value = 1, AdjacentVertices = new System.Collections.Generic.List <int> { 1 } }, new GraphVertex <int> { Value = 2, }, }; Assert.False(CycleDetector.IsCyclic(graph)); }
protected override int Execute() { string workspace = Directory.GetCurrentDirectory(); if (!Helper.IsCurrentDirectoryModule(Path.Combine(workspace, module))) { throw new CementTrackException($"{workspace} is not cement workspace directory."); } configuration = string.IsNullOrEmpty(configuration) ? "full-build" : configuration; Log.Info("Updating packages"); PackageUpdater.UpdatePackages(); GetModule(); CycleDetector.WarnIfCycle(module, configuration, Log); Log.Info("SUCCESS get " + module); return(0); }
public void TestSimpleCycle() { using (var env = new TestEnvironment()) { env.CreateRepo("A", new Dictionary <string, DepsContent> { { "full-build", new DepsContent(null, new List <Dep> { new Dep("B") }) } }); env.CreateRepo("B", new Dictionary <string, DepsContent> { { "full-build", new DepsContent(null, new List <Dep> { new Dep("A") }) } }); Helper.SetWorkspace(env.RemoteWorkspace); var cycle = CycleDetector.TryFindCycle("A"); Assert.AreEqual(new[] { "A/full-build", "B/full-build", "A/full-build" }, cycle.ToArray()); } }
public void TestNoCycleIfDifferentConfigs() { using (var env = new TestEnvironment()) { env.CreateRepo("A", new Dictionary <string, DepsData> { { "full-build", new DepsData(null, new List <Dep> { new Dep("B") }) }, { "client", new DepsData(null, new List <Dep>()) } }); env.CreateRepo("B", new Dictionary <string, DepsData> { { "full-build", new DepsData(null, new List <Dep> { new Dep("A", null, "client") }) } }); Helper.SetWorkspace(env.RemoteWorkspace); var cycle = CycleDetector.TryFindCycle("A/full-build"); Assert.IsNull(cycle); } }
private void ReportFailuresForCycles() { var syntaxTreeGraph = syntaxTrees.Values.OfType <SyntaxTree>() .SelectMany(tree => GetModuleSyntaxes(tree).Where(moduleLookup.ContainsKey).Select(x => moduleLookup[x]).Distinct().Select(x => (tree, x))) .ToLookup(x => x.Item1, x => x.Item2); var cycles = CycleDetector <SyntaxTree> .FindCycles(syntaxTreeGraph); foreach (var kvp in moduleLookup) { if (cycles.TryGetValue(kvp.Value, out var cycle)) { if (cycle.Length == 1) { moduleFailureLookup[kvp.Key] = x => x.CyclicModuleSelfReference(); } else { moduleFailureLookup[kvp.Key] = x => x.CyclicModule(cycle.Select(x => x.FileUri.LocalPath)); } } } }
public void TestCycleWithDefaultConfig() { using (var env = new TestEnvironment()) { env.CreateRepo("A", new Dictionary <string, DepsData> { { "full-build", new DepsData(null, new List <Dep> { new Dep("B") }) }, { "client *default", new DepsData(null, new List <Dep> { new Dep("B") }) } }); env.CreateRepo("B", new Dictionary <string, DepsData> { { "full-build", new DepsData(null, new List <Dep> { new Dep("A", null, "full-build") }) } }); Helper.SetWorkspace(env.RemoteWorkspace); var cycle = CycleDetector.TryFindCycle("A"); Assert.AreEqual(new[] { "A/client", "B/full-build", "A/full-build", "B/full-build" }, cycle); } }
public void Graph_Cycle_Detection_Tests() { var graph = new DiGraph <char>(); graph.AddVertex('A'); graph.AddVertex('B'); graph.AddVertex('C'); graph.AddVertex('D'); graph.AddVertex('E'); graph.AddVertex('F'); graph.AddVertex('G'); graph.AddVertex('H'); graph.AddEdge('A', 'B'); graph.AddEdge('B', 'C'); graph.AddEdge('C', 'A'); graph.AddEdge('C', 'D'); graph.AddEdge('D', 'E'); graph.AddEdge('E', 'F'); graph.AddEdge('F', 'G'); graph.AddEdge('G', 'E'); graph.AddEdge('F', 'H'); var algo = new CycleDetector <char>(); Assert.IsTrue(algo.HasCycle(graph)); graph.RemoveEdge('C', 'A'); graph.RemoveEdge('G', 'E'); Assert.IsFalse(algo.HasCycle(graph)); }
public void Graph_Cycle_Detection_AdjancencyListGraph_Tests() { var graph = new Advanced.Algorithms.DataStructures.Graph.AdjacencyList.DiGraph <char>(); graph.AddVertex('A'); graph.AddVertex('B'); graph.AddVertex('C'); graph.AddVertex('D'); graph.AddVertex('E'); graph.AddVertex('F'); graph.AddVertex('G'); graph.AddVertex('H'); graph.AddEdge('A', 'B'); graph.AddEdge('B', 'C'); graph.AddEdge('C', 'A'); graph.AddEdge('C', 'D'); graph.AddEdge('D', 'E'); graph.AddEdge('E', 'F'); graph.AddEdge('F', 'G'); graph.AddEdge('G', 'E'); graph.AddEdge('F', 'H'); var algorithm = new CycleDetector <char>(); Assert.IsTrue(algorithm.HasCycle(graph)); graph.RemoveEdge('C', 'A'); graph.RemoveEdge('G', 'E'); Assert.IsFalse(algorithm.HasCycle(graph)); }
public static void GetCyclePaths_GivenTablesWithCycle_ReturnsEmptyCollection() { var cycleDetector = new CycleDetector(); var mockChildKey = new Mock <IDatabaseKey>(); mockChildKey.Setup(c => c.KeyType).Returns(DatabaseKeyType.Foreign); var childKey = mockChildKey.Object; var mockParentKey = new Mock <IDatabaseKey>(); mockParentKey.Setup(p => p.KeyType).Returns(DatabaseKeyType.Primary); var parentKey = mockParentKey.Object; // create tables with no cycle where the path is a -> b -> c -> a var tableAMock = new Mock <IRelationalDatabaseTable>(); tableAMock.Setup(t => t.Name).Returns(Identifier.CreateQualifiedIdentifier("a")); tableAMock.Setup(t => t.ParentKeys).Returns(new[] { new DatabaseRelationalKey( Identifier.CreateQualifiedIdentifier("a"), childKey, Identifier.CreateQualifiedIdentifier("b"), parentKey, ReferentialAction.NoAction, ReferentialAction.NoAction ) }); var tableBMock = new Mock <IRelationalDatabaseTable>(); tableBMock.Setup(t => t.Name).Returns(Identifier.CreateQualifiedIdentifier("b")); tableBMock.Setup(t => t.ParentKeys).Returns(new[] { new DatabaseRelationalKey( Identifier.CreateQualifiedIdentifier("b"), childKey, Identifier.CreateQualifiedIdentifier("c"), parentKey, ReferentialAction.NoAction, ReferentialAction.NoAction ) }); var tableCMock = new Mock <IRelationalDatabaseTable>(); tableCMock.Setup(t => t.Name).Returns(Identifier.CreateQualifiedIdentifier("c")); tableCMock.Setup(t => t.ParentKeys).Returns(new[] { new DatabaseRelationalKey( Identifier.CreateQualifiedIdentifier("c"), childKey, Identifier.CreateQualifiedIdentifier("a"), parentKey, ReferentialAction.NoAction, ReferentialAction.NoAction ) }); var tables = new[] { tableAMock.Object, tableBMock.Object, tableCMock.Object }; var result = cycleDetector.GetCyclePaths(tables); var cycleTableNames = result.SelectMany(c => c.Select(t => t.LocalName)).ToList(); var expectedCycle = new[] { "a", "b", "c" }; Assert.Multiple(() => { Assert.That(result, Has.Exactly(1).Items); Assert.That(cycleTableNames, Has.Exactly(3).Items); Assert.That(cycleTableNames, Is.EquivalentTo(expectedCycle)); }); }
public static void GetCyclePaths_GivenTablesWithNoCycle_ReturnsEmptyCollection() { var cycleDetector = new CycleDetector(); var mockChildKey = new Mock <IDatabaseKey>(); mockChildKey.Setup(c => c.KeyType).Returns(DatabaseKeyType.Foreign); var childKey = mockChildKey.Object; var mockParentKey = new Mock <IDatabaseKey>(); mockParentKey.Setup(p => p.KeyType).Returns(DatabaseKeyType.Primary); var parentKey = mockParentKey.Object; // create tables with no cycle where the path is a -> b -> c var tableAMock = new Mock <IRelationalDatabaseTable>(); tableAMock.Setup(t => t.Name).Returns(Identifier.CreateQualifiedIdentifier("a")); tableAMock.Setup(t => t.ParentKeys).Returns(new[] { new DatabaseRelationalKey( Identifier.CreateQualifiedIdentifier("a"), childKey, Identifier.CreateQualifiedIdentifier("b"), parentKey, ReferentialAction.NoAction, ReferentialAction.NoAction ) }); var tableBMock = new Mock <IRelationalDatabaseTable>(); tableBMock.Setup(t => t.Name).Returns(Identifier.CreateQualifiedIdentifier("b")); tableBMock.Setup(t => t.ParentKeys).Returns(new[] { new DatabaseRelationalKey( Identifier.CreateQualifiedIdentifier("b"), childKey, Identifier.CreateQualifiedIdentifier("c"), parentKey, ReferentialAction.NoAction, ReferentialAction.NoAction ) }); var tableCMock = new Mock <IRelationalDatabaseTable>(); tableCMock.Setup(t => t.Name).Returns(Identifier.CreateQualifiedIdentifier("c")); tableCMock.Setup(t => t.ParentKeys).Returns(Array.Empty <IDatabaseRelationalKey>()); var tables = new[] { tableAMock.Object, tableBMock.Object, tableCMock.Object }; var result = cycleDetector.GetCyclePaths(tables); Assert.That(result, Is.Empty); }
void OnChipNetworkModified() { CycleDetector.MarkAllCycles(this); }
public void Init() { this.storage = new Mock <IMetaDataStorage>(); this.underTest = new CycleDetector(this.storage.Object); }
/// <summary> /// Finds and initializes all property dependencies expressed via /// <see cref="T:ESRI.ArcLogistics.Data.PropertyDependsOnAttribute"/> attribute. /// </summary> /// <returns>Dictionary mapping names of source properties to a list /// of dependendent property names.</returns> private IDictionary<string, List<string>> _InitPropertyDependencies() { var bindingFlags = BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public; var dependentProperties = from property in this.GetType().GetProperties(bindingFlags) from attribute in property.GetCustomAttributes<PropertyDependsOnAttribute>() where !string.IsNullOrEmpty(attribute.PropertyName) group property.Name by attribute.PropertyName; var dependencies = dependentProperties.ToDictionary( group => group.Key, group => group.ToList()); var cycleDetector = new CycleDetector<string>(property => { List<string> peers; if (dependencies.TryGetValue(property, out peers)) { return peers; } return Enumerable.Empty<string>(); }); foreach (var property in dependencies.Keys) { var cycle = cycleDetector.FindCycle(property); if (cycle.Any()) { throw new PropertyDependenciesCycleException( property, cycle); } } return dependencies; }
public override GridCell[][] CalculateNextIteration() { var cycleDetector = new CycleDetector(DataGrid, CycleBaseType.Maximizing).Detect(); if (cycleDetector.Error.IsError) { Error = cycleDetector.Error; return(null); } IsOptimal = cycleDetector.IsOptimal; if (cycleDetector.IsOptimal) { IsCorrect = true; return(null); } var cycle = cycleDetector.WyznaczonyCykl; Cycle = cycle; var przydzial = cycleDetector.FindPrzydzialDoOptymalizacji(); var nextIterationGrid = Utility.CreateEmptyCellGrid(DataGrid.Length, DataGrid[0].Length); var cyclePoints = cycle.ToPointsList(); var poz_el = cycle.Start.Id; var punktyCyklu = cyclePoints.ToList(); punktyCyklu.Remove(punktyCyklu.Single(e => e.Id == poz_el)); var p1_negatywny = punktyCyklu.Single(x => x.Y == int.Parse(poz_el[0].ToString())); punktyCyklu.Remove(p1_negatywny); var p2_negatywny = punktyCyklu.Single(x => x.X == int.Parse(poz_el[1].ToString())); punktyCyklu.Remove(p2_negatywny); var p2_pozytywny = punktyCyklu.First(); for (int j = 0; j < DataGrid.Length; j++) { for (int i = 0; i < DataGrid[j].Length; i++) { nextIterationGrid[j][i].KosztyJednostkowe = DataGrid[j][i].KosztyJednostkowe; nextIterationGrid[j][i].Zysk = DataGrid[j][i].Zysk; nextIterationGrid[j][i].IsVirtual = DataGrid[j][i].IsVirtual; var wsp = cyclePoints.SingleOrDefault(e => e.Id == DataGrid[j][i].Id); if (wsp is null) { nextIterationGrid[j][i].Przydzial = DataGrid[j][i].Przydzial; } else { var isEx = true; if (p1_negatywny.Id == wsp.Id || p2_negatywny.Id == wsp.Id) { if (DataGrid[j][i].Przydzial is null) { DataGrid[j][i].Przydzial = 0; isEx = false; } nextIterationGrid[j][i].Przydzial = DataGrid[j][i].Przydzial - przydzial; } else { if (DataGrid[j][i].Przydzial is null) { DataGrid[j][i].Przydzial = 0; isEx = false; } nextIterationGrid[j][i].Przydzial = DataGrid[j][i].Przydzial + przydzial; } if (nextIterationGrid[j][i].Przydzial == 0 && isEx) { nextIterationGrid[j][i].Przydzial = null; } } } } IsCorrect = true; return(nextIterationGrid); }
public static void GetCyclePaths_GivenNullTables_ThrowsArgumentNullException() { var cycleDetector = new CycleDetector(); Assert.That(() => cycleDetector.GetCyclePaths(null), Throws.ArgumentNullException); }