Implement TaskHost IBuildEngine callback support (Phases 1-3)

src/Build.UnitTests/BackEnd/TaskHostQueryPackets_Tests.cs

@@ -0,0 +1,99 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using Microsoft.Build.BackEnd;
+using Microsoft.Build.CommandLine;
+using Shouldly;
+using Xunit;
+
+#nullable disable
+
+namespace Microsoft.Build.UnitTests.BackEnd
+{
+    /// <summary>
+    /// Unit Tests for TaskHostQueryRequest and TaskHostQueryResponse packets.
+    /// </summary>
+    public class TaskHostQueryPackets_Tests
+    {
+        /// <summary>
+        /// Test the constructor for TaskHostQueryRequest.
+        /// </summary>
+        [Fact]
+        public void TestQueryRequestConstructor()
+        {
+            TaskHostQueryRequest request = new TaskHostQueryRequest(42, TaskHostQueryType.IsRunningMultipleNodes);
+
+            request.RequestId.ShouldBe(42);
+            request.QueryType.ShouldBe(TaskHostQueryType.IsRunningMultipleNodes);
+            request.Type.ShouldBe(NodePacketType.TaskHostQueryRequest);
+        }
+
+        /// <summary>
+        /// Test serialization and deserialization of TaskHostQueryRequest.
+        /// </summary>
+        [Fact]
+        public void TestQueryRequestTranslation()
+        {
+            TaskHostQueryRequest request = new TaskHostQueryRequest(123, TaskHostQueryType.IsRunningMultipleNodes);
+
+            ((ITranslatable)request).Translate(TranslationHelpers.GetWriteTranslator());
+            INodePacket packet = TaskHostQueryRequest.FactoryForDeserialization(TranslationHelpers.GetReadTranslator());
+
+            packet.ShouldBeOfType<TaskHostQueryRequest>();
+
+            TaskHostQueryRequest deserializedRequest = (TaskHostQueryRequest)packet;
+            deserializedRequest.RequestId.ShouldBe(123);
+            deserializedRequest.QueryType.ShouldBe(TaskHostQueryType.IsRunningMultipleNodes);
+        }
+
+        /// <summary>
+        /// Test the constructor for TaskHostQueryResponse.
+        /// </summary>
+        [Fact]
+        public void TestQueryResponseConstructor()
+        {
+            TaskHostQueryResponse response = new TaskHostQueryResponse(42, TaskHostQueryType.IsRunningMultipleNodes, true);
+
+            response.RequestId.ShouldBe(42);
+            response.QueryType.ShouldBe(TaskHostQueryType.IsRunningMultipleNodes);
+            response.BoolResult.ShouldBeTrue();
+            response.Type.ShouldBe(NodePacketType.TaskHostQueryResponse);
+        }
+
+        /// <summary>
+        /// Test serialization and deserialization of TaskHostQueryResponse.
+        /// </summary>
+        [Fact]
+        public void TestQueryResponseTranslation()
+        {
+            TaskHostQueryResponse response = new TaskHostQueryResponse(456, TaskHostQueryType.IsRunningMultipleNodes, false);
+
+            ((ITranslatable)response).Translate(TranslationHelpers.GetWriteTranslator());
+            INodePacket packet = TaskHostQueryResponse.FactoryForDeserialization(TranslationHelpers.GetReadTranslator());
+
+            packet.ShouldBeOfType<TaskHostQueryResponse>();
+
+            TaskHostQueryResponse deserializedResponse = (TaskHostQueryResponse)packet;
+            deserializedResponse.RequestId.ShouldBe(456);
+            deserializedResponse.QueryType.ShouldBe(TaskHostQueryType.IsRunningMultipleNodes);
+            deserializedResponse.BoolResult.ShouldBeFalse();
+        }
+
+        /// <summary>
+        /// Test round-trip serialization with true result.
+        /// </summary>
+        [Fact]
+        public void TestRoundTripWithTrueResult()
+        {
+            TaskHostQueryResponse response = new TaskHostQueryResponse(789, TaskHostQueryType.IsRunningMultipleNodes, true);
+
+            ((ITranslatable)response).Translate(TranslationHelpers.GetWriteTranslator());
+            TaskHostQueryResponse deserializedResponse = 
+                (TaskHostQueryResponse)TaskHostQueryResponse.FactoryForDeserialization(TranslationHelpers.GetReadTranslator());
+
+            deserializedResponse.RequestId.ShouldBe(789);
+            deserializedResponse.QueryType.ShouldBe(TaskHostQueryType.IsRunningMultipleNodes);
+            deserializedResponse.BoolResult.ShouldBeTrue();
+        }
+    }
+}

src/Build.UnitTests/BackEnd/TaskHostResourcePackets_Tests.cs

@@ -0,0 +1,128 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using Microsoft.Build.BackEnd;
+using Microsoft.Build.CommandLine;
+using Shouldly;
+using Xunit;
+
+#nullable disable
+
+namespace Microsoft.Build.UnitTests.BackEnd
+{
+    /// <summary>
+    /// Unit Tests for TaskHostResourceRequest and TaskHostResourceResponse packets.
+    /// </summary>
+    public class TaskHostResourcePackets_Tests
+    {
+        /// <summary>
+        /// Test the constructor for TaskHostResourceRequest with RequestCores.
+        /// </summary>
+        [Fact]
+        public void TestResourceRequestConstructor_RequestCores()
+        {
+            TaskHostResourceRequest request = new TaskHostResourceRequest(42, TaskHostResourceRequestType.RequestCores, 4);
+
+            request.RequestId.ShouldBe(42);
+            request.RequestType.ShouldBe(TaskHostResourceRequestType.RequestCores);
+            request.NumCores.ShouldBe(4);
+            request.Type.ShouldBe(NodePacketType.TaskHostResourceRequest);
+        }
+
+        /// <summary>
+        /// Test the constructor for TaskHostResourceRequest with ReleaseCores.
+        /// </summary>
+        [Fact]
+        public void TestResourceRequestConstructor_ReleaseCores()
+        {
+            TaskHostResourceRequest request = new TaskHostResourceRequest(123, TaskHostResourceRequestType.ReleaseCores, 2);
+
+            request.RequestId.ShouldBe(123);
+            request.RequestType.ShouldBe(TaskHostResourceRequestType.ReleaseCores);
+            request.NumCores.ShouldBe(2);
+            request.Type.ShouldBe(NodePacketType.TaskHostResourceRequest);
+        }
+
+        /// <summary>
+        /// Test serialization and deserialization of TaskHostResourceRequest.
+        /// </summary>
+        [Fact]
+        public void TestResourceRequestTranslation()
+        {
+            TaskHostResourceRequest request = new TaskHostResourceRequest(456, TaskHostResourceRequestType.RequestCores, 8);
+
+            ((ITranslatable)request).Translate(TranslationHelpers.GetWriteTranslator());
+            INodePacket packet = TaskHostResourceRequest.FactoryForDeserialization(TranslationHelpers.GetReadTranslator());
+
+            packet.ShouldBeOfType<TaskHostResourceRequest>();
+
+            TaskHostResourceRequest deserializedRequest = (TaskHostResourceRequest)packet;
+            deserializedRequest.RequestId.ShouldBe(456);
+            deserializedRequest.RequestType.ShouldBe(TaskHostResourceRequestType.RequestCores);
+            deserializedRequest.NumCores.ShouldBe(8);
+        }
+
+        /// <summary>
+        /// Test the constructor for TaskHostResourceResponse.
+        /// </summary>
+        [Fact]
+        public void TestResourceResponseConstructor()
+        {
+            TaskHostResourceResponse response = new TaskHostResourceResponse(42, TaskHostResourceRequestType.RequestCores, 3);
+
+            response.RequestId.ShouldBe(42);
+            response.RequestType.ShouldBe(TaskHostResourceRequestType.RequestCores);
+            response.NumCoresGranted.ShouldBe(3);
+            response.Type.ShouldBe(NodePacketType.TaskHostResourceResponse);
+        }
+
+        /// <summary>
+        /// Test serialization and deserialization of TaskHostResourceResponse.
+        /// </summary>
+        [Fact]
+        public void TestResourceResponseTranslation()
+        {
+            TaskHostResourceResponse response = new TaskHostResourceResponse(789, TaskHostResourceRequestType.ReleaseCores, 0);
+
+            ((ITranslatable)response).Translate(TranslationHelpers.GetWriteTranslator());
+            INodePacket packet = TaskHostResourceResponse.FactoryForDeserialization(TranslationHelpers.GetReadTranslator());
+
+            packet.ShouldBeOfType<TaskHostResourceResponse>();
+
+            TaskHostResourceResponse deserializedResponse = (TaskHostResourceResponse)packet;
+            deserializedResponse.RequestId.ShouldBe(789);
+            deserializedResponse.RequestType.ShouldBe(TaskHostResourceRequestType.ReleaseCores);
+            deserializedResponse.NumCoresGranted.ShouldBe(0);
+        }
+
+        /// <summary>
+        /// Test round-trip serialization with multiple cores granted.
+        /// </summary>
+        [Fact]
+        public void TestRoundTripWithMultipleCores()
+        {
+            TaskHostResourceResponse response = new TaskHostResourceResponse(999, TaskHostResourceRequestType.RequestCores, 16);
+
+            ((ITranslatable)response).Translate(TranslationHelpers.GetWriteTranslator());
+            TaskHostResourceResponse deserializedResponse = 
+                (TaskHostResourceResponse)TaskHostResourceResponse.FactoryForDeserialization(TranslationHelpers.GetReadTranslator());
+
+            deserializedResponse.RequestId.ShouldBe(999);
+            deserializedResponse.RequestType.ShouldBe(TaskHostResourceRequestType.RequestCores);
+            deserializedResponse.NumCoresGranted.ShouldBe(16);
+        }
+
+        /// <summary>
+        /// Test request with zero cores.
+        /// </summary>
+        [Fact]
+        public void TestResourceRequestWithZeroCores()
+        {
+            TaskHostResourceRequest request = new TaskHostResourceRequest(100, TaskHostResourceRequestType.RequestCores, 0);
+
+            request.RequestId.ShouldBe(100);
+            request.RequestType.ShouldBe(TaskHostResourceRequestType.RequestCores);
+            request.NumCores.ShouldBe(0);
+        }
+    }
+}

src/Build.UnitTests/BackEnd/TaskHostYieldPackets_Tests.cs

@@ -0,0 +1,125 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using Microsoft.Build.BackEnd;
+using Microsoft.Build.CommandLine;
+using Shouldly;
+using Xunit;
+
+#nullable disable
+
+namespace Microsoft.Build.UnitTests.BackEnd
+{
+    /// <summary>
+    /// Unit Tests for TaskHostYieldRequest and TaskHostYieldResponse packets.
+    /// </summary>
+    public class TaskHostYieldPackets_Tests
+    {
+        /// <summary>
+        /// Test the constructor for TaskHostYieldRequest with Yield.
+        /// </summary>
+        [Fact]
+        public void TestYieldRequestConstructor_Yield()
+        {
+            TaskHostYieldRequest request = new TaskHostYieldRequest(42, TaskHostYieldRequestType.Yield);
+
+            request.RequestId.ShouldBe(42);
+            request.RequestType.ShouldBe(TaskHostYieldRequestType.Yield);
+            request.Type.ShouldBe(NodePacketType.TaskHostYieldRequest);
+        }
+
+        /// <summary>
+        /// Test the constructor for TaskHostYieldRequest with Reacquire.
+        /// </summary>
+        [Fact]
+        public void TestYieldRequestConstructor_Reacquire()
+        {
+            TaskHostYieldRequest request = new TaskHostYieldRequest(123, TaskHostYieldRequestType.Reacquire);
+
+            request.RequestId.ShouldBe(123);
+            request.RequestType.ShouldBe(TaskHostYieldRequestType.Reacquire);
+            request.Type.ShouldBe(NodePacketType.TaskHostYieldRequest);
+        }
+
+        /// <summary>
+        /// Test serialization and deserialization of TaskHostYieldRequest.
+        /// </summary>
+        [Fact]
+        public void TestYieldRequestTranslation()
+        {
+            TaskHostYieldRequest request = new TaskHostYieldRequest(456, TaskHostYieldRequestType.Yield);
+
+            ((ITranslatable)request).Translate(TranslationHelpers.GetWriteTranslator());
+            INodePacket packet = TaskHostYieldRequest.FactoryForDeserialization(TranslationHelpers.GetReadTranslator());
+
+            packet.ShouldBeOfType<TaskHostYieldRequest>();
+
+            TaskHostYieldRequest deserializedRequest = (TaskHostYieldRequest)packet;
+            deserializedRequest.RequestId.ShouldBe(456);
+            deserializedRequest.RequestType.ShouldBe(TaskHostYieldRequestType.Yield);
+        }
+
+        /// <summary>
+        /// Test the constructor for TaskHostYieldResponse.
+        /// </summary>
+        [Fact]
+        public void TestYieldResponseConstructor()
+        {
+            TaskHostYieldResponse response = new TaskHostYieldResponse(42, TaskHostYieldRequestType.Yield);
+
+            response.RequestId.ShouldBe(42);
+            response.RequestType.ShouldBe(TaskHostYieldRequestType.Yield);
+            response.Type.ShouldBe(NodePacketType.TaskHostYieldResponse);
+        }
+
+        /// <summary>
+        /// Test serialization and deserialization of TaskHostYieldResponse.
+        /// </summary>
+        [Fact]
+        public void TestYieldResponseTranslation()
+        {
+            TaskHostYieldResponse response = new TaskHostYieldResponse(789, TaskHostYieldRequestType.Reacquire);
+
+            ((ITranslatable)response).Translate(TranslationHelpers.GetWriteTranslator());
+            INodePacket packet = TaskHostYieldResponse.FactoryForDeserialization(TranslationHelpers.GetReadTranslator());
+
+            packet.ShouldBeOfType<TaskHostYieldResponse>();
+
+            TaskHostYieldResponse deserializedResponse = (TaskHostYieldResponse)packet;
+            deserializedResponse.RequestId.ShouldBe(789);
+            deserializedResponse.RequestType.ShouldBe(TaskHostYieldRequestType.Reacquire);
+        }
+
+        /// <summary>
+        /// Test round-trip serialization with Yield type.
+        /// </summary>
+        [Fact]
+        public void TestRoundTripWithYieldType()
+        {
+            TaskHostYieldResponse response = new TaskHostYieldResponse(999, TaskHostYieldRequestType.Yield);
+
+            ((ITranslatable)response).Translate(TranslationHelpers.GetWriteTranslator());
+            TaskHostYieldResponse deserializedResponse = 
+                (TaskHostYieldResponse)TaskHostYieldResponse.FactoryForDeserialization(TranslationHelpers.GetReadTranslator());
+
+            deserializedResponse.RequestId.ShouldBe(999);
+            deserializedResponse.RequestType.ShouldBe(TaskHostYieldRequestType.Yield);
+        }
+
+        /// <summary>
+        /// Test round-trip serialization with Reacquire type.
+        /// </summary>
+        [Fact]
+        public void TestRoundTripWithReacquireType()
+        {
+            TaskHostYieldRequest request = new TaskHostYieldRequest(888, TaskHostYieldRequestType.Reacquire);
+
+            ((ITranslatable)request).Translate(TranslationHelpers.GetWriteTranslator());
+            TaskHostYieldRequest deserializedRequest = 
+                (TaskHostYieldRequest)TaskHostYieldRequest.FactoryForDeserialization(TranslationHelpers.GetReadTranslator());
+
+            deserializedRequest.RequestId.ShouldBe(888);
+            deserializedRequest.RequestType.ShouldBe(TaskHostYieldRequestType.Reacquire);
+        }
+    }
+}