Add cocoa fact attribute and related unit tests

Directory.Build.props

@@ -14,6 +14,7 @@
     <ProduceReferenceAssembly>true</ProduceReferenceAssembly>
     <EnableWindowsTargeting>true</EnableWindowsTargeting>
     <TargetingWindows Condition=" '$(TargetFramework)' == 'net472' or $(TargetFramework.EndsWith('-windows')) ">true</TargetingWindows>
+    <TargetingMacos Condition=" '$(TargetFramework)' == 'net6.0-macos10.15' or $(TargetFramework.EndsWith('-macos')) ">true</TargetingMacos>
 
     <!-- https://github.com/dotnet/msbuild/blob/main/documentation/ProjectReference-Protocol.md#setplatform-negotiation -->
     <EnableDynamicPlatformResolution>true</EnableDynamicPlatformResolution>

global.json

@@ -1,6 +1,6 @@
 {
   "sdk": {
-    "version": "7.0.101",
+    "version": "7.0.100",
     "rollForward": "patch",
     "allowPrerelease": false
   }

src/Xunit.StaFact/Mac/CocoaFactAttribute.cs

@@ -0,0 +1,18 @@
+// Copyright (c) Andrew Arnott. All rights reserved.
+// Licensed under the Ms-PL license. See LICENSE.txt file in the project root for full license information.
+using System;
+using System.Threading;
+using Xunit.Sdk;
+
+namespace Xunit
+{
+    /// <summary>
+    /// Identifies an xunit test that starts on with a <see cref="System.Threading.SynchronizationContext"/>
+    /// running on <see cref="Foundation.NSRunLoop.Main"/>.
+    /// </summary>
+    [AttributeUsage(AttributeTargets.Method, AllowMultiple = false)]
+    [XunitTestCaseDiscoverer("Xunit.Sdk.CocoaFactDiscoverer", ThisAssembly.AssemblyName)]
+    public class CocoaFactAttribute : FactAttribute
+    {
+    }
+}

src/Xunit.StaFact/Mac/CocoaTheoryAttribute.cs

@@ -0,0 +1,18 @@
+// Copyright (c) Andrew Arnott. All rights reserved.
+// Licensed under the Ms-PL license. See LICENSE.txt file in the project root for full license information.
+using System;
+using System.Threading;
+using Xunit.Sdk;
+
+namespace Xunit
+{
+    /// <summary>
+    /// Identifies an xunit theory that starts on with a <see cref="System.Threading.SynchronizationContext"/>
+    /// running on <see cref="Foundation.NSRunLoop.Main"/>
+    /// </summary>
+    [AttributeUsage(AttributeTargets.Method, AllowMultiple = false)]
+    [XunitTestCaseDiscoverer("Xunit.Sdk.CocoaTheoryDiscoverer", ThisAssembly.AssemblyName)]
+    public class CocoaTheoryAttribute : TheoryAttribute
+    {
+    }
+}

src/Xunit.StaFact/Sdk.Mac/CocoaFactDiscoverer.cs

@@ -0,0 +1,56 @@
+// Copyright (c) Andrew Arnott. All rights reserved.
+// Licensed under the Ms-PL license. See LICENSE.txt file in the project root for full license information.
+
+using System;
+using System.Linq;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using Xunit.Abstractions;
+
+namespace Xunit.Sdk
+{
+    /// <summary>
+    /// The discovery class for <see cref="CocoaFactDiscoverer"/>.
+    /// </summary>
+    public class CocoaFactDiscoverer : FactDiscoverer
+    {
+        private readonly IMessageSink diagnosticMessageSink;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="CocoaFactDiscoverer"/> class.
+        /// </summary>
+        /// <param name="diagnosticMessageSink">The diagnostic message sink.</param>
+        public CocoaFactDiscoverer(IMessageSink diagnosticMessageSink)
+            : base(diagnosticMessageSink)
+        {
+            this.diagnosticMessageSink = diagnosticMessageSink;
+        }
+
+        class MyMessage: IMessageSinkMessage
+        {
+            public string Message { get; set; }
+        }
+
+        protected override IXunitTestCase CreateTestCase(ITestFrameworkDiscoveryOptions discoveryOptions, ITestMethod testMethod, IAttributeInfo factAttribute)
+        {
+            var message = new MyMessage
+            {
+                Message = "Hello"
+            };
+
+            Console.WriteLine("hello!!");
+            diagnosticMessageSink.OnMessage(message);
+            if (testMethod.Method.ReturnType.Name == "System.Void" &&
+                testMethod.Method.GetCustomAttributes(typeof(AsyncStateMachineAttribute)).Any())
+            {
+                return new ExecutionErrorTestCase(this.diagnosticMessageSink, discoveryOptions.MethodDisplayOrDefault(), TestMethodDisplayOptions.None, testMethod, "Async void methods are not supported.");
+            }
+
+            return (IXunitTestCase)new UITestCase(UITestCase.SyncContextType.Cocoa, this.diagnosticMessageSink, discoveryOptions.MethodDisplayOrDefault(), testMethod);
+
+            //return RuntimeInformation.IsOSPlatform(OSPlatform.OSX)
+            //    ? (IXunitTestCase)new UITestCase(UITestCase.SyncContextType.Cocoa, this.diagnosticMessageSink, discoveryOptions.MethodDisplayOrDefault(), testMethod)
+             //    : new XunitSkippedDataRowTestCase(this.diagnosticMessageSink, discoveryOptions.MethodDisplayOrDefault(), discoveryOptions.MethodDisplayOptionsOrDefault(), testMethod, "Cocoa only exists on macOS.");
+        }
+    }
+}

src/Xunit.StaFact/Sdk.Mac/CocoaSynchronizationContext.cs

@@ -0,0 +1,198 @@
+// Copyright (c) Aaron Bockover. All rights reserved.
+// Licensed under the Ms-PL license. See LICENSE.txt file in the project root for full license information.
+
+using System.Threading;
+
+using Foundation;
+
+namespace Xunit.Sdk
+{
+    internal sealed class CocoaSynchronizationContext : SynchronizationContext
+    {
+
+        private readonly Queue<KeyValuePair<SendOrPostCallback, object?>> messageQueue = new Queue<KeyValuePair<SendOrPostCallback, object?>>();
+        private readonly int mainThread = Environment.CurrentManagedThreadId;
+        private readonly AsyncAutoResetEvent workItemDone = new AsyncAutoResetEvent();
+        private readonly string name;
+        private readonly bool shouldSetAsCurrent;
+        private int activeOperations;
+        private bool pumping;
+        private bool pumpingEnded;
+        private ExceptionAggregator? aggregator;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="CocoaSynchronizationContext"/> class.
+        /// </summary>
+        public CocoaSynchronizationContext(string name, bool shouldSetAsCurrent)
+        {
+            this.name = name;
+            this.shouldSetAsCurrent = shouldSetAsCurrent;
+        }
+
+        internal bool IsInContext => this.mainThread == Environment.CurrentManagedThreadId;
+
+        private bool AnyMessagesInQueue
+        {
+            get
+            {
+                lock (this.messageQueue)
+                {
+                    return this.messageQueue.Count > 0;
+                }
+            }
+        }
+
+        private bool AnyPendingOperations => Volatile.Read(ref this.activeOperations) > 0;
+
+        public override SynchronizationContext CreateCopy()
+            => new CocoaSynchronizationContext(name, shouldSetAsCurrent);
+
+        public override void Post(SendOrPostCallback d, object state)
+            => NSRunLoop.Main.BeginInvokeOnMainThread(() => d(state));
+
+        public override void Send(SendOrPostCallback d, object state)
+            => NSRunLoop.Main.InvokeOnMainThread(() => d(state));
+
+        /// <summary>
+        /// Blocks the calling thread to pump messages until a task has completed.
+        /// </summary>
+        /// <param name="untilCompleted">The task that must complete to break out of the message loop.</param>
+        public void PumpMessages(Task untilCompleted)
+        {
+            this.VerifyState();
+
+            this.pumping = true;
+            try
+            {
+                // Arrange to wake up immediately when the task completes.
+                untilCompleted.ContinueWith(
+                    _ =>
+                    {
+                        lock (this.messageQueue)
+                        {
+                            Monitor.Pulse(this.messageQueue);
+                        }
+                    },
+                    TaskScheduler.Default);
+
+                // Now run the message loop until the task completes.
+                while (!untilCompleted.IsCompleted)
+                {
+                    this.TryOneWorkItem();
+                }
+            }
+            finally
+            {
+                this.pumping = false;
+                this.pumpingEnded = true;
+            }
+        }
+
+        public async Task WaitForOperationCompletionAsync()
+        {
+            while (this.AnyPendingOperations || this.AnyMessagesInQueue)
+            {
+                await this.workItemDone.WaitAsync().ConfigureAwait(false);
+            }
+        }
+
+        /// <summary>
+        /// Pump messages until all pending operations have completed
+        /// and the message queue is empty.
+        /// </summary>
+        public void CompleteOperations()
+        {
+            this.VerifyState();
+            this.pumping = true;
+            try
+            {
+                while (this.AnyPendingOperations || this.AnyMessagesInQueue)
+                {
+                    this.TryOneWorkItem();
+                }
+            }
+            finally
+            {
+                this.pumping = false;
+            }
+        }
+
+        /// <inheritdoc />
+        public override void OperationStarted()
+        {
+            Interlocked.Increment(ref this.activeOperations);
+        }
+
+        /// <inheritdoc />
+        public override void OperationCompleted()
+        {
+            int result = Interlocked.Decrement(ref this.activeOperations);
+            if (result == 0)
+            {
+                // Give any message waiter a heads up that the operation count has reached zero,
+                // in case the queue is empty at the same time the operation count is, which
+                // is usually a sign to return to its caller.
+                lock (this.messageQueue)
+                {
+                    Monitor.Pulse(this.messageQueue);
+                }
+            }
+        }
+
+        internal void SetExceptionAggregator(ExceptionAggregator aggregator)
+        {
+            this.aggregator = aggregator;
+        }
+
+        private void VerifyState()
+        {
+            if (Environment.CurrentManagedThreadId != this.mainThread)
+            {
+                throw new InvalidOperationException("Wrong thread");
+            }
+
+            if (Current != this && this.shouldSetAsCurrent)
+            {
+                throw new InvalidOperationException("Wrong sync context");
+            }
+
+            if (this.pumping)
+            {
+                throw new InvalidOperationException("Already pumping");
+            }
+        }
+
+        private bool TryOneWorkItem()
+        {
+            KeyValuePair<SendOrPostCallback, object?> work = default;
+            lock (this.messageQueue)
+            {
+                if (this.messageQueue.Count == 0)
+                {
+                    Monitor.Wait(this.messageQueue);
+                    return false;
+                }
+
+                work = this.messageQueue.Dequeue();
+            }
+
+            try
+            {
+                if (this.aggregator is object)
+                {
+                    this.aggregator.Run(() => work.Key(work.Value));
+                }
+                else
+                {
+                    work.Key(work.Value);
+                }
+
+                return true;
+            }
+            finally
+            {
+                this.workItemDone.Set();
+            }
+        }
+    }
+}

src/Xunit.StaFact/Sdk.Mac/CocoaSynchronizationContextAdapter.cs

@@ -0,0 +1,35 @@
+// Copyright (c) Aaron Bockover. All rights reserved.
+// Licensed under the Ms-PL license. See LICENSE.txt file in the project root for full license information.
+
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+
+using Foundation;
+
+namespace Xunit.Sdk
+{
+    internal class CocoaSynchronizationContextAdapter : SyncContextAdapter
+    {
+        internal static readonly SyncContextAdapter Default = new CocoaSynchronizationContextAdapter();
+
+        private CocoaSynchronizationContextAdapter()
+        {
+        }
+
+        internal override bool CanCompleteOperations => true;
+
+        internal override SynchronizationContext Create(string name) => new CocoaSynchronizationContext(name, this.ShouldSetAsCurrent);
+
+        internal override Task WaitForOperationCompletionAsync(SynchronizationContext syncContext) => ((CocoaSynchronizationContext)syncContext).WaitForOperationCompletionAsync();
+
+        // internal override void CompleteOperations()
+        // {
+        // }
+
+        internal override void PumpTill(SynchronizationContext synchronizationContext, Task task)
+        {
+            ((CocoaSynchronizationContext)synchronizationContext).PumpMessages(task);
+        }
+    }
+}

src/Xunit.StaFact/Sdk.Mac/CocoaTheoryDiscoverer.cs

@@ -0,0 +1,40 @@
+// Copyright (c) Andrew Arnott. All rights reserved.
+// Licensed under the Ms-PL license. See LICENSE.txt file in the project root for full license information.
+
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+using Xunit.Abstractions;
+
+namespace Xunit.Sdk
+{
+    /// <summary>
+    /// The discovery class for <see cref="CocoaTheoryAttribute"/>.
+    /// </summary>
+    public class CocoaTheoryDiscoverer : TheoryDiscoverer
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="CocoaTheoryDiscoverer"/> class.
+        /// </summary>
+        /// <param name="diagnosticMessageSink">The diagnostic message sink.</param>
+        public CocoaTheoryDiscoverer(IMessageSink diagnosticMessageSink)
+            : base(diagnosticMessageSink)
+        {
+        }
+
+        protected override IEnumerable<IXunitTestCase> CreateTestCasesForDataRow(ITestFrameworkDiscoveryOptions discoveryOptions, ITestMethod testMethod, IAttributeInfo theoryAttribute, object[] dataRow)
+        {
+            yield return (IXunitTestCase)new UITestCase(UITestCase.SyncContextType.Cocoa, this.DiagnosticMessageSink, discoveryOptions.MethodDisplayOrDefault(), testMethod, dataRow);
+            //yield return RuntimeInformation.IsOSPlatform(OSPlatform.OSX)
+            //    ? (IXunitTestCase)new UITestCase(UITestCase.SyncContextType.Cocoa, this.DiagnosticMessageSink, discoveryOptions.MethodDisplayOrDefault(), testMethod, dataRow)
+            //    : new XunitSkippedDataRowTestCase(this.DiagnosticMessageSink, discoveryOptions.MethodDisplayOrDefault(), discoveryOptions.MethodDisplayOptionsOrDefault(), testMethod, "Cocoa only exists on macOS.");
+        }
+
+        protected override IEnumerable<IXunitTestCase> CreateTestCasesForTheory(ITestFrameworkDiscoveryOptions discoveryOptions, ITestMethod testMethod, IAttributeInfo theoryAttribute)
+        {
+            yield return (IXunitTestCase)new UITheoryTestCase(UITestCase.SyncContextType.Cocoa, this.DiagnosticMessageSink, discoveryOptions.MethodDisplayOrDefault(), TestMethodDisplayOptions.None, testMethod);
+            //yield return RuntimeInformation.IsOSPlatform(OSPlatform.OSX)
+            //    ? (IXunitTestCase)new UITheoryTestCase(UITestCase.SyncContextType.Cocoa, this.DiagnosticMessageSink, discoveryOptions.MethodDisplayOrDefault(), TestMethodDisplayOptions.None, testMethod)
+            //    : new XunitSkippedDataRowTestCase(this.DiagnosticMessageSink, discoveryOptions.MethodDisplayOrDefault(), discoveryOptions.MethodDisplayOptionsOrDefault(), testMethod, "Cocoa only exists on macOS.");
+        }
+    }
+}