Support IRevitTask functions as parameters

CHANGELOG.md

@@ -4,6 +4,15 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/)
 and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.html).
 
+## [1.6.1] / 2024-11-02
+### Features
+- Support `IRevitTask` functions as parameters.
+### Application
+- Add 8 functions parameters in the tests to enable `IRevitTask` functions. (Fix: #61)
+### Tests
+- Update `TestsRevitTask` with `RevitTaskBase` using base parameter.
+- Add `TestsFuncTaskParameters` to test each parameter function.
+
 ## [1.6.0] / 2024-09-25 - 2024-10-06
 ### Features
 - Support `TestAdapter` custom executer.
@@ -513,6 +522,7 @@ and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.
 - [x] TestsFail
 
 [vNext]: ../../compare/1.0.0...HEAD
+[1.6.1]: ../../compare/1.6.0...1.6.1
 [1.6.0]: ../../compare/1.5.0...1.6.0
 [1.5.0]: ../../compare/1.4.1...1.5.0
 [1.4.1]: ../../compare/1.4.0...1.4.1

Directory.Build.props

@@ -1,5 +1,5 @@
 <Project>
 	<PropertyGroup>
-		<Version>1.6.0</Version>
+		<Version>1.6.1-alpha</Version>
 	</PropertyGroup>
 </Project>

ricaun.RevitTest.Application/Revit/App.cs

@@ -29,6 +29,17 @@ public class App : IExternalApplication
         private const int TestThreadSleepMin = 50;
         private const int TestAfterFinishSleepTime = 100;
 
+        #region RevitTask Parameter
+        static Func<Action, Task> revitTaskNone0 => RevitTask.Run;
+        static Func<Action<UIApplication>, Task> revitTaskNone1 => RevitTask.Run;
+        static Func<Func<object>, Task<object>> revitTaskNone2 => RevitTask.Run;
+        static Func<Func<UIApplication, object>, Task<object>> revitTaskNone3 => RevitTask.Run;
+        static Func<Action, System.Threading.CancellationToken, Task> revitTaskToken0 => RevitTask.Run;
+        static Func<Action<UIApplication>, System.Threading.CancellationToken, Task> revitTaskToken1 => RevitTask.Run;
+        static Func<Func<object>, System.Threading.CancellationToken, Task<object>> revitTaskToken2 => RevitTask.Run;
+        static Func<Func<UIApplication, object>, System.Threading.CancellationToken, Task<object>> revitTaskToken3 => RevitTask.Run;
+        #endregion
+
         public Result OnStartup(UIControlledApplication application)
         {
             Log.Initilize(application);
@@ -55,6 +66,10 @@ public Result OnStartup(UIControlledApplication application)
                 application.GetUIApplication(),
                 application.ControlledApplication.GetApplication());
 
+            // Add RevitTask Parameters
+            RevitParameters.AddParameter(revitTaskNone0, revitTaskNone1, revitTaskNone2, revitTaskNone3);
+            RevitParameters.AddParameter(revitTaskToken0, revitTaskToken1, revitTaskToken2, revitTaskToken3);
+
             PipeTestServer_Initialize();
 
             CreateRibbonPanel(application);

ricaun.RevitTest.Tests/TestsRevitTask.cs

@@ -2,52 +2,97 @@
 using NUnit.Framework;
 using ricaun.Revit.UI.Tasks;
 using System;
+using System.Threading;
 using System.Threading.Tasks;
 
-[assembly: System.Reflection.AssemblyDescription("{\"TestAsync\":\"TestAsync\",\"TimeOut\":60.0}")]
+[assembly: System.Reflection.AssemblyDescription("{\"TestAsync\":\"RevitTask\",\"TimeOut\":60.0}")]
 
 namespace ricaun.RevitTest.Tests
 {
-    public class TestsRevitTask
+    public class RevitTaskBase
     {
-        static IRevitTask RevitTask;
+        protected IRevitTask RevitTask { get; private set; }
+
         [OneTimeSetUp]
-        public void Initialize(UIApplication uiapp)
+        public void Initialize(Func<Func<UIApplication, object>, CancellationToken, Task<object>> revitTask)
+        {
+            RevitTask = new RevitTaskFuncService(revitTask);
+        }
+
+        public class RevitTaskFuncService : IRevitTask
         {
-            if (RevitTask is null)
+            private Func<Func<UIApplication, object>, CancellationToken, Task<object>> RevitTask;
+            public RevitTaskFuncService(Func<Func<UIApplication, object>, CancellationToken, Task<object>> revitTask)
             {
-                var revitTask = new RevitTaskService(uiapp);
-                revitTask.Initialize();
                 RevitTask = revitTask;
             }
+            public async Task<TResult> Run<TResult>(Func<UIApplication, TResult> function, CancellationToken cancellationToken)
+            {
+                var result = await RevitTask.Invoke((uiapp) => { return function(uiapp); }, cancellationToken);
+
+                if (result is TResult t)
+                    return t;
+
+                return default;
+            }
         }
+    }
+
+    public class TestsRevitTask : RevitTaskBase
+    {
         /// <summary>
-        /// This method is required to initialize the RevitTask
+        /// Check is Revit API is in context using the ActiveAddInId property.
         /// </summary>
+        /// <remarks>
+        /// The ActiveAddInId property is null when the Revit API is not in context.
+        /// </remarks>
+        private bool InContext(UIApplication uiapp)
+        {
+            return !(uiapp.ActiveAddInId is null);
+        }
+
+        [Test] 
+        public async Task RunContext()
+        {
+            var application = await RevitTask.Run((uiapp) => { return uiapp; });
+            Assert.IsFalse(InContext(application));
+
+            var inContext = await RevitTask.Run(() => { return InContext(application); });
+            Assert.IsTrue(inContext);
+
+            var inContext2 = await RevitTask.Run((uiapp) => { return InContext(uiapp); });
+            Assert.IsTrue(inContext2);
+        }
+
         [Test]
-        public void Test_Initialize()
+        public async Task RunAddInName(UIControlledApplication application)
         {
-            Assert.IsNotNull(RevitTask);
+            Console.WriteLine($"AddInName: {application.ActiveAddInId?.GetAddInName()}");
+
+            await RevitTask.Run(() => { Console.WriteLine($"AddInName: {application.ActiveAddInId?.GetAddInName()}"); });
+
+            await RevitTask.Run((uiapp) => { Console.WriteLine($"AddInName: {uiapp.ActiveAddInId?.GetAddInName()}"); });
+
+            var addInName1 = await RevitTask.Run(() => { return application.ActiveAddInId?.GetAddInName(); });
+            Console.WriteLine($"AddInName: {addInName1}");
+
+            var addInName2 = await RevitTask.Run((uiapp) => { return uiapp.ActiveAddInId?.GetAddInName(); });
+            Console.WriteLine($"AddInName: {addInName2}");
         }
 
-#if !(NET)
         [Test]
-        public async Task TestAsync_MacroManager()
+        public async Task TestPostableCommand_NewProject()
         {
             await RevitTask.Run((uiapp) =>
             {
                 uiapp.DialogBoxShowing += DialogBoxShowingForceClose;
-                uiapp.PostCommand(RevitCommandId.LookupPostableCommandId(PostableCommand.MacroManager));
+                uiapp.PostCommand(RevitCommandId.LookupPostableCommandId(PostableCommand.NewProject));
             });
 
             await RevitTask.Run((uiapp) =>
             {
                 uiapp.DialogBoxShowing -= DialogBoxShowingForceClose;
             });
-
-            var inContext = await RevitTask.Run((uiapp) => { return InContext(uiapp); });
-            Assert.IsTrue(inContext);
-
         }
         private void DialogBoxShowingForceClose(object sender, Autodesk.Revit.UI.Events.DialogBoxShowingEventArgs e)
         {
@@ -56,7 +101,7 @@ private void DialogBoxShowingForceClose(object sender, Autodesk.Revit.UI.Events.
             Console.WriteLine($"DialogBoxShowing {e.DialogId}");
             e.OverrideResult((int)TaskDialogResult.Close);
         }
-#endif
+
         [Test]
         public async Task TestAsync_Idling()
         {
@@ -127,19 +172,62 @@ public async Task TestAsync(UIApplication uiapp)
 
         }
 
-        private bool InContext(UIApplication uiapp)
+    }
+
+    public class TestsFuncTaskParameters
+    {
+        [Test]
+        public async Task RevitTaskNone0(Func<Action, Task> revitTask)
         {
-            void Uiapp_Idling(object sender, Autodesk.Revit.UI.Events.IdlingEventArgs e)
-            {
-            }
-            try
-            {
-                uiapp.Idling += Uiapp_Idling;
-                uiapp.Idling -= Uiapp_Idling;
-                return true;
-            }
-            catch { }
-            return false;
+            var result = false;
+            await revitTask.Invoke(() => { result = true; });
+            Assert.IsTrue(result);
+        }
+        [Test]
+        public async Task RevitTaskNone1(Func<Action<UIApplication>, Task> revitTask)
+        {
+            var result = false;
+            await revitTask.Invoke((uiapp) => { result = true; });
+            Assert.IsTrue(result);
+        }
+        [Test]
+        public async Task RevitTaskNone2(Func<Func<object>, Task<object>> revitTask)
+        {
+            var result = (bool)await revitTask.Invoke(() => { return true; });
+            Assert.IsTrue(result);
+        }
+        [Test]
+        public async Task RevitTaskNone3(Func<Func<UIApplication, object>, Task<object>> revitTask)
+        {
+            var result = (bool)await revitTask.Invoke((uiapp) => { return true; });
+            Assert.IsTrue(result);
+        }
+
+        [Test]
+        public async Task RevitTaskToken0(Func<Action, CancellationToken, Task> revitTask)
+        {
+            var result = false;
+            await revitTask.Invoke(() => { result = true; }, CancellationToken.None);
+            Assert.IsTrue(result);
+        }
+        [Test]
+        public async Task RevitTaskToken1(Func<Action<UIApplication>, CancellationToken, Task> revitTask)
+        {
+            var result = false;
+            await revitTask.Invoke((uiapp) => { result = true; }, CancellationToken.None);
+            Assert.IsTrue(result);
+        }
+        [Test]
+        public async Task RevitTaskToken2(Func<Func<object>, CancellationToken, Task<object>> revitTask)
+        {
+            var result = (bool) await revitTask.Invoke(() => { return true; }, CancellationToken.None);
+            Assert.IsTrue(result);
+        }
+        [Test]
+        public async Task RevitTaskToken3(Func<Func<UIApplication, object>, CancellationToken, Task<object>> revitTask)
+        {
+            var result = (bool) await revitTask.Invoke((uiapp) => { return true; }, CancellationToken.None);
+            Assert.IsTrue(result);
         }
     }
 }