[Helix] Try out the new dotnet test blame functionality

.azure/pipelines/helix-matrix.yml

@@ -1,5 +1,9 @@
 # We only want to run full helix matrix on master
-pr: none
+pr:
+  autoCancel: true
+  branches:
+    include:
+    - '*'
 trigger: none
 schedules:
 - cron: "0 */12 * * *"

eng/helix/content/RunTests/TestRunner.cs

@@ -247,7 +247,7 @@ public async Task<int> RunTestsAsync()
             {
                 // Timeout test run 5 minutes before the Helix job would timeout
                 var cts = new CancellationTokenSource(Options.Timeout.Subtract(TimeSpan.FromMinutes(5)));
-                var commonTestArgs = $"test {Options.Target} --logger:xunit --logger:\"console;verbosity=normal\" --blame \"CollectHangDump;TestTimeout=5m\"";                
+                var commonTestArgs = $"test {Options.Target} --logger:xunit --logger:\"console;verbosity=normal\" --blame \"CollectHangDump;TestTimeout=5m\"";
                 if (Options.Quarantined)
                 {
                     Console.WriteLine("Running quarantined tests.");
@@ -322,9 +322,7 @@ public void UploadResults()
                     // Combine the directory name + log name for the copied log file name to avoid overwriting duplicate test names in different test projects
                     var logName = $"{Path.GetFileName(Path.GetDirectoryName(file))}_{Path.GetFileName(file)}";
                     Console.WriteLine($"Copying: {file} to {Path.Combine(HELIX_WORKITEM_UPLOAD_ROOT, logName)}");
-                    // Need to copy to HELIX_WORKITEM_UPLOAD_ROOT and HELIX_WORKITEM_UPLOAD_ROOT/../ in order for Azure Devops attachments to link properly and for Helix to store the logs
                     File.Copy(file, Path.Combine(HELIX_WORKITEM_UPLOAD_ROOT, logName));
-                    File.Copy(file, Path.Combine(HELIX_WORKITEM_UPLOAD_ROOT, "..", logName));
                 }
             }
             else
@@ -338,15 +336,27 @@ public void UploadResults()
                 {
                     var fileName = Path.GetFileName(file);
                     Console.WriteLine($"Copying: {file} to {Path.Combine(HELIX_WORKITEM_UPLOAD_ROOT, fileName)}");
-                    // Need to copy to HELIX_WORKITEM_UPLOAD_ROOT and HELIX_WORKITEM_UPLOAD_ROOT/../ in order for Azure Devops attachments to link properly and for Helix to store the logs
                     File.Copy(file, Path.Combine(HELIX_WORKITEM_UPLOAD_ROOT, fileName));
-                    File.Copy(file, Path.Combine(HELIX_WORKITEM_UPLOAD_ROOT, "..", fileName));
                 }
             }
             else
             {
                 Console.WriteLine("No dmps found in TestResults");
-            }            
+            }
+            Console.WriteLine($"Copying TestResults/**/*.trx to {HELIX_WORKITEM_UPLOAD_ROOT}/");
+            if (Directory.Exists("TestResults"))
+            {
+                foreach (var file in Directory.EnumerateFiles("TestResults", "*.trx", SearchOption.AllDirectories))
+                {
+                    var fileName = Path.GetFileName(file);
+                    Console.WriteLine($"Copying: {file} to {Path.Combine(HELIX_WORKITEM_UPLOAD_ROOT, fileName)}");
+                    File.Copy(file, Path.Combine(HELIX_WORKITEM_UPLOAD_ROOT, fileName));
+                }
+            }
+            else
+            {
+                Console.WriteLine("No trx found in TestResults");
+            }
         }
     }
 }

src/Components/Components/src/Rendering/RenderTreeBuilder.cs

@@ -162,7 +162,6 @@ public void AddAttribute(int sequence, string name)
                 throw new InvalidOperationException($"Valueless attributes may only be added immediately after frames of type {RenderTreeFrameType.Element}");
             }
 
-
             _entries.AppendAttribute(sequence, name, BoxedTrue);
         }
 

src/Framework/test/HangingTest.cs

@@ -0,0 +1,158 @@
+using System;
+using System.Diagnostics;
+using System.Runtime.CompilerServices;
+using System.Threading;
+using System.Threading.Tasks;
+using Xunit;
+
+namespace XUnitTestProject3
+{
+    public class UnitTest1
+    {
+        static UnitTest1()
+        {
+            AppDomain.CurrentDomain.FirstChanceException += (sender, e) =>
+            {
+                if (e.Exception is TestTimeoutException)
+                {
+                    // Block forever, this allows the test host to collect a dump with the test still on the stack
+                    new ManualResetEventSlim().Wait();
+                }
+            };
+        }
+
+        [Fact]
+        public async Task AsyncTimeoutTest()
+        {
+            var tcs = new TaskCompletionSource<object>();
+
+            await tcs.Task.OrTimeout();
+        }
+    }
+
+
+    static class TaskExtensions
+    {
+        private const int DefaultTimeout = 5 * 1000;
+
+        public static Task OrTimeout(this ValueTask task, int milliseconds = DefaultTimeout, [CallerMemberName] string memberName = null, [CallerFilePath] string filePath = null, [CallerLineNumber] int? lineNumber = null)
+        {
+            return OrTimeout(task, new TimeSpan(0, 0, 0, 0, milliseconds), memberName, filePath, lineNumber);
+        }
+
+        public static Task OrTimeout(this ValueTask task, TimeSpan timeout, [CallerMemberName] string memberName = null, [CallerFilePath] string filePath = null, [CallerLineNumber] int? lineNumber = null)
+        {
+            return task.AsTask().TimeoutAfter(timeout, filePath, lineNumber ?? 0);
+        }
+
+        public static Task OrTimeout(this Task task, int milliseconds = DefaultTimeout, [CallerMemberName] string memberName = null, [CallerFilePath] string filePath = null, [CallerLineNumber] int? lineNumber = null)
+        {
+            return OrTimeout(task, new TimeSpan(0, 0, 0, 0, milliseconds), memberName, filePath, lineNumber);
+        }
+
+        public static Task OrTimeout(this Task task, TimeSpan timeout, [CallerMemberName] string memberName = null, [CallerFilePath] string filePath = null, [CallerLineNumber] int? lineNumber = null)
+        {
+            return task.TimeoutAfter(timeout, filePath, lineNumber ?? 0);
+        }
+
+        public static Task<T> OrTimeout<T>(this ValueTask<T> task, int milliseconds = DefaultTimeout, [CallerMemberName] string memberName = null, [CallerFilePath] string filePath = null, [CallerLineNumber] int? lineNumber = null) =>
+            OrTimeout(task, new TimeSpan(0, 0, 0, 0, milliseconds), memberName, filePath, lineNumber);
+
+        public static Task<T> OrTimeout<T>(this ValueTask<T> task, TimeSpan timeout, [CallerMemberName] string memberName = null, [CallerFilePath] string filePath = null, [CallerLineNumber] int? lineNumber = null) =>
+            task.AsTask().OrTimeout(timeout, memberName, filePath, lineNumber);
+
+        public static Task<T> OrTimeout<T>(this Task<T> task, int milliseconds = DefaultTimeout, [CallerMemberName] string memberName = null, [CallerFilePath] string filePath = null, [CallerLineNumber] int? lineNumber = null)
+        {
+            return OrTimeout(task, new TimeSpan(0, 0, 0, 0, milliseconds), memberName, filePath, lineNumber);
+        }
+
+        public static Task<T> OrTimeout<T>(this Task<T> task, TimeSpan timeout, [CallerMemberName] string memberName = null, [CallerFilePath] string filePath = null, [CallerLineNumber] int? lineNumber = null)
+        {
+            return task.TimeoutAfter(timeout, filePath, lineNumber ?? 0);
+        }
+
+        public static async Task OrThrowIfOtherFails(this Task task, Task otherTask)
+        {
+            var completed = await Task.WhenAny(task, otherTask);
+            if (completed == otherTask && otherTask.IsFaulted)
+            {
+                // Manifest the exception
+                otherTask.GetAwaiter().GetResult();
+                throw new Exception("Unreachable code");
+            }
+            else
+            {
+                // Await the task we were asked to await. Either it's finished, or the otherTask finished successfully, and it's not our job to check that
+                await task;
+            }
+        }
+
+        public static async Task<T> OrThrowIfOtherFails<T>(this Task<T> task, Task otherTask)
+        {
+            await OrThrowIfOtherFails((Task)task, otherTask);
+
+            // If we get here, 'task' is finished and succeeded.
+            return task.GetAwaiter().GetResult();
+        }
+
+        public static async Task<T> TimeoutAfter<T>(this Task<T> task, TimeSpan timeout,
+            [CallerFilePath] string filePath = null,
+            [CallerLineNumber] int lineNumber = default)
+        {
+            // Don't create a timer if the task is already completed
+            // or the debugger is attached
+            if (task.IsCompleted || Debugger.IsAttached)
+            {
+                return await task;
+            }
+
+            var cts = new CancellationTokenSource();
+            if (task == await Task.WhenAny(task, Task.Delay(timeout, cts.Token)))
+            {
+                cts.Cancel();
+                return await task;
+            }
+            else
+            {
+                throw new TestTimeoutException(CreateMessage(timeout, filePath, lineNumber));
+            }
+        }
+
+        public static async Task TimeoutAfter(this Task task, TimeSpan timeout,
+            [CallerFilePath] string filePath = null,
+            [CallerLineNumber] int lineNumber = default)
+        {
+            // Don't create a timer if the task is already completed
+            // or the debugger is attached
+            if (task.IsCompleted || Debugger.IsAttached)
+            {
+                await task;
+                return;
+            }
+
+            var cts = new CancellationTokenSource();
+            if (task == await Task.WhenAny(task, Task.Delay(timeout, cts.Token)))
+            {
+                cts.Cancel();
+                await task;
+            }
+            else
+            {
+                throw new TimeoutException(CreateMessage(timeout, filePath, lineNumber));
+            }
+        }
+
+        private static string CreateMessage(TimeSpan timeout, string filePath, int lineNumber)
+            => string.IsNullOrEmpty(filePath)
+            ? $"The operation timed out after reaching the limit of {timeout.TotalMilliseconds}ms."
+            : $"The operation at {filePath}:{lineNumber} timed out after reaching the limit of {timeout.TotalMilliseconds}ms.";
+    }
+
+    public class TestTimeoutException : TimeoutException
+    {
+        public TestTimeoutException(string message) : base(message)
+        {
+
+        }
+    }    
+}

src/Identity/src/Common/AssemblyResolution.cs

@@ -0,0 +1,58 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+#if NET472
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Reflection;
+using Microsoft.Build.Framework;
+using Microsoft.Build.Utilities;
+
+namespace Microsoft.DotNet
+{
+    internal static class AssemblyResolution
+    {
+        internal static TaskLoggingHelper Log;
+
+        public static void Initialize()
+        {
+            AppDomain.CurrentDomain.AssemblyResolve += AssemblyResolve;
+        }
+
+        private static Assembly AssemblyResolve(object sender, ResolveEventArgs args)
+        {
+            var name = new AssemblyName(args.Name);
+
+            if (!name.Name.Equals("System.Collections.Immutable", StringComparison.OrdinalIgnoreCase))
+            {
+                return null;
+            }
+
+            var fullPath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "System.Collections.Immutable.dll");
+
+            Assembly sci;
+            try
+            {
+                sci = Assembly.LoadFile(fullPath);
+            }
+            catch (Exception e)
+            {
+                Log?.LogWarning($"AssemblyResolve: exception while loading '{fullPath}': {e.Message}");
+                return null;
+            }
+
+            if (name.Version <= sci.GetName().Version)
+            {
+                Log?.LogMessage(MessageImportance.Low, $"AssemblyResolve: loaded '{fullPath}' to {AppDomain.CurrentDomain.FriendlyName}");
+                return sci;
+            }
+
+            return null;
+        }
+    }
+}
+
+#endif

src/Identity/src/Common/AssemblyResolver.cs

@@ -0,0 +1,109 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Diagnostics;
+using System.IO;
+using System.Reflection;
+
+namespace Microsoft.DotNet.Build.Common.Desktop
+{
+    /// <summary>
+    /// Used to enable app-local assembly unification.
+    /// </summary>
+    internal static class AssemblyResolver
+    {
+        static AssemblyResolver()
+        {
+            AppDomain.CurrentDomain.AssemblyResolve += CurrentDomain_AssemblyResolve;
+        }
+
+        /// <summary>
+        /// Call to enable the assembly resolver for the current AppDomain.
+        /// </summary>
+        public static void Enable()
+        {
+            // intentionally empty.  This is just meant to ensure the static constructor
+            // has run.
+        }
+
+        private static Assembly CurrentDomain_AssemblyResolve(object sender, ResolveEventArgs args)
+        {
+            // apply any existing policy
+            AssemblyName referenceName = new AssemblyName(AppDomain.CurrentDomain.ApplyPolicy(args.Name));
+
+            string fileName = referenceName.Name + ".dll";
+            string assemblyPath = null;
+            string probingPath = null;
+            Assembly assm = null;
+
+            // look next to requesting assembly
+            assemblyPath = args.RequestingAssembly?.Location;
+            if (!String.IsNullOrEmpty(assemblyPath))
+            {
+                probingPath = Path.Combine(Path.GetDirectoryName(assemblyPath), fileName);
+                Debug.WriteLine($"Considering {probingPath} based on RequestingAssembly");
+                if (Probe(probingPath, referenceName.Version, out assm))
+                {
+                    return assm;
+                }
+            }
+
+            // look next to the executing assembly
+            assemblyPath = Assembly.GetExecutingAssembly().Location;
+            if (!String.IsNullOrEmpty(assemblyPath))
+            {
+                probingPath = Path.Combine(Path.GetDirectoryName(assemblyPath), fileName);
+
+                Debug.WriteLine($"Considering {probingPath} based on ExecutingAssembly");
+                if (Probe(probingPath, referenceName.Version, out assm))
+                {
+                    return assm;
+                }
+            }
+
+            // look in AppDomain base directory
+            probingPath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, fileName);
+            Debug.WriteLine($"Considering {probingPath} based on BaseDirectory");
+            if (Probe(probingPath, referenceName.Version, out assm))
+            {
+                return assm;
+            }
+
+            // look in current directory
+            Debug.WriteLine($"Considering {fileName}");
+            if (Probe(fileName, referenceName.Version, out assm))
+            {
+                return assm;
+            }
+
+            return null;
+        }
+
+        /// <summary>
+        /// Considers a path to load for satisfying an assembly ref and loads it
+        /// if the file exists and version is sufficient.
+        /// </summary>
+        /// <param name="filePath">Path to consider for load</param>
+        /// <param name="minimumVersion">Minimum version to consider</param>
+        /// <param name="assembly">loaded assembly</param>
+        /// <returns>true if assembly was loaded</returns>
+        private static bool Probe(string filePath, Version minimumVersion, out Assembly assembly)
+        {
+            if (File.Exists(filePath))
+            {
+                AssemblyName name = AssemblyName.GetAssemblyName(filePath);
+
+                if (name.Version >= minimumVersion)
+                {
+                    assembly = Assembly.Load(name);
+                    return true;
+                }
+            }
+
+            assembly = null;
+            return false;
+        }
+    }
+}