Add WpfFactAttribute from Roslyn

Author: sharwell

Tvl.VisualStudio.MouseFastScroll.IntegrationTests/Threading/ConditionalWpfFactAttribute.cs

@@ -0,0 +1,18 @@
+// Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
+
+using System;
+
+namespace Roslyn.Test.Utilities
+{
+    public class ConditionalWpfFactAttribute : WpfFactAttribute
+    {
+        public ConditionalWpfFactAttribute(Type skipCondition)
+        {
+            var condition = Activator.CreateInstance(skipCondition) as ExecutionCondition;
+            if (condition.ShouldSkip)
+            {
+                Skip = condition.SkipReason;
+            }
+        }
+    }
+}

Tvl.VisualStudio.MouseFastScroll.IntegrationTests/Threading/ConditionalWpfTheoryAttribute.cs

@@ -0,0 +1,18 @@
+// Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
+
+using System;
+
+namespace Roslyn.Test.Utilities
+{
+    public class ConditionalWpfTheoryAttribute : WpfTheoryAttribute
+    {
+        public ConditionalWpfTheoryAttribute(Type skipCondition)
+        {
+            var condition = Activator.CreateInstance(skipCondition) as ExecutionCondition;
+            if (condition.ShouldSkip)
+            {
+                Skip = condition.SkipReason;
+            }
+        }
+    }
+}

Tvl.VisualStudio.MouseFastScroll.IntegrationTests/Threading/SemaphoreExtensions.cs

@@ -0,0 +1,54 @@
+// Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
+
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace Roslyn.Utilities
+{
+    internal static class SemaphoreExtensions
+    {
+        public static SemaphoreDisposer DisposableWait(this Semaphore semaphore, CancellationToken cancellationToken)
+        {
+            if (cancellationToken.CanBeCanceled)
+            {
+                int signalledIndex = WaitHandle.WaitAny(new[] { semaphore, cancellationToken.WaitHandle });
+                if (signalledIndex != 0)
+                {
+                    cancellationToken.ThrowIfCancellationRequested();
+                    throw ExceptionUtilities.Unreachable;
+                }
+            }
+            else
+            {
+                semaphore.WaitOne();
+            }
+
+            return new SemaphoreDisposer(semaphore);
+        }
+
+        public static Task<SemaphoreDisposer> DisposableWaitAsync(this Semaphore semaphore, CancellationToken cancellationToken)
+        {
+            return Task.Factory.StartNew(
+                () => DisposableWait(semaphore, cancellationToken),
+                cancellationToken,
+                TaskCreationOptions.LongRunning,
+                TaskScheduler.Default);
+        }
+
+        internal struct SemaphoreDisposer : IDisposable
+        {
+            private readonly Semaphore _semaphore;
+
+            public SemaphoreDisposer(Semaphore semaphore)
+            {
+                _semaphore = semaphore;
+            }
+
+            public void Dispose()
+            {
+                _semaphore.Release();
+            }
+        }
+    }
+}

Tvl.VisualStudio.MouseFastScroll.IntegrationTests/Threading/StaTaskScheduler.cs

@@ -0,0 +1,77 @@
+// Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
+
+using System;
+using System.Threading;
+using System.Windows.Threading;
+
+namespace Roslyn.Test.Utilities
+{
+    public sealed class StaTaskScheduler : IDisposable
+    {
+        /// <summary>Gets a <see cref="StaTaskScheduler"/> for the current <see cref="AppDomain"/>.</summary>
+        /// <remarks>We use a count of 1, because the editor ends up re-using <see cref="DispatcherObject"/>
+        /// instances between tests, so we need to always use the same thread for our Sta tests.</remarks>
+        public static StaTaskScheduler DefaultSta { get; } = new StaTaskScheduler();
+
+        /// <summary>The STA threads used by the scheduler.</summary>
+        public Thread StaThread { get; }
+
+        public bool IsRunningInScheduler => StaThread.ManagedThreadId == Thread.CurrentThread.ManagedThreadId;
+
+        /// <summary>Initializes a new instance of the <see cref="StaTaskScheduler"/> class.</summary>
+        public StaTaskScheduler()
+        {
+            using (var threadStartedEvent = new ManualResetEventSlim(initialState: false))
+            {
+                DispatcherSynchronizationContext synchronizationContext = null;
+                StaThread = new Thread(() =>
+                {
+                    var oldContext = SynchronizationContext.Current;
+                    try
+                    {
+                        // All WPF Tests need a DispatcherSynchronizationContext and we dont want to block pending keyboard
+                        // or mouse input from the user. So use background priority which is a single level below user input.
+                        synchronizationContext = new DispatcherSynchronizationContext();
+
+                        // xUnit creates its own synchronization context and wraps any existing context so that messages are
+                        // still pumped as necessary. So we are safe setting it here, where we are not safe setting it in test.
+                        SynchronizationContext.SetSynchronizationContext(synchronizationContext);
+
+                        threadStartedEvent.Set();
+
+                        Dispatcher.Run();
+                    }
+                    finally
+                    {
+                        SynchronizationContext.SetSynchronizationContext(oldContext);
+                    }
+                });
+                StaThread.Name = $"{nameof(StaTaskScheduler)} thread";
+                StaThread.IsBackground = true;
+                StaThread.SetApartmentState(ApartmentState.STA);
+                StaThread.Start();
+
+                threadStartedEvent.Wait();
+                DispatcherSynchronizationContext = synchronizationContext;
+            };
+        }
+
+        public DispatcherSynchronizationContext DispatcherSynchronizationContext
+        {
+            get;
+        }
+
+        /// <summary>
+        /// Cleans up the scheduler by indicating that no more tasks will be queued.
+        /// This method blocks until all threads successfully shutdown.
+        /// </summary>
+        public void Dispose()
+        {
+            if (StaThread.IsAlive)
+            {
+                DispatcherSynchronizationContext.Post(_ => Dispatcher.ExitAllFrames(), null);
+                StaThread.Join();
+            }
+        }
+    }
+}

Tvl.VisualStudio.MouseFastScroll.IntegrationTests/Threading/SynchronizationContextTaskScheduler.cs

@@ -0,0 +1,48 @@
+// Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
+
+using System;
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace Microsoft.CodeAnalysis.Editor.Shared.Utilities
+{
+    // Based on CoreCLR's implementation of the TaskScheduler they return from TaskScheduler.FromCurrentSynchronizationContext
+    internal class SynchronizationContextTaskScheduler : TaskScheduler
+    {
+        private readonly SendOrPostCallback _postCallback;
+        private readonly SynchronizationContext _synchronizationContext;
+
+        internal SynchronizationContextTaskScheduler(SynchronizationContext synchronizationContext)
+        {
+            _postCallback = new SendOrPostCallback(PostCallback);
+            _synchronizationContext = synchronizationContext ?? throw new ArgumentNullException(nameof(synchronizationContext));
+        }
+
+        public override Int32 MaximumConcurrencyLevel => 1;
+
+        protected override void QueueTask(Task task)
+        {
+            _synchronizationContext.Post(_postCallback, task);
+        }
+        protected override bool TryExecuteTaskInline(Task task, bool taskWasPreviouslyQueued)
+        {
+            if (SynchronizationContext.Current == _synchronizationContext)
+            {
+                return TryExecuteTask(task);
+            }
+
+            return false;
+        }
+
+        protected override IEnumerable<Task> GetScheduledTasks()
+        {
+            return null;
+        }
+
+        private void PostCallback(object obj)
+        {
+            TryExecuteTask((Task)obj);
+        }
+    }
+}

Tvl.VisualStudio.MouseFastScroll.IntegrationTests/Threading/TaskJoinExtensions.cs

@@ -0,0 +1,60 @@
+// Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
+
+using System.Threading;
+using System.Threading.Tasks;
+using System.Windows.Threading;
+using Xunit;
+
+namespace Roslyn.Test.Utilities
+{
+    public static class TaskJoinExtensions
+    {
+        /// <summary>
+        /// Joins a <see cref="Task"/> to the current thread with a <see cref="Dispatcher"/> message pump in place
+        /// during the join operation.
+        /// </summary>
+        public static void JoinUsingDispatcher(this Task task, CancellationToken cancellationToken)
+        {
+            JoinUsingDispatcherNoResult(task, cancellationToken);
+
+            // Handle task completion by throwing the appropriate exception on failure
+            task.GetAwaiter().GetResult();
+        }
+
+        /// <summary>
+        /// Joins a <see cref="Task{TResult}"/> to the current thread with a <see cref="Dispatcher"/> message pump in
+        /// place during the join operation.
+        /// </summary>
+        public static TResult JoinUsingDispatcher<TResult>(this Task<TResult> task, CancellationToken cancellationToken)
+        {
+            JoinUsingDispatcherNoResult(task, cancellationToken);
+
+            // Handle task completion by throwing the appropriate exception on failure
+            return task.GetAwaiter().GetResult();
+        }
+
+        private static void JoinUsingDispatcherNoResult(Task task, CancellationToken cancellationToken)
+        {
+            var frame = new DispatcherFrame();
+
+            // When the task completes or cancellation is requested, mark the frame so we leave the message pump
+            task.ContinueWith(
+                t => frame.Continue = false,
+                CancellationToken.None,
+                TaskContinuationOptions.ExecuteSynchronously,
+                TaskScheduler.Default);
+
+            using (var registration = cancellationToken.Register(() => frame.Continue = false))
+            {
+                Dispatcher.PushFrame(frame);
+            }
+
+            // Handle cancellation by throwing an exception
+            if (!task.IsCompleted)
+            {
+                Assert.True(cancellationToken.IsCancellationRequested);
+                cancellationToken.ThrowIfCancellationRequested();
+            }
+        }
+    }
+}

Tvl.VisualStudio.MouseFastScroll.IntegrationTests/Threading/WpfFactAttribute.cs

@@ -0,0 +1,14 @@
+// Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
+
+using System;
+using Xunit;
+using Xunit.Sdk;
+
+namespace Roslyn.Test.Utilities
+{
+    [AttributeUsage(AttributeTargets.Method, AllowMultiple = false)]
+    [XunitTestCaseDiscoverer("Roslyn.Test.Utilities.WpfFactDiscoverer", "Roslyn.Services.Test.Utilities")]
+    public class WpfFactAttribute : FactAttribute
+    {
+    }
+}

Tvl.VisualStudio.MouseFastScroll.IntegrationTests/Threading/WpfFactDiscoverer.cs

@@ -0,0 +1,43 @@
+// Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
+
+using System.Collections.Generic;
+using Xunit.Abstractions;
+using Xunit.Sdk;
+
+namespace Roslyn.Test.Utilities
+{
+    public class WpfFactDiscoverer : FactDiscoverer
+    {
+        private readonly IMessageSink _diagnosticMessageSink;
+ 
+        public WpfFactDiscoverer(IMessageSink diagnosticMessageSink) : base(diagnosticMessageSink)
+        {
+            _diagnosticMessageSink = diagnosticMessageSink;
+        }
+
+        protected override IXunitTestCase CreateTestCase(ITestFrameworkDiscoveryOptions discoveryOptions, ITestMethod testMethod, IAttributeInfo factAttribute)
+            => new WpfTestCase(_diagnosticMessageSink, discoveryOptions.MethodDisplayOrDefault(), testMethod);
+    }
+
+    public class WpfTheoryDiscoverer : TheoryDiscoverer
+    {
+        private readonly IMessageSink _diagnosticMessageSink;
+ 
+        public WpfTheoryDiscoverer(IMessageSink diagnosticMessageSink) : base(diagnosticMessageSink)
+        {
+            _diagnosticMessageSink = diagnosticMessageSink;
+        }
+
+        protected override IEnumerable<IXunitTestCase> CreateTestCasesForDataRow(ITestFrameworkDiscoveryOptions discoveryOptions, ITestMethod testMethod, IAttributeInfo theoryAttribute, object[] dataRow)
+        {
+            var testCase = new WpfTestCase(_diagnosticMessageSink, discoveryOptions.MethodDisplayOrDefault(), testMethod, dataRow);
+            return new[] { testCase };
+        }
+
+        protected override IEnumerable<IXunitTestCase> CreateTestCasesForTheory(ITestFrameworkDiscoveryOptions discoveryOptions, ITestMethod testMethod, IAttributeInfo theoryAttribute)
+        {
+            var testCase = new WpfTheoryTestCase(_diagnosticMessageSink, discoveryOptions.MethodDisplayOrDefault(), testMethod);
+            return new[] { testCase };
+        }
+    }
+}

Tvl.VisualStudio.MouseFastScroll.IntegrationTests/Threading/WpfTestCase.cs

@@ -0,0 +1,40 @@
+// Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
+
+using System;
+using System.ComponentModel;
+using System.Threading;
+using System.Threading.Tasks;
+using Xunit.Abstractions;
+using Xunit.Sdk;
+
+namespace Roslyn.Test.Utilities
+{
+    public sealed class WpfTestCase : XunitTestCase
+    {
+        public WpfTestSharedData SharedData { get; private set; }
+ 
+        [EditorBrowsable(EditorBrowsableState.Never)]
+        [Obsolete("Called by the de-serializer; should only be called by deriving classes for de-serialization purposes")]
+        public WpfTestCase()
+        {
+        }
+ 
+        public WpfTestCase(IMessageSink diagnosticMessageSink, TestMethodDisplay defaultMethodDisplay, ITestMethod testMethod, object[] testMethodArguments = null)
+            : base(diagnosticMessageSink, defaultMethodDisplay, testMethod, testMethodArguments)
+        {
+            SharedData = WpfTestSharedData.Instance;
+        }
+ 
+        public override Task<RunSummary> RunAsync(IMessageSink diagnosticMessageSink, IMessageBus messageBus, object[] constructorArguments, ExceptionAggregator aggregator, CancellationTokenSource cancellationTokenSource)
+        {
+            var runner = new WpfTestCaseRunner(SharedData, this, DisplayName, SkipReason, constructorArguments, TestMethodArguments, messageBus, aggregator, cancellationTokenSource);
+            return runner.RunAsync();
+        }
+ 
+        public override void Deserialize(IXunitSerializationInfo data)
+        {
+            base.Deserialize(data);
+            SharedData = WpfTestSharedData.Instance;
+        }
+    }
+}