Implement dotnet test help option

src/Cli/dotnet/commands/dotnet-test/CliConstants.cs

@@ -0,0 +1,19 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace Microsoft.DotNet.Cli
+{
+    internal static class CliConstants
+    {
+        public const string HelpOptionKey = "--help";
+        public const string MSBuildOptionKey = "--additional-msbuild-params";
+        public const string NoBuildOptionKey = "--no-build";
+        public const string ServerOptionKey = "--server";
+        public const string DotNetTestPipeOptionKey = "--dotnet-test-pipe";
+
+        public const string ServerOptionValue = "dotnettestcli";
+
+        public const string MSBuildExeName = "MSBuild.dll";
+
+    }
+}

src/Cli/dotnet/commands/dotnet-test/CustomEventArgs.cs

@@ -0,0 +1,17 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using Microsoft.DotNet.Tools.Test;
+
+namespace Microsoft.DotNet.Cli
+{
+    internal class ErrorEventArgs : EventArgs
+    {
+        public string ErrorMessage { get; set; }
+    }
+
+    internal class HelpEventArgs : EventArgs
+    {
+        public CommandLineOptionMessages CommandLineOptionMessages { get; set; }
+    }
+}

src/Cli/dotnet/commands/dotnet-test/IPC/IClient.cs

@@ -0,0 +1,20 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace Microsoft.DotNet.Tools.Test;
+
+internal interface IClient : IDisposable
+#if NETCOREAPP
+#pragma warning disable SA1001 // Commas should be spaced correctly
+    , IAsyncDisposable
+#pragma warning restore SA1001 // Commas should be spaced correctly
+#endif
+{
+    bool IsConnected { get; }
+
+    Task ConnectAsync(CancellationToken cancellationToken);
+
+    Task<TResponse> RequestReplyAsync<TRequest, TResponse>(TRequest request, CancellationToken cancellationToken)
+        where TRequest : IRequest
+        where TResponse : IResponse;
+}

src/Cli/dotnet/commands/dotnet-test/IPC/INamedPipeIC.cs

@@ -0,0 +1,9 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace Microsoft.DotNet.Tools.Test;
+
+internal interface INamedPipeBase
+{
+    void RegisterSerializer<T>(INamedPipeSerializer namedPipeSerializer);
+}

src/Cli/dotnet/commands/dotnet-test/IPC/INamedPipeSerializer.cs

@@ -0,0 +1,13 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace Microsoft.DotNet.Tools.Test;
+
+internal interface INamedPipeSerializer
+{
+    int Id { get; }
+
+    void Serialize(object objectToSerialize, Stream stream);
+
+    object Deserialize(Stream stream);
+}

src/Cli/dotnet/commands/dotnet-test/IPC/IRequest.cs

@@ -0,0 +1,8 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace Microsoft.DotNet.Tools.Test;
+
+internal interface IRequest
+{
+}

src/Cli/dotnet/commands/dotnet-test/IPC/IResponse.cs

@@ -0,0 +1,8 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace Microsoft.DotNet.Tools.Test;
+
+internal interface IResponse
+{
+}

src/Cli/dotnet/commands/dotnet-test/IPC/IServer.cs

@@ -0,0 +1,16 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace Microsoft.DotNet.Tools.Test;
+
+internal interface IServer : INamedPipeBase, IDisposable
+#if NETCOREAPP
+#pragma warning disable SA1001 // Commas should be spaced correctly
+    , IAsyncDisposable
+#pragma warning restore SA1001 // Commas should be spaced correctly
+#endif
+{
+    PipeNameDescription PipeName { get; }
+
+    Task WaitConnectionAsync(CancellationToken cancellationToken);
+}

src/Cli/dotnet/commands/dotnet-test/IPC/Models/CommandLineOptionMessages.cs

@@ -0,0 +1,9 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace Microsoft.DotNet.Tools.Test
+{
+    internal sealed record class CommandLineOptionMessage(string Name, string Description, bool IsHidden, bool IsBuiltIn) : IRequest;
+
+    internal sealed record class CommandLineOptionMessages(string ModuleName, CommandLineOptionMessage[] CommandLineOptionMessageList) : IRequest;
+}

src/Cli/dotnet/commands/dotnet-test/IPC/Models/Module.cs

@@ -0,0 +1,6 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace Microsoft.DotNet.Tools.Test;
+
+internal sealed record class Module(string Name) : IRequest;

src/Cli/dotnet/commands/dotnet-test/IPC/Models/VoidResponse.cs

@@ -0,0 +1,9 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace Microsoft.DotNet.Tools.Test;
+
+internal sealed class VoidResponse : IResponse
+{
+    public static readonly VoidResponse CachedInstance = new();
+}

src/Cli/dotnet/commands/dotnet-test/IPC/NamedPipeBase.cs

@@ -0,0 +1,38 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+#pragma warning disable IDE0240 // Remove redundant nullable directive
+#nullable disable
+#pragma warning restore IDE0240 // Remove redundant nullable directive
+
+using System.Globalization;
+
+namespace Microsoft.DotNet.Tools.Test;
+
+internal abstract class NamedPipeBase
+{
+    private readonly Dictionary<Type, object> _typeSerializer = [];
+    private readonly Dictionary<int, object> _idSerializer = [];
+
+    public void RegisterSerializer<T>(INamedPipeSerializer namedPipeSerializer)
+    {
+        _typeSerializer.Add(typeof(T), namedPipeSerializer);
+        _idSerializer.Add(namedPipeSerializer.Id, namedPipeSerializer);
+    }
+
+    protected INamedPipeSerializer GetSerializer(int id)
+        => _idSerializer.TryGetValue(id, out object serializer)
+            ? (INamedPipeSerializer)serializer
+            : throw new InvalidOperationException(string.Format(
+                CultureInfo.InvariantCulture,
+                "No serializer registered with id '{0}'",
+                id));
+
+    protected INamedPipeSerializer GetSerializer(Type type)
+        => _typeSerializer.TryGetValue(type, out object serializer)
+            ? (INamedPipeSerializer)serializer
+            : throw new InvalidOperationException(string.Format(
+                CultureInfo.InvariantCulture,
+                "No serializer registered with type '{0}'",
+                type));
+}

src/Cli/dotnet/commands/dotnet-test/IPC/NamedPipeClient.cs

@@ -0,0 +1,210 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Buffers;
+using System.IO.Pipes;
+
+namespace Microsoft.DotNet.Tools.Test;
+
+internal sealed class NamedPipeClient : NamedPipeBase, IClient
+{
+    private readonly NamedPipeClientStream _namedPipeClientStream;
+    private readonly SemaphoreSlim _lock = new(1, 1);
+
+    private readonly MemoryStream _serializationBuffer = new();
+    private readonly MemoryStream _messageBuffer = new();
+    private readonly byte[] _readBuffer = new byte[250000];
+
+    private bool _disposed;
+
+    public NamedPipeClient(string name)
+    {
+        _namedPipeClientStream = new(".", name, PipeDirection.InOut);
+        PipeName = name;
+    }
+
+    public string PipeName { get; }
+
+    public bool IsConnected => _namedPipeClientStream.IsConnected;
+
+    public async Task ConnectAsync(CancellationToken cancellationToken)
+        => await _namedPipeClientStream.ConnectAsync(cancellationToken);
+
+    public async Task<TResponse> RequestReplyAsync<TRequest, TResponse>(TRequest request, CancellationToken cancellationToken)
+       where TRequest : IRequest
+       where TResponse : IResponse
+    {
+        await _lock.WaitAsync(cancellationToken);
+        try
+        {
+            INamedPipeSerializer requestNamedPipeSerializer = GetSerializer(typeof(TRequest));
+
+            // Ask to serialize the body
+            _serializationBuffer.Position = 0;
+            requestNamedPipeSerializer.Serialize(request, _serializationBuffer);
+
+            // Write the message size
+            _messageBuffer.Position = 0;
+
+            // The length of the message is the size of the message plus one byte to store the serializer id
+            // Space for the message
+            int sizeOfTheWholeMessage = (int)_serializationBuffer.Position;
+
+            // Space for the serializer id
+            sizeOfTheWholeMessage += sizeof(int);
+
+            // Write the message size
+#if NETCOREAPP
+            byte[] bytes = ArrayPool<byte>.Shared.Rent(sizeof(int));
+            try
+            {
+                BitConverter.TryWriteBytes(bytes, sizeOfTheWholeMessage);
+                await _messageBuffer.WriteAsync(bytes.AsMemory(0, sizeof(int)), cancellationToken);
+            }
+            finally
+            {
+                ArrayPool<byte>.Shared.Return(bytes);
+            }
+#else
+            await _messageBuffer.WriteAsync(BitConverter.GetBytes(sizeOfTheWholeMessage), 0, sizeof(int), cancellationToken);
+#endif
+
+            // Write the serializer id
+#if NETCOREAPP
+            bytes = ArrayPool<byte>.Shared.Rent(sizeof(int));
+            try
+            {
+                BitConverter.TryWriteBytes(bytes, requestNamedPipeSerializer.Id);
+                await _messageBuffer.WriteAsync(bytes.AsMemory(0, sizeof(int)), cancellationToken);
+            }
+            finally
+            {
+                ArrayPool<byte>.Shared.Return(bytes);
+            }
+#else
+            await _messageBuffer.WriteAsync(BitConverter.GetBytes(requestNamedPipeSerializer.Id), 0, sizeof(int), cancellationToken);
+#endif
+
+            try
+            {
+                // Write the message
+#if NETCOREAPP
+                await _messageBuffer.WriteAsync(_serializationBuffer.GetBuffer().AsMemory(0, (int)_serializationBuffer.Position), cancellationToken);
+#else
+                await _messageBuffer.WriteAsync(_serializationBuffer.GetBuffer(), 0, (int)_serializationBuffer.Position, cancellationToken);
+#endif
+            }
+            finally
+            {
+                // Reset the serialization buffer
+                _serializationBuffer.Position = 0;
+            }
+
+            // Send the message
+            try
+            {
+#if NETCOREAPP
+                await _namedPipeClientStream.WriteAsync(_messageBuffer.GetBuffer().AsMemory(0, (int)_messageBuffer.Position), cancellationToken);
+#else
+                await _namedPipeClientStream.WriteAsync(_messageBuffer.GetBuffer(), 0, (int)_messageBuffer.Position, cancellationToken);
+#endif
+                await _namedPipeClientStream.FlushAsync(cancellationToken);
+                if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
+                {
+                    _namedPipeClientStream.WaitForPipeDrain();
+                }
+            }
+            finally
+            {
+                // Reset the buffers
+                _messageBuffer.Position = 0;
+                _serializationBuffer.Position = 0;
+            }
+
+            // Read the response
+            int currentMessageSize = 0;
+            int missingBytesToReadOfWholeMessage = 0;
+            while (true)
+            {
+                int missingBytesToReadOfCurrentChunk = 0;
+                int currentReadIndex = 0;
+#if NETCOREAPP
+                int currentReadBytes = await _namedPipeClientStream.ReadAsync(_readBuffer.AsMemory(currentReadIndex, _readBuffer.Length), cancellationToken);
+#else
+                int currentReadBytes = await _namedPipeClientStream.ReadAsync(_readBuffer, currentReadIndex, _readBuffer.Length, cancellationToken);
+#endif
+                // Reset the current chunk size
+                missingBytesToReadOfCurrentChunk = currentReadBytes;
+
+                // If currentRequestSize is 0, we need to read the message size
+                if (currentMessageSize == 0)
+                {
+                    // We need to read the message size, first 4 bytes
+                    currentMessageSize = BitConverter.ToInt32(_readBuffer, 0);
+                    missingBytesToReadOfCurrentChunk = currentReadBytes - sizeof(int);
+                    missingBytesToReadOfWholeMessage = currentMessageSize;
+                    currentReadIndex = sizeof(int);
+                }
+
+                if (missingBytesToReadOfCurrentChunk > 0)
+                {
+                    // We need to read the rest of the message
+#if NETCOREAPP
+                    await _messageBuffer.WriteAsync(_readBuffer.AsMemory(currentReadIndex, missingBytesToReadOfCurrentChunk), cancellationToken);
+#else
+                    await _messageBuffer.WriteAsync(_readBuffer, currentReadIndex, missingBytesToReadOfCurrentChunk, cancellationToken);
+#endif
+                    missingBytesToReadOfWholeMessage -= missingBytesToReadOfCurrentChunk;
+                }
+
+                // If we have read all the message, we can deserialize it
+                if (missingBytesToReadOfWholeMessage == 0)
+                {
+                    // Deserialize the message
+                    _messageBuffer.Position = 0;
+
+                    // Get the serializer id
+                    int serializerId = BitConverter.ToInt32(_messageBuffer.GetBuffer(), 0);
+
+                    // Get the serializer
+                    _messageBuffer.Position += sizeof(int); // Skip the serializer id
+                    INamedPipeSerializer responseNamedPipeSerializer = GetSerializer(serializerId);
+
+                    // Deserialize the message
+                    try
+                    {
+                        return (TResponse)responseNamedPipeSerializer.Deserialize(_messageBuffer);
+                    }
+                    finally
+                    {
+                        // Reset the message buffer
+                        _messageBuffer.Position = 0;
+                    }
+                }
+            }
+        }
+        finally
+        {
+            _lock.Release();
+        }
+    }
+    public void Dispose()
+    {
+        if (!_disposed)
+        {
+            _namedPipeClientStream.Dispose();
+            _disposed = true;
+        }
+    }
+
+#if NETCOREAPP
+    public async ValueTask DisposeAsync()
+    {
+        if (!_disposed)
+        {
+            await _namedPipeClientStream.DisposeAsync();
+            _disposed = true;
+        }
+    }
+#endif
+}