public void TransitiveReduceThreeNodes()
        {
            var graph = new DependencyGraph<char>();
            graph.AddDependency('a', 'b');
            graph.AddDependency('b', 'c');
            graph.AddDependency('a', 'c');

            graph.TransitiveReduce();

            CollectionAssert.AreEqual(new[] { 'a', 'b', 'c' }, graph.Nodes);
            CollectionAssert.AreEqual(new[] { 'b' }, graph.GetDependenciesForNode('a'));
            CollectionAssert.AreEqual(new[] { 'c' }, graph.GetDependenciesForNode('b'));
        }
        public void TransitiveReduceCycles()
        {
            var graph = new DependencyGraph<char>();

            graph.AddDependency('a', 'b'); // a <--> b
            graph.AddDependency('b', 'a');

            graph.AddDependency('a', 'c'); // a --> c
            graph.AddDependency('b', 'c'); // b --> c

            graph.TransitiveReduce();

            // NOTE result here depends upon order of enumeration from HashSet<char>, making this test potentially fragile

            CollectionAssert.AreEqual(new[] { 'b' }, graph.GetDependenciesForNode('a'));
            CollectionAssert.AreEqual(new[] { 'a', 'c' }, graph.GetDependenciesForNode('b'));
        }
        public void AddDependencyTest()
        {
            var graph = new DependencyGraph<string>();
            graph.AddDependency("A", "B");

            CollectionAssert.AreEqual(new[] { "A", "B" }, graph.Nodes);
            CollectionAssert.AreEqual(new[] { "B" }, graph.GetDependenciesForNode("A"));
        }
예제 #4
0
        protected override IEnumerable<IComponent> GetComponentsToRun(string action, ComponentRunContext runContext)
        {
            var graph = new DependencyGraph<IComponent>();

            var prerequisites = new PrerequisitesComponent(mReleaseInfo);
            var tplComponent = new TemplatesComponent(mReleaseInfo);
            var reportsComponent = new ReportsComponent(mReleaseInfo);
            var scriptsComponent = new ScriptsComponent(mReleaseInfo, mDbConnection);

            graph.AddDependency(prerequisites, tplComponent);
            graph.AddDependency(prerequisites, reportsComponent);
            graph.AddDependency(prerequisites, scriptsComponent);
            graph.AddDependency(tplComponent, scriptsComponent);
            graph.AddDependency(reportsComponent, scriptsComponent);

            return graph.GetPath();
        }
        public void AddDependencyTest()
        {
            var graph = new DependencyGraph<string>();
            graph.AddDependency("A", "B");

            TestHelper.AssertEqualArrays(new[] { "A", "B" }, graph.GetNodes().ToArray());
            TestHelper.AssertEqualArrays(new[] { "B" }, graph.GetDependenciesForNode("A").ToArray());
        }
        public void GenerateDotCommand_ExclusionList()
        {
            var graph = new DependencyGraph<string>();
            graph.AddDependency("A", "B");
            graph.AddDependency("B", "C");
            graph.AddDependency("C", "A");

            var filterPreferences = new AssemblyFilterPreferences();
            filterPreferences.SetAssemblyNames(graph.GetNodes());
            filterPreferences.Exclude("C");

            var command = new DotCommandBuilder().GenerateDotCommand(graph, filterPreferences);
            
            const string expected = @"digraph G {
    1 -> 2;
    1 [label=""A""];
    2 [label=""B""];
}";

            Assertion.AssertEquals(expected, command);
        }
        public void CircularReferences2()
        {
            var dependencies = new DependencyGraph<string>();
            dependencies.AddDependency("A", "A");

            var allNodes = dependencies.Nodes;
            var startNodes = allNodes.Where(x => !allNodes.Any(y => dependencies.GetDependenciesForNode(y).Contains(x)));
            var endNodes = allNodes.Where(x => dependencies.GetDependenciesForNode(x).Count() == 0);

            var circularReferences = CircularReferencesHelper.FindCircularReferences(dependencies, startNodes, endNodes);
            Assert.IsTrue(circularReferences.Count() > 0);
        }
        public void TransitiveReduceCascade()
        {
            var graph = new DependencyGraph<char>();

            for (var c1 = 'a'; c1 < 'f'; c1++)
                for (var c2 = (char)(c1 + 1); c2 < 'f'; c2++)
                    graph.AddDependency(c1, c2);

            graph.TransitiveReduce();

            for (var c = 'a'; c < 'f' - 1; c++)
                CollectionAssert.AreEqual(new[] { (char)(c + 1) }, graph.GetDependenciesForNode(c), $"Dep of {c} should be {(char)(c+1)}");
        }
        public void GenerateDotCommand()
        {
            var graph = new DependencyGraph<string>();
            graph.AddDependency("A", "B");

            var filterPreferences = new AssemblyFilterPreferences();
            filterPreferences.SetAssemblyNames(graph.Nodes);
            var command = DotCommandBuilder.Generate(graph, filterPreferences);

            const string expected = @"digraph G {
            1 -> 2;
            1 [label=""A""];
            2 [label=""B""];
            }";

            Assert.AreEqual(expected, command);
        }
예제 #10
0
        public void Init()
        {
            var teamCollection = TfsTeamProjectCollectionFactory.GetTeamProjectCollection(new Uri("http://logpmtfs01v:8080/tfs/Logitravel"));
            var buildServer = teamCollection.GetService<IBuildServer>();
            var commonStructureService = teamCollection.GetService<Microsoft.TeamFoundation.Server.ICommonStructureService>();
            var buildDefinitionResults = Helpers.QueryBuildDefinitions(commonStructureService, buildServer, buildName: "");
            var buildDefinition = buildDefinitionResults.FirstOrDefault().Definitions.FirstOrDefault(bd => bd != null && bd.QueueStatus == DefinitionQueueStatus.Enabled);

            Graph = new DependencyGraph<ProjectInfo>();

            var ti = new TeamCollectionInfo(teamCollection);
            var bi = new BuildDefinitionInfo(ti, buildDefinition);
            var si = new SolutionInfo(bi, "S1");
            var pA = new ProjectInfo(si) { ProjectGuid = Guid.Empty, GeneratedAssembly = "A", ReferencedProjects = new System.Collections.Generic.HashSet<Guid>() };
            var pB = new ProjectInfo(si) { ProjectGuid = Guid.Empty, GeneratedAssembly = "B", ReferencedProjects = new System.Collections.Generic.HashSet<Guid>() };
            var pC = new ProjectInfo(si) { ProjectGuid = Guid.Empty, GeneratedAssembly = "C", ReferencedProjects = new System.Collections.Generic.HashSet<Guid>() };
            var pD = new ProjectInfo(si) { ProjectGuid = Guid.Empty, GeneratedAssembly = "D", ReferencedProjects = new System.Collections.Generic.HashSet<Guid>() };
            var pE = new ProjectInfo(si) { ProjectGuid = Guid.Empty, GeneratedAssembly = "E", ReferencedProjects = new System.Collections.Generic.HashSet<Guid>() };
            var pF = new ProjectInfo(si) { ProjectGuid = Guid.Empty, GeneratedAssembly = "F", ReferencedProjects = new System.Collections.Generic.HashSet<Guid>() };
            var pG = new ProjectInfo(si) { ProjectGuid = Guid.Empty, GeneratedAssembly = "G", ReferencedProjects = new System.Collections.Generic.HashSet<Guid>() };
            var pH = new ProjectInfo(si) { ProjectGuid = Guid.Empty, GeneratedAssembly = "H", ReferencedProjects = new System.Collections.Generic.HashSet<Guid>() };

            Graph.Nodes.Add(pA);
            Graph.Nodes.Add(pB);
            Graph.Nodes.Add(pC);
            Graph.Nodes.Add(pD);
            Graph.Nodes.Add(pE);
            Graph.Nodes.Add(pF);
            Graph.Nodes.Add(pG);
            Graph.Nodes.Add(pH);

            Graph.AddDependency(pA, pC);
            Graph.AddDependency(pA, pF);
            Graph.AddDependency(pA, pD);
            Graph.AddDependency(pD, pF);
            Graph.AddDependency(pD, pG);
            Graph.AddDependency(pB, pD);
            Graph.AddDependency(pB, pG);
            Graph.AddDependency(pE, pG);
            Graph.AddDependency(pG, pF);
            Graph.AddDependency(pG, pH);
        }
예제 #11
0
        private IDependencyGraph<BranchInfo> CreateBranchGraph(Configuration config)
        {
            var branchesByName = config.Branches.ToDictionary(x => x.Name);
            var graph = new DependencyGraph<BranchInfo>();

            foreach (var branchInfo in config.Branches)
            {
                if (branchInfo.Parent != null)
                {
                    var source = branchesByName[branchInfo.Parent];
                    var target = branchesByName[branchInfo.Name];
                    graph.AddDependency(source, target);
                }
                else
                {
                    graph.AddNode(branchesByName[branchInfo.Name]);
                }
            }

            return graph;
        }
예제 #12
0
 internal DependencyGraph<ProjectInfo> GetProjectsDependencies()
 {
     DependencyGraph<ProjectInfo> dependencyGraph = new DependencyGraph<ProjectInfo>();
     foreach (TeamCollectionInfo current in this.TeamCollections)
     {
         foreach (BuildDefinitionInfo current2 in current.BuildDefinitions)
         {
             foreach (SolutionInfo current3 in current2.Solutions)
             {
                 foreach (ProjectInfo current4 in current3.Projects)
                 {
                     dependencyGraph.Nodes.Add(current4);
                     current4.DependentProjects = new List<ProjectInfo>();
                     foreach (TeamCollectionInfo current5 in this.TeamCollections)
                     {
                         foreach (BuildDefinitionInfo current6 in current5.BuildDefinitions)
                         {
                             foreach (SolutionInfo current7 in current6.Solutions)
                             {
                                 foreach (ProjectInfo current8 in current7.Projects)
                                 {
                                     if (current8.ReferencedAssemblies.Contains(current4.GeneratedAssembly))
                                     {
                                         dependencyGraph.AddDependency(current8, current4);
                                         current8.DependentProjects.Add(current4);
                                     }
                                 }
                             }
                         }
                     }
                 }
             }
         }
     }
     return dependencyGraph;
 }
예제 #13
0
        public void StressTest15()
        {
            // Dependency graph
            DependencyGraph t = new DependencyGraph();

            // A bunch of strings to use
            const int SIZE = 800;

            string[] letters = new string[SIZE];
            for (int i = 0; i < SIZE; i++)
            {
                letters[i] = ("" + (char)('a' + i));
            }

            // The correct answers
            HashSet <string>[] dents = new HashSet <string> [SIZE];
            HashSet <string>[] dees  = new HashSet <string> [SIZE];
            for (int i = 0; i < SIZE; i++)
            {
                dents[i] = new HashSet <string>();
                dees[i]  = new HashSet <string>();
            }

            // Add a bunch of dependencies
            for (int i = 0; i < SIZE; i++)
            {
                for (int j = i + 1; j < SIZE; j++)
                {
                    t.AddDependency(letters[i], letters[j]);
                    dents[i].Add(letters[j]);
                    dees[j].Add(letters[i]);
                }
            }

            // Remove a bunch of dependencies
            for (int i = 0; i < SIZE; i++)
            {
                for (int j = i + 2; j < SIZE; j += 3)
                {
                    t.RemoveDependency(letters[i], letters[j]);
                    dents[i].Remove(letters[j]);
                    dees[j].Remove(letters[i]);
                }
            }

            // Replace a bunch of dependees
            for (int i = 0; i < SIZE; i += 2)
            {
                HashSet <string> newDees = new HashSet <String>();
                for (int j = 0; j < SIZE; j += 9)
                {
                    newDees.Add(letters[j]);
                }
                t.ReplaceDependees(letters[i], newDees);

                foreach (string s in dees[i])
                {
                    dents[s[0] - 'a'].Remove(letters[i]);
                }

                foreach (string s in newDees)
                {
                    dents[s[0] - 'a'].Add(letters[i]);
                }

                dees[i] = newDees;
            }

            // Make sure everything is right
            for (int i = 0; i < SIZE; i++)
            {
                Assert.IsTrue(dents[i].SetEquals(new HashSet <string>(t.GetDependents(letters[i]))));
                Assert.IsTrue(dees[i].SetEquals(new HashSet <string>(t.GetDependees(letters[i]))));
            }
        }
예제 #14
0
        public void AddToEmpty()
        {
            DependencyGraph t = new DependencyGraph();

            t.AddDependency("a", "b");
        }
예제 #15
0
        public void EmptyTest8()
        {
            DependencyGraph t = new DependencyGraph();

            t.AddDependency("a", "b");
        }
예제 #16
0
        public void SpecTest()
        {
            DependencyGraph g = new DependencyGraph();

            g.AddDependency("a", "b");
            g.AddDependency("a", "c");
            g.AddDependency("b", "d");
            g.AddDependency("d", "d");

            Assert.IsTrue(g.HasDependents("a"));
            Assert.IsTrue(g.HasDependents("b"));
            Assert.IsFalse(g.HasDependents("c"));
            Assert.IsTrue(g.HasDependents("d"));

            Assert.IsFalse(g.HasDependees("a"));
            Assert.IsTrue(g.HasDependees("b"));
            Assert.IsTrue(g.HasDependees("c"));
            Assert.IsTrue(g.HasDependees("d"));

            // Test "a"
            HashSet <string> aDependents = new HashSet <string>();

            aDependents.Add("b");
            aDependents.Add("c");
            HashSet <string> aDependees = new HashSet <string>();

            foreach (string aDependent in g.GetDependents("a"))
            {
                Assert.IsTrue(aDependents.Remove(aDependent));
            }
            Assert.AreEqual(aDependents.Count, 0);
            foreach (string aDependee in g.GetDependees("a"))
            {
                Assert.IsTrue(aDependees.Remove(aDependee));
            }
            Assert.AreEqual(aDependees.Count, 0);


            // Test "b"
            HashSet <string> bDependents = new HashSet <string>();

            bDependents.Add("d");
            HashSet <string> bDependees = new HashSet <string>();

            bDependees.Add("a");
            foreach (string bDependent in g.GetDependents("b"))
            {
                Assert.IsTrue(bDependents.Remove(bDependent));
            }
            Assert.AreEqual(bDependents.Count, 0);
            foreach (string bDependee in g.GetDependees("b"))
            {
                Assert.IsTrue(bDependees.Remove(bDependee));
            }
            Assert.AreEqual(bDependees.Count, 0);


            // Test "c"
            HashSet <string> cDependents = new HashSet <string>();
            HashSet <string> cDependees  = new HashSet <string>();

            cDependees.Add("a");
            foreach (string cDependent in g.GetDependents("c"))
            {
                Assert.IsTrue(cDependents.Remove(cDependent));
            }
            Assert.AreEqual(cDependents.Count, 0);
            foreach (string cDependee in g.GetDependees("c"))
            {
                Assert.IsTrue(cDependees.Remove(cDependee));
            }
            Assert.AreEqual(cDependees.Count, 0);


            // Test "d"
            HashSet <string> dDependents = new HashSet <string>();

            dDependents.Add("d");
            HashSet <string> dDependees = new HashSet <string>();

            dDependees.Add("d");
            dDependees.Add("b");
            foreach (string dDependent in g.GetDependents("d"))
            {
                Assert.IsTrue(dDependents.Remove(dDependent));
            }
            Assert.AreEqual(dDependents.Count, 0);
            foreach (string dDependee in g.GetDependees("d"))
            {
                Assert.IsTrue(dDependees.Remove(dDependee));
            }
            Assert.AreEqual(dDependees.Count, 0);
        }
        public void TestMethod13()
        {
            DependencyGraph graph = new DependencyGraph();

            graph.AddDependency(null, null);
        }
예제 #18
0
        public void NullTest1()
        {
            DependencyGraph dependencyGraph = new DependencyGraph();

            dependencyGraph.AddDependency(null, "1");
        }
예제 #19
0
        /// <summary>
        /// Builds join tuple composer.
        /// </summary>
        /// <param name="statementName">Name of the statement.</param>
        /// <param name="statementId">The statement identifier.</param>
        /// <param name="outerJoinDescList">list of descriptors for outer join criteria</param>
        /// <param name="optionalFilterNode">filter tree for analysis to build indexes for fast access</param>
        /// <param name="streamTypes">types of streams</param>
        /// <param name="streamNames">names of streams</param>
        /// <param name="streamJoinAnalysisResult">The stream join analysis result.</param>
        /// <param name="queryPlanLogging">if set to <c>true</c> [query plan logging].</param>
        /// <param name="statementContext">The statement context.</param>
        /// <param name="historicalViewableDesc">The historical viewable desc.</param>
        /// <param name="exprEvaluatorContext">The expr evaluator context.</param>
        /// <param name="selectsRemoveStream">if set to <c>true</c> [selects remove stream].</param>
        /// <param name="hasAggregations">if set to <c>true</c> [has aggregations].</param>
        /// <param name="tableService">The table service.</param>
        /// <param name="isOnDemandQuery">if set to <c>true</c> [is on demand query].</param>
        /// <param name="allowIndexInit">if set to <c>true</c> [allow index initialize].</param>
        /// <returns>
        /// composer implementation
        /// </returns>
        /// <throws>com.espertech.esper.epl.expression.core.ExprValidationException is thrown to indicate thatvalidation of view use in joins failed.
        /// {D255958A-8513-4226-94B9-080D98F904A1}</throws>
        public static JoinSetComposerPrototype MakeComposerPrototype(string statementName, int statementId, OuterJoinDesc[] outerJoinDescList, ExprNode optionalFilterNode, EventType[] streamTypes, string[] streamNames, StreamJoinAnalysisResult streamJoinAnalysisResult, bool queryPlanLogging, StatementContext statementContext, HistoricalViewableDesc historicalViewableDesc, ExprEvaluatorContext exprEvaluatorContext, bool selectsRemoveStream, bool hasAggregations, TableService tableService, bool isOnDemandQuery, bool allowIndexInit)
        {
            // Determine if there is a historical stream, and what dependencies exist
            var historicalDependencyGraph = new DependencyGraph(streamTypes.Length, false);

            for (var i = 0; i < streamTypes.Length; i++)
            {
                if (historicalViewableDesc.Historical[i])
                {
                    var streamsThisStreamDependsOn = historicalViewableDesc.DependenciesPerHistorical[i];
                    historicalDependencyGraph.AddDependency(i, streamsThisStreamDependsOn);
                }
            }

            if (log.IsDebugEnabled)
            {
                log.Debug("Dependency graph: " + historicalDependencyGraph);
            }

            // Handle a join with a database or other historical data source for 2 streams
            if ((historicalViewableDesc.HasHistorical) && (streamTypes.Length == 2))
            {
                return(MakeComposerHistorical2Stream(outerJoinDescList, optionalFilterNode, streamTypes, historicalViewableDesc, queryPlanLogging, exprEvaluatorContext, statementContext, streamNames, allowIndexInit));
            }

            var isOuterJoins = !OuterJoinDesc.ConsistsOfAllInnerJoins(outerJoinDescList);

            // Query graph for graph relationships between streams/historicals
            // For outer joins the query graph will just contain outer join relationships
            var hint       = ExcludePlanHint.GetHint(streamNames, statementContext);
            var queryGraph = new QueryGraph(streamTypes.Length, hint, false);

            if (outerJoinDescList.Length > 0)
            {
                OuterJoinAnalyzer.Analyze(outerJoinDescList, queryGraph);
                if (log.IsDebugEnabled)
                {
                    log.Debug(".makeComposer After outer join queryGraph=\n" + queryGraph);
                }
            }

            // Let the query graph reflect the where-clause
            if (optionalFilterNode != null)
            {
                // Analyze relationships between streams using the optional filter expression.
                // Relationships are properties in AND and EQUALS nodes of joins.
                FilterExprAnalyzer.Analyze(optionalFilterNode, queryGraph, isOuterJoins);
                if (log.IsDebugEnabled)
                {
                    log.Debug(".makeComposer After filter expression queryGraph=\n" + queryGraph);
                }

                // Add navigation entries based on key and index property equivalency (a=b, b=c follows a=c)
                QueryGraph.FillEquivalentNav(streamTypes, queryGraph);
                if (log.IsDebugEnabled)
                {
                    log.Debug(".makeComposer After fill equiv. nav. queryGraph=\n" + queryGraph);
                }
            }

            // Historical index lists
            var historicalStreamIndexLists = new HistoricalStreamIndexList[streamTypes.Length];

            var queryPlan = QueryPlanBuilder.GetPlan(streamTypes, outerJoinDescList, queryGraph, streamNames,
                                                     historicalViewableDesc, historicalDependencyGraph, historicalStreamIndexLists,
                                                     streamJoinAnalysisResult, queryPlanLogging, statementContext.Annotations, exprEvaluatorContext);

            // remove unused indexes - consider all streams or all unidirectional
            var usedIndexes = new HashSet <TableLookupIndexReqKey>();
            var indexSpecs  = queryPlan.IndexSpecs;

            for (var streamNum = 0; streamNum < queryPlan.ExecNodeSpecs.Length; streamNum++)
            {
                var planNode = queryPlan.ExecNodeSpecs[streamNum];
                if (planNode != null)
                {
                    planNode.AddIndexes(usedIndexes);
                }
            }
            foreach (var indexSpec in indexSpecs)
            {
                if (indexSpec == null)
                {
                    continue;
                }
                var items      = indexSpec.Items;
                var indexNames = items.Keys.ToArray();
                foreach (var indexName in indexNames)
                {
                    if (!usedIndexes.Contains(indexName))
                    {
                        items.Remove(indexName);
                    }
                }
            }

            var hook = QueryPlanIndexHookUtil.GetHook(statementContext.Annotations);

            if (queryPlanLogging && (QueryPlanLog.IsInfoEnabled || hook != null))
            {
                QueryPlanLog.Info("Query plan: " + queryPlan.ToQueryPlan());
                if (hook != null)
                {
                    hook.Join(queryPlan);
                }
            }

            // register index-use references for tables
            if (!isOnDemandQuery)
            {
                foreach (var usedIndex in usedIndexes)
                {
                    if (usedIndex.TableName != null)
                    {
                        tableService.GetTableMetadata(usedIndex.TableName).AddIndexReference(usedIndex.Name, statementName);
                    }
                }
            }

            var joinRemoveStream = selectsRemoveStream || hasAggregations;

            return(new JoinSetComposerPrototypeImpl(
                       statementName,
                       statementId,
                       outerJoinDescList,
                       optionalFilterNode,
                       streamTypes,
                       streamNames,
                       streamJoinAnalysisResult,
                       statementContext.Annotations,
                       historicalViewableDesc,
                       exprEvaluatorContext,
                       indexSpecs,
                       queryPlan,
                       historicalStreamIndexLists,
                       joinRemoveStream,
                       isOuterJoins,
                       tableService,
                       statementContext.EventTableIndexService));
        }
예제 #20
0
        private static JoinSetComposerPrototype MakeComposerHistorical2Stream(OuterJoinDesc[] outerJoinDescList, ExprNode optionalFilterNode, EventType[] streamTypes, HistoricalViewableDesc historicalViewableDesc, bool queryPlanLogging, ExprEvaluatorContext exprEvaluatorContext, StatementContext statementContext, string[] streamNames, bool allowIndexInit)
        {
            var polledViewNum = 0;
            var streamViewNum = 1;

            if (historicalViewableDesc.Historical[1])
            {
                streamViewNum = 0;
                polledViewNum = 1;
            }

            // if all-historical join, check dependency
            var isAllHistoricalNoSubordinate = false;

            if ((historicalViewableDesc.Historical[0]) && historicalViewableDesc.Historical[1])
            {
                var graph = new DependencyGraph(2, false);
                graph.AddDependency(0, historicalViewableDesc.DependenciesPerHistorical[0]);
                graph.AddDependency(1, historicalViewableDesc.DependenciesPerHistorical[1]);
                if (graph.FirstCircularDependency != null)
                {
                    throw new ExprValidationException("Circular dependency detected between historical streams");
                }

                // if both streams are independent
                if (graph.RootNodes.Count == 2)
                {
                    isAllHistoricalNoSubordinate = true;     // No parameters used by either historical
                }
                else
                {
                    if ((graph.GetDependenciesForStream(0).Count == 0))
                    {
                        streamViewNum = 0;
                        polledViewNum = 1;
                    }
                    else
                    {
                        streamViewNum = 1;
                        polledViewNum = 0;
                    }
                }
            }

            // Build an outer join expression node
            var      isOuterJoin         = false;
            var      isInnerJoinOnly     = false;
            ExprNode outerJoinEqualsNode = null;

            if (outerJoinDescList.Length > 0)
            {
                var outerJoinDesc = outerJoinDescList[0];
                isInnerJoinOnly = outerJoinDesc.OuterJoinType == OuterJoinType.INNER;

                if (outerJoinDesc.OuterJoinType.Equals(OuterJoinType.FULL))
                {
                    isOuterJoin = true;
                }
                else if ((outerJoinDesc.OuterJoinType.Equals(OuterJoinType.LEFT)) &&
                         (streamViewNum == 0))
                {
                    isOuterJoin = true;
                }
                else if ((outerJoinDesc.OuterJoinType.Equals(OuterJoinType.RIGHT)) &&
                         (streamViewNum == 1))
                {
                    isOuterJoin = true;
                }

                outerJoinEqualsNode = outerJoinDesc.MakeExprNode(exprEvaluatorContext);
            }

            // Determine filter for indexing purposes
            ExprNode filterForIndexing = null;

            if ((outerJoinEqualsNode != null) && (optionalFilterNode != null) && isInnerJoinOnly)      // both filter and outer join, add
            {
                filterForIndexing = new ExprAndNodeImpl();
                filterForIndexing.AddChildNode(optionalFilterNode);
                filterForIndexing.AddChildNode(outerJoinEqualsNode);
            }
            else if ((outerJoinEqualsNode == null) && (optionalFilterNode != null))
            {
                filterForIndexing = optionalFilterNode;
            }
            else if (outerJoinEqualsNode != null)
            {
                filterForIndexing = outerJoinEqualsNode;
            }

            var indexStrategies =
                DetermineIndexing(filterForIndexing, streamTypes[polledViewNum], streamTypes[streamViewNum], polledViewNum, streamViewNum, statementContext, streamNames);

            var hook = QueryPlanIndexHookUtil.GetHook(statementContext.Annotations);

            if (queryPlanLogging && (QueryPlanLog.IsInfoEnabled || hook != null))
            {
                QueryPlanLog.Info("historical lookup strategy: " + indexStrategies.First.ToQueryPlan());
                QueryPlanLog.Info("historical index strategy: " + indexStrategies.Second.ToQueryPlan());
                if (hook != null)
                {
                    hook.Historical(new QueryPlanIndexDescHistorical(indexStrategies.First.GetType().Name, indexStrategies.Second.GetType().Name));
                }
            }

            return(new JoinSetComposerPrototypeHistorical2StreamImpl(
                       optionalFilterNode,
                       streamTypes,
                       exprEvaluatorContext,
                       polledViewNum,
                       streamViewNum,
                       isOuterJoin,
                       outerJoinEqualsNode,
                       indexStrategies,
                       isAllHistoricalNoSubordinate,
                       outerJoinDescList,
                       allowIndexInit));
        }
        public void CircularReferences3()
        {
            var dependencies = new DependencyGraph<string>();
            dependencies.AddDependency("1", "2");
            dependencies.AddDependency("1", "3");
            dependencies.AddDependency("3", "2");
            dependencies.AddDependency("3", "10");
            dependencies.AddDependency("3", "1");
            dependencies.AddDependency("4", "2");

            dependencies.AddDependency("4", "3");
            dependencies.AddDependency("4", "1");
            dependencies.AddDependency("5", "3");
            dependencies.AddDependency("5", "2");
            dependencies.AddDependency("6", "2");
            dependencies.AddDependency("7", "2");
            dependencies.AddDependency("8", "2");
            dependencies.AddDependency("8", "8");
            dependencies.AddDependency("9", "2");
            dependencies.AddDependency("9", "3");
            dependencies.AddDependency("10", "2");
            dependencies.AddDependency("11", "2");
            dependencies.AddDependency("12", "2");

            var allNodes = dependencies.Nodes;
            var startNodes = allNodes.Where(x => !allNodes.Any(y => dependencies.GetDependenciesForNode(y).Contains(x)));
            var endNodes = allNodes.Where(x => dependencies.GetDependenciesForNode(x).Count() == 0);

            var circularReferences = CircularReferencesHelper.FindCircularReferences(dependencies, startNodes, endNodes);
            Assert.IsTrue(circularReferences.Count() == 1);
            Assert.IsTrue(circularReferences[0][0] == "1");
            Assert.IsTrue(circularReferences[0][1] == "");
        }
예제 #22
0
        public void ComplexTest()
        {
            DependencyGraph t = new DependencyGraph();

            t.AddDependency("a", "a");
            t.AddDependency("a", "b");
            t.AddDependency("a", "c");
            t.AddDependency("a", "d");
            t.AddDependency("b", "a");
            t.AddDependency("b", "c");
            t.AddDependency("b", "d");
            t.AddDependency("c", "c");
            t.AddDependency("c", "d");
            t.AddDependency("c", "e");
            t.AddDependency("d", "a");
            t.AddDependency("d", "b");
            t.AddDependency("d", "c");
            t.AddDependency("d", "k");
            t.AddDependency("f", "a");
            t.AddDependency("g", "a");
            t.AddDependency("x", "g");
            HashSet <string> newDependents = new HashSet <string>()
            {
                "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z"
            };
            HashSet <string> newDependees = new HashSet <string>()
            {
                "a", "b", "c", "d", "e", "f", "g", "h", "i"
            };

            t.ReplaceDependents("d", newDependents);
            t.ReplaceDependents("f", newDependents);
            t.ReplaceDependents("g", newDependents);
            t.ReplaceDependees("g", newDependees);
            HashSet <String> aDents = new HashSet <string>()
            {
                "a", "b", "c", "d", "g"
            };
            HashSet <String> bDents = new HashSet <string>()
            {
                "a", "c", "d", "g"
            };
            HashSet <String> cDents = new HashSet <string>()
            {
                "c", "d", "e", "g"
            };
            HashSet <string> dDents = new HashSet <string>()
            {
                "g", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z"
            };
            HashSet <string> gDents = new HashSet <string>()
            {
                "g", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z"
            };
            HashSet <string> gDees = new HashSet <string>()
            {
                "a", "b", "c", "d", "e", "f", "g", "h", "i"
            };
            HashSet <string> kDees = new HashSet <string>()
            {
                "d", "f", "g"
            };
            HashSet <string> aDees = new HashSet <string>()
            {
                "a", "b"
            };

            Assert.IsTrue(aDents.SetEquals(t.GetDependents("a")));
            Assert.IsTrue(bDents.SetEquals(t.GetDependents("b")));
            Assert.IsTrue(cDents.SetEquals(t.GetDependents("c")));
            Assert.IsTrue(dDents.SetEquals(t.GetDependents("d")));
            Assert.IsTrue(gDents.SetEquals(t.GetDependents("g")));
            Assert.IsTrue(gDees.SetEquals(t.GetDependees("g")));
            Assert.IsTrue(kDees.SetEquals(t.GetDependees("k")));
            Assert.IsTrue(aDees.SetEquals(t.GetDependees("a")));
        }
예제 #23
0
        public void ABunchOfTiming()
        {
            DependencyGraph dg       = new DependencyGraph();
            List <String>   cellList = GetListOfCells(1, 26, 1, 200); //A1:Z200

            Random r = new Random();

            Stopwatch stopWatch = new Stopwatch();
            TimeSpan  t         = stopWatch.Elapsed;

            //add 50,000
            for (int i = 0; i < 50000; i++)
            {
                int first  = r.Next(0, 1299);
                int second = r.Next(0, 1299);

                if (cellList[first] != cellList[second])
                {
                    String s = ("(" + cellList[first] + "), (" + cellList[second] + ")");
                    dg.AddDependency(cellList[first], cellList[second]);
                }
            }

            //Add known value
            dg.AddDependency("Z8", "A5");
            dg.AddDependency("Z8", "A6");
            dg.AddDependency("Z8", "A7");
            dg.AddDependency("Z9", "A7");
            dg.AddDependency("Z10", "A7");

            //add 50,000 more
            while (dg.Size <= 100000)
            {
                //add 50,000 more(if they don't exist)

                int first  = r.Next(0, 1299);
                int second = r.Next(0, 1299);

                if (cellList[first] != cellList[second])
                {
                    String s = ("(" + cellList[first] + "), (" + cellList[second] + ")");
                    dg.AddDependency(cellList[first], cellList[second]);
                }
            }

            //Test removing
            stopWatch.Start();
            dg.RemoveDependency("Z8", "A5");
            stopWatch.Stop();
            double elapsed = t.Milliseconds;

            Assert.IsTrue(elapsed < 1000);

            //Test Getting dependents
            stopWatch = new Stopwatch();
            t         = stopWatch.Elapsed;
            stopWatch.Start();
            var nl = dg.GetDependents("Z8");

            stopWatch.Stop();
            elapsed = t.Milliseconds;
            Assert.IsTrue(elapsed < 1000);

            //Test replacing dependants
            stopWatch = new Stopwatch();
            t         = stopWatch.Elapsed;
            stopWatch.Start();
            dg.ReplaceDependees("A3", nl);
            stopWatch.Stop();
            elapsed = t.Milliseconds;
            Assert.IsTrue(elapsed < 1000);


            //Test Getting dependees
            stopWatch = new Stopwatch();
            t         = stopWatch.Elapsed;
            stopWatch.Start();
            nl = dg.GetDependees("A7");
            stopWatch.Stop();
            elapsed = t.Milliseconds;
            Assert.IsTrue(elapsed < 1000);

            //Test replacing dependees
            stopWatch = new Stopwatch();
            t         = stopWatch.Elapsed;
            stopWatch.Start();
            dg.ReplaceDependees("A7", nl);
            stopWatch.Stop();
            elapsed = t.Milliseconds;
            Assert.IsTrue(elapsed < 1000);
        }
예제 #24
0
        public void NullTest()
        {
            DependencyGraph t = new DependencyGraph();

            t.AddDependency("", "");
        }
예제 #25
0
        public void NullTest2()
        {
            DependencyGraph test = new DependencyGraph();

            test.AddDependency(null, null);
        }
예제 #26
0
        public void SizeTest3()
        {
            DependencyGraph t = new DependencyGraph();

            t.AddDependency("b", "a");
            t.AddDependency("c", "a");
            t.AddDependency("d", "a");
            t.AddDependency("e", "a");
            t.AddDependency("g", "a");
            t.AddDependency("j", "a");
            t.AddDependency("t", "a");
            t.AddDependency("z", "a");
            t.AddDependency("u", "a");
            t.AddDependency("i", "a");
            t.AddDependency("m", "a");
            t.AddDependency("q", "a");
            t.ReplaceDependees("a", new HashSet <string>()
            {
                "t", "u"
            });
            Assert.AreEqual(2, t.Size);
        }
예제 #27
0
        private void UndeployAllInternal(UndeploymentOptions options)
        {
            if (options == null)
            {
                options = new UndeploymentOptions();
            }

            var deploymentSvc = _services.DeploymentLifecycleService;
            var deployments   = _services.DeploymentLifecycleService.DeploymentIds;

            if (deployments.Length == 0)
            {
                return;
            }

            if (deployments.Length == 1)
            {
                Undeploy(deployments[0]);
                return;
            }

            if (deployments.Length == 2)
            {
                var zero          = deploymentSvc.GetDeploymentById(deployments[0]);
                var zeroDependsOn = zero.DeploymentIdDependencies;
                if (zeroDependsOn != null && zeroDependsOn.Length > 0)
                {
                    Undeploy(deployments[0]);
                    Undeploy(deployments[1]);
                }
                else
                {
                    Undeploy(deployments[1]);
                    Undeploy(deployments[0]);
                }

                return;
            }

            // build map of deployment-to-index
            var deploymentIndexes = new Dictionary <string, int>();
            var count             = 0;

            foreach (var deployment in deployments)
            {
                deploymentIndexes.Put(deployment, count++);
            }

            var graph = new DependencyGraph(deployments.Length, false);

            foreach (var deploymentId in deployments)
            {
                var deployment  = deploymentSvc.GetDeploymentById(deploymentId);
                var dependentOn = deployment.DeploymentIdDependencies;
                if (dependentOn == null || dependentOn.Length == 0)
                {
                    continue;
                }

                foreach (var target in dependentOn)
                {
                    int fromIndex   = deploymentIndexes.Get(deploymentId);
                    int targetIndex = deploymentIndexes.Get(target);
                    graph.AddDependency(targetIndex, fromIndex);
                }
            }

            var undeployed = new HashSet <string>();

            foreach (var rootIndex in graph.RootNodes)
            {
                RecursiveUndeploy(rootIndex, deployments, graph, undeployed, options);
            }
        }
예제 #28
0
        public void NullTest2()
        {
            DependencyGraph dependencyGraph = new DependencyGraph();

            dependencyGraph.AddDependency("A", null);
        }
        public void StressTest()
        {
            // Dependency graph
            DependencyGraph t = new DependencyGraph();

            // A bunch of strings to use
            const int SIZE = 400;

            string[] letters = new string[SIZE];
            for (int i = 0; i < SIZE; i++)
            {
                letters[i] = ("" + (char)('a' + i));
            }

            // The correct answers
            HashSet <string>[] dents = new HashSet <string> [SIZE];
            HashSet <string>[] dees  = new HashSet <string> [SIZE];
            for (int i = 0; i < SIZE; i++)
            {
                dents[i] = new HashSet <string>();
                dees[i]  = new HashSet <string>();
            }

            // Add a bunch of dependencies
            for (int i = 0; i < SIZE; i++)
            {
                for (int j = i + 1; j < SIZE; j++)
                {
                    t.AddDependency(letters[i], letters[j]);
                    dents[i].Add(letters[j]);
                    dees[j].Add(letters[i]);
                }
            }

            // Remove a bunch of dependencies
            for (int i = 0; i < SIZE; i++)
            {
                for (int j = i + 4; j < SIZE; j += 4)
                {
                    t.RemoveDependency(letters[i], letters[j]);
                    dents[i].Remove(letters[j]);
                    dees[j].Remove(letters[i]);
                }
            }

            // Add some back
            for (int i = 0; i < SIZE; i++)
            {
                for (int j = i + 1; j < SIZE; j += 2)
                {
                    t.AddDependency(letters[i], letters[j]);
                    dents[i].Add(letters[j]);
                    dees[j].Add(letters[i]);
                }
            }

            // Remove some more
            for (int i = 0; i < SIZE; i += 2)
            {
                for (int j = i + 3; j < SIZE; j += 3)
                {
                    t.RemoveDependency(letters[i], letters[j]);
                    dents[i].Remove(letters[j]);
                    dees[j].Remove(letters[i]);
                }
            }

            // Make sure everything is right
            for (int i = 0; i < SIZE; i++)
            {
                Assert.IsTrue(dents[i].SetEquals(new HashSet <string>(t.GetDependents(letters[i]))));
                Assert.IsTrue(dees[i].SetEquals(new HashSet <string>(t.GetDependees(letters[i]))));
            }
        }
예제 #30
0
        public void NullTest8()
        {
            DependencyGraph d = new DependencyGraph();

            d.AddDependency("test", null);
        }
예제 #31
0
        public void NullException1()
        {
            DependencyGraph G = new DependencyGraph();

            G.AddDependency("a", null);
        }
예제 #32
0
        public DeploymentOrder GetDeploymentOrder(ICollection <Module> modules, DeploymentOrderOptions options)
        {
            using (_iLock.Acquire())
            {
                if (options == null)
                {
                    options = new DeploymentOrderOptions();
                }

                var deployments     = _deploymentStateService.Deployments;
                var proposedModules = new List <Module>();
                proposedModules.AddAll(modules);

                ICollection <String> availableModuleNames = new HashSet <String>();
                foreach (var proposedModule in proposedModules)
                {
                    if (proposedModule.Name != null)
                    {
                        availableModuleNames.Add(proposedModule.Name);
                    }
                }

                // Collect all uses-dependencies of existing modules
                IDictionary <String, ICollection <String> > usesPerModuleName =
                    new Dictionary <String, ICollection <String> >();
                foreach (var deployment in deployments)
                {
                    var info = _deploymentStateService.GetDeployment(deployment);
                    if (info == null)
                    {
                        continue;
                    }
                    if ((info.Module.Name == null) || (info.Module.Uses == null))
                    {
                        continue;
                    }
                    var usesSet = usesPerModuleName.Get(info.Module.Name);
                    if (usesSet == null)
                    {
                        usesSet = new HashSet <String>();
                        usesPerModuleName.Put(info.Module.Name, usesSet);
                    }
                    usesSet.AddAll(info.Module.Uses);
                }

                // Collect uses-dependencies of proposed modules
                foreach (var proposedModule in proposedModules)
                {
                    // check uses-dependency is available
                    if (options.IsCheckUses)
                    {
                        if (proposedModule.Uses != null)
                        {
                            foreach (var uses in proposedModule.Uses)
                            {
                                if (availableModuleNames.Contains(uses))
                                {
                                    continue;
                                }
                                if (IsDeployed(uses))
                                {
                                    continue;
                                }
                                var message = "Module-dependency not found";
                                if (proposedModule.Name != null)
                                {
                                    message += " as declared by module '" + proposedModule.Name + "'";
                                }
                                message += " for uses-declaration '" + uses + "'";
                                throw new DeploymentOrderException(message);
                            }
                        }
                    }

                    if ((proposedModule.Name == null) || (proposedModule.Uses == null))
                    {
                        continue;
                    }
                    var usesSet = usesPerModuleName.Get(proposedModule.Name);
                    if (usesSet == null)
                    {
                        usesSet = new HashSet <String>();
                        usesPerModuleName.Put(proposedModule.Name, usesSet);
                    }
                    usesSet.AddAll(proposedModule.Uses);
                }

                var proposedModuleNames = new HashMap <String, SortedSet <int> >();
                var count = 0;
                foreach (var proposedModule in proposedModules)
                {
                    var moduleNumbers = proposedModuleNames.Get(proposedModule.Name);
                    if (moduleNumbers == null)
                    {
                        moduleNumbers = new SortedSet <int>();
                        proposedModuleNames.Put(proposedModule.Name, moduleNumbers);
                    }
                    moduleNumbers.Add(count);
                    count++;
                }

                var graph      = new DependencyGraph(proposedModules.Count, false);
                var fromModule = 0;
                foreach (var proposedModule in proposedModules)
                {
                    if ((proposedModule.Uses == null) || (proposedModule.Uses.IsEmpty()))
                    {
                        fromModule++;
                        continue;
                    }
                    var dependentModuleNumbers = new SortedSet <int>();
                    foreach (var use in proposedModule.Uses)
                    {
                        var moduleNumbers = proposedModuleNames.Get(use);
                        if (moduleNumbers == null)
                        {
                            continue;
                        }
                        dependentModuleNumbers.AddAll(moduleNumbers);
                    }
                    dependentModuleNumbers.Remove(fromModule);
                    graph.AddDependency(fromModule, dependentModuleNumbers);
                    fromModule++;
                }

                if (options.IsCheckCircularDependency)
                {
                    var circular = graph.FirstCircularDependency;
                    if (circular != null)
                    {
                        var message   = "";
                        var delimiter = "";
                        foreach (var i in circular)
                        {
                            message  += delimiter;
                            message  += "module '" + proposedModules[i].Name + "'";
                            delimiter = " uses (depends on) ";
                        }
                        throw new DeploymentOrderException(
                                  "Circular dependency detected in module uses-relationships: " + message);
                    }
                }

                var reverseDeployList = new List <Module>();
                var ignoreList        = new HashSet <int>();
                while (ignoreList.Count < proposedModules.Count)
                {
                    // seconardy sort according to the order of listing
                    ICollection <int> rootNodes = new SortedSet <int>(
                        new StandardComparer <int>((o1, o2) => - 1 * o1.CompareTo(o2)));

                    rootNodes.AddAll(graph.GetRootNodes(ignoreList));

                    if (rootNodes.IsEmpty())
                    {
                        // circular dependency could cause this
                        for (var i = 0; i < proposedModules.Count; i++)
                        {
                            if (!ignoreList.Contains(i))
                            {
                                rootNodes.Add(i);
                                break;
                            }
                        }
                    }

                    foreach (var root in rootNodes)
                    {
                        ignoreList.Add(root);
                        reverseDeployList.Add(proposedModules[root]);
                    }
                }

                reverseDeployList.Reverse();
                return(new DeploymentOrder(reverseDeployList));
            }
        }
예제 #33
0
파일: UnitTest1.cs 프로젝트: jimibue/cs3505
        public void MyTest()
        {
            DependencyGraph t = new DependencyGraph();

            t.AddDependency("a", "b");
            t.AddDependency("a", "c");
            t.AddDependency("b", "d");
            t.AddDependency("d", "d");
            Assert.IsTrue(t.GetDependents("a").ToHashSet().SetEquals(new HashSet <string>()
            {
                "b", "c"
            }));
            Assert.IsTrue(t.GetDependents("b").ToHashSet().SetEquals(new HashSet <string>()
            {
                "d"
            }));
            Assert.IsTrue(t.GetDependents("c").ToHashSet().SetEquals(new HashSet <string>()
            {
            }));
            Assert.IsTrue(t.GetDependents("d").ToHashSet().SetEquals(new HashSet <string>()
            {
                "d"
            }));
            Assert.IsTrue(t.GetDependees("a").ToHashSet().SetEquals(new HashSet <string>()
            {
            }));
            Assert.IsTrue(t.GetDependees("b").ToHashSet().SetEquals(new HashSet <string>()
            {
                "a"
            }));
            Assert.AreEqual(1, t["b"]);
            Assert.IsTrue(t.GetDependees("c").ToHashSet().SetEquals(new HashSet <string>()
            {
                "a"
            }));
            Assert.IsTrue(t.GetDependees("d").ToHashSet().SetEquals(new HashSet <string>()
            {
                "b", "d"
            }));
            Assert.AreEqual(2, t["d"]);
            Assert.AreEqual(0, t["h"]);
            Assert.AreEqual(0, t["a"]);
            Assert.IsFalse(t.HasDependees("a"));
            Assert.IsFalse(t.HasDependees("f"));
            Assert.IsFalse(t.HasDependents("c"));
            Assert.IsTrue(t.HasDependents("a"));
            Assert.IsFalse(t.HasDependents("h"));
            Assert.IsTrue(t.HasDependents("d"));
            Assert.IsTrue(t.HasDependees("b"));
            Assert.IsTrue(t.HasDependees("c"));
            Assert.IsTrue(t.HasDependees("d"));
            Assert.AreEqual(4, t.Size);



            t.RemoveDependency("a", "b");
            Assert.IsTrue(t.GetDependents("a").ToHashSet().SetEquals(new HashSet <string>()
            {
                "c"
            }));
            Assert.IsTrue(t.GetDependees("b").ToHashSet().SetEquals(new HashSet <string>()
            {
            }));

            t.AddDependency("a", "b");
            t.AddDependency("a", "b");
            t.ReplaceDependents("a", new HashSet <string>()
            {
                "x", "y", "x", "y", "z"
            });
            Assert.IsTrue(t.GetDependents("a").ToHashSet().SetEquals(new HashSet <string>()
            {
                "x", "y", "z"
            }));
            Assert.AreEqual(5, t.Size);


            t.ReplaceDependees("b", new HashSet <string>()
            {
                "x", "y", "x", "y"
            });
            Assert.IsTrue(t.GetDependees("b").ToHashSet().SetEquals(new HashSet <string>()
            {
                "x", "y"
            }));
            Assert.AreEqual(7, t.Size);
            Assert.AreEqual(2, t["b"]);


            //Assert.AreEqual(4, t.Size);
        }
예제 #34
0
        public void StressTest15()
        {
            // Dependency graph
            var graph = new DependencyGraph();

            // A bunch of strings to use
            const int size    = 100;
            var       letters = new string[size];

            for (var i = 0; i < size; i++)
            {
                letters[i] = ("" + (char)('a' + i));
            }

            // The correct answers
            var dents = new HashSet <string> [size];
            var dees  = new HashSet <string> [size];

            for (var i = 0; i < size; i++)
            {
                dents[i] = new HashSet <string>();
                dees[i]  = new HashSet <string>();
            }

            // Add a bunch of dependencies
            for (var i = 0; i < size; i++)
            {
                for (var j = i + 1; j < size; j++)
                {
                    graph.AddDependency(letters[i], letters[j]);
                    dents[i].Add(letters[j]);
                    dees[j].Add(letters[i]);
                }
            }

            // Remove a bunch of dependencies
            for (var i = 0; i < size; i++)
            {
                for (var j = i + 2; j < size; j += 2)
                {
                    graph.RemoveDependency(letters[i], letters[j]);
                    dents[i].Remove(letters[j]);
                    dees[j].Remove(letters[i]);
                }
            }

            // Replace a bunch of dependees
            for (var i = 0; i < size; i += 4)
            {
                var newDees = new HashSet <string>();
                for (var j = 0; j < size; j += 7)
                {
                    newDees.Add(letters[j]);
                }
                graph.ReplaceDependees(letters[i], newDees);

                foreach (var s in dees[i])
                {
                    dents[s[0] - 'a'].Remove(letters[i]);
                }

                foreach (var s in newDees)
                {
                    dents[s[0] - 'a'].Add(letters[i]);
                }

                dees[i] = newDees;
            }

            // Make sure everything is right
            for (var i = 0; i < size; i++)
            {
                Assert.IsTrue(dents[i].SetEquals(new HashSet <string>(graph.GetDependents(letters[i]))));
                Assert.IsTrue(dees[i].SetEquals(new HashSet <string>(graph.GetDependees(letters[i]))));
            }
        }
예제 #35
0
        public void EqualDependents()
        {
            DependencyGraph t = new DependencyGraph();

            t.AddDependency("a", "a");
            t.AddDependency("a", "b");
            t.AddDependency("a", "c");
            t.AddDependency("a", "d");
            t.AddDependency("a", "e");
            t.AddDependency("a", "f");
            t.AddDependency("a", "g");
            t.AddDependency("b", "a");
            t.AddDependency("b", "b");
            t.AddDependency("b", "c");
            t.AddDependency("b", "d");
            t.AddDependency("b", "e");
            t.AddDependency("b", "f");
            t.AddDependency("b", "g");

            HashSet <String> aDents = new HashSet <String>(t.GetDependents("a"));
            HashSet <String> bDents = new HashSet <String>(t.GetDependents("b"));

            Assert.IsTrue(aDents.Count == bDents.Count);
        }
예제 #36
0
        public void StressTestCombinedLargeSize()
        {
            Stopwatch stopWatch = new Stopwatch();

            stopWatch.Start();

            // Dependency graph
            DependencyGraph t = new DependencyGraph();

            // A bunch of strings to use
            const int SIZE = 2000;

            string[] letters = new string[SIZE];
            for (int i = 0; i < SIZE; i++)
            {
                letters[i] = ("" + (char)('a' + i));
            }

            // The correct answers
            HashSet <string>[] dents = new HashSet <string> [SIZE];
            HashSet <string>[] dees  = new HashSet <string> [SIZE];
            for (int i = 0; i < SIZE; i++)
            {
                dents[i] = new HashSet <string>();
                dees[i]  = new HashSet <string>();
            }

            // Add a bunch of dependencies
            for (int i = 0; i < SIZE; i++)
            {
                for (int j = i + 1; j < SIZE; j++)
                {
                    t.AddDependency(letters[i], letters[j]);
                    dents[i].Add(letters[j]);
                    dees[j].Add(letters[i]);
                }
            }

            // Remove a bunch of dependencies
            for (int i = 0; i < SIZE; i++)
            {
                for (int j = i + 2; j < SIZE; j += 2)
                {
                    t.RemoveDependency(letters[i], letters[j]);
                    dents[i].Remove(letters[j]);
                    dees[j].Remove(letters[i]);
                }
            }

            // Replace a bunch of dependents
            for (int i = 0; i < SIZE; i += 4)
            {
                HashSet <string> newDents = new HashSet <String>();
                for (int j = 0; j < SIZE; j += 7)
                {
                    newDents.Add(letters[j]);
                }
                t.ReplaceDependents(letters[i], newDents);

                foreach (string s in dents[i])
                {
                    dees[s[0] - 'a'].Remove(letters[i]);
                }

                foreach (string s in newDents)
                {
                    dees[s[0] - 'a'].Add(letters[i]);
                }

                dents[i] = newDents;
            }

            // Replace a bunch of dependees
            for (int i = 0; i < SIZE; i += 4)
            {
                HashSet <string> newDees = new HashSet <String>();
                for (int j = 0; j < SIZE; j += 7)
                {
                    newDees.Add(letters[j]);
                }
                t.ReplaceDependees(letters[i], newDees);

                foreach (string s in dees[i])
                {
                    dents[s[0] - 'a'].Remove(letters[i]);
                }

                foreach (string s in newDees)
                {
                    dents[s[0] - 'a'].Add(letters[i]);
                }

                dees[i] = newDees;
            }

            // Make sure everything is right
            for (int i = 0; i < SIZE; i++)
            {
                Assert.IsTrue(dents[i].SetEquals(new HashSet <string>(t.GetDependents(letters[i]))));
                Assert.IsTrue(dees[i].SetEquals(new HashSet <string>(t.GetDependees(letters[i]))));
            }

            stopWatch.Stop();
            TimeSpan time = stopWatch.Elapsed;

            Assert.IsTrue(time.Seconds < 10);
        }
예제 #37
0
        public void EqualDependees()
        {
            DependencyGraph t = new DependencyGraph();

            t.AddDependency("a", "a");
            t.AddDependency("a", "b");
            t.AddDependency("a", "c");
            t.AddDependency("a", "d");
            t.AddDependency("a", "e");
            t.AddDependency("a", "f");
            t.AddDependency("a", "g");
            t.AddDependency("b", "a");
            t.AddDependency("b", "b");
            t.AddDependency("b", "c");
            t.AddDependency("b", "d");
            t.AddDependency("b", "e");
            t.AddDependency("b", "f");
            t.AddDependency("b", "g");



            HashSet <String> aDees = new HashSet <String>(t.GetDependees("a"));
            HashSet <String> bDees = new HashSet <String>(t.GetDependees("b"));
            HashSet <String> cDees = new HashSet <String>(t.GetDependees("c"));
            HashSet <String> dDees = new HashSet <String>(t.GetDependees("d"));
            HashSet <String> eDees = new HashSet <String>(t.GetDependees("e"));
            HashSet <String> fDees = new HashSet <String>(t.GetDependees("f"));
            HashSet <String> gDees = new HashSet <String>(t.GetDependees("g"));

            Assert.IsTrue(aDees.Count == 2);
            Assert.IsTrue(bDees.Count == 2);
            Assert.IsTrue(cDees.Count == 2);
            Assert.IsTrue(dDees.Count == 2);
            Assert.IsTrue(eDees.Count == 2);
            Assert.IsTrue(fDees.Count == 2);
            Assert.IsTrue(gDees.Count == 2);
        }
예제 #38
0
        public void TestMethod13()
        {
            DependencyGraph dg = new DependencyGraph();

            dg.AddDependency(null, "b");
        }
예제 #39
0
        public void TestSize3()
        {
            DependencyGraph t = new DependencyGraph();

            t.AddDependency("a", "a");
            t.AddDependency("a", "b");
            t.AddDependency("a", "c");
            t.AddDependency("a", "d");
            t.AddDependency("f", "d");
            t.AddDependency("e", "c");
            t.AddDependency("r", "m");
            t.AddDependency("a", "d");
            t.AddDependency("a", "d");
            t.AddDependency("m", "r");
            t.AddDependency("m", "r");
            t.AddDependency("m", "r");
            t.AddDependency("e", "c");
            t.AddDependency("m", "r");
            t.RemoveDependency("m", "r");
            t.RemoveDependency("a", "b");
            t.RemoveDependency("a", "b");
            Assert.AreEqual(6, t.Size);
        }
예제 #40
0
        public void NullTest7()
        {
            DependencyGraph d = new DependencyGraph();

            d.AddDependency(null, null);
        }
예제 #41
0
        public void TestMethod3()
        {
            DependencyGraph dg = new DependencyGraph();

            dg.AddDependency("a", "b");
        }
예제 #42
0
        public void Null1()
        {
            DependencyGraph d = new DependencyGraph();

            d.AddDependency("a", null);
        }
예제 #43
0
        public void TestMethod6()
        {
            DependencyGraph dg = new DependencyGraph();

            dg.AddDependency("a", null);
        }