From c73cc474dd013077327112ce0e50d7ef112e9387 Mon Sep 17 00:00:00 2001
From: dotnet-bot <dotnet-bot@microsoft.com>
Date: Thu, 16 Jul 2026 13:59:28 +0900
Subject: [PATCH 1/2] Add DependencyAnalysisFramework tests from CoreRT repo

---
 .../DependencyAnalysisFrameworkTests.cs       | 202 ++++++++++++++++++
 .../TestGraph.cs                              | 177 +++++++++++++++
 2 files changed, 379 insertions(+)
 create mode 100644 src/coreclr/tools/aot/ILCompiler.DependencyAnalysisFramework.Tests/DependencyAnalysisFrameworkTests.cs
 create mode 100644 src/coreclr/tools/aot/ILCompiler.DependencyAnalysisFramework.Tests/TestGraph.cs

diff --git a/src/coreclr/tools/aot/ILCompiler.DependencyAnalysisFramework.Tests/DependencyAnalysisFrameworkTests.cs b/src/coreclr/tools/aot/ILCompiler.DependencyAnalysisFramework.Tests/DependencyAnalysisFrameworkTests.cs
new file mode 100644
index 00000000000000..5213f6e4b9b4d8
--- /dev/null
+++ b/src/coreclr/tools/aot/ILCompiler.DependencyAnalysisFramework.Tests/DependencyAnalysisFrameworkTests.cs
@@ -0,0 +1,202 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+
+using ILCompiler.DependencyAnalysisFramework;
+
+using Xunit;
+
+namespace ILCompiler.DependencyAnalysisFramework.Tests
+{
+    public class DependencyTests
+    {
+        public DependencyTests()
+        {
+        }
+
+        /// <summary>
+        /// Test on every graph type. Used to ensure that the behavior of the various markers is consistent
+        /// </summary>
+        /// <param name="testGraph"></param>
+        private void TestOnGraphTypes(Action<TestGraph, DependencyAnalyzerBase<TestGraph>> testGraph)
+        {
+            // Test using the full logging strategy
+            TestGraph testGraphFull = new TestGraph();
+            DependencyAnalyzerBase<TestGraph> analyzerFull = new DependencyAnalyzer<FullGraphLogStrategy<TestGraph>, TestGraph>(testGraphFull, null);
+            testGraphFull.AttachToDependencyAnalyzer(analyzerFull);
+            testGraph(testGraphFull, analyzerFull);
+
+            TestGraph testGraphFirstMark = new TestGraph();
+            DependencyAnalyzerBase<TestGraph> analyzerFirstMark = new DependencyAnalyzer<FirstMarkLogStrategy<TestGraph>, TestGraph>(testGraphFirstMark, null);
+            testGraphFirstMark.AttachToDependencyAnalyzer(analyzerFirstMark);
+            testGraph(testGraphFirstMark, analyzerFirstMark);
+
+            TestGraph testGraphNoLog = new TestGraph();
+            DependencyAnalyzerBase<TestGraph> analyzerNoLog = new DependencyAnalyzer<NoLogStrategy<TestGraph>, TestGraph>(testGraphNoLog, null);
+            testGraphNoLog.AttachToDependencyAnalyzer(analyzerNoLog);
+            testGraph(testGraphNoLog, analyzerNoLog);
+        }
+
+        [Fact]
+        public void TestADependsOnB()
+        {
+            TestOnGraphTypes((TestGraph testGraph, DependencyAnalyzerBase<TestGraph> analyzer) =>
+            {
+                testGraph.AddStaticRule("A", "B", "A depends on B");
+                testGraph.AddRoot("A", "A is root");
+                List<string> results = testGraph.AnalysisResults;
+
+                Assert.Contains("A", results);
+                Assert.Contains("B", results);
+            });
+        }
+
+        [Fact]
+        public void TestADependsOnBIfC_NoC()
+        {
+            TestOnGraphTypes((TestGraph testGraph, DependencyAnalyzerBase<TestGraph> analyzer) =>
+            {
+                testGraph.AddConditionalRule("A", "C", "B", "A depends on B if C");
+                testGraph.AddRoot("A", "A is root");
+                List<string> results = testGraph.AnalysisResults;
+
+                Assert.Contains("A", results);
+                Assert.DoesNotContain("B", results);
+                Assert.DoesNotContain("C", results);
+                Assert.True(results.Count == 1);
+            });
+        }
+
+        [Fact]
+        public void TestADependsOnBIfC_HasC()
+        {
+            TestOnGraphTypes((TestGraph testGraph, DependencyAnalyzerBase<TestGraph> analyzer) =>
+            {
+                testGraph.AddConditionalRule("A", "C", "B", "A depends on B if C");
+                testGraph.AddRoot("A", "A is root");
+                testGraph.AddRoot("C", "C is root");
+                List<string> results = testGraph.AnalysisResults;
+
+                Assert.Contains("A", results);
+                Assert.Contains("B", results);
+                Assert.Contains("C", results);
+                Assert.True(results.Count == 3);
+            });
+        }
+
+        [Fact]
+        public void TestSimpleDynamicRule()
+        {
+            TestOnGraphTypes((TestGraph testGraph, DependencyAnalyzerBase<TestGraph> analyzer) =>
+            {
+                testGraph.SetDynamicDependencyRule((string nodeA, string nodeB) =>
+                {
+                    if (nodeA.EndsWith("*") && nodeB.StartsWith("*"))
+                    {
+                        return new Tuple<string, string>(nodeA + nodeB, "DynamicRule");
+                    }
+                    return null;
+                });
+
+                testGraph.AddRoot("A*", "A* is root");
+                testGraph.AddRoot("B*", "B* is root");
+                testGraph.AddRoot("*C", "*C is root");
+                testGraph.AddRoot("*D", "*D is root");
+                testGraph.AddRoot("A*B", "A*B is root");
+                List<string> results = testGraph.AnalysisResults;
+
+                Assert.Contains("A*", results);
+                Assert.Contains("B*", results);
+                Assert.Contains("*C", results);
+                Assert.Contains("*D", results);
+                Assert.Contains("A*B", results);
+                Assert.Contains("A**C", results);
+                Assert.Contains("A**D", results);
+                Assert.Contains("B**C", results);
+                Assert.Contains("B**D", results);
+                Assert.True(results.Count == 9);
+            });
+        }
+
+        private void BuildGraphUsingAllTypesOfRules(TestGraph testGraph, DependencyAnalyzerBase<TestGraph> analyzer)
+        {
+            testGraph.SetDynamicDependencyRule((string nodeA, string nodeB) =>
+            {
+                if (nodeA.EndsWith("*") && nodeB.StartsWith("*"))
+                {
+                    return new Tuple<string, string>(nodeA + nodeB, "DynamicRule");
+                }
+                return null;
+            });
+
+            testGraph.AddConditionalRule("A**C", "B**D", "D", "A**C depends on D if B**D");
+            testGraph.AddStaticRule("D", "E", "D depends on E");
+
+            // Rules to ensure that there are some nodes that have multiple reasons to exist
+            testGraph.AddStaticRule("A*", "E", "A* depends on E");
+            testGraph.AddStaticRule("*C", "E", "*C depends on E");
+
+            testGraph.AddRoot("A*", "A* is root");
+            testGraph.AddRoot("B*", "B* is root");
+            testGraph.AddRoot("*C", "*C is root");
+            testGraph.AddRoot("*D", "*D is root");
+            testGraph.AddRoot("A*B", "A*B is root");
+
+            List<string> results = testGraph.AnalysisResults;
+            Assert.Contains("A*", results);
+            Assert.Contains("B*", results);
+            Assert.Contains("*C", results);
+            Assert.Contains("*D", results);
+            Assert.Contains("A*B", results);
+            Assert.Contains("A**C", results);
+            Assert.Contains("A**D", results);
+            Assert.Contains("B**C", results);
+            Assert.Contains("B**D", results);
+            Assert.Contains("D", results);
+            Assert.Contains("E", results);
+            Assert.True(results.Count == 11);
+        }
+
+        [Fact]
+        public void TestDGMLOutput()
+        {
+            Dictionary<string, string> dgmlOutputs = new Dictionary<string, string>();
+            TestOnGraphTypes((TestGraph testGraph, DependencyAnalyzerBase<TestGraph> analyzer) =>
+            {
+                BuildGraphUsingAllTypesOfRules(testGraph, analyzer);
+                MemoryStream dgmlOutput = new MemoryStream();
+                DgmlWriter.WriteDependencyGraphToStream(dgmlOutput, analyzer, testGraph);
+                dgmlOutput.Seek(0, SeekOrigin.Begin);
+                TextReader tr = new StreamReader(dgmlOutput);
+                dgmlOutputs[analyzer.GetType().FullName] = tr.ReadToEnd();
+            });
+
+            foreach (var pair in dgmlOutputs)
+            {
+                int nodeCount = pair.Value.Split(new string[] { "<Node " }, StringSplitOptions.None).Length - 1;
+                int edgeCount = pair.Value.Split(new string[] { "<Link " }, StringSplitOptions.None).Length - 1;
+                if (pair.Key.Contains("FullGraph"))
+                {
+                    Assert.Equal(21, nodeCount);
+                    Assert.Equal(23, edgeCount);
+                }
+                else if (pair.Key.Contains("FirstMark"))
+                {
+                    // There are 2 edges in the all types of rules graph that are duplicates. Note that the edge count is 
+                    // 2 less than the full graph edge count
+                    Assert.Equal(21, nodeCount);
+                    Assert.Equal(21, edgeCount);
+                }
+                else
+                {
+                    Assert.Contains("NoLog", pair.Key);
+                    Assert.Equal(11, nodeCount);
+                    Assert.Equal(0, edgeCount);
+                }
+            }
+        }
+    }
+}
diff --git a/src/coreclr/tools/aot/ILCompiler.DependencyAnalysisFramework.Tests/TestGraph.cs b/src/coreclr/tools/aot/ILCompiler.DependencyAnalysisFramework.Tests/TestGraph.cs
new file mode 100644
index 00000000000000..d7b2c7393b9b44
--- /dev/null
+++ b/src/coreclr/tools/aot/ILCompiler.DependencyAnalysisFramework.Tests/TestGraph.cs
@@ -0,0 +1,177 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using ILCompiler.DependencyAnalysisFramework;
+
+namespace ILCompiler.DependencyAnalysisFramework.Tests
+{
+    class TestGraph
+    {
+        public class TestNode : ComputedStaticDependencyNode<TestGraph>
+        {
+            private readonly string _data;
+            private static readonly CombinedDependencyListEntry[] s_emptyDynamicList = new CombinedDependencyListEntry[0];
+
+            public TestNode(string data)
+            {
+                _data = data;
+            } 
+
+            public string Data
+            {
+                get
+                {
+                    return _data;
+                }
+            }
+
+            protected override string GetName(TestGraph context)
+            {
+                return _data;
+            }
+
+            public override bool HasDynamicDependencies
+            {
+                get
+                {
+                    return true;
+                }
+            }
+
+            public override IEnumerable<CombinedDependencyListEntry> SearchDynamicDependencies(List<DependencyNodeCore<TestGraph>> markedNodes, int firstNode, TestGraph context)
+            {
+                if (context._dynamicDependencyComputer == null)
+                    return s_emptyDynamicList;
+
+                IEnumerable<CombinedDependencyListEntry> returnValue = s_emptyDynamicList;
+                List<CombinedDependencyListEntry> returnValueWithData = null;
+                for (int i = firstNode; i < markedNodes.Count; i++)
+                {
+                    Tuple<string,string> nextResult = context._dynamicDependencyComputer(this.Data, ((TestNode)markedNodes[i]).Data);
+
+                    if (nextResult != null)
+                    {
+                        if (returnValueWithData == null)
+                        {
+                            returnValueWithData = new List<DependencyNodeCore<TestGraph>.CombinedDependencyListEntry>();
+                            returnValue = returnValueWithData;
+                        }
+
+                        returnValueWithData.Add(new CombinedDependencyListEntry(context.GetNode(nextResult.Item1), markedNodes[i], nextResult.Item2));
+                    }
+                }
+
+                return returnValue;
+            }
+        }
+
+        Dictionary<string, HashSet<Tuple<string, string>>> _staticNonConditionalRules = new Dictionary<string, HashSet<Tuple<string, string>>>();
+        Dictionary<string, HashSet<Tuple<string, Tuple<string, string>>>> _staticConditionalRules = new Dictionary<string, HashSet<Tuple<string, Tuple<string, string>>>>();
+
+        Func<string, string, Tuple<string,string>> _dynamicDependencyComputer;
+        Dictionary<string, TestNode> _nodes = new Dictionary<string, TestNode>();
+        DependencyAnalyzerBase<TestGraph> _analyzer;
+
+        public void AddStaticRule(string depender, string dependedOn, string reason)
+        {
+            HashSet<Tuple<string, string>> knownEdges = null;
+            if (!_staticNonConditionalRules.TryGetValue(depender, out knownEdges))
+            {
+                knownEdges = new HashSet<Tuple<string, string>>();
+                _staticNonConditionalRules[depender] = knownEdges;
+            }
+            knownEdges.Add(new Tuple<string,string>(dependedOn, reason));
+        }
+
+        public void AddConditionalRule(string depender, string otherdepender, string dependedOn, string reason)
+        {
+            HashSet<Tuple<string, Tuple<string, string>>> knownEdges = null;
+            if (!_staticConditionalRules.TryGetValue(depender, out knownEdges))
+            {
+                knownEdges = new HashSet<Tuple<string, Tuple<string, string>>>();
+                _staticConditionalRules[depender] = knownEdges;
+            }
+
+            knownEdges.Add(new Tuple<string, Tuple<string, string>>(dependedOn, new Tuple<string,string>(otherdepender, reason)));
+        }
+
+        public void SetDynamicDependencyRule(Func<string, string, Tuple<string, string>> dynamicDependencyComputer)
+        {
+            _dynamicDependencyComputer = dynamicDependencyComputer;
+        }
+
+        public void AddRoot(string nodeNode, string reason)
+        {
+            _analyzer.AddRoot(this.GetNode(nodeNode), reason);
+        }
+
+        public TestNode GetNode(string nodeName)
+        {
+            TestNode node;
+            if (!_nodes.TryGetValue(nodeName, out node))
+            {
+                node = new TestNode(nodeName);
+                _nodes.Add(nodeName, node);
+            }
+
+            return node;
+        }
+
+        public void AttachToDependencyAnalyzer(DependencyAnalyzerBase<TestGraph> analyzer)
+        {
+            analyzer.ComputeDependencyRoutine += Analyzer_ComputeDependencyRoutine;
+            _analyzer = analyzer;
+        }
+
+        private void Analyzer_ComputeDependencyRoutine(List<DependencyNodeCore<TestGraph>> obj)
+        {
+            foreach (TestNode node in obj)
+            {
+                List<TestNode.DependencyListEntry> staticList = new List<DependencyNodeCore<TestGraph>.DependencyListEntry>();
+                List<TestNode.CombinedDependencyListEntry> conditionalStaticList = new List<DependencyNodeCore<TestGraph>.CombinedDependencyListEntry>();
+
+                HashSet<Tuple<string, string>> nonConditionalRules;
+                if (_staticNonConditionalRules.TryGetValue(node.Data, out nonConditionalRules))
+                {
+                    foreach (Tuple<string, string> dependedOn in nonConditionalRules)
+                    {
+                        staticList.Add(new TestNode.DependencyListEntry(GetNode(dependedOn.Item1), dependedOn.Item2));
+                    }
+                }
+
+                HashSet<Tuple<string, Tuple<string, string>>> conditionalRules;
+                if (_staticConditionalRules.TryGetValue(node.Data, out conditionalRules))
+                {
+                    foreach (Tuple<string, Tuple<string, string>> dependedOn in conditionalRules)
+                    {
+                        conditionalStaticList.Add(new TestNode.CombinedDependencyListEntry(GetNode(dependedOn.Item1), GetNode(dependedOn.Item2.Item1), dependedOn.Item2.Item2));
+                    }
+                }
+
+                node.SetStaticDependencies(staticList, conditionalStaticList);
+            }
+        }
+
+        public List<string> AnalysisResults
+        {
+            get
+            {
+                List<string> liveNodes = new List<string>();
+
+                _analyzer.ComputeMarkedNodes();
+
+                foreach (var node in _analyzer.MarkedNodeList)
+                {
+                    liveNodes.Add(((TestNode)node).Data);
+                }
+
+                return liveNodes;
+            }
+        }
+    }
+}

From c9a00a5d86a6f3fd87458fcf3b342dad6a34f4a6 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Michal=20Strehovsk=C3=BD?=
 <MichalStrehovsky@users.noreply.github.com>
Date: Thu, 16 Jul 2026 13:59:51 +0900
Subject: [PATCH 2/2] Hook the new tests to build

---
 eng/Subsets.props                             |  2 ++
 ...r.DependencyAnalysisFramework.Tests.csproj | 20 +++++++++++++++++++
 2 files changed, 22 insertions(+)
 create mode 100644 src/coreclr/tools/aot/ILCompiler.DependencyAnalysisFramework.Tests/ILCompiler.DependencyAnalysisFramework.Tests.csproj

diff --git a/eng/Subsets.props b/eng/Subsets.props
index be4331b5e2fda6..4cac6ef4c52e6b 100644
--- a/eng/Subsets.props
+++ b/eng/Subsets.props
@@ -502,6 +502,8 @@
   </ItemGroup>
 
   <ItemGroup Condition="$(_subset.Contains('+clr.toolstests+'))">
+    <ProjectToBuild Include="$(CoreClrProjectRoot)tools\aot\ILCompiler.DependencyAnalysisFramework.Tests\ILCompiler.DependencyAnalysisFramework.Tests.csproj"
+      Test="true" Category="clr" Condition="'$(DotNetBuildSourceOnly)' != 'true'"/>
     <ProjectToBuild Include="$(CoreClrProjectRoot)tools\aot\ILCompiler.TypeSystem.Tests\ILCompiler.TypeSystem.Tests.csproj"
       Test="true" Category="clr" Condition="'$(DotNetBuildSourceOnly)' != 'true'"/>
     <ProjectToBuild Include="$(CoreClrProjectRoot)tools\aot\ILCompiler.Compiler.Tests\ILCompiler.Compiler.Tests.csproj"
diff --git a/src/coreclr/tools/aot/ILCompiler.DependencyAnalysisFramework.Tests/ILCompiler.DependencyAnalysisFramework.Tests.csproj b/src/coreclr/tools/aot/ILCompiler.DependencyAnalysisFramework.Tests/ILCompiler.DependencyAnalysisFramework.Tests.csproj
new file mode 100644
index 00000000000000..349e8facdd913d
--- /dev/null
+++ b/src/coreclr/tools/aot/ILCompiler.DependencyAnalysisFramework.Tests/ILCompiler.DependencyAnalysisFramework.Tests.csproj
@@ -0,0 +1,20 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <AssemblyName>ILCompiler.DependencyAnalysisFramework.Tests</AssemblyName>
+    <TargetFramework>$(NetCoreAppToolCurrent)</TargetFramework>
+    <Configurations>Debug;Release;Checked</Configurations>
+    <TestRunnerAdditionalArguments>-notrait category=failing</TestRunnerAdditionalArguments>
+    <!-- xunit.runner.visualstudio is restored for .NET Framework instead of Core-->
+    <NoWarn>$(NoWarn);NU1701</NoWarn>
+    <Platforms>x86;x64</Platforms>
+    <PlatformTarget>AnyCPU</PlatformTarget>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.DotNet.XUnitExtensions" Version="$(MicrosoftDotNetXUnitExtensionsVersion)" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\ILCompiler.DependencyAnalysisFramework\ILCompiler.DependencyAnalysisFramework.csproj" />
+  </ItemGroup>
+</Project>