Update version

These are only used for debug information and I'm okayish with them failing at runtime.

.github/FUNDING.yml

@@ -1,4 +1,3 @@
 github: Tyrrrz
 patreon: Tyrrrz
-open_collective: Tyrrrz
+custom: ['buymeacoffee.com/Tyrrrz', 'tyrrrz.me/donate']
-custom: ['buymeacoffee.com/Tyrrrz']

.github/workflows/CD.yml

@@ -0,0 +1,25 @@
+name: CD
+
+on:
+  push:
+    tags:
+    - '*'
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+
+    steps:
+    - name: Checkout
+      uses: actions/checkout@v2
+
+    - name: Install .NET Core
+      uses: actions/setup-dotnet@v1.4.0
+      with:
+        dotnet-version: 3.1.100
+
+    - name: Pack
+      run: dotnet pack CliFx --configuration Release
+
+    - name: Deploy
+      run: dotnet nuget push CliFx/bin/Release/*.nupkg -s nuget.org -k ${{ secrets.NUGET_TOKEN }}

.github/workflows/CI.yml

@@ -0,0 +1,35 @@
+name: CI
+
+on: [push, pull_request]
+
+jobs:
+  build:
+    runs-on: ${{ matrix.os }}
+
+    strategy:
+      matrix:
+        os: [ubuntu-latest, windows-latest, macos-latest]
+
+    steps:
+    - name: Checkout
+      uses: actions/checkout@v2
+
+    - name: Install .NET Core
+      uses: actions/setup-dotnet@v1.4.0
+      with:
+        dotnet-version: 3.1.100
+
+    - name: Build & test
+      run: dotnet test --configuration Release --logger GitHubActions
+
+    - name: Upload coverage
+      uses: codecov/codecov-action@v1.0.5
+      with:
+        token: ${{ secrets.CODECOV_TOKEN }}
+        file: CliFx.Tests/bin/Release/Coverage.xml
+
+    - name: Upload coverage (analyzers)
+      uses: codecov/codecov-action@v1.0.5
+      with:
+        token: ${{ secrets.CODECOV_TOKEN }}
+        file: CliFx.Analyzers.Tests/bin/Release/Coverage.xml

.gitignore

@@ -143,6 +143,7 @@ _TeamCity*
 _NCrunch_*
 .*crunch*.local.xml
 nCrunchTemp_*
+.ncrunchsolution
 
 # MightyMoose
 *.mm.*

Changelog.md

@@ -0,0 +1,39 @@
+### v1.4 (20-Aug-2020)
+
+- Added `VirtualConsole.CreateBuffered()` method to simplify test setup when using in-memory backing stores for output and error streams. Please refer to the readme for updated recommendations on how to test applications built with CliFx.
+- Added generic `CliApplicationBuilder.AddCommand<TCommand>()`. This overload simplifies adding commands one-by-one as it also checks that the type implements `ICommand`.
+
+### v1.3.2 (31-Jul-2020)
+
+- Fixed an issue where a command was incorrectly allowed to execute when the user did not specify any value for a non-scalar parameter. Since they are always required, a parameter needs to be bound to (at least) one value. (Thanks [@Daniel Hix](https://github.com/ADustyOldMuffin))
+- Fixed an issue where `CliApplication.RunAsync(...)` threw `ArgumentException` if there were two environment variables, whose names differed only in case. Environment variable names are now treated case-sensitively. (Thanks [@Ron Myers](https://github.com/ron-myers))
+
+### v1.3.1 (19-Jul-2020)
+
+- Running the application with the debug directive (`myapp [debug]`) will now also try to launch a debugger instance. In most cases it will save time as you won't need to attach the debugger manually. (Thanks [@Volodymyr Shkolka](https://github.com/BlackGad))
+- Fixed an issue where unhandled generic exceptions (i.e. not `CommandException`) sometimes caused the application to incorrectly return successful exit code due to an overflow issue on Unix systems. Starting from this version, all unhandled generic exceptions will produce `1` as the exit code when thrown. Instances of `CommandException` can still be configured to return any specified exit code, but it's recommended to constrain the values between `1` and `255` to avoid overflow issues. (Thanks [@Ihor Nechyporuk](https://github.com/inech))
+
+### v1.3 (23-May-2020)
+
+- Changed analyzers to report errors instead of warnings. If you find that some analyzer works incorrectly, please report it on GitHub. You can also configure inspection severity overrides in your project if you need to.
+- Improved help text by showing default values for non-required options. This only works on types that have a custom override for `ToString()` method. Additionally, if the type implements `IFormattable`, the overload with a format provider will be used instead. (Thanks [@Domn Werner](https://github.com/domn1995))
+- Changed default version text to only show 3 version components instead of 4, if the last component (revision) is not specified or is zero. This makes the default version text compliant with semantic versioning.
+- Fixed an issue where it was possible to define a command with an option that has the same name or short name as built-in help or version options. Previously it would lead to the user-defined option being ignored in favor of the built-in option. Now this will throw an exception instead.
+- Changed the underlying representation of `StreamReader`/`StreamWriter` objects used in `SystemConsole` and `VirtualConsole` to be thread-safe.
+
+### v1.2 (11-May-2020)
+
+- Added built-in Roslyn analyzers that help catch incorrect usage of the library. Currently, all analyzers report issues as warnings so as to not prevent the project from building. In the future that may change.
+- Added an optional parameter to `new CommandException(...)` called `showHelp` which can be used to instruct CliFx to show help for the current command after printing the error. (Thanks [@Domn Werner](https://github.com/domn1995))
+- Improved help text shown for enum options and parameters by providing the list of valid values that the enum can accept. (Thanks [@Domn Werner](https://github.com/domn1995))
+- Fixed an issue where it was possible to set an option without providing a value, while the option was marked as required.
+- Fixed an issue where it was possible to configure an option with an empty name or a name consisting of a single character. If you want to use a single character as a name, you should set the option's short name instead.
+- Added `CursorLeft` and `CursorTop` properties to `IConsole` and its implementations. In `VirtualConsole`, these are just auto-properties.
+- Improved exception messages.
+- Improved exceptions related to user input by also showing help text after the error message. (Thanks [@Domn Werner](https://github.com/domn1995))
+
+### v1.1 (16-Mar-2020)
+
+- Changed `IConsole` interface (and as a result, `SystemConsole` and `VirtualConsole`) to support writing binary data. Instead of `TextReader`/`TextWriter` instances, the streams are now exposed as `StreamReader`/`StreamWriter` which provide the `BaseStream` property that allows raw access. Existing usages inside commands should remain the same because `StreamReader`/`StreamWriter` are compatible with their base classes `TextReader`/`TextWriter`, but if you were using `VirtualConsole` in tests, you may have to update it to the new API. Refer to the readme for more info.
+- Changed argument binding behavior so that an error is produced if the user provides an argument that doesn't match with any parameter or option. This is done in order to improve user experience, as otherwise the user may make a typo without knowing that their input wasn't taken into account.
+- Changed argument binding behavior so that options can be set to multiple argument values while specifying them with mixed naming. For example, `--option value1 -o value2 --option value3` would result in the option being set to corresponding three values, assuming `--option` and `-o` match with the same option.

CliFx.Analyzers.Tests/AnalyzerTestCase.cs

@@ -0,0 +1,43 @@
+using System.Collections.Generic;
+using System.Linq;
+using Microsoft.CodeAnalysis;
+
+namespace CliFx.Analyzers.Tests
+{
+    public class AnalyzerTestCase
+    {
+        public string Name { get; }
+
+        public IReadOnlyList<DiagnosticDescriptor> TestedDiagnostics { get; }
+
+        public IReadOnlyList<string> SourceCodes { get; }
+
+        public AnalyzerTestCase(
+            string name,
+            IReadOnlyList<DiagnosticDescriptor> testedDiagnostics,
+            IReadOnlyList<string> sourceCodes)
+        {
+            Name = name;
+            TestedDiagnostics = testedDiagnostics;
+            SourceCodes = sourceCodes;
+        }
+
+        public AnalyzerTestCase(
+            string name,
+            IReadOnlyList<DiagnosticDescriptor> testedDiagnostics,
+            string sourceCode)
+            : this(name, testedDiagnostics, new[] {sourceCode})
+        {
+        }
+
+        public AnalyzerTestCase(
+            string name,
+            DiagnosticDescriptor testedDiagnostic,
+            string sourceCode)
+            : this(name, new[] {testedDiagnostic}, sourceCode)
+        {
+        }
+
+        public override string ToString() => $"{Name} [{string.Join(", ", TestedDiagnostics.Select(d => d.Id))}]";
+    }
+}

CliFx.Analyzers.Tests/CliFx.Analyzers.Tests.csproj

@@ -0,0 +1,29 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <Import Project="../CliFx.props" />
+
+  <PropertyGroup>
+    <TargetFramework>netcoreapp3.1</TargetFramework>
+    <IsPackable>false</IsPackable>
+    <IsTestProject>true</IsTestProject>
+    <CollectCoverage>true</CollectCoverage>
+    <CoverletOutputFormat>opencover</CoverletOutputFormat>
+    <CoverletOutput>bin/$(Configuration)/Coverage.xml</CoverletOutput>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Gu.Roslyn.Asserts" Version="3.3.0" />
+    <PackageReference Include="GitHubActionsTestLogger" Version="1.0.0" />
+    <PackageReference Include="FluentAssertions" Version="5.10.2" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.2.0" />
+    <PackageReference Include="xunit" Version="2.4.0" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="2.4.0" />
+    <PackageReference Include="Microsoft.CodeAnalysis.CSharp.Workspaces" Version="3.4.0" />
+    <PackageReference Include="coverlet.msbuild" Version="2.8.0" PrivateAssets="all" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\CliFx.Analyzers\CliFx.Analyzers.csproj" />
+    <ProjectReference Include="..\CliFx\CliFx.csproj" />
+  </ItemGroup>
+
+</Project>

CliFx.Analyzers.Tests/CommandSchemaAnalyzerTests.cs

@@ -0,0 +1,489 @@
+using System.Collections.Generic;
+using CliFx.Analyzers.Tests.Internal;
+using Microsoft.CodeAnalysis.Diagnostics;
+using Xunit;
+
+namespace CliFx.Analyzers.Tests
+{
+    public class CommandSchemaAnalyzerTests
+    {
+        private static DiagnosticAnalyzer Analyzer { get; } = new CommandSchemaAnalyzer();
+
+        public static IEnumerable<object[]> GetValidCases()
+        {
+            yield return new object[]
+            {
+                new AnalyzerTestCase(
+                    "Non-command type",
+                    Analyzer.SupportedDiagnostics,
+
+                    // language=cs
+                    @"
+public class Foo
+{
+    public int Bar { get; set; } = 5;
+}"
+                )
+            };
+
+            yield return new object[]
+            {
+                new AnalyzerTestCase(
+                    "Command implements interface and has attribute",
+                    Analyzer.SupportedDiagnostics,
+
+                    // language=cs
+                    @"
+[Command]
+public class MyCommand : ICommand
+{
+    public ValueTask ExecuteAsync(IConsole console) => default;
+}"
+                )
+            };
+
+            yield return new object[]
+            {
+                new AnalyzerTestCase(
+                    "Command doesn't have an attribute but is an abstract type",
+                    Analyzer.SupportedDiagnostics,
+
+                    // language=cs
+                    @"
+public abstract class MyCommand : ICommand
+{
+    public ValueTask ExecuteAsync(IConsole console) => default;
+}"
+                )
+            };
+
+            yield return new object[]
+            {
+                new AnalyzerTestCase(
+                    "Parameters with unique order",
+                    Analyzer.SupportedDiagnostics,
+
+                    // language=cs
+                    @"
+[Command]
+public class MyCommand : ICommand
+{
+    [CommandParameter(13)]
+    public string ParamA { get; set; }
+    
+    [CommandParameter(15)]
+    public string ParamB { get; set; }
+
+    public ValueTask ExecuteAsync(IConsole console) => default;
+}"
+                )
+            };
+
+            yield return new object[]
+            {
+                new AnalyzerTestCase(
+                    "Parameters with unique names",
+                    Analyzer.SupportedDiagnostics,
+
+                    // language=cs
+                    @"
+[Command]
+public class MyCommand : ICommand
+{
+    [CommandParameter(13, Name = ""foo"")]
+    public string ParamA { get; set; }
+    
+    [CommandParameter(15, Name = ""bar"")]
+    public string ParamB { get; set; }
+
+    public ValueTask ExecuteAsync(IConsole console) => default;
+}"
+                )
+            };
+
+            yield return new object[]
+            {
+                new AnalyzerTestCase(
+                    "Single non-scalar parameter",
+                    Analyzer.SupportedDiagnostics,
+
+                    // language=cs
+                    @"
+[Command]
+public class MyCommand : ICommand
+{
+    [CommandParameter(1)]
+    public string ParamA { get; set; }
+    
+    [CommandParameter(2)]
+    public HashSet<string> ParamB { get; set; }
+
+    public ValueTask ExecuteAsync(IConsole console) => default;
+}"
+                )
+            };
+
+            yield return new object[]
+            {
+                new AnalyzerTestCase(
+                    "Non-scalar parameter is last in order",
+                    Analyzer.SupportedDiagnostics,
+
+                    // language=cs
+                    @"
+[Command]
+public class MyCommand : ICommand
+{
+    [CommandParameter(1)]
+    public string ParamA { get; set; }
+    
+    [CommandParameter(2)]
+    public IReadOnlyList<string> ParamB { get; set; }
+
+    public ValueTask ExecuteAsync(IConsole console) => default;
+}"
+                )
+            };
+
+            yield return new object[]
+            {
+                new AnalyzerTestCase(
+                    "Option with a proper name",
+                    Analyzer.SupportedDiagnostics,
+
+                    // language=cs
+                    @"
+[Command]
+public class MyCommand : ICommand
+{
+    [CommandOption(""foo"")]
+    public string Param { get; set; }
+
+    public ValueTask ExecuteAsync(IConsole console) => default;
+}"
+                )
+            };
+
+            yield return new object[]
+            {
+                new AnalyzerTestCase(
+                    "Option with a proper name and short name",
+                    Analyzer.SupportedDiagnostics,
+
+                    // language=cs
+                    @"
+[Command]
+public class MyCommand : ICommand
+{
+    [CommandOption(""foo"", 'f')]
+    public string Param { get; set; }
+
+    public ValueTask ExecuteAsync(IConsole console) => default;
+}"
+                )
+            };
+
+            yield return new object[]
+            {
+                new AnalyzerTestCase(
+                    "Options with unique names",
+                    Analyzer.SupportedDiagnostics,
+
+                    // language=cs
+                    @"
+[Command]
+public class MyCommand : ICommand
+{
+    [CommandOption(""foo"")]
+    public string ParamA { get; set; }
+    
+    [CommandOption(""bar"")]
+    public string ParamB { get; set; }
+
+    public ValueTask ExecuteAsync(IConsole console) => default;
+}"
+                )
+            };
+
+            yield return new object[]
+            {
+                new AnalyzerTestCase(
+                    "Options with unique short names",
+                    Analyzer.SupportedDiagnostics,
+
+                    // language=cs
+                    @"
+[Command]
+public class MyCommand : ICommand
+{
+    [CommandOption('f')]
+    public string ParamA { get; set; }
+    
+    [CommandOption('x')]
+    public string ParamB { get; set; }
+
+    public ValueTask ExecuteAsync(IConsole console) => default;
+}"
+                )
+            };
+
+            yield return new object[]
+            {
+                new AnalyzerTestCase(
+                    "Options with unique environment variable names",
+                    Analyzer.SupportedDiagnostics,
+
+                    // language=cs
+                    @"
+[Command]
+public class MyCommand : ICommand
+{
+    [CommandOption('a', EnvironmentVariableName = ""env_var_a"")]
+    public string ParamA { get; set; }
+    
+    [CommandOption('b', EnvironmentVariableName = ""env_var_b"")]
+    public string ParamB { get; set; }
+
+    public ValueTask ExecuteAsync(IConsole console) => default;
+}"
+                )
+            };
+        }
+
+        public static IEnumerable<object[]> GetInvalidCases()
+        {
+            yield return new object[]
+            {
+                new AnalyzerTestCase(
+                    "Command is missing the attribute",
+                    DiagnosticDescriptors.CliFx0002,
+
+                    // language=cs
+                    @"
+public class MyCommand : ICommand
+{
+    public ValueTask ExecuteAsync(IConsole console) => default;
+}"
+                )
+            };
+
+            yield return new object[]
+            {
+                new AnalyzerTestCase(
+                    "Command doesn't implement the interface",
+                    DiagnosticDescriptors.CliFx0001,
+
+                    // language=cs
+                    @"
+[Command]
+public class MyCommand
+{
+    public ValueTask ExecuteAsync(IConsole console) => default;
+}"
+                )
+            };
+
+            yield return new object[]
+            {
+                new AnalyzerTestCase(
+                    "Parameters with duplicate order",
+                    DiagnosticDescriptors.CliFx0021,
+
+                    // language=cs
+                    @"
+[Command]
+public class MyCommand : ICommand
+{
+    [CommandParameter(13)]
+    public string ParamA { get; set; }
+    
+    [CommandParameter(13)]
+    public string ParamB { get; set; }
+
+    public ValueTask ExecuteAsync(IConsole console) => default;
+}"
+                )
+            };
+
+            yield return new object[]
+            {
+                new AnalyzerTestCase(
+                    "Parameters with duplicate names",
+                    DiagnosticDescriptors.CliFx0022,
+
+                    // language=cs
+                    @"
+[Command]
+public class MyCommand : ICommand
+{
+    [CommandParameter(13, Name = ""foo"")]
+    public string ParamA { get; set; }
+    
+    [CommandParameter(15, Name = ""foo"")]
+    public string ParamB { get; set; }
+
+    public ValueTask ExecuteAsync(IConsole console) => default;
+}"
+                )
+            };
+
+            yield return new object[]
+            {
+                new AnalyzerTestCase(
+                    "Multiple non-scalar parameters",
+                    DiagnosticDescriptors.CliFx0023,
+
+                    // language=cs
+                    @"
+[Command]
+public class MyCommand : ICommand
+{
+    [CommandParameter(1)]
+    public IReadOnlyList<string> ParamA { get; set; }
+    
+    [CommandParameter(2)]
+    public HashSet<string> ParamB { get; set; }
+
+    public ValueTask ExecuteAsync(IConsole console) => default;
+}"
+                )
+            };
+
+            yield return new object[]
+            {
+                new AnalyzerTestCase(
+                    "Non-last non-scalar parameter",
+                    DiagnosticDescriptors.CliFx0024,
+
+                    // language=cs
+                    @"
+[Command]
+public class MyCommand : ICommand
+{
+    [CommandParameter(1)]
+    public IReadOnlyList<string> ParamA { get; set; }
+    
+    [CommandParameter(2)]
+    public string ParamB { get; set; }
+
+    public ValueTask ExecuteAsync(IConsole console) => default;
+}"
+                )
+            };
+
+            yield return new object[]
+            {
+                new AnalyzerTestCase(
+                    "Option with an empty name",
+                    DiagnosticDescriptors.CliFx0041,
+
+                    // language=cs
+                    @"
+[Command]
+public class MyCommand : ICommand
+{
+    [CommandOption("""")]
+    public string Param { get; set; }
+
+    public ValueTask ExecuteAsync(IConsole console) => default;
+}"
+                )
+            };
+
+            yield return new object[]
+            {
+                new AnalyzerTestCase(
+                    "Option with a name which is too short",
+                    DiagnosticDescriptors.CliFx0042,
+
+                    // language=cs
+                    @"
+[Command]
+public class MyCommand : ICommand
+{
+    [CommandOption(""a"")]
+    public string Param { get; set; }
+
+    public ValueTask ExecuteAsync(IConsole console) => default;
+}"
+                )
+            };
+
+            yield return new object[]
+            {
+                new AnalyzerTestCase(
+                    "Options with duplicate names",
+                    DiagnosticDescriptors.CliFx0043,
+
+                    // language=cs
+                    @"
+[Command]
+public class MyCommand : ICommand
+{
+    [CommandOption(""foo"")]
+    public string ParamA { get; set; }
+    
+    [CommandOption(""foo"")]
+    public string ParamB { get; set; }
+
+    public ValueTask ExecuteAsync(IConsole console) => default;
+}"
+                )
+            };
+
+            yield return new object[]
+            {
+                new AnalyzerTestCase(
+                    "Options with duplicate short names",
+                    DiagnosticDescriptors.CliFx0044,
+
+                    // language=cs
+                    @"
+[Command]
+public class MyCommand : ICommand
+{
+    [CommandOption('f')]
+    public string ParamA { get; set; }
+    
+    [CommandOption('f')]
+    public string ParamB { get; set; }
+
+    public ValueTask ExecuteAsync(IConsole console) => default;
+}"
+                )
+            };
+
+            yield return new object[]
+            {
+                new AnalyzerTestCase(
+                    "Options with duplicate environment variable names",
+                    DiagnosticDescriptors.CliFx0045,
+
+                    // language=cs
+                    @"
+[Command]
+public class MyCommand : ICommand
+{
+    [CommandOption('a', EnvironmentVariableName = ""env_var"")]
+    public string ParamA { get; set; }
+    
+    [CommandOption('b', EnvironmentVariableName = ""env_var"")]
+    public string ParamB { get; set; }
+
+    public ValueTask ExecuteAsync(IConsole console) => default;
+}"
+                )
+            };
+        }
+
+        [Theory]
+        [MemberData(nameof(GetValidCases))]
+        public void Valid(AnalyzerTestCase testCase) =>
+            Analyzer.Should().NotProduceDiagnostics(testCase);
+
+        [Theory]
+        [MemberData(nameof(GetInvalidCases))]
+        public void Invalid(AnalyzerTestCase testCase) =>
+            Analyzer.Should().ProduceDiagnostics(testCase);
+    }
+}

CliFx.Analyzers.Tests/ConsoleUsageAnalyzerTests.cs

@@ -0,0 +1,144 @@
+using System.Collections.Generic;
+using CliFx.Analyzers.Tests.Internal;
+using Microsoft.CodeAnalysis.Diagnostics;
+using Xunit;
+
+namespace CliFx.Analyzers.Tests
+{
+    public class ConsoleUsageAnalyzerTests
+    {
+        private static DiagnosticAnalyzer Analyzer { get; } = new ConsoleUsageAnalyzer();
+
+        public static IEnumerable<object[]> GetValidCases()
+        {
+            yield return new object[]
+            {
+                new AnalyzerTestCase(
+                    "Using console abstraction",
+                    Analyzer.SupportedDiagnostics,
+
+                    // language=cs
+                    @"
+[Command]
+public class MyCommand : ICommand
+{
+    public ValueTask ExecuteAsync(IConsole console)
+    {
+        console.Output.WriteLine(""Hello world"");
+        return default;
+    }
+}"
+                )
+            };
+
+            yield return new object[]
+            {
+                new AnalyzerTestCase(
+                    "Console abstraction is not available in scope",
+                    Analyzer.SupportedDiagnostics,
+
+                    // language=cs
+                    @"
+[Command]
+public class MyCommand : ICommand
+{
+    public void SomeOtherMethod() => Console.WriteLine(""Test"");
+
+    public ValueTask ExecuteAsync(IConsole console) => default;
+}"
+                )
+            };
+        }
+
+        public static IEnumerable<object[]> GetInvalidCases()
+        {
+            yield return new object[]
+            {
+                new AnalyzerTestCase(
+                    "Not using available console abstraction in the ExecuteAsync method",
+                    Analyzer.SupportedDiagnostics,
+
+                    // language=cs
+                    @"
+[Command]
+public class MyCommand : ICommand
+{
+    public ValueTask ExecuteAsync(IConsole console)
+    {
+        Console.WriteLine(""Hello world"");
+        return default;
+    }
+}"
+                )
+            };
+
+            yield return new object[]
+            {
+                new AnalyzerTestCase(
+                    "Not using available console abstraction in the ExecuteAsync method when writing stderr",
+                    Analyzer.SupportedDiagnostics,
+
+                    // language=cs
+                    @"
+[Command]
+public class MyCommand : ICommand
+{
+    public ValueTask ExecuteAsync(IConsole console)
+    {
+        Console.Error.WriteLine(""Hello world"");
+        return default;
+    }
+}"
+                )
+            };
+
+            yield return new object[]
+            {
+                new AnalyzerTestCase(
+                    "Not using available console abstraction while referencing System.Console by full name",
+                    Analyzer.SupportedDiagnostics,
+
+                    // language=cs
+                    @"
+[Command]
+public class MyCommand : ICommand
+{
+    public ValueTask ExecuteAsync(IConsole console)
+    {
+        System.Console.Error.WriteLine(""Hello world"");
+        return default;
+    }
+}"
+                )
+            };
+
+            yield return new object[]
+            {
+                new AnalyzerTestCase(
+                    "Not using available console abstraction in another method",
+                    DiagnosticDescriptors.CliFx0100,
+
+                    // language=cs
+                    @"
+[Command]
+public class MyCommand : ICommand
+{
+    public void SomeOtherMethod(IConsole console) => Console.WriteLine(""Test"");
+
+    public ValueTask ExecuteAsync(IConsole console) => default;
+}"
+                )
+            };
+        }
+
+        [Theory]
+        [MemberData(nameof(GetValidCases))]
+        public void Valid(AnalyzerTestCase testCase) =>
+            Analyzer.Should().NotProduceDiagnostics(testCase);
+
+        [Theory]
+        [MemberData(nameof(GetInvalidCases))]
+        public void Invalid(AnalyzerTestCase testCase) =>
+            Analyzer.Should().ProduceDiagnostics(testCase);
+    }
+}

CliFx.Analyzers.Tests/Internal/AnalyzerAssertions.cs

@@ -0,0 +1,107 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using FluentAssertions.Execution;
+using FluentAssertions.Primitives;
+using Gu.Roslyn.Asserts;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.Diagnostics;
+
+namespace CliFx.Analyzers.Tests.Internal
+{
+    internal partial class AnalyzerAssertions : ReferenceTypeAssertions<DiagnosticAnalyzer, AnalyzerAssertions>
+    {
+        protected override string Identifier { get; } = "analyzer";
+
+        public AnalyzerAssertions(DiagnosticAnalyzer analyzer)
+            : base(analyzer)
+        {
+        }
+
+        public void ProduceDiagnostics(
+            IReadOnlyList<DiagnosticDescriptor> diagnostics,
+            IReadOnlyList<string> sourceCodes)
+        {
+            var producedDiagnostics = GetProducedDiagnostics(Subject, sourceCodes);
+
+            var expectedIds = diagnostics.Select(d => d.Id).Distinct().OrderBy(d => d).ToArray();
+            var producedIds = producedDiagnostics.Select(d => d.Id).Distinct().OrderBy(d => d).ToArray();
+
+            var result = expectedIds.Intersect(producedIds).Count() == expectedIds.Length;
+
+            Execute.Assertion.ForCondition(result).FailWith($@"
+Expected and produced diagnostics do not match.
+
+Expected: {string.Join(", ", expectedIds)}
+Produced: {(producedIds.Any() ? string.Join(", ", producedIds) : "<none>")}
+".Trim());
+        }
+
+        public void ProduceDiagnostics(AnalyzerTestCase testCase) =>
+            ProduceDiagnostics(testCase.TestedDiagnostics, testCase.SourceCodes);
+
+        public void NotProduceDiagnostics(
+            IReadOnlyList<DiagnosticDescriptor> diagnostics,
+            IReadOnlyList<string> sourceCodes)
+        {
+            var producedDiagnostics = GetProducedDiagnostics(Subject, sourceCodes);
+
+            var expectedIds = diagnostics.Select(d => d.Id).Distinct().OrderBy(d => d).ToArray();
+            var producedIds = producedDiagnostics.Select(d => d.Id).Distinct().OrderBy(d => d).ToArray();
+
+            var result = !expectedIds.Intersect(producedIds).Any();
+
+            Execute.Assertion.ForCondition(result).FailWith($@"
+Expected no produced diagnostics.
+
+Produced: {string.Join(", ", producedIds)}
+".Trim());
+        }
+
+        public void NotProduceDiagnostics(AnalyzerTestCase testCase) =>
+            NotProduceDiagnostics(testCase.TestedDiagnostics, testCase.SourceCodes);
+    }
+
+    internal partial class AnalyzerAssertions
+    {
+        private static IReadOnlyList<MetadataReference> DefaultMetadataReferences { get; } =
+            MetadataReferences.Transitive(typeof(CliApplication).Assembly).ToArray();
+
+        private static string WrapCodeWithUsingDirectives(string code)
+        {
+            var usingDirectives = new[]
+            {
+                "using System;",
+                "using System.Collections.Generic;",
+                "using System.Threading.Tasks;",
+                "using CliFx;",
+                "using CliFx.Attributes;",
+                "using CliFx.Exceptions;",
+                "using CliFx.Utilities;"
+            };
+
+            return
+                string.Join(Environment.NewLine, usingDirectives) +
+                Environment.NewLine +
+                code;
+        }
+
+        private static IReadOnlyList<Diagnostic> GetProducedDiagnostics(
+            DiagnosticAnalyzer analyzer,
+            IReadOnlyList<string> sourceCodes)
+        {
+            var compilationOptions = new CSharpCompilationOptions(OutputKind.ConsoleApplication);
+            var wrappedSourceCodes = sourceCodes.Select(WrapCodeWithUsingDirectives).ToArray();
+
+            return Analyze.GetDiagnostics(analyzer, wrappedSourceCodes, compilationOptions, DefaultMetadataReferences)
+                .SelectMany(d => d)
+                .ToArray();
+        }
+    }
+
+    internal static class AnalyzerAssertionsExtensions
+    {
+        public static AnalyzerAssertions Should(this DiagnosticAnalyzer analyzer) => new AnalyzerAssertions(analyzer);
+    }
+}

CliFx.Analyzers/CliFx.Analyzers.csproj

@@ -0,0 +1,13 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <Import Project="../CliFx.props" />
+
+  <PropertyGroup>
+    <TargetFramework>netstandard2.0</TargetFramework>
+    <Nullable>annotations</Nullable>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.CodeAnalysis.CSharp.Workspaces" Version="3.4.0" PrivateAssets="all" />
+  </ItemGroup>
+
+</Project>

CliFx.Analyzers/CommandSchemaAnalyzer.cs

@@ -0,0 +1,297 @@
+using System;
+using System.Collections.Generic;
+using System.Collections.Immutable;
+using System.Linq;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.Diagnostics;
+
+namespace CliFx.Analyzers
+{
+    [DiagnosticAnalyzer(LanguageNames.CSharp)]
+    public class CommandSchemaAnalyzer : DiagnosticAnalyzer
+    {
+        public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics { get; } = ImmutableArray.Create(
+            DiagnosticDescriptors.CliFx0001,
+            DiagnosticDescriptors.CliFx0002,
+            DiagnosticDescriptors.CliFx0021,
+            DiagnosticDescriptors.CliFx0022,
+            DiagnosticDescriptors.CliFx0023,
+            DiagnosticDescriptors.CliFx0024,
+            DiagnosticDescriptors.CliFx0041,
+            DiagnosticDescriptors.CliFx0042,
+            DiagnosticDescriptors.CliFx0043,
+            DiagnosticDescriptors.CliFx0044,
+            DiagnosticDescriptors.CliFx0045
+        );
+
+        private static bool IsScalarType(ITypeSymbol typeSymbol) =>
+            KnownSymbols.IsSystemString(typeSymbol) ||
+            !typeSymbol.AllInterfaces.Select(i => i.ConstructedFrom).Any(KnownSymbols.IsSystemCollectionsGenericIEnumerable);
+
+        private static void CheckCommandParameterProperties(
+            SymbolAnalysisContext context,
+            IReadOnlyList<IPropertySymbol> properties)
+        {
+            var parameters = properties
+                .Select(p =>
+                {
+                    var attribute = p
+                        .GetAttributes()
+                        .First(a => KnownSymbols.IsCommandParameterAttribute(a.AttributeClass));
+
+                    var order = attribute
+                        .ConstructorArguments
+                        .Select(a => a.Value)
+                        .FirstOrDefault() as int?;
+
+                    var name = attribute
+                        .NamedArguments
+                        .Where(a => a.Key == "Name")
+                        .Select(a => a.Value.Value)
+                        .FirstOrDefault() as string;
+
+                    return new
+                    {
+                        Property = p,
+                        Order = order,
+                        Name = name
+                    };
+                })
+                .ToArray();
+
+            // Duplicate order
+            var duplicateOrderParameters = parameters
+                .Where(p => p.Order != null)
+                .GroupBy(p => p.Order)
+                .Where(g => g.Count() > 1)
+                .SelectMany(g => g.AsEnumerable())
+                .ToArray();
+
+            foreach (var parameter in duplicateOrderParameters)
+            {
+                context.ReportDiagnostic(
+                    Diagnostic.Create(DiagnosticDescriptors.CliFx0021, parameter.Property.Locations.First()));
+            }
+
+            // Duplicate name
+            var duplicateNameParameters = parameters
+                .Where(p => !string.IsNullOrWhiteSpace(p.Name))
+                .GroupBy(p => p.Name, StringComparer.OrdinalIgnoreCase)
+                .Where(g => g.Count() > 1)
+                .SelectMany(g => g.AsEnumerable())
+                .ToArray();
+
+            foreach (var parameter in duplicateNameParameters)
+            {
+                context.ReportDiagnostic(
+                    Diagnostic.Create(DiagnosticDescriptors.CliFx0022, parameter.Property.Locations.First()));
+            }
+
+            // Multiple non-scalar
+            var nonScalarParameters = parameters
+                .Where(p => !IsScalarType(p.Property.Type))
+                .ToArray();
+
+            if (nonScalarParameters.Length > 1)
+            {
+                foreach (var parameter in nonScalarParameters)
+                {
+                    context.ReportDiagnostic(
+                        Diagnostic.Create(DiagnosticDescriptors.CliFx0023, parameter.Property.Locations.First()));
+                }
+            }
+
+            // Non-last non-scalar
+            var nonLastNonScalarParameter = parameters
+                .OrderByDescending(a => a.Order)
+                .Skip(1)
+                .LastOrDefault(p => !IsScalarType(p.Property.Type));
+
+            if (nonLastNonScalarParameter != null)
+            {
+                context.ReportDiagnostic(
+                    Diagnostic.Create(DiagnosticDescriptors.CliFx0024, nonLastNonScalarParameter.Property.Locations.First()));
+            }
+        }
+
+        private static void CheckCommandOptionProperties(
+            SymbolAnalysisContext context,
+            IReadOnlyList<IPropertySymbol> properties)
+        {
+            var options = properties
+                .Select(p =>
+                {
+                    var attribute = p
+                        .GetAttributes()
+                        .First(a => KnownSymbols.IsCommandOptionAttribute(a.AttributeClass));
+
+                    var name = attribute
+                        .ConstructorArguments
+                        .Where(a => KnownSymbols.IsSystemString(a.Type))
+                        .Select(a => a.Value)
+                        .FirstOrDefault() as string;
+
+                    var shortName = attribute
+                        .ConstructorArguments
+                        .Where(a => KnownSymbols.IsSystemChar(a.Type))
+                        .Select(a => a.Value)
+                        .FirstOrDefault() as char?;
+
+                    var envVarName = attribute
+                        .NamedArguments
+                        .Where(a => a.Key == "EnvironmentVariableName")
+                        .Select(a => a.Value.Value)
+                        .FirstOrDefault() as string;
+
+                    return new
+                    {
+                        Property = p,
+                        Name = name,
+                        ShortName = shortName,
+                        EnvironmentVariableName = envVarName
+                    };
+                })
+                .ToArray();
+
+            // No name
+            var noNameOptions = options
+                .Where(o => string.IsNullOrWhiteSpace(o.Name) && o.ShortName == null)
+                .ToArray();
+
+            foreach (var option in noNameOptions)
+            {
+                context.ReportDiagnostic(
+                    Diagnostic.Create(DiagnosticDescriptors.CliFx0041, option.Property.Locations.First()));
+            }
+
+            // Too short name
+            var invalidNameLengthOptions = options
+                .Where(o => !string.IsNullOrWhiteSpace(o.Name) && o.Name.Length <= 1)
+                .ToArray();
+
+            foreach (var option in invalidNameLengthOptions)
+            {
+                context.ReportDiagnostic(
+                    Diagnostic.Create(DiagnosticDescriptors.CliFx0042, option.Property.Locations.First()));
+            }
+
+            // Duplicate name
+            var duplicateNameOptions = options
+                .Where(p => !string.IsNullOrWhiteSpace(p.Name))
+                .GroupBy(p => p.Name, StringComparer.OrdinalIgnoreCase)
+                .Where(g => g.Count() > 1)
+                .SelectMany(g => g.AsEnumerable())
+                .ToArray();
+
+            foreach (var option in duplicateNameOptions)
+            {
+                context.ReportDiagnostic(
+                    Diagnostic.Create(DiagnosticDescriptors.CliFx0043, option.Property.Locations.First()));
+            }
+
+            // Duplicate name
+            var duplicateShortNameOptions = options
+                .Where(p => p.ShortName != null)
+                .GroupBy(p => p.ShortName)
+                .Where(g => g.Count() > 1)
+                .SelectMany(g => g.AsEnumerable())
+                .ToArray();
+
+            foreach (var option in duplicateShortNameOptions)
+            {
+                context.ReportDiagnostic(
+                    Diagnostic.Create(DiagnosticDescriptors.CliFx0044, option.Property.Locations.First()));
+            }
+
+            // Duplicate environment variable name
+            var duplicateEnvironmentVariableNameOptions = options
+                .Where(p => !string.IsNullOrWhiteSpace(p.EnvironmentVariableName))
+                .GroupBy(p => p.EnvironmentVariableName, StringComparer.Ordinal)
+                .Where(g => g.Count() > 1)
+                .SelectMany(g => g.AsEnumerable())
+                .ToArray();
+
+            foreach (var option in duplicateEnvironmentVariableNameOptions)
+            {
+                context.ReportDiagnostic(
+                    Diagnostic.Create(DiagnosticDescriptors.CliFx0045, option.Property.Locations.First()));
+            }
+        }
+
+        private static void CheckCommandType(SymbolAnalysisContext context)
+        {
+            // Named type: MyCommand
+            if (!(context.Symbol is INamedTypeSymbol namedTypeSymbol))
+                return;
+
+            // Only classes
+            if (namedTypeSymbol.TypeKind != TypeKind.Class)
+                return;
+
+            // Implements ICommand?
+            var implementsCommandInterface = namedTypeSymbol
+                .AllInterfaces
+                .Any(KnownSymbols.IsCommandInterface);
+
+            // Has CommandAttribute?
+            var hasCommandAttribute = namedTypeSymbol
+                .GetAttributes()
+                .Select(a => a.AttributeClass)
+                .Any(KnownSymbols.IsCommandAttribute);
+
+            var isValidCommandType =
+                // implements interface
+                implementsCommandInterface && (
+                    // and either abstract class or has attribute
+                    namedTypeSymbol.IsAbstract || hasCommandAttribute
+                );
+
+            if (!isValidCommandType)
+            {
+                // See if this was meant to be a command type (either interface or attribute present)
+                var isAlmostValidCommandType = implementsCommandInterface ^ hasCommandAttribute;
+
+                if (isAlmostValidCommandType && !implementsCommandInterface)
+                    context.ReportDiagnostic(Diagnostic.Create(DiagnosticDescriptors.CliFx0001, namedTypeSymbol.Locations.First()));
+
+                if (isAlmostValidCommandType && !hasCommandAttribute)
+                    context.ReportDiagnostic(Diagnostic.Create(DiagnosticDescriptors.CliFx0002, namedTypeSymbol.Locations.First()));
+
+                return;
+            }
+
+            var properties = namedTypeSymbol
+                .GetMembers()
+                .Where(m => m.Kind == SymbolKind.Property)
+                .OfType<IPropertySymbol>().ToArray();
+
+            // Check parameters
+            var parameterProperties = properties
+                .Where(p => p
+                    .GetAttributes()
+                    .Select(a => a.AttributeClass)
+                    .Any(KnownSymbols.IsCommandParameterAttribute))
+                .ToArray();
+
+            CheckCommandParameterProperties(context, parameterProperties);
+
+            // Check options
+            var optionsProperties = properties
+                .Where(p => p
+                    .GetAttributes()
+                    .Select(a => a.AttributeClass)
+                    .Any(KnownSymbols.IsCommandOptionAttribute))
+                .ToArray();
+
+            CheckCommandOptionProperties(context, optionsProperties);
+        }
+
+        public override void Initialize(AnalysisContext context)
+        {
+            context.EnableConcurrentExecution();
+            context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.None);
+
+            context.RegisterSymbolAction(CheckCommandType, SymbolKind.NamedType);
+        }
+    }
+}

CliFx.Analyzers/ConsoleUsageAnalyzer.cs

@@ -0,0 +1,80 @@
+using System.Collections.Immutable;
+using System.Linq;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.Diagnostics;
+
+namespace CliFx.Analyzers
+{
+    [DiagnosticAnalyzer(LanguageNames.CSharp)]
+    public class ConsoleUsageAnalyzer : DiagnosticAnalyzer
+    {
+        public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics { get; } = ImmutableArray.Create(
+            DiagnosticDescriptors.CliFx0100
+        );
+
+        private static bool IsSystemConsoleInvocation(
+            SyntaxNodeAnalysisContext context,
+            InvocationExpressionSyntax invocationSyntax)
+        {
+            // Get the method member access (Console.WriteLine or Console.Error.WriteLine)
+            if (!(invocationSyntax.Expression is MemberAccessExpressionSyntax memberAccessSyntax))
+                return false;
+
+            // Get the semantic model for the invoked method
+            if (!(context.SemanticModel.GetSymbolInfo(memberAccessSyntax).Symbol is IMethodSymbol methodSymbol))
+                return false;
+
+            // Check if contained within System.Console
+            if (KnownSymbols.IsSystemConsole(methodSymbol.ContainingType))
+                return true;
+
+            // In case with Console.Error.WriteLine that wouldn't work, we need to check parent member access too
+            if (!(memberAccessSyntax.Expression is MemberAccessExpressionSyntax parentMemberAccessSyntax))
+                return false;
+
+            // Get the semantic model for the parent member
+            if (!(context.SemanticModel.GetSymbolInfo(parentMemberAccessSyntax).Symbol is IPropertySymbol propertySymbol))
+                return false;
+
+            // Check if contained within System.Console
+            if (KnownSymbols.IsSystemConsole(propertySymbol.ContainingType))
+                return true;
+
+            return false;
+        }
+
+        private static void CheckSystemConsoleUsage(SyntaxNodeAnalysisContext context)
+        {
+            if (!(context.Node is InvocationExpressionSyntax invocationSyntax))
+                return;
+
+            if (!IsSystemConsoleInvocation(context, invocationSyntax))
+                return;
+
+            // Check if IConsole is available in the scope as a viable alternative
+            var isConsoleInterfaceAvailable = invocationSyntax
+                .Ancestors()
+                .OfType<MethodDeclarationSyntax>()
+                .SelectMany(m => m.ParameterList.Parameters)
+                .Select(p => p.Type)
+                .Select(t => context.SemanticModel.GetSymbolInfo(t).Symbol)
+                .Where(s => s != null)
+                .Any(KnownSymbols.IsConsoleInterface!);
+
+            if (!isConsoleInterfaceAvailable)
+                return;
+
+            context.ReportDiagnostic(Diagnostic.Create(DiagnosticDescriptors.CliFx0100, invocationSyntax.GetLocation()));
+        }
+
+        public override void Initialize(AnalysisContext context)
+        {
+            context.EnableConcurrentExecution();
+            context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.None);
+
+            context.RegisterSyntaxNodeAction(CheckSystemConsoleUsage, SyntaxKind.InvocationExpression);
+        }
+    }
+}

CliFx.Analyzers/DiagnosticDescriptors.cs

@@ -0,0 +1,79 @@
+using Microsoft.CodeAnalysis;
+
+namespace CliFx.Analyzers
+{
+    public static class DiagnosticDescriptors
+    {
+        public static readonly DiagnosticDescriptor CliFx0001 =
+            new DiagnosticDescriptor(nameof(CliFx0001),
+                "Type must implement the 'CliFx.ICommand' interface in order to be a valid command",
+                "Type must implement the 'CliFx.ICommand' interface in order to be a valid command",
+                "Usage", DiagnosticSeverity.Error, true);
+
+        public static readonly DiagnosticDescriptor CliFx0002 =
+            new DiagnosticDescriptor(nameof(CliFx0002),
+                "Type must be annotated with the 'CliFx.Attributes.CommandAttribute' in order to be a valid command",
+                "Type must be annotated with the 'CliFx.Attributes.CommandAttribute' in order to be a valid command",
+                "Usage", DiagnosticSeverity.Error, true);
+
+        public static readonly DiagnosticDescriptor CliFx0021 =
+            new DiagnosticDescriptor(nameof(CliFx0021),
+                "Parameter order must be unique within its command",
+                "Parameter order must be unique within its command",
+                "Usage", DiagnosticSeverity.Error, true);
+
+        public static readonly DiagnosticDescriptor CliFx0022 =
+            new DiagnosticDescriptor(nameof(CliFx0022),
+                "Parameter order must have unique name within its command",
+                "Parameter order must have unique name within its command",
+                "Usage", DiagnosticSeverity.Error, true);
+
+        public static readonly DiagnosticDescriptor CliFx0023 =
+            new DiagnosticDescriptor(nameof(CliFx0023),
+                "Only one non-scalar parameter per command is allowed",
+                "Only one non-scalar parameter per command is allowed",
+                "Usage", DiagnosticSeverity.Error, true);
+
+        public static readonly DiagnosticDescriptor CliFx0024 =
+            new DiagnosticDescriptor(nameof(CliFx0024),
+                "Non-scalar parameter must be last in order",
+                "Non-scalar parameter must be last in order",
+                "Usage", DiagnosticSeverity.Error, true);
+
+        public static readonly DiagnosticDescriptor CliFx0041 =
+            new DiagnosticDescriptor(nameof(CliFx0041),
+                "Option must have a name or short name specified",
+                "Option must have a name or short name specified",
+                "Usage", DiagnosticSeverity.Error, true);
+
+        public static readonly DiagnosticDescriptor CliFx0042 =
+            new DiagnosticDescriptor(nameof(CliFx0042),
+                "Option name must be at least 2 characters long",
+                "Option name must be at least 2 characters long",
+                "Usage", DiagnosticSeverity.Error, true);
+
+        public static readonly DiagnosticDescriptor CliFx0043 =
+            new DiagnosticDescriptor(nameof(CliFx0043),
+                "Option name must be unique within its command",
+                "Option name must be unique within its command",
+                "Usage", DiagnosticSeverity.Error, true);
+
+        public static readonly DiagnosticDescriptor CliFx0044 =
+            new DiagnosticDescriptor(nameof(CliFx0044),
+                "Option short name must be unique within its command",
+                "Option short name must be unique within its command",
+                "Usage", DiagnosticSeverity.Error, true);
+
+        public static readonly DiagnosticDescriptor CliFx0045 =
+            new DiagnosticDescriptor(nameof(CliFx0045),
+                "Option environment variable name must be unique within its command",
+                "Option environment variable name must be unique within its command",
+                "Usage", DiagnosticSeverity.Error, true);
+
+        public static readonly DiagnosticDescriptor CliFx0100 =
+            new DiagnosticDescriptor(nameof(CliFx0100),
+                "Use the provided IConsole abstraction instead of System.Console to ensure that the command can be tested in isolation",
+                "Use the provided IConsole abstraction instead of System.Console to ensure that the command can be tested in isolation",
+                "Usage", DiagnosticSeverity.Warning, true);
+    }
+}

CliFx.Analyzers/Internal/RoslynExtensions.cs

@@ -0,0 +1,11 @@
+using System;
+using Microsoft.CodeAnalysis;
+
+namespace CliFx.Analyzers.Internal
+{
+    internal static class RoslynExtensions
+    {
+        public static bool DisplayNameMatches(this ISymbol symbol, string name) =>
+            string.Equals(symbol.ToDisplayString(), name, StringComparison.Ordinal);
+    }
+}

CliFx.Analyzers/KnownSymbols.cs

@@ -0,0 +1,37 @@
+using CliFx.Analyzers.Internal;
+using Microsoft.CodeAnalysis;
+
+namespace CliFx.Analyzers
+{
+    public static class KnownSymbols
+    {
+        public static bool IsSystemString(ISymbol symbol) =>
+            symbol.DisplayNameMatches("string") ||
+            symbol.DisplayNameMatches("System.String");
+
+        public static bool IsSystemChar(ISymbol symbol) =>
+            symbol.DisplayNameMatches("char") ||
+            symbol.DisplayNameMatches("System.Char");
+
+        public static bool IsSystemCollectionsGenericIEnumerable(ISymbol symbol) =>
+            symbol.DisplayNameMatches("System.Collections.Generic.IEnumerable<T>");
+
+        public static bool IsSystemConsole(ISymbol symbol) =>
+            symbol.DisplayNameMatches("System.Console");
+
+        public static bool IsConsoleInterface(ISymbol symbol) =>
+            symbol.DisplayNameMatches("CliFx.IConsole");
+
+        public static bool IsCommandInterface(ISymbol symbol) =>
+            symbol.DisplayNameMatches("CliFx.ICommand");
+
+        public static bool IsCommandAttribute(ISymbol symbol) =>
+            symbol.DisplayNameMatches("CliFx.Attributes.CommandAttribute");
+
+        public static bool IsCommandParameterAttribute(ISymbol symbol) =>
+            symbol.DisplayNameMatches("CliFx.Attributes.CommandParameterAttribute");
+
+        public static bool IsCommandOptionAttribute(ISymbol symbol) =>
+            symbol.DisplayNameMatches("CliFx.Attributes.CommandOptionAttribute");
+    }
+}

CliFx.Benchmarks/Benchmark.cs

@@ -1,34 +0,0 @@
-using System.Threading.Tasks;
-using BenchmarkDotNet.Attributes;
-using CliFx.Benchmarks.Commands;
-
-namespace CliFx.Benchmarks
-{
-    [CoreJob]
-    [RankColumn]
-    public class Benchmark
-    {
-        private static readonly string[] Arguments = { "--str", "hello world", "-i", "13", "-b" };
-
-        [Benchmark(Description = "CliFx", Baseline = true)]
-        public Task<int> ExecuteWithCliFx() => new CliApplicationBuilder().AddCommand(typeof(CliFxCommand)).Build().RunAsync(Arguments);
-
-        [Benchmark(Description = "System.CommandLine")]
-        public Task<int> ExecuteWithSystemCommandLine() => new SystemCommandLineCommand().ExecuteAsync(Arguments);
-
-        [Benchmark(Description = "McMaster.Extensions.CommandLineUtils")]
-        public int ExecuteWithMcMaster() => McMaster.Extensions.CommandLineUtils.CommandLineApplication.Execute<McMasterCommand>(Arguments);
-
-        // Skipped because this benchmark freezes after a couple of iterations
-        // Probably wasn't designed to run multiple times in single process execution
-        //[Benchmark(Description = "CommandLineParser")]
-        public void ExecuteWithCommandLineParser()
-        {
-            var parsed = CommandLine.Parser.Default.ParseArguments(Arguments, typeof(CommandLineParserCommand));
-            CommandLine.ParserResultExtensions.WithParsed<CommandLineParserCommand>(parsed, c => c.Execute());
-        }
-
-        [Benchmark(Description = "PowerArgs")]
-        public void ExecuteWithPowerArgs() => PowerArgs.Args.InvokeMain<PowerArgsCommand>(Arguments);
-    }
-}

CliFx.Benchmarks/Benchmarks.cs

@@ -0,0 +1,52 @@
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using BenchmarkDotNet.Attributes;
+using BenchmarkDotNet.Configs;
+using BenchmarkDotNet.Order;
+using BenchmarkDotNet.Running;
+using CliFx.Benchmarks.Commands;
+using CommandLine;
+
+namespace CliFx.Benchmarks
+{
+    [SimpleJob]
+    [RankColumn]
+    [Orderer(SummaryOrderPolicy.FastestToSlowest)]
+    public class Benchmarks
+    {
+        private static readonly string[] Arguments = {"--str", "hello world", "-i", "13", "-b"};
+
+        [Benchmark(Description = "CliFx", Baseline = true)]
+        public async ValueTask<int> ExecuteWithCliFx() =>
+            await new CliApplicationBuilder().AddCommand<CliFxCommand>().Build().RunAsync(Arguments, new Dictionary<string, string>());
+
+        [Benchmark(Description = "System.CommandLine")]
+        public async Task<int> ExecuteWithSystemCommandLine() =>
+            await new SystemCommandLineCommand().ExecuteAsync(Arguments);
+
+        [Benchmark(Description = "McMaster.Extensions.CommandLineUtils")]
+        public int ExecuteWithMcMaster() =>
+            McMaster.Extensions.CommandLineUtils.CommandLineApplication.Execute<McMasterCommand>(Arguments);
+
+        [Benchmark(Description = "CommandLineParser")]
+        public void ExecuteWithCommandLineParser() =>
+            new Parser()
+                .ParseArguments(Arguments, typeof(CommandLineParserCommand))
+                .WithParsed<CommandLineParserCommand>(c => c.Execute());
+
+        [Benchmark(Description = "PowerArgs")]
+        public void ExecuteWithPowerArgs() =>
+            PowerArgs.Args.InvokeMain<PowerArgsCommand>(Arguments);
+
+        [Benchmark(Description = "Clipr")]
+        public void ExecuteWithClipr() =>
+            clipr.CliParser.Parse<CliprCommand>(Arguments).Execute();
+
+        [Benchmark(Description = "Cocona")]
+        public void ExecuteWithCocona() =>
+            Cocona.CoconaApp.Run<CoconaCommand>(Arguments);
+
+        public static void Main() =>
+            BenchmarkRunner.Run<Benchmarks>(DefaultConfig.Instance.With(ConfigOptions.DisableOptimizationsValidator));
+    }
+}

CliFx.Benchmarks/CliFx.Benchmarks.csproj

@@ -1,15 +1,17 @@
 <Project Sdk="Microsoft.NET.Sdk">
+  <Import Project="../CliFx.props" />
 
   <PropertyGroup>
     <OutputType>Exe</OutputType>
-    <TargetFramework>netcoreapp2.2</TargetFramework>
+    <TargetFramework>netcoreapp3.1</TargetFramework>
-    <LangVersion>latest</LangVersion>
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="BenchmarkDotNet" Version="0.11.5" />
+    <PackageReference Include="BenchmarkDotNet" Version="0.12.0" />
-    <PackageReference Include="CommandLineParser" Version="2.6.0" />
+    <PackageReference Include="clipr" Version="1.6.1" />
-    <PackageReference Include="McMaster.Extensions.CommandLineUtils" Version="2.3.4" />
+    <PackageReference Include="Cocona" Version="1.3.0" />
+    <PackageReference Include="CommandLineParser" Version="2.7.82" />
+    <PackageReference Include="McMaster.Extensions.CommandLineUtils" Version="2.6.0" />
     <PackageReference Include="PowerArgs" Version="3.6.0" />
     <PackageReference Include="System.CommandLine.Experimental" Version="0.3.0-alpha.19317.1" />
   </ItemGroup>

CliFx.Benchmarks/Commands/CliFxCommand.cs

@@ -1,6 +1,5 @@
 using System.Threading.Tasks;
 using CliFx.Attributes;
-using CliFx.Services;
 
 namespace CliFx.Benchmarks.Commands
 {
@@ -8,7 +7,7 @@ namespace CliFx.Benchmarks.Commands
     public class CliFxCommand : ICommand
     {
         [CommandOption("str", 's')]
-        public string StrOption { get; set; }
+        public string? StrOption { get; set; }
 
         [CommandOption("int", 'i')]
         public int IntOption { get; set; }
@@ -16,6 +15,6 @@ namespace CliFx.Benchmarks.Commands
         [CommandOption("bool", 'b')]
         public bool BoolOption { get; set; }
 
-        public Task ExecuteAsync(IConsole console) => Task.CompletedTask;
+        public ValueTask ExecuteAsync(IConsole console) => default;
     }
 }

CliFx.Benchmarks/Commands/CliprCommand.cs

@@ -0,0 +1,20 @@
+using clipr;
+
+namespace CliFx.Benchmarks.Commands
+{
+    public class CliprCommand
+    {
+        [NamedArgument('s', "str")]
+        public string? StrOption { get; set; }
+
+        [NamedArgument('i', "int")]
+        public int IntOption { get; set; }
+
+        [NamedArgument('b', "bool", Constraint = NumArgsConstraint.Optional, Const = true)]
+        public bool BoolOption { get; set; }
+
+        public void Execute()
+        {
+        }
+    }
+}

CliFx.Benchmarks/Commands/CoconaCommand.cs

@@ -0,0 +1,17 @@
+using Cocona;
+
+namespace CliFx.Benchmarks.Commands
+{
+    public class CoconaCommand
+    {
+        public void Execute(
+            [Option("str", new []{'s'})]
+            string? strOption,
+            [Option("int", new []{'i'})]
+            int intOption,
+            [Option("bool", new []{'b'})]
+            bool boolOption)
+        {
+        }
+    }
+}

CliFx.Benchmarks/Commands/CommandLineParserCommand.cs

@@ -5,7 +5,7 @@ namespace CliFx.Benchmarks.Commands
     public class CommandLineParserCommand
     {
         [Option('s', "str")]
-        public string StrOption { get; set; }
+        public string? StrOption { get; set; }
 
         [Option('i', "int")]
         public int IntOption { get; set; }

CliFx.Benchmarks/Commands/McMasterCommand.cs

@@ -5,7 +5,7 @@ namespace CliFx.Benchmarks.Commands
     public class McMasterCommand
     {
         [Option("--str|-s")]
-        public string StrOption { get; set; }
+        public string? StrOption { get; set; }
 
         [Option("--int|-i")]
         public int IntOption { get; set; }

CliFx.Benchmarks/Commands/PowerArgsCommand.cs

@@ -5,7 +5,7 @@ namespace CliFx.Benchmarks.Commands
     public class PowerArgsCommand
     {
         [ArgShortcut("--str"), ArgShortcut("-s")]
-        public string StrOption { get; set; }
+        public string? StrOption { get; set; }
 
         [ArgShortcut("--int"), ArgShortcut("-i")]
         public int IntOption { get; set; }

CliFx.Benchmarks/Commands/SystemCommandLineCommand.cs

@@ -14,7 +14,7 @@ namespace CliFx.Benchmarks.Commands
             {
                 new Option(new[] {"--str", "-s"})
                 {
-                    Argument = new Argument<string>()
+                    Argument = new Argument<string?>()
                 },
                 new Option(new[] {"--int", "-i"})
                 {

CliFx.Benchmarks/Program.cs

@@ -1,12 +0,0 @@
-using BenchmarkDotNet.Configs;
-using BenchmarkDotNet.Running;
-
-namespace CliFx.Benchmarks
-{
-    public static class Program
-    {
-        public static void Main() =>
-            BenchmarkRunner.Run(typeof(Program).Assembly, DefaultConfig.Instance
-                .With(ConfigOptions.DisableOptimizationsValidator));
-    }
-}

CliFx.Demo/CliFx.Demo.csproj

@@ -1,18 +1,19 @@
 <Project Sdk="Microsoft.NET.Sdk">
+  <Import Project="../CliFx.props" />
 
   <PropertyGroup>
     <OutputType>Exe</OutputType>
-    <TargetFramework>netcoreapp2.2</TargetFramework>
+    <TargetFramework>netcoreapp3.1</TargetFramework>
-    <LangVersion>latest</LangVersion>
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="2.2.0" />
+    <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="3.1.2" />
-    <PackageReference Include="Newtonsoft.Json" Version="12.0.2" />
+    <PackageReference Include="Newtonsoft.Json" Version="12.0.3" />
   </ItemGroup>
 
   <ItemGroup>
     <ProjectReference Include="..\CliFx\CliFx.csproj" />
+    <ProjectReference Include="..\CliFx.Analyzers\CliFx.Analyzers.csproj" ReferenceOutputAssembly="false" OutputItemType="Analyzer" />
   </ItemGroup>
 
 </Project>

CliFx.Demo/Commands/BookAddCommand.cs

@@ -5,7 +5,6 @@ using CliFx.Demo.Internal;
 using CliFx.Demo.Models;
 using CliFx.Demo.Services;
 using CliFx.Exceptions;
-using CliFx.Services;
 
 namespace CliFx.Demo.Commands
 {
@@ -14,31 +13,25 @@ namespace CliFx.Demo.Commands
     {
         private readonly LibraryService _libraryService;
 
-        [CommandOption("title", 't', IsRequired = true, Description = "Book title.")]
+        [CommandParameter(0, Name = "title", Description = "Book title.")]
-        public string Title { get; set; }
+        public string Title { get; set; } = "";
 
         [CommandOption("author", 'a', IsRequired = true, Description = "Book author.")]
-        public string Author { get; set; }
+        public string Author { get; set; } = "";
 
         [CommandOption("published", 'p', Description = "Book publish date.")]
-        public DateTimeOffset Published { get; set; }
+        public DateTimeOffset Published { get; set; } = CreateRandomDate();
 
         [CommandOption("isbn", 'n', Description = "Book ISBN.")]
-        public Isbn Isbn { get; set; }
+        public Isbn Isbn { get; set; } = CreateRandomIsbn();
 
         public BookAddCommand(LibraryService libraryService)
         {
             _libraryService = libraryService;
         }
 
-        public Task ExecuteAsync(IConsole console)
+        public ValueTask ExecuteAsync(IConsole console)
         {
-            // To make the demo simpler, we will just generate random publish date and ISBN if they were not set
-            if (Published == default)
-                Published = CreateRandomDate();
-            if (Isbn == default)
-                Isbn = CreateRandomIsbn();
-
             if (_libraryService.GetBook(Title) != null)
                 throw new CommandException("Book already exists.", 1);
 
@@ -48,7 +41,7 @@ namespace CliFx.Demo.Commands
             console.Output.WriteLine("Book added.");
             console.RenderBook(book);
 
-            return Task.CompletedTask;
+            return default;
         }
     }
 
@@ -65,7 +58,7 @@ namespace CliFx.Demo.Commands
             Random.Next(1, 59),
             TimeSpan.Zero);
 
-        public static Isbn CreateRandomIsbn() => new Isbn(
+        private static Isbn CreateRandomIsbn() => new Isbn(
             Random.Next(0, 999),
             Random.Next(0, 99),
             Random.Next(0, 99999),

CliFx.Demo/Commands/BookCommand.cs

@@ -3,7 +3,6 @@ using CliFx.Attributes;
 using CliFx.Demo.Internal;
 using CliFx.Demo.Services;
 using CliFx.Exceptions;
-using CliFx.Services;
 
 namespace CliFx.Demo.Commands
 {
@@ -12,15 +11,15 @@ namespace CliFx.Demo.Commands
     {
         private readonly LibraryService _libraryService;
 
-        [CommandOption("title", 't', IsRequired = true, Description = "Book title.")]
+        [CommandParameter(0, Name = "title", Description = "Book title.")]
-        public string Title { get; set; }
+        public string Title { get; set; } = "";
 
         public BookCommand(LibraryService libraryService)
         {
             _libraryService = libraryService;
         }
 
-        public Task ExecuteAsync(IConsole console)
+        public ValueTask ExecuteAsync(IConsole console)
         {
             var book = _libraryService.GetBook(Title);
 
@@ -29,7 +28,7 @@ namespace CliFx.Demo.Commands
 
             console.RenderBook(book);
 
-            return Task.CompletedTask;
+            return default;
         }
     }
 }

CliFx.Demo/Commands/BookListCommand.cs

@@ -2,7 +2,6 @@
 using CliFx.Attributes;
 using CliFx.Demo.Internal;
 using CliFx.Demo.Services;
-using CliFx.Services;
 
 namespace CliFx.Demo.Commands
 {
@@ -16,7 +15,7 @@ namespace CliFx.Demo.Commands
             _libraryService = libraryService;
         }
 
-        public Task ExecuteAsync(IConsole console)
+        public ValueTask ExecuteAsync(IConsole console)
         {
             var library = _libraryService.GetLibrary();
 
@@ -32,7 +31,7 @@ namespace CliFx.Demo.Commands
                 console.RenderBook(book);
             }
 
-            return Task.CompletedTask;
+            return default;
         }
     }
 }

CliFx.Demo/Commands/BookRemoveCommand.cs

@@ -2,7 +2,6 @@
 using CliFx.Attributes;
 using CliFx.Demo.Services;
 using CliFx.Exceptions;
-using CliFx.Services;
 
 namespace CliFx.Demo.Commands
 {
@@ -11,15 +10,15 @@ namespace CliFx.Demo.Commands
     {
         private readonly LibraryService _libraryService;
 
-        [CommandOption("title", 't', IsRequired = true, Description = "Book title.")]
+        [CommandParameter(0, Name = "title", Description = "Book title.")]
-        public string Title { get; set; }
+        public string Title { get; set; } = "";
 
         public BookRemoveCommand(LibraryService libraryService)
         {
             _libraryService = libraryService;
         }
 
-        public Task ExecuteAsync(IConsole console)
+        public ValueTask ExecuteAsync(IConsole console)
         {
             var book = _libraryService.GetBook(Title);
 
@@ -30,7 +29,7 @@ namespace CliFx.Demo.Commands
 
             console.Output.WriteLine($"Book {Title} removed.");
 
-            return Task.CompletedTask;
+            return default;
         }
     }
 }

CliFx.Demo/Internal/Extensions.cs

@@ -1,6 +1,5 @@
 using System;
 using CliFx.Demo.Models;
-using CliFx.Services;
 
 namespace CliFx.Demo.Internal
 {

CliFx.Demo/Models/Isbn.cs

@@ -1,5 +1,4 @@
 using System;
-using System.Globalization;
 
 namespace CliFx.Demo.Models
 {
@@ -24,21 +23,23 @@ namespace CliFx.Demo.Models
             CheckDigit = checkDigit;
         }
 
-        public override string ToString() => $"{EanPrefix:000}-{RegistrationGroup:00}-{Registrant:00000}-{Publication:00}-{CheckDigit:0}";
+        public override string ToString() =>
+            $"{EanPrefix:000}-{RegistrationGroup:00}-{Registrant:00000}-{Publication:00}-{CheckDigit:0}";
     }
 
     public partial class Isbn
     {
-        public static Isbn Parse(string value)
+        public static Isbn Parse(string value, IFormatProvider formatProvider)
         {
             var components = value.Split('-', 5, StringSplitOptions.RemoveEmptyEntries);
 
             return new Isbn(
-                int.Parse(components[0], CultureInfo.InvariantCulture),
+                int.Parse(components[0], formatProvider),
-                int.Parse(components[1], CultureInfo.InvariantCulture),
+                int.Parse(components[1], formatProvider),
-                int.Parse(components[2], CultureInfo.InvariantCulture),
+                int.Parse(components[2], formatProvider),
-                int.Parse(components[3], CultureInfo.InvariantCulture),
+                int.Parse(components[3], formatProvider),
-                int.Parse(components[4], CultureInfo.InvariantCulture));
+                int.Parse(components[4], formatProvider)
+            );
         }
     }
 }

CliFx.Demo/Program.cs

@@ -1,4 +1,5 @@
-using System.Threading.Tasks;
+using System;
+using System.Threading.Tasks;
 using CliFx.Demo.Commands;
 using CliFx.Demo.Services;
 using Microsoft.Extensions.DependencyInjection;
@@ -7,7 +8,7 @@ namespace CliFx.Demo
 {
     public static class Program
     {
-        public static Task<int> Main(string[] args)
+        private static IServiceProvider GetServiceProvider()
         {
             // We use Microsoft.Extensions.DependencyInjection for injecting dependencies in commands
             var services = new ServiceCollection();
@@ -21,13 +22,14 @@ namespace CliFx.Demo
             services.AddTransient<BookRemoveCommand>();
             services.AddTransient<BookListCommand>();
 
-            var serviceProvider = services.BuildServiceProvider();
+            return services.BuildServiceProvider();
-
-            return new CliApplicationBuilder()
-                .AddCommandsFromThisAssembly()
-                .UseCommandFactory(schema => (ICommand) serviceProvider.GetRequiredService(schema.Type))
-                .Build()
-                .RunAsync(args);
         }
+
+        public static async Task<int> Main() =>
+            await new CliApplicationBuilder()
+                .AddCommandsFromThisAssembly()
+                .UseTypeActivator(GetServiceProvider().GetService)
+                .Build()
+                .RunAsync();
     }
 }

CliFx.Demo/Readme.md

@@ -2,6 +2,6 @@
 
 Sample command line interface for managing a library of books.
 
-This demo project shows basic CliFx functionality such as command routing, option parsing, autogenerated help text, and some other things.
+This demo project shows basic CliFx functionality such as command routing, argument parsing, autogenerated help text, and some other things.
 
 You can get a list of available commands by running `CliFx.Demo --help`.

CliFx.Demo/Services/LibraryService.cs

@@ -25,7 +25,7 @@ namespace CliFx.Demo.Services
             return JsonConvert.DeserializeObject<Library>(data);
         }
 
-        public Book GetBook(string title) => GetLibrary().Books.FirstOrDefault(b => b.Title == title);
+        public Book? GetBook(string title) => GetLibrary().Books.FirstOrDefault(b => b.Title == title);
 
         public void AddBook(Book book)
         {

CliFx.Tests.Dummy/CliFx.Tests.Dummy.csproj

@@ -1,14 +1,14 @@
 <Project Sdk="Microsoft.NET.Sdk">
+  <Import Project="../CliFx.props" />
 
   <PropertyGroup>
     <OutputType>Exe</OutputType>
-    <TargetFramework>net46</TargetFramework>
+    <TargetFramework>netcoreapp3.1</TargetFramework>
-    <Version>1.2.3.4</Version>
-    <LangVersion>latest</LangVersion>
   </PropertyGroup>
 
   <ItemGroup>
     <ProjectReference Include="..\CliFx\CliFx.csproj" />
+    <ProjectReference Include="..\CliFx.Analyzers\CliFx.Analyzers.csproj" ReferenceOutputAssembly="false" OutputItemType="Analyzer" />
   </ItemGroup>
 
 </Project>

CliFx.Tests.Dummy/Commands/ConsoleTestCommand.cs

@@ -0,0 +1,23 @@
+using System;
+using System.Threading.Tasks;
+using CliFx.Attributes;
+
+namespace CliFx.Tests.Dummy.Commands
+{
+    [Command("console-test")]
+    public class ConsoleTestCommand : ICommand
+    {
+        public ValueTask ExecuteAsync(IConsole console)
+        {
+            var input = console.Input.ReadToEnd();
+
+            console.WithColors(ConsoleColor.Black, ConsoleColor.White, () =>
+            {
+                console.Output.WriteLine(input);
+                console.Error.WriteLine(input);
+            });
+
+            return default;
+        }
+    }
+}

CliFx.Tests.Dummy/Commands/GreeterCommand.cs

@@ -1,31 +0,0 @@
-using System.Text;
-using System.Threading.Tasks;
-using CliFx.Attributes;
-using CliFx.Services;
-
-namespace CliFx.Tests.Dummy.Commands
-{
-    [Command]
-    public class GreeterCommand : ICommand
-    {
-        [CommandOption("target", 't', Description = "Greeting target.")]
-        public string Target { get; set; } = "world";
-
-        [CommandOption('e', Description = "Whether the greeting should be exclaimed.")]
-        public bool IsExclaimed { get; set; }
-
-        public Task ExecuteAsync(IConsole console)
-        {
-            var buffer = new StringBuilder();
-
-            buffer.Append("Hello").Append(' ').Append(Target);
-
-            if (IsExclaimed)
-                buffer.Append('!');
-
-            console.Output.WriteLine(buffer.ToString());
-
-            return Task.CompletedTask;
-        }
-    }
-}

CliFx.Tests.Dummy/Commands/HelloWorldCommand.cs

@@ -0,0 +1,19 @@
+using System.Threading.Tasks;
+using CliFx.Attributes;
+
+namespace CliFx.Tests.Dummy.Commands
+{
+    [Command]
+    public class HelloWorldCommand : ICommand
+    {
+        [CommandOption("target", EnvironmentVariableName = "ENV_TARGET")]
+        public string Target { get; set; } = "World";
+
+        public ValueTask ExecuteAsync(IConsole console)
+        {
+            console.Output.WriteLine($"Hello {Target}!");
+
+            return default;
+        }
+    }
+}

CliFx.Tests.Dummy/Commands/LogCommand.cs

@@ -1,25 +0,0 @@
-using System;
-using System.Threading.Tasks;
-using CliFx.Attributes;
-using CliFx.Services;
-
-namespace CliFx.Tests.Dummy.Commands
-{
-    [Command("log", Description = "Calculate the logarithm of a value.")]
-    public class LogCommand : ICommand
-    {
-        [CommandOption("value", 'v', IsRequired = true, Description = "Value whose logarithm is to be found.")]
-        public double Value { get; set; }
-
-        [CommandOption("base", 'b', Description = "Logarithm base.")]
-        public double Base { get; set; } = 10;
-
-        public Task ExecuteAsync(IConsole console)
-        {
-            var result = Math.Log(Value, Base);
-            console.Output.WriteLine(result);
-
-            return Task.CompletedTask;
-        }
-    }
-}

CliFx.Tests.Dummy/Commands/SumCommand.cs

@@ -1,23 +0,0 @@
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading.Tasks;
-using CliFx.Attributes;
-using CliFx.Services;
-
-namespace CliFx.Tests.Dummy.Commands
-{
-    [Command("sum", Description = "Calculate the sum of all input values.")]
-    public class SumCommand : ICommand
-    {
-        [CommandOption("values", 'v', IsRequired = true, Description = "Input values.")]
-        public IReadOnlyList<double> Values { get; set; }
-
-        public Task ExecuteAsync(IConsole console)
-        {
-            var result = Values.Sum();
-            console.Output.WriteLine(result);
-
-            return Task.CompletedTask;
-        }
-    }
-}

CliFx.Tests.Dummy/Program.cs

@@ -1,21 +1,21 @@
-using System.Globalization;
+using System.Reflection;
 using System.Threading.Tasks;
 
 namespace CliFx.Tests.Dummy
 {
-    public static class Program
+    public static partial class Program
     {
-        public static Task<int> Main(string[] args)
+        public static Assembly Assembly { get; } = typeof(Program).Assembly;
-        {
-            // Set culture to invariant to maintain consistent format because we rely on it in tests
-            CultureInfo.DefaultThreadCurrentCulture = CultureInfo.InvariantCulture;
-            CultureInfo.DefaultThreadCurrentUICulture = CultureInfo.InvariantCulture;
 
-            return new CliApplicationBuilder()
+        public static string Location { get; } = Assembly.Location;
+    }
+
+    public static partial class Program
+    {
+        public static async Task Main() =>
+            await new CliApplicationBuilder()
                 .AddCommandsFromThisAssembly()
-                .UseDescription("Dummy program used for E2E tests.")
                 .Build()
-                .RunAsync(args);
+                .RunAsync();
-        }
     }
 }

CliFx.Tests/ApplicationSpecs.cs

@@ -0,0 +1,375 @@
+using System;
+using System.IO;
+using System.Threading.Tasks;
+using CliFx.Tests.Commands;
+using CliFx.Tests.Commands.Invalid;
+using FluentAssertions;
+using Xunit;
+using Xunit.Abstractions;
+
+namespace CliFx.Tests
+{
+    public class ApplicationSpecs
+    {
+        private readonly ITestOutputHelper _output;
+
+        public ApplicationSpecs(ITestOutputHelper output) => _output = output;
+
+        [Fact]
+        public void Application_can_be_created_with_a_default_configuration()
+        {
+            // Act
+            var app = new CliApplicationBuilder()
+                .AddCommandsFromThisAssembly()
+                .Build();
+
+            // Assert
+            app.Should().NotBeNull();
+        }
+
+        [Fact]
+        public void Application_can_be_created_with_a_custom_configuration()
+        {
+            // Act
+            var app = new CliApplicationBuilder()
+                .AddCommand<DefaultCommand>()
+                .AddCommandsFrom(typeof(DefaultCommand).Assembly)
+                .AddCommands(new[] {typeof(DefaultCommand)})
+                .AddCommandsFrom(new[] {typeof(DefaultCommand).Assembly})
+                .AddCommandsFromThisAssembly()
+                .AllowDebugMode()
+                .AllowPreviewMode()
+                .UseTitle("test")
+                .UseExecutableName("test")
+                .UseVersionText("test")
+                .UseDescription("test")
+                .UseConsole(new VirtualConsole(Stream.Null))
+                .UseTypeActivator(Activator.CreateInstance!)
+                .Build();
+
+            // Assert
+            app.Should().NotBeNull();
+        }
+
+        [Fact]
+        public async Task At_least_one_command_must_be_defined_in_an_application()
+        {
+            var (console, _, stdErr) = VirtualConsole.CreateBuffered();
+
+            var application = new CliApplicationBuilder()
+                .UseConsole(console)
+                .Build();
+
+            // Act
+            var exitCode = await application.RunAsync(Array.Empty<string>());
+
+            // Assert
+            exitCode.Should().NotBe(0);
+            stdErr.GetString().Should().NotBeNullOrWhiteSpace();
+
+            _output.WriteLine(stdErr.GetString());
+        }
+
+        [Fact]
+        public async Task Commands_must_implement_the_corresponding_interface()
+        {
+            var (console, _, stdErr) = VirtualConsole.CreateBuffered();
+
+            var application = new CliApplicationBuilder()
+                .AddCommand(typeof(NonImplementedCommand))
+                .UseConsole(console)
+                .Build();
+
+            // Act
+            var exitCode = await application.RunAsync(Array.Empty<string>());
+
+            // Assert
+            exitCode.Should().NotBe(0);
+            stdErr.GetString().Should().NotBeNullOrWhiteSpace();
+
+            _output.WriteLine(stdErr.GetString());
+        }
+
+        [Fact]
+        public async Task Commands_must_be_annotated_by_an_attribute()
+        {
+            var (console, _, stdErr) = VirtualConsole.CreateBuffered();
+
+            var application = new CliApplicationBuilder()
+                .AddCommand<NonAnnotatedCommand>()
+                .UseConsole(console)
+                .Build();
+
+            // Act
+            var exitCode = await application.RunAsync(Array.Empty<string>());
+
+            // Assert
+            exitCode.Should().NotBe(0);
+            stdErr.GetString().Should().NotBeNullOrWhiteSpace();
+
+            _output.WriteLine(stdErr.GetString());
+        }
+
+        [Fact]
+        public async Task Commands_must_have_unique_names()
+        {
+            var (console, _, stdErr) = VirtualConsole.CreateBuffered();
+
+            var application = new CliApplicationBuilder()
+                .AddCommand<GenericExceptionCommand>()
+                .AddCommand<CommandExceptionCommand>()
+                .UseConsole(console)
+                .Build();
+
+            // Act
+            var exitCode = await application.RunAsync(Array.Empty<string>());
+
+            // Assert
+            exitCode.Should().NotBe(0);
+            stdErr.GetString().Should().NotBeNullOrWhiteSpace();
+
+            _output.WriteLine(stdErr.GetString());
+        }
+
+        [Fact]
+        public async Task Command_can_be_default_but_only_if_it_is_the_only_such_command()
+        {
+            var (console, _, stdErr) = VirtualConsole.CreateBuffered();
+
+            var application = new CliApplicationBuilder()
+                .AddCommand<DefaultCommand>()
+                .AddCommand<OtherDefaultCommand>()
+                .UseConsole(console)
+                .Build();
+
+            // Act
+            var exitCode = await application.RunAsync(Array.Empty<string>());
+
+            // Assert
+            exitCode.Should().NotBe(0);
+            stdErr.GetString().Should().NotBeNullOrWhiteSpace();
+
+            _output.WriteLine(stdErr.GetString());
+        }
+
+        [Fact]
+        public async Task Command_parameters_must_have_unique_order()
+        {
+            var (console, _, stdErr) = VirtualConsole.CreateBuffered();
+
+            var application = new CliApplicationBuilder()
+                .AddCommand<DuplicateParameterOrderCommand>()
+                .UseConsole(console)
+                .Build();
+
+            // Act
+            var exitCode = await application.RunAsync(Array.Empty<string>());
+
+            // Assert
+            exitCode.Should().NotBe(0);
+            stdErr.GetString().Should().NotBeNullOrWhiteSpace();
+
+            _output.WriteLine(stdErr.GetString());
+        }
+
+        [Fact]
+        public async Task Command_parameters_must_have_unique_names()
+        {
+            var (console, _, stdErr) = VirtualConsole.CreateBuffered();
+
+            var application = new CliApplicationBuilder()
+                .AddCommand<DuplicateParameterNameCommand>()
+                .UseConsole(console)
+                .Build();
+
+            // Act
+            var exitCode = await application.RunAsync(Array.Empty<string>());
+
+            // Assert
+            exitCode.Should().NotBe(0);
+            stdErr.GetString().Should().NotBeNullOrWhiteSpace();
+
+            _output.WriteLine(stdErr.GetString());
+        }
+
+        [Fact]
+        public async Task Command_parameter_can_be_non_scalar_only_if_no_other_such_parameter_is_present()
+        {
+            var (console, _, stdErr) = VirtualConsole.CreateBuffered();
+
+            var application = new CliApplicationBuilder()
+                .AddCommand<MultipleNonScalarParametersCommand>()
+                .UseConsole(console)
+                .Build();
+
+            // Act
+            var exitCode = await application.RunAsync(Array.Empty<string>());
+
+            // Assert
+            exitCode.Should().NotBe(0);
+            stdErr.GetString().Should().NotBeNullOrWhiteSpace();
+
+            _output.WriteLine(stdErr.GetString());
+        }
+
+        [Fact]
+        public async Task Command_parameter_can_be_non_scalar_only_if_it_is_the_last_in_order()
+        {
+            var (console, _, stdErr) = VirtualConsole.CreateBuffered();
+
+            var application = new CliApplicationBuilder()
+                .AddCommand<NonLastNonScalarParameterCommand>()
+                .UseConsole(console)
+                .Build();
+
+            // Act
+            var exitCode = await application.RunAsync(Array.Empty<string>());
+
+            // Assert
+            exitCode.Should().NotBe(0);
+            stdErr.GetString().Should().NotBeNullOrWhiteSpace();
+
+            _output.WriteLine(stdErr.GetString());
+        }
+
+        [Fact]
+        public async Task Command_options_must_have_names_that_are_not_empty()
+        {
+            var (console, _, stdErr) = VirtualConsole.CreateBuffered();
+
+            var application = new CliApplicationBuilder()
+                .AddCommand<EmptyOptionNameCommand>()
+                .UseConsole(console)
+                .Build();
+
+            // Act
+            var exitCode = await application.RunAsync(Array.Empty<string>());
+
+            // Assert
+            exitCode.Should().NotBe(0);
+            stdErr.GetString().Should().NotBeNullOrWhiteSpace();
+
+            _output.WriteLine(stdErr.GetString());
+        }
+
+        [Fact]
+        public async Task Command_options_must_have_names_that_are_longer_than_one_character()
+        {
+            var (console, _, stdErr) = VirtualConsole.CreateBuffered();
+
+            var application = new CliApplicationBuilder()
+                .AddCommand<SingleCharacterOptionNameCommand>()
+                .UseConsole(console)
+                .Build();
+
+            // Act
+            var exitCode = await application.RunAsync(Array.Empty<string>());
+
+            // Assert
+            exitCode.Should().NotBe(0);
+            stdErr.GetString().Should().NotBeNullOrWhiteSpace();
+
+            _output.WriteLine(stdErr.GetString());
+        }
+
+        [Fact]
+        public async Task Command_options_must_have_unique_names()
+        {
+            var (console, _, stdErr) = VirtualConsole.CreateBuffered();
+
+            var application = new CliApplicationBuilder()
+                .AddCommand<DuplicateOptionNamesCommand>()
+                .UseConsole(console)
+                .Build();
+
+            // Act
+            var exitCode = await application.RunAsync(Array.Empty<string>());
+
+            // Assert
+            exitCode.Should().NotBe(0);
+            stdErr.GetString().Should().NotBeNullOrWhiteSpace();
+
+            _output.WriteLine(stdErr.GetString());
+        }
+
+        [Fact]
+        public async Task Command_options_must_have_unique_short_names()
+        {
+            var (console, _, stdErr) = VirtualConsole.CreateBuffered();
+
+            var application = new CliApplicationBuilder()
+                .AddCommand<DuplicateOptionShortNamesCommand>()
+                .UseConsole(console)
+                .Build();
+
+            // Act
+            var exitCode = await application.RunAsync(Array.Empty<string>());
+
+            // Assert
+            exitCode.Should().NotBe(0);
+            stdErr.GetString().Should().NotBeNullOrWhiteSpace();
+
+            _output.WriteLine(stdErr.GetString());
+        }
+
+        [Fact]
+        public async Task Command_options_must_have_unique_environment_variable_names()
+        {
+            var (console, _, stdErr) = VirtualConsole.CreateBuffered();
+
+            var application = new CliApplicationBuilder()
+                .AddCommand<DuplicateOptionEnvironmentVariableNamesCommand>()
+                .UseConsole(console)
+                .Build();
+
+            // Act
+            var exitCode = await application.RunAsync(Array.Empty<string>());
+
+            // Assert
+            exitCode.Should().NotBe(0);
+            stdErr.GetString().Should().NotBeNullOrWhiteSpace();
+
+            _output.WriteLine(stdErr.GetString());
+        }
+
+        [Fact]
+        public async Task Command_options_must_not_have_conflicts_with_the_implicit_help_option()
+        {
+            var (console, _, stdErr) = VirtualConsole.CreateBuffered();
+
+            var application = new CliApplicationBuilder()
+                .AddCommand<ConflictWithHelpOptionCommand>()
+                .UseConsole(console)
+                .Build();
+
+            // Act
+            var exitCode = await application.RunAsync(Array.Empty<string>());
+
+            // Assert
+            exitCode.Should().NotBe(0);
+            stdErr.GetString().Should().NotBeNullOrWhiteSpace();
+
+            _output.WriteLine(stdErr.GetString());
+        }
+
+        [Fact]
+        public async Task Command_options_must_not_have_conflicts_with_the_implicit_version_option()
+        {
+            var (console, _, stdErr) = VirtualConsole.CreateBuffered();
+
+            var application = new CliApplicationBuilder()
+                .AddCommand<ConflictWithVersionOptionCommand>()
+                .UseConsole(console)
+                .Build();
+
+            // Act
+            var exitCode = await application.RunAsync(Array.Empty<string>());
+
+            // Assert
+            exitCode.Should().NotBe(0);
+            stdErr.GetString().Should().NotBeNullOrWhiteSpace();
+
+            _output.WriteLine(stdErr.GetString());
+        }
+    }
+}

CliFx.Tests/ArgumentBindingSpecs.cs

@@ -0,0 +1,242 @@
+using System.Threading.Tasks;
+using CliFx.Tests.Commands;
+using CliFx.Tests.Internal;
+using FluentAssertions;
+using Xunit;
+using Xunit.Abstractions;
+
+namespace CliFx.Tests
+{
+    public class ArgumentBindingSpecs
+    {
+        private readonly ITestOutputHelper _output;
+
+        public ArgumentBindingSpecs(ITestOutputHelper output) => _output = output;
+
+        [Fact]
+        public async Task Property_annotated_as_an_option_can_be_bound_from_multiple_values_even_if_the_inputs_use_mixed_naming()
+        {
+            // Arrange
+            var (console, stdOut, _) = VirtualConsole.CreateBuffered();
+
+            var application = new CliApplicationBuilder()
+                .AddCommand<WithStringArrayOptionCommand>()
+                .UseConsole(console)
+                .Build();
+
+            // Act
+            var exitCode = await application.RunAsync(new[]
+            {
+                "cmd", "--opt", "foo", "-o", "bar", "--opt", "baz"
+            });
+
+            var commandInstance = stdOut.GetString().DeserializeJson<WithStringArrayOptionCommand>();
+
+            // Assert
+            exitCode.Should().Be(0);
+
+            commandInstance.Should().BeEquivalentTo(new WithStringArrayOptionCommand
+            {
+                Opt = new[] {"foo", "bar", "baz"}
+            });
+        }
+
+        [Fact]
+        public async Task Property_annotated_as_a_required_option_must_always_be_set()
+        {
+            // Arrange
+            var (console, _, stdErr) = VirtualConsole.CreateBuffered();
+
+            var application = new CliApplicationBuilder()
+                .AddCommand<WithSingleRequiredOptionCommand>()
+                .UseConsole(console)
+                .Build();
+
+            // Act
+            var exitCode = await application.RunAsync(new[]
+            {
+                "cmd", "--opt-a", "foo"
+            });
+
+            // Assert
+            exitCode.Should().NotBe(0);
+            stdErr.GetString().Should().NotBeNullOrWhiteSpace();
+
+            _output.WriteLine(stdErr.GetString());
+        }
+
+        [Fact]
+        public async Task Property_annotated_as_a_required_option_must_always_be_bound_to_some_value()
+        {
+            // Arrange
+            var (console, _, stdErr) = VirtualConsole.CreateBuffered();
+
+            var application = new CliApplicationBuilder()
+                .AddCommand<WithSingleRequiredOptionCommand>()
+                .UseConsole(console)
+                .Build();
+
+            // Act
+            var exitCode = await application.RunAsync(new[]
+            {
+                "cmd", "--opt-a"
+            });
+
+            // Assert
+            exitCode.Should().NotBe(0);
+            stdErr.GetString().Should().NotBeNullOrWhiteSpace();
+
+            _output.WriteLine(stdErr.GetString());
+        }
+
+        [Fact]
+        public async Task Property_annotated_as_a_required_option_must_always_be_bound_to_at_least_one_value_if_it_expects_multiple_values()
+        {
+            // Arrange
+            var (console, _, stdErr) = VirtualConsole.CreateBuffered();
+
+            var application = new CliApplicationBuilder()
+                .AddCommand<WithRequiredOptionsCommand>()
+                .UseConsole(console)
+                .Build();
+
+            // Act
+            var exitCode = await application.RunAsync(new[]
+            {
+                "cmd", "--opt-a", "foo"
+            });
+
+            // Assert
+            exitCode.Should().NotBe(0);
+            stdErr.GetString().Should().NotBeNullOrWhiteSpace();
+
+            _output.WriteLine(stdErr.GetString());
+        }
+
+        [Fact]
+        public async Task Property_annotated_as_parameter_is_bound_directly_from_argument_value_according_to_the_order()
+        {
+            // Arrange
+            var (console, stdOut, _) = VirtualConsole.CreateBuffered();
+
+            var application = new CliApplicationBuilder()
+                .AddCommand<WithParametersCommand>()
+                .UseConsole(console)
+                .Build();
+
+            // Act
+            var exitCode = await application.RunAsync(new[]
+            {
+                "cmd", "foo", "13", "bar", "baz"
+            });
+
+            var commandInstance = stdOut.GetString().DeserializeJson<WithParametersCommand>();
+
+            // Assert
+            exitCode.Should().Be(0);
+
+            commandInstance.Should().BeEquivalentTo(new WithParametersCommand
+            {
+                ParamA = "foo",
+                ParamB = 13,
+                ParamC = new[] {"bar", "baz"}
+            });
+        }
+
+        [Fact]
+        public async Task Property_annotated_as_parameter_must_always_be_bound_to_some_value()
+        {
+            // Arrange
+            var (console, _, stdErr) = VirtualConsole.CreateBuffered();
+
+            var application = new CliApplicationBuilder()
+                .AddCommand<WithSingleParameterCommand>()
+                .UseConsole(console)
+                .Build();
+
+            // Act
+            var exitCode = await application.RunAsync(new[]
+            {
+                "cmd"
+            });
+
+            // Assert
+            exitCode.Should().NotBe(0);
+            stdErr.GetString().Should().NotBeNullOrWhiteSpace();
+
+            _output.WriteLine(stdErr.GetString());
+        }
+
+        [Fact]
+        public async Task Property_annotated_as_parameter_must_always_be_bound_to_at_least_one_value_if_it_expects_multiple_values()
+        {
+            // Arrange
+            var (console, _, stdErr) = VirtualConsole.CreateBuffered();
+
+            var application = new CliApplicationBuilder()
+                .AddCommand<WithParametersCommand>()
+                .UseConsole(console)
+                .Build();
+
+            // Act
+            var exitCode = await application.RunAsync(new[]
+            {
+                "cmd", "foo", "13"
+            });
+
+            // Assert
+            exitCode.Should().NotBe(0);
+            stdErr.GetString().Should().NotBeNullOrWhiteSpace();
+
+            _output.WriteLine(stdErr.GetString());
+        }
+
+        [Fact]
+        public async Task All_provided_option_arguments_must_be_bound_to_corresponding_properties()
+        {
+            // Arrange
+            var (console, _, stdErr) = VirtualConsole.CreateBuffered();
+
+            var application = new CliApplicationBuilder()
+                .AddCommand<SupportedArgumentTypesCommand>()
+                .UseConsole(console)
+                .Build();
+
+            // Act
+            var exitCode = await application.RunAsync(new[]
+            {
+                "cmd", "--non-existing-option", "13"
+            });
+
+            // Assert
+            exitCode.Should().NotBe(0);
+            stdErr.GetString().Should().NotBeNullOrWhiteSpace();
+
+            _output.WriteLine(stdErr.GetString());
+        }
+
+        [Fact]
+        public async Task All_provided_parameter_arguments_must_be_bound_to_corresponding_properties()
+        {
+            // Arrange
+            var (console, _, stdErr) = VirtualConsole.CreateBuffered();
+
+            var application = new CliApplicationBuilder()
+                .AddCommand<SupportedArgumentTypesCommand>()
+                .UseConsole(console)
+                .Build();
+
+            // Act
+            var exitCode = await application.RunAsync(new[]
+            {
+                "cnd", "non-existing-parameter"
+            });
+
+            // Assert
+            exitCode.Should().NotBe(0);
+            stdErr.GetString().Should().NotBeNullOrWhiteSpace();
+
+            _output.WriteLine(stdErr.GetString());
+        }
+    }
+}

CliFx.Tests/CancellationSpecs.cs

@@ -0,0 +1,36 @@
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+using CliFx.Tests.Commands;
+using FluentAssertions;
+using Xunit;
+
+namespace CliFx.Tests
+{
+    public class CancellationSpecs
+    {
+        [Fact]
+        public async Task Command_can_perform_additional_cleanup_if_cancellation_is_requested()
+        {
+            // Can't test it with a real console because CliWrap can't send Ctrl+C
+
+            // Arrange
+            using var cts = new CancellationTokenSource();
+            var (console, stdOut, _) = VirtualConsole.CreateBuffered(cts.Token);
+
+            var application = new CliApplicationBuilder()
+                .AddCommand<CancellableCommand>()
+                .UseConsole(console)
+                .Build();
+
+            // Act
+            cts.CancelAfter(TimeSpan.FromSeconds(0.2));
+
+            var exitCode = await application.RunAsync(new[] {"cmd"});
+
+            // Assert
+            exitCode.Should().NotBe(0);
+            stdOut.GetString().Trim().Should().Be(CancellableCommand.CancellationOutputText);
+        }
+    }
+}

CliFx.Tests/CliApplicationTests.Commands.cs

@@ -1,53 +0,0 @@
-using System;
-using System.Threading.Tasks;
-using CliFx.Attributes;
-using CliFx.Exceptions;
-using CliFx.Services;
-
-namespace CliFx.Tests
-{
-    public partial class CliApplicationTests
-    {
-        [Command]
-        private class DefaultCommand : ICommand
-        {
-            public Task ExecuteAsync(IConsole console)
-            {
-                console.Output.WriteLine("DefaultCommand executed.");
-                return Task.CompletedTask;
-            }
-        }
-
-        [Command("cmd")]
-        private class NamedCommand : ICommand
-        {
-            public Task ExecuteAsync(IConsole console)
-            {
-                console.Output.WriteLine("NamedCommand executed.");
-                return Task.CompletedTask;
-            }
-        }
-    }
-
-    // Negative
-    public partial class CliApplicationTests
-    {
-        [Command("faulty1")]
-        private class FaultyCommand1 : ICommand
-        {
-            public Task ExecuteAsync(IConsole console) => throw new CommandException(150);
-        }
-
-        [Command("faulty2")]
-        private class FaultyCommand2 : ICommand
-        {
-            public Task ExecuteAsync(IConsole console) => throw new CommandException("FaultyCommand2 error message.", 150);
-        }
-
-        [Command("faulty3")]
-        private class FaultyCommand3 : ICommand
-        {
-            public Task ExecuteAsync(IConsole console) => throw new Exception("FaultyCommand3 error message.");
-        }
-    }
-}

CliFx.Tests/CliApplicationTests.cs

@@ -1,174 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Threading.Tasks;
-using CliFx.Services;
-using FluentAssertions;
-using NUnit.Framework;
-
-namespace CliFx.Tests
-{
-    [TestFixture]
-    public partial class CliApplicationTests
-    {
-        private static IEnumerable<TestCaseData> GetTestCases_RunAsync()
-        {
-            yield return new TestCaseData(
-                new[] {typeof(DefaultCommand)},
-                new string[0],
-                "DefaultCommand executed."
-            );
-
-            yield return new TestCaseData(
-                new[] {typeof(NamedCommand)},
-                new[] {"cmd"},
-                "NamedCommand executed."
-            );
-        }
-
-        private static IEnumerable<TestCaseData> GetTestCases_HelpAndVersion_RunAsync()
-        {
-            yield return new TestCaseData(
-                new[] {typeof(DefaultCommand)},
-                new string[0]
-            );
-
-            yield return new TestCaseData(
-                new[] {typeof(DefaultCommand)},
-                new[] {"-h"}
-            );
-
-            yield return new TestCaseData(
-                new[] {typeof(DefaultCommand)},
-                new[] {"--help"}
-            );
-
-            yield return new TestCaseData(
-                new[] {typeof(DefaultCommand)},
-                new[] {"--version"}
-            );
-
-            yield return new TestCaseData(
-                new[] {typeof(NamedCommand)},
-                new string[0]
-            );
-
-            yield return new TestCaseData(
-                new[] {typeof(NamedCommand)},
-                new[] {"cmd", "-h"}
-            );
-
-            yield return new TestCaseData(
-                new[] {typeof(FaultyCommand1)},
-                new[] {"faulty1", "-h"}
-            );
-
-            yield return new TestCaseData(
-                new[] {typeof(FaultyCommand2)},
-                new[] {"faulty2", "-h"}
-            );
-
-            yield return new TestCaseData(
-                new[] {typeof(FaultyCommand3)},
-                new[] {"faulty3", "-h"}
-            );
-        }
-
-        private static IEnumerable<TestCaseData> GetTestCases_RunAsync_Negative()
-        {
-            yield return new TestCaseData(
-                new Type[0],
-                new string[0]
-            );
-
-            yield return new TestCaseData(
-                new[] {typeof(DefaultCommand)},
-                new[] {"non-existing"}
-            );
-
-            yield return new TestCaseData(
-                new[] {typeof(FaultyCommand1)},
-                new[] {"faulty1"}
-            );
-
-            yield return new TestCaseData(
-                new[] {typeof(FaultyCommand2)},
-                new[] {"faulty2"}
-            );
-
-            yield return new TestCaseData(
-                new[] {typeof(FaultyCommand3)},
-                new[] {"faulty3"}
-            );
-        }
-
-        [Test]
-        [TestCaseSource(nameof(GetTestCases_RunAsync))]
-        public async Task RunAsync_Test(IReadOnlyList<Type> commandTypes, IReadOnlyList<string> commandLineArguments, string expectedStdOut)
-        {
-            // Arrange
-            using (var stdout = new StringWriter())
-            {
-                var console = new VirtualConsole(stdout);
-
-                var application = new CliApplicationBuilder()
-                    .AddCommands(commandTypes)
-                    .UseConsole(console)
-                    .Build();
-
-                // Act
-                var exitCode = await application.RunAsync(commandLineArguments);
-
-                // Assert
-                exitCode.Should().Be(0);
-                stdout.ToString().Trim().Should().Be(expectedStdOut);
-            }
-        }
-
-        [Test]
-        [TestCaseSource(nameof(GetTestCases_HelpAndVersion_RunAsync))]
-        public async Task RunAsync_HelpAndVersion_Test(IReadOnlyList<Type> commandTypes, IReadOnlyList<string> commandLineArguments)
-        {
-            // Arrange
-            using (var stdout = new StringWriter())
-            {
-                var console = new VirtualConsole(stdout);
-
-                var application = new CliApplicationBuilder()
-                    .AddCommands(commandTypes)
-                    .UseConsole(console)
-                    .Build();
-
-                // Act
-                var exitCode = await application.RunAsync(commandLineArguments);
-
-                // Assert
-                exitCode.Should().Be(0);
-                stdout.ToString().Should().NotBeNullOrWhiteSpace();
-            }
-        }
-
-        [Test]
-        [TestCaseSource(nameof(GetTestCases_RunAsync_Negative))]
-        public async Task RunAsync_Negative_Test(IReadOnlyList<Type> commandTypes, IReadOnlyList<string> commandLineArguments)
-        {
-            // Arrange
-            using (var stderr = new StringWriter())
-            {
-                var console = new VirtualConsole(TextWriter.Null, stderr);
-
-                var application = new CliApplicationBuilder()
-                    .AddCommands(commandTypes)
-                    .UseConsole(console)
-                    .Build();
-
-                // Act
-                var exitCode = await application.RunAsync(commandLineArguments);
-
-                // Assert
-                exitCode.Should().NotBe(0);
-                stderr.ToString().Should().NotBeNullOrWhiteSpace();
-            }
-        }
-    }
-}

CliFx.Tests/CliFx.Tests.csproj

@@ -1,25 +1,28 @@
 <Project Sdk="Microsoft.NET.Sdk">
+  <Import Project="../CliFx.props" />
 
   <PropertyGroup>
-    <TargetFramework>net46</TargetFramework>
+    <TargetFramework>netcoreapp3.1</TargetFramework>
     <IsPackable>false</IsPackable>
     <IsTestProject>true</IsTestProject>
     <CollectCoverage>true</CollectCoverage>
     <CoverletOutputFormat>opencover</CoverletOutputFormat>
     <CoverletOutput>bin/$(Configuration)/Coverage.xml</CoverletOutput>
-    <LangVersion>latest</LangVersion>
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="FluentAssertions" Version="5.8.0" />
+    <Content Include="xunit.runner.json" CopyToOutputDirectory="PreserveNewest" />
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.2.0" />
+  </ItemGroup>
-    <PackageReference Include="NUnit" Version="3.12.0" />
+
-    <PackageReference Include="NUnit3TestAdapter" Version="3.14.0" />
+  <ItemGroup>
-    <PackageReference Include="CliWrap" Version="2.3.1" />
+    <PackageReference Include="CliWrap" Version="3.0.0" />
-    <PackageReference Include="coverlet.msbuild" Version="2.6.3">
+    <PackageReference Include="FluentAssertions" Version="5.10.2" />
-      <PrivateAssets>all</PrivateAssets>
+    <PackageReference Include="GitHubActionsTestLogger" Version="1.0.0" />
-      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.5.0" />
-    </PackageReference>
+    <PackageReference Include="Newtonsoft.Json" Version="12.0.3" />
+    <PackageReference Include="xunit" Version="2.4.1" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="2.4.1" />
+    <PackageReference Include="coverlet.msbuild" Version="2.8.0" PrivateAssets="all" />
   </ItemGroup>
 
   <ItemGroup>
@@ -27,4 +30,12 @@
     <ProjectReference Include="..\CliFx\CliFx.csproj" />
   </ItemGroup>
 
+  <ItemGroup>
+    <None Include="../CliFx.Tests.Dummy/bin/$(Configuration)/$(TargetFramework)/CliFx.Tests.Dummy.runtimeconfig.json">
+      <Link>CliFx.Tests.Dummy.runtimeconfig.json</Link>
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+      <Visible>False</Visible>
+    </None>
+  </ItemGroup>
+
 </Project>

CliFx.Tests/CommandFactoryTests.Commands.cs

@@ -1,15 +0,0 @@
-using System.Threading.Tasks;
-using CliFx.Attributes;
-using CliFx.Services;
-
-namespace CliFx.Tests
-{
-    public partial class CommandFactoryTests
-    {
-        [Command]
-        private class TestCommand : ICommand
-        {
-            public Task ExecuteAsync(IConsole console) => Task.CompletedTask;
-        }
-    }
-}

CliFx.Tests/CommandFactoryTests.cs

@@ -1,36 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using CliFx.Models;
-using CliFx.Services;
-using FluentAssertions;
-using NUnit.Framework;
-
-namespace CliFx.Tests
-{
-    [TestFixture]
-    public partial class CommandFactoryTests
-    {
-        private static CommandSchema GetCommandSchema(Type commandType) =>
-            new CommandSchemaResolver().GetCommandSchemas(new[] {commandType}).Single();
-
-        private static IEnumerable<TestCaseData> GetTestCases_CreateCommand()
-        {
-            yield return new TestCaseData(GetCommandSchema(typeof(TestCommand)));
-        }
-
-        [Test]
-        [TestCaseSource(nameof(GetTestCases_CreateCommand))]
-        public void CreateCommand_Test(CommandSchema commandSchema)
-        {
-            // Arrange
-            var factory = new CommandFactory();
-
-            // Act
-            var command = factory.CreateCommand(commandSchema);
-
-            // Assert
-            command.Should().BeOfType(commandSchema.Type);
-        }
-    }
-}

CliFx.Tests/CommandInitializerTests.Commands.cs

@@ -1,21 +0,0 @@
-using System.Threading.Tasks;
-using CliFx.Attributes;
-using CliFx.Services;
-
-namespace CliFx.Tests
-{
-    public partial class CommandInitializerTests
-    {
-        [Command]
-        private class TestCommand : ICommand
-        {
-            [CommandOption("int", 'i', IsRequired = true)]
-            public int IntOption { get; set; } = 24;
-
-            [CommandOption("str", 's')]
-            public string StringOption { get; set; } = "foo bar";
-
-            public Task ExecuteAsync(IConsole console) => Task.CompletedTask;
-        }
-    }
-}

CliFx.Tests/CommandInitializerTests.cs

@@ -1,96 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using CliFx.Exceptions;
-using CliFx.Models;
-using CliFx.Services;
-using FluentAssertions;
-using NUnit.Framework;
-
-namespace CliFx.Tests
-{
-    [TestFixture]
-    public partial class CommandInitializerTests
-    {
-        private static CommandSchema GetCommandSchema(Type commandType) =>
-            new CommandSchemaResolver().GetCommandSchemas(new[] {commandType}).Single();
-
-        private static IEnumerable<TestCaseData> GetTestCases_InitializeCommand()
-        {
-            yield return new TestCaseData(
-                new TestCommand(),
-                GetCommandSchema(typeof(TestCommand)),
-                new CommandInput(new[]
-                {
-                    new CommandOptionInput("int", "13")
-                }),
-                new TestCommand {IntOption = 13}
-            );
-
-            yield return new TestCaseData(
-                new TestCommand(),
-                GetCommandSchema(typeof(TestCommand)),
-                new CommandInput(new[]
-                {
-                    new CommandOptionInput("int", "13"),
-                    new CommandOptionInput("str", "hello world")
-                }),
-                new TestCommand {IntOption = 13, StringOption = "hello world"}
-            );
-
-            yield return new TestCaseData(
-                new TestCommand(),
-                GetCommandSchema(typeof(TestCommand)),
-                new CommandInput(new[]
-                {
-                    new CommandOptionInput("i", "13")
-                }),
-                new TestCommand {IntOption = 13}
-            );
-        }
-
-        private static IEnumerable<TestCaseData> GetTestCases_InitializeCommand_Negative()
-        {
-            yield return new TestCaseData(
-                new TestCommand(),
-                GetCommandSchema(typeof(TestCommand)),
-                CommandInput.Empty
-            );
-
-            yield return new TestCaseData(
-                new TestCommand(),
-                GetCommandSchema(typeof(TestCommand)),
-                new CommandInput(new[]
-                {
-                    new CommandOptionInput("str", "hello world")
-                })
-            );
-        }
-
-        [Test]
-        [TestCaseSource(nameof(GetTestCases_InitializeCommand))]
-        public void InitializeCommand_Test(ICommand command, CommandSchema commandSchema, CommandInput commandInput, ICommand expectedCommand)
-        {
-            // Arrange
-            var initializer = new CommandInitializer();
-
-            // Act
-            initializer.InitializeCommand(command, commandSchema, commandInput);
-
-            // Assert
-            command.Should().BeEquivalentTo(expectedCommand, o => o.RespectingRuntimeTypes());
-        }
-
-        [Test]
-        [TestCaseSource(nameof(GetTestCases_InitializeCommand_Negative))]
-        public void InitializeCommand_Negative_Test(ICommand command, CommandSchema commandSchema, CommandInput commandInput)
-        {
-            // Arrange
-            var initializer = new CommandInitializer();
-
-            // Act & Assert
-            initializer.Invoking(i => i.InitializeCommand(command, commandSchema, commandInput))
-                .Should().ThrowExactly<MissingCommandOptionInputException>();
-        }
-    }
-}

CliFx.Tests/CommandInputParserTests.cs

@@ -1,184 +0,0 @@
-using System.Collections.Generic;
-using CliFx.Models;
-using CliFx.Services;
-using FluentAssertions;
-using NUnit.Framework;
-
-namespace CliFx.Tests
-{
-    [TestFixture]
-    public class CommandInputParserTests
-    {
-        private static IEnumerable<TestCaseData> GetTestCases_ParseCommandInput()
-        {
-            yield return new TestCaseData(new string[0], CommandInput.Empty);
-
-            yield return new TestCaseData(
-                new[] {"--option", "value"},
-                new CommandInput(new[]
-                {
-                    new CommandOptionInput("option", "value")
-                })
-            );
-
-            yield return new TestCaseData(
-                new[] {"--option1", "value1", "--option2", "value2"},
-                new CommandInput(new[]
-                {
-                    new CommandOptionInput("option1", "value1"),
-                    new CommandOptionInput("option2", "value2")
-                })
-            );
-
-            yield return new TestCaseData(
-                new[] {"--option", "value1", "value2"},
-                new CommandInput(new[]
-                {
-                    new CommandOptionInput("option", new[] {"value1", "value2"})
-                })
-            );
-
-            yield return new TestCaseData(
-                new[] {"--option", "value1", "--option", "value2"},
-                new CommandInput(new[]
-                {
-                    new CommandOptionInput("option", new[] {"value1", "value2"})
-                })
-            );
-
-            yield return new TestCaseData(
-                new[] {"-a", "value"},
-                new CommandInput(new[]
-                {
-                    new CommandOptionInput("a", "value")
-                })
-            );
-
-            yield return new TestCaseData(
-                new[] {"-a", "value1", "-b", "value2"},
-                new CommandInput(new[]
-                {
-                    new CommandOptionInput("a", "value1"),
-                    new CommandOptionInput("b", "value2")
-                })
-            );
-
-            yield return new TestCaseData(
-                new[] {"-a", "value1", "value2"},
-                new CommandInput(new[]
-                {
-                    new CommandOptionInput("a", new[] {"value1", "value2"})
-                })
-            );
-
-            yield return new TestCaseData(
-                new[] {"-a", "value1", "-a", "value2"},
-                new CommandInput(new[]
-                {
-                    new CommandOptionInput("a", new[] {"value1", "value2"})
-                })
-            );
-
-            yield return new TestCaseData(
-                new[] {"--option1", "value1", "-b", "value2"},
-                new CommandInput(new[]
-                {
-                    new CommandOptionInput("option1", "value1"),
-                    new CommandOptionInput("b", "value2")
-                })
-            );
-
-            yield return new TestCaseData(
-                new[] {"--switch"},
-                new CommandInput(new[]
-                {
-                    new CommandOptionInput("switch")
-                })
-            );
-
-            yield return new TestCaseData(
-                new[] {"--switch1", "--switch2"},
-                new CommandInput(new[]
-                {
-                    new CommandOptionInput("switch1"),
-                    new CommandOptionInput("switch2")
-                })
-            );
-
-            yield return new TestCaseData(
-                new[] {"-s"},
-                new CommandInput(new[]
-                {
-                    new CommandOptionInput("s")
-                })
-            );
-
-            yield return new TestCaseData(
-                new[] {"-a", "-b"},
-                new CommandInput(new[]
-                {
-                    new CommandOptionInput("a"),
-                    new CommandOptionInput("b")
-                })
-            );
-
-            yield return new TestCaseData(
-                new[] {"-ab"},
-                new CommandInput(new[]
-                {
-                    new CommandOptionInput("a"),
-                    new CommandOptionInput("b")
-                })
-            );
-
-            yield return new TestCaseData(
-                new[] {"-ab", "value"},
-                new CommandInput(new[]
-                {
-                    new CommandOptionInput("a"),
-                    new CommandOptionInput("b", "value")
-                })
-            );
-
-            yield return new TestCaseData(
-                new[] {"command"},
-                new CommandInput("command")
-            );
-
-            yield return new TestCaseData(
-                new[] {"command", "--option", "value"},
-                new CommandInput("command", new[]
-                {
-                    new CommandOptionInput("option", "value")
-                })
-            );
-
-            yield return new TestCaseData(
-                new[] {"long", "command", "name"},
-                new CommandInput("long command name")
-            );
-
-            yield return new TestCaseData(
-                new[] {"long", "command", "name", "--option", "value"},
-                new CommandInput("long command name", new[]
-                {
-                    new CommandOptionInput("option", "value")
-                })
-            );
-        }
-
-        [Test]
-        [TestCaseSource(nameof(GetTestCases_ParseCommandInput))]
-        public void ParseCommandInput_Test(IReadOnlyList<string> commandLineArguments, CommandInput expectedCommandInput)
-        {
-            // Arrange
-            var parser = new CommandInputParser();
-
-            // Act
-            var commandInput = parser.ParseCommandInput(commandLineArguments);
-
-            // Assert
-            commandInput.Should().BeEquivalentTo(expectedCommandInput);
-        }
-    }
-}

CliFx.Tests/CommandOptionInputConverterTests.Types.cs

@@ -1,63 +0,0 @@
-using System;
-
-namespace CliFx.Tests
-{
-    public partial class CommandOptionInputConverterTests
-    {
-        private enum TestEnum
-        {
-            Value1,
-            Value2,
-            Value3
-        }
-
-        private class TestStringConstructable
-        {
-            public string Value { get; }
-
-            public TestStringConstructable(string value)
-            {
-                Value = value;
-            }
-        }
-
-        private class TestStringParseable
-        {
-            public string Value { get; }
-
-            private TestStringParseable(string value)
-            {
-                Value = value;
-            }
-
-            public static TestStringParseable Parse(string value) => new TestStringParseable(value);
-        }
-
-        private class TestStringParseableWithFormatProvider
-        {
-            public string Value { get; }
-
-            private TestStringParseableWithFormatProvider(string value)
-            {
-                Value = value;
-            }
-
-            public static TestStringParseableWithFormatProvider Parse(string value, IFormatProvider formatProvider) =>
-                new TestStringParseableWithFormatProvider(value + " " + formatProvider);
-        }
-    }
-
-    // Negative
-    public partial class CommandOptionInputConverterTests
-    {
-        private class NonStringParseable
-        {
-            public int Value { get; }
-
-            public NonStringParseable(int value)
-            {
-                Value = value;
-            }
-        }
-    }
-}

CliFx.Tests/CommandOptionInputConverterTests.cs

@@ -1,305 +0,0 @@
-using System;
-using System.Collections;
-using System.Collections.Generic;
-using System.Globalization;
-using CliFx.Exceptions;
-using CliFx.Models;
-using CliFx.Services;
-using FluentAssertions;
-using NUnit.Framework;
-
-namespace CliFx.Tests
-{
-    [TestFixture]
-    public partial class CommandOptionInputConverterTests
-    {
-        private static IEnumerable<TestCaseData> GetTestCases_ConvertOptionInput()
-        {
-            yield return new TestCaseData(
-                new CommandOptionInput("option", "value"),
-                typeof(string),
-                "value"
-            );
-
-            yield return new TestCaseData(
-                new CommandOptionInput("option", "value"),
-                typeof(object),
-                "value"
-            );
-
-            yield return new TestCaseData(
-                new CommandOptionInput("option", "true"),
-                typeof(bool),
-                true
-            );
-
-            yield return new TestCaseData(
-                new CommandOptionInput("option", "false"),
-                typeof(bool),
-                false
-            );
-
-            yield return new TestCaseData(
-                new CommandOptionInput("option"),
-                typeof(bool),
-                true
-            );
-
-            yield return new TestCaseData(
-                new CommandOptionInput("option", "a"),
-                typeof(char),
-                'a'
-            );
-
-            yield return new TestCaseData(
-                new CommandOptionInput("option", "15"),
-                typeof(sbyte),
-                (sbyte) 15
-            );
-
-            yield return new TestCaseData(
-                new CommandOptionInput("option", "15"),
-                typeof(byte),
-                (byte) 15
-            );
-
-            yield return new TestCaseData(
-                new CommandOptionInput("option", "15"),
-                typeof(short),
-                (short) 15
-            );
-
-            yield return new TestCaseData(
-                new CommandOptionInput("option", "15"),
-                typeof(ushort),
-                (ushort) 15
-            );
-
-            yield return new TestCaseData(
-                new CommandOptionInput("option", "123"),
-                typeof(int),
-                123
-            );
-
-            yield return new TestCaseData(
-                new CommandOptionInput("option", "123"),
-                typeof(uint),
-                123u
-            );
-
-            yield return new TestCaseData(
-                new CommandOptionInput("option", "123"),
-                typeof(long),
-                123L
-            );
-
-            yield return new TestCaseData(
-                new CommandOptionInput("option", "123"),
-                typeof(ulong),
-                123UL
-            );
-
-            yield return new TestCaseData(
-                new CommandOptionInput("option", "123.45"),
-                typeof(float),
-                123.45f
-            );
-
-            yield return new TestCaseData(
-                new CommandOptionInput("option", "123.45"),
-                typeof(double),
-                123.45
-            );
-
-            yield return new TestCaseData(
-                new CommandOptionInput("option", "123.45"),
-                typeof(decimal),
-                123.45m
-            );
-
-            yield return new TestCaseData(
-                new CommandOptionInput("option", "28 Apr 1995"),
-                typeof(DateTime),
-                new DateTime(1995, 04, 28)
-            );
-
-            yield return new TestCaseData(
-                new CommandOptionInput("option", "28 Apr 1995"),
-                typeof(DateTimeOffset),
-                new DateTimeOffset(new DateTime(1995, 04, 28))
-            );
-
-            yield return new TestCaseData(
-                new CommandOptionInput("option", "00:14:59"),
-                typeof(TimeSpan),
-                new TimeSpan(00, 14, 59)
-            );
-
-            yield return new TestCaseData(
-                new CommandOptionInput("option", "value2"),
-                typeof(TestEnum),
-                TestEnum.Value2
-            );
-
-            yield return new TestCaseData(
-                new CommandOptionInput("option", "666"),
-                typeof(int?),
-                666
-            );
-
-            yield return new TestCaseData(
-                new CommandOptionInput("option"),
-                typeof(int?),
-                null
-            );
-
-            yield return new TestCaseData(
-                new CommandOptionInput("option", "value3"),
-                typeof(TestEnum?),
-                TestEnum.Value3
-            );
-
-            yield return new TestCaseData(
-                new CommandOptionInput("option"),
-                typeof(TestEnum?),
-                null
-            );
-
-            yield return new TestCaseData(
-                new CommandOptionInput("option", "01:00:00"),
-                typeof(TimeSpan?),
-                new TimeSpan(01, 00, 00)
-            );
-
-            yield return new TestCaseData(
-                new CommandOptionInput("option"),
-                typeof(TimeSpan?),
-                null
-            );
-
-            yield return new TestCaseData(
-                new CommandOptionInput("option", "value"),
-                typeof(TestStringConstructable),
-                new TestStringConstructable("value")
-            );
-
-            yield return new TestCaseData(
-                new CommandOptionInput("option", "value"),
-                typeof(TestStringParseable),
-                TestStringParseable.Parse("value")
-            );
-
-            yield return new TestCaseData(
-                new CommandOptionInput("option", "value"),
-                typeof(TestStringParseableWithFormatProvider),
-                TestStringParseableWithFormatProvider.Parse("value", CultureInfo.InvariantCulture)
-            );
-
-            yield return new TestCaseData(
-                new CommandOptionInput("option", new[] {"value1", "value2"}),
-                typeof(string[]),
-                new[] {"value1", "value2"}
-            );
-
-            yield return new TestCaseData(
-                new CommandOptionInput("option", new[] {"value1", "value2"}),
-                typeof(object[]),
-                new[] {"value1", "value2"}
-            );
-
-            yield return new TestCaseData(
-                new CommandOptionInput("option", new[] {"47", "69"}),
-                typeof(int[]),
-                new[] {47, 69}
-            );
-
-            yield return new TestCaseData(
-                new CommandOptionInput("option", new[] {"value1", "value3"}),
-                typeof(TestEnum[]),
-                new[] {TestEnum.Value1, TestEnum.Value3}
-            );
-
-            yield return new TestCaseData(
-                new CommandOptionInput("option", new[] {"1337", "2441"}),
-                typeof(int?[]),
-                new int?[] {1337, 2441}
-            );
-
-            yield return new TestCaseData(
-                new CommandOptionInput("option", new[] {"value1", "value2"}),
-                typeof(TestStringConstructable[]),
-                new[] {new TestStringConstructable("value1"), new TestStringConstructable("value2")}
-            );
-
-            yield return new TestCaseData(
-                new CommandOptionInput("option", new[] {"value1", "value2"}),
-                typeof(IEnumerable),
-                new[] {"value1", "value2"}
-            );
-
-            yield return new TestCaseData(
-                new CommandOptionInput("option", new[] {"value1", "value2"}),
-                typeof(IEnumerable<string>),
-                new[] {"value1", "value2"}
-            );
-
-            yield return new TestCaseData(
-                new CommandOptionInput("option", new[] {"value1", "value2"}),
-                typeof(IReadOnlyList<string>),
-                new[] {"value1", "value2"}
-            );
-
-            yield return new TestCaseData(
-                new CommandOptionInput("option", new[] {"value1", "value2"}),
-                typeof(List<string>),
-                new List<string> {"value1", "value2"}
-            );
-
-            yield return new TestCaseData(
-                new CommandOptionInput("option", new[] {"value1", "value2"}),
-                typeof(HashSet<string>),
-                new HashSet<string> {"value1", "value2"}
-            );
-        }
-
-        private static IEnumerable<TestCaseData> GetTestCases_ConvertOptionInput_Negative()
-        {
-            yield return new TestCaseData(
-                new CommandOptionInput("option", "1234.5"),
-                typeof(int)
-            );
-
-            yield return new TestCaseData(
-                new CommandOptionInput("option", "123"),
-                typeof(NonStringParseable)
-            );
-        }
-
-        [Test]
-        [TestCaseSource(nameof(GetTestCases_ConvertOptionInput))]
-        public void ConvertOptionInput_Test(CommandOptionInput optionInput, Type targetType, object expectedConvertedValue)
-        {
-            // Arrange
-            var converter = new CommandOptionInputConverter();
-
-            // Act
-            var convertedValue = converter.ConvertOptionInput(optionInput, targetType);
-
-            // Assert
-            convertedValue.Should().BeEquivalentTo(expectedConvertedValue);
-            convertedValue?.Should().BeAssignableTo(targetType);
-        }
-
-        [Test]
-        [TestCaseSource(nameof(GetTestCases_ConvertOptionInput_Negative))]
-        public void ConvertOptionInput_Negative_Test(CommandOptionInput optionInput, Type targetType)
-        {
-            // Arrange
-            var converter = new CommandOptionInputConverter();
-
-            // Act & Assert
-            converter.Invoking(c => c.ConvertOptionInput(optionInput, targetType))
-                .Should().ThrowExactly<InvalidCommandOptionInputException>();
-        }
-    }
-}

CliFx.Tests/CommandSchemaResolverTests.Commands.cs

@@ -1,81 +0,0 @@
-using System;
-using System.Threading.Tasks;
-using CliFx.Attributes;
-using CliFx.Services;
-
-namespace CliFx.Tests
-{
-    public partial class CommandSchemaResolverTests
-    {
-        [Command("cmd", Description = "NormalCommand1 description.")]
-        private class NormalCommand1 : ICommand
-        {
-            [CommandOption("option-a", 'a')]
-            public int OptionA { get; set; }
-
-            [CommandOption("option-b", IsRequired = true)]
-            public string OptionB { get; set; }
-
-            public Task ExecuteAsync(IConsole console) => Task.CompletedTask;
-        }
-
-        [Command(Description = "NormalCommand2 description.")]
-        private class NormalCommand2 : ICommand
-        {
-            [CommandOption("option-c", Description = "OptionC description.")]
-            public bool OptionC { get; set; }
-
-            [CommandOption("option-d", 'd')]
-            public DateTimeOffset OptionD { get; set; }
-
-            public string NotAnOption { get; set; }
-
-            public Task ExecuteAsync(IConsole console) => Task.CompletedTask;
-        }
-    }
-
-    // Negative
-    public partial class CommandSchemaResolverTests
-    {
-        [Command("conflict")]
-        private class ConflictingCommand1 : ICommand
-        {
-            public Task ExecuteAsync(IConsole console) => Task.CompletedTask;
-        }
-
-        [Command("conflict")]
-        private class ConflictingCommand2 : ICommand
-        {
-            public Task ExecuteAsync(IConsole console) => Task.CompletedTask;
-        }
-
-        [Command]
-        private class InvalidCommand1
-        {
-        }
-
-        [Command]
-        private class InvalidCommand2 : ICommand
-        {
-            [CommandOption("conflict")]
-            public string ConflictingOption1 { get; set; }
-
-            [CommandOption("conflict")]
-            public string ConflictingOption2 { get; set; }
-
-            public Task ExecuteAsync(IConsole console) => Task.CompletedTask;
-        }
-
-        [Command]
-        private class InvalidCommand3 : ICommand
-        {
-            [CommandOption('c')]
-            public string ConflictingOption1 { get; set; }
-
-            [CommandOption('c')]
-            public string ConflictingOption2 { get; set; }
-
-            public Task ExecuteAsync(IConsole console) => Task.CompletedTask;
-        }
-    }
-}

CliFx.Tests/CommandSchemaResolverTests.cs

@@ -1,94 +0,0 @@
-using System;
-using System.Collections.Generic;
-using CliFx.Exceptions;
-using CliFx.Models;
-using CliFx.Services;
-using FluentAssertions;
-using NUnit.Framework;
-
-namespace CliFx.Tests
-{
-    [TestFixture]
-    public partial class CommandSchemaResolverTests
-    {
-        private static IEnumerable<TestCaseData> GetTestCases_GetCommandSchemas()
-        {
-            yield return new TestCaseData(
-                new[] {typeof(NormalCommand1), typeof(NormalCommand2)},
-                new[]
-                {
-                    new CommandSchema(typeof(NormalCommand1), "cmd", "NormalCommand1 description.",
-                        new[]
-                        {
-                            new CommandOptionSchema(typeof(NormalCommand1).GetProperty(nameof(NormalCommand1.OptionA)),
-                                "option-a", 'a', false, null),
-                            new CommandOptionSchema(typeof(NormalCommand1).GetProperty(nameof(NormalCommand1.OptionB)),
-                                "option-b", null, true, null)
-                        }),
-                    new CommandSchema(typeof(NormalCommand2), null, "NormalCommand2 description.",
-                        new[]
-                        {
-                            new CommandOptionSchema(typeof(NormalCommand2).GetProperty(nameof(NormalCommand2.OptionC)),
-                                "option-c", null, false, "OptionC description."),
-                            new CommandOptionSchema(typeof(NormalCommand2).GetProperty(nameof(NormalCommand2.OptionD)),
-                                "option-d", 'd', false, null)
-                        })
-                }
-            );
-        }
-
-        private static IEnumerable<TestCaseData> GetTestCases_GetCommandSchemas_Negative()
-        {
-            yield return new TestCaseData(new object[]
-            {
-                new Type[0]
-            });
-
-            yield return new TestCaseData(new object[]
-            {
-                new[] {typeof(ConflictingCommand1), typeof(ConflictingCommand2)}
-            });
-
-            yield return new TestCaseData(new object[]
-            {
-                new[] {typeof(InvalidCommand1)}
-            });
-
-            yield return new TestCaseData(new object[]
-            {
-                new[] {typeof(InvalidCommand2)}
-            });
-
-            yield return new TestCaseData(new object[]
-            {
-                new[] {typeof(InvalidCommand3)}
-            });
-        }
-
-        [Test]
-        [TestCaseSource(nameof(GetTestCases_GetCommandSchemas))]
-        public void GetCommandSchemas_Test(IReadOnlyList<Type> commandTypes, IReadOnlyList<CommandSchema> expectedCommandSchemas)
-        {
-            // Arrange
-            var commandSchemaResolver = new CommandSchemaResolver();
-
-            // Act
-            var commandSchemas = commandSchemaResolver.GetCommandSchemas(commandTypes);
-
-            // Assert
-            commandSchemas.Should().BeEquivalentTo(expectedCommandSchemas);
-        }
-
-        [Test]
-        [TestCaseSource(nameof(GetTestCases_GetCommandSchemas_Negative))]
-        public void GetCommandSchemas_Negative_Test(IReadOnlyList<Type> commandTypes)
-        {
-            // Arrange
-            var resolver = new CommandSchemaResolver();
-
-            // Act & Assert
-            resolver.Invoking(r => r.GetCommandSchemas(commandTypes))
-                .Should().ThrowExactly<InvalidCommandSchemaException>();
-        }
-    }
-}

CliFx.Tests/Commands/CancellableCommand.cs

@@ -0,0 +1,31 @@
+using System;
+using System.Threading.Tasks;
+using CliFx.Attributes;
+
+namespace CliFx.Tests.Commands
+{
+    [Command("cmd")]
+    public class CancellableCommand : ICommand
+    {
+        public const string CompletionOutputText = "Finished";
+        public const string CancellationOutputText = "Canceled";
+
+        public async ValueTask ExecuteAsync(IConsole console)
+        {
+            try
+            {
+                await Task.Delay(
+                    TimeSpan.FromSeconds(3),
+                    console.GetCancellationToken()
+                );
+
+                console.Output.WriteLine(CompletionOutputText);
+            }
+            catch (OperationCanceledException)
+            {
+                console.Output.WriteLine(CancellationOutputText);
+                throw;
+            }
+        }
+    }
+}

CliFx.Tests/Commands/CommandExceptionCommand.cs

@@ -0,0 +1,21 @@
+using System.Threading.Tasks;
+using CliFx.Attributes;
+using CliFx.Exceptions;
+
+namespace CliFx.Tests.Commands
+{
+    [Command("cmd")]
+    public class CommandExceptionCommand : ICommand
+    {
+        [CommandOption("code", 'c')]
+        public int ExitCode { get; set; } = 133;
+
+        [CommandOption("msg", 'm')]
+        public string? Message { get; set; }
+
+        [CommandOption("show-help")]
+        public bool ShowHelp { get; set; }
+
+        public ValueTask ExecuteAsync(IConsole console) => throw new CommandException(Message, ExitCode, ShowHelp);
+    }
+}

CliFx.Tests/Commands/DefaultCommand.cs

@@ -0,0 +1,17 @@
+using System.Threading.Tasks;
+using CliFx.Attributes;
+
+namespace CliFx.Tests.Commands
+{
+    [Command(Description = "Default command description")]
+    public class DefaultCommand : ICommand
+    {
+        public const string ExpectedOutputText = nameof(DefaultCommand);
+
+        public ValueTask ExecuteAsync(IConsole console)
+        {
+            console.Output.WriteLine(ExpectedOutputText);
+            return default;
+        }
+    }
+}

CliFx.Tests/Commands/GenericExceptionCommand.cs

@@ -0,0 +1,15 @@
+using System;
+using System.Threading.Tasks;
+using CliFx.Attributes;
+
+namespace CliFx.Tests.Commands
+{
+    [Command("cmd")]
+    public class GenericExceptionCommand : ICommand
+    {
+        [CommandOption("msg", 'm')]
+        public string? Message { get; set; }
+
+        public ValueTask ExecuteAsync(IConsole console) => throw new Exception(Message);
+    }
+}

CliFx.Tests/Commands/Invalid/ConflictWithHelpOptionCommand.cs

@@ -0,0 +1,11 @@
+using CliFx.Attributes;
+
+namespace CliFx.Tests.Commands.Invalid
+{
+    [Command("cmd")]
+    public class ConflictWithHelpOptionCommand : SelfSerializeCommandBase
+    {
+        [CommandOption("option-h", 'h')]
+        public string? OptionH { get; set; }
+    }
+}

CliFx.Tests/Commands/Invalid/ConflictWithVersionOptionCommand.cs

@@ -0,0 +1,12 @@
+using CliFx.Attributes;
+
+namespace CliFx.Tests.Commands.Invalid
+{
+    // Must be default because version option is available only on default commands
+    [Command]
+    public class ConflictWithVersionOptionCommand : SelfSerializeCommandBase
+    {
+        [CommandOption("version")]
+        public string? Version { get; set; }
+    }
+}

CliFx.Tests/Commands/Invalid/DuplicateOptionEnvironmentVariableNamesCommand.cs

@@ -0,0 +1,14 @@
+using CliFx.Attributes;
+
+namespace CliFx.Tests.Commands.Invalid
+{
+    [Command("cmd")]
+    public class DuplicateOptionEnvironmentVariableNamesCommand : SelfSerializeCommandBase
+    {
+        [CommandOption("option-a", EnvironmentVariableName = "ENV_VAR")]
+        public string? OptionA { get; set; }
+
+        [CommandOption("option-b", EnvironmentVariableName = "ENV_VAR")]
+        public string? OptionB { get; set; }
+    }
+}

CliFx.Tests/Commands/Invalid/DuplicateOptionNamesCommand.cs

@@ -0,0 +1,14 @@
+using CliFx.Attributes;
+
+namespace CliFx.Tests.Commands.Invalid
+{
+    [Command("cmd")]
+    public class DuplicateOptionNamesCommand : SelfSerializeCommandBase
+    {
+        [CommandOption("fruits")]
+        public string? Apples { get; set; }
+
+        [CommandOption("fruits")]
+        public string? Oranges { get; set; }
+    }
+}

CliFx.Tests/Commands/Invalid/DuplicateOptionShortNamesCommand.cs

@@ -0,0 +1,14 @@
+using CliFx.Attributes;
+
+namespace CliFx.Tests.Commands.Invalid
+{
+    [Command("cmd")]
+    public class DuplicateOptionShortNamesCommand : SelfSerializeCommandBase
+    {
+        [CommandOption('x')]
+        public string? OptionA { get; set; }
+
+        [CommandOption('x')]
+        public string? OptionB { get; set; }
+    }
+}

CliFx.Tests/Commands/Invalid/DuplicateParameterNameCommand.cs

@@ -0,0 +1,14 @@
+using CliFx.Attributes;
+
+namespace CliFx.Tests.Commands.Invalid
+{
+    [Command("cmd")]
+    public class DuplicateParameterNameCommand : SelfSerializeCommandBase
+    {
+        [CommandParameter(0, Name = "param")]
+        public string? ParamA { get; set; }
+
+        [CommandParameter(1, Name = "param")]
+        public string? ParamB { get; set; }
+    }
+}

CliFx.Tests/Commands/Invalid/DuplicateParameterOrderCommand.cs

@@ -0,0 +1,14 @@
+using CliFx.Attributes;
+
+namespace CliFx.Tests.Commands.Invalid
+{
+    [Command("cmd")]
+    public class DuplicateParameterOrderCommand : SelfSerializeCommandBase
+    {
+        [CommandParameter(13)]
+        public string? ParamA { get; set; }
+
+        [CommandParameter(13)]
+        public string? ParamB { get; set; }
+    }
+}

CliFx.Tests/Commands/Invalid/EmptyOptionNameCommand.cs

@@ -0,0 +1,11 @@
+using CliFx.Attributes;
+
+namespace CliFx.Tests.Commands.Invalid
+{
+    [Command("cmd")]
+    public class EmptyOptionNameCommand : SelfSerializeCommandBase
+    {
+        [CommandOption("")]
+        public string? Apples { get; set; }
+    }
+}

CliFx.Tests/Commands/Invalid/MultipleNonScalarParametersCommand.cs

@@ -0,0 +1,15 @@
+using System.Collections.Generic;
+using CliFx.Attributes;
+
+namespace CliFx.Tests.Commands.Invalid
+{
+    [Command("cmd")]
+    public class MultipleNonScalarParametersCommand : SelfSerializeCommandBase
+    {
+        [CommandParameter(0)]
+        public IReadOnlyList<string>? ParamA { get; set; }
+
+        [CommandParameter(1)]
+        public IReadOnlyList<string>? ParamB { get; set; }
+    }
+}

CliFx.Tests/Commands/Invalid/NonAnnotatedCommand.cs

@@ -0,0 +1,6 @@
+namespace CliFx.Tests.Commands.Invalid
+{
+    public class NonAnnotatedCommand : SelfSerializeCommandBase
+    {
+    }
+}

CliFx.Tests/Commands/Invalid/NonImplementedCommand.cs

@@ -0,0 +1,9 @@
+using CliFx.Attributes;
+
+namespace CliFx.Tests.Commands.Invalid
+{
+    [Command]
+    public class NonImplementedCommand
+    {
+    }
+}

CliFx.Tests/Commands/Invalid/NonLastNonScalarParameterCommand.cs

@@ -0,0 +1,15 @@
+using System.Collections.Generic;
+using CliFx.Attributes;
+
+namespace CliFx.Tests.Commands.Invalid
+{
+    [Command("cmd")]
+    public class NonLastNonScalarParameterCommand : SelfSerializeCommandBase
+    {
+        [CommandParameter(0)]
+        public IReadOnlyList<string>? ParamA { get; set; }
+
+        [CommandParameter(1)]
+        public string? ParamB { get; set; }
+    }
+}

CliFx.Tests/Commands/Invalid/OtherDefaultCommand.cs

@@ -0,0 +1,9 @@
+using CliFx.Attributes;
+
+namespace CliFx.Tests.Commands.Invalid
+{
+    [Command]
+    public class OtherDefaultCommand : SelfSerializeCommandBase
+    {
+    }
+}

CliFx.Tests/Commands/Invalid/SingleCharacterOptionNameCommand.cs

@@ -0,0 +1,11 @@
+using CliFx.Attributes;
+
+namespace CliFx.Tests.Commands.Invalid
+{
+    [Command("cmd")]
+    public class SingleCharacterOptionNameCommand : SelfSerializeCommandBase
+    {
+        [CommandOption("a")]
+        public string? Apples { get; set; }
+    }
+}

CliFx.Tests/Commands/NamedCommand.cs

@@ -0,0 +1,17 @@
+using System.Threading.Tasks;
+using CliFx.Attributes;
+
+namespace CliFx.Tests.Commands
+{
+    [Command("named", Description = "Named command description")]
+    public class NamedCommand : ICommand
+    {
+        public const string ExpectedOutputText = nameof(NamedCommand);
+
+        public ValueTask ExecuteAsync(IConsole console)
+        {
+            console.Output.WriteLine(ExpectedOutputText);
+            return default;
+        }
+    }
+}

CliFx.Tests/Commands/NamedSubCommand.cs

@@ -0,0 +1,17 @@
+using System.Threading.Tasks;
+using CliFx.Attributes;
+
+namespace CliFx.Tests.Commands
+{
+    [Command("named sub", Description = "Named sub command description")]
+    public class NamedSubCommand : ICommand
+    {
+        public const string ExpectedOutputText = nameof(NamedSubCommand);
+
+        public ValueTask ExecuteAsync(IConsole console)
+        {
+            console.Output.WriteLine(ExpectedOutputText);
+            return default;
+        }
+    }
+}

CliFx.Tests/Commands/SelfSerializeCommandBase.cs

@@ -0,0 +1,14 @@
+using System.Threading.Tasks;
+using Newtonsoft.Json;
+
+namespace CliFx.Tests.Commands
+{
+    public abstract class SelfSerializeCommandBase : ICommand
+    {
+        public ValueTask ExecuteAsync(IConsole console)
+        {
+            console.Output.WriteLine(JsonConvert.SerializeObject(this));
+            return default;
+        }
+    }
+}

CliFx.Tests/Commands/SupportedArgumentTypesCommand.cs

@@ -0,0 +1,155 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using CliFx.Attributes;
+using Newtonsoft.Json;
+
+namespace CliFx.Tests.Commands
+{
+    [Command("cmd")]
+    public partial class SupportedArgumentTypesCommand : SelfSerializeCommandBase
+    {
+        [CommandOption("obj")]
+        public object? Object { get; set; } = 42;
+
+        [CommandOption("str")]
+        public string? String { get; set; } = "foo bar";
+
+        [CommandOption("bool")]
+        public bool Bool { get; set; }
+
+        [CommandOption("char")]
+        public char Char { get; set; }
+
+        [CommandOption("sbyte")]
+        public sbyte Sbyte { get; set; }
+
+        [CommandOption("byte")]
+        public byte Byte { get; set; }
+
+        [CommandOption("short")]
+        public short Short { get; set; }
+
+        [CommandOption("ushort")]
+        public ushort Ushort { get; set; }
+
+        [CommandOption("int")]
+        public int Int { get; set; }
+
+        [CommandOption("uint")]
+        public uint Uint { get; set; }
+
+        [CommandOption("long")]
+        public long Long { get; set; }
+
+        [CommandOption("ulong")]
+        public ulong Ulong { get; set; }
+
+        [CommandOption("float")]
+        public float Float { get; set; }
+
+        [CommandOption("double")]
+        public double Double { get; set; }
+
+        [CommandOption("decimal")]
+        public decimal Decimal { get; set; }
+
+        [CommandOption("datetime")]
+        public DateTime DateTime { get; set; }
+
+        [CommandOption("datetime-offset")]
+        public DateTimeOffset DateTimeOffset { get; set; }
+
+        [CommandOption("timespan")]
+        public TimeSpan TimeSpan { get; set; }
+
+        [CommandOption("enum")]
+        public CustomEnum Enum { get; set; }
+
+        [CommandOption("int-nullable")]
+        public int? IntNullable { get; set; }
+
+        [CommandOption("enum-nullable")]
+        public CustomEnum? EnumNullable { get; set; }
+
+        [CommandOption("timespan-nullable")]
+        public TimeSpan? TimeSpanNullable { get; set; }
+
+        [CommandOption("str-constructible")]
+        public CustomStringConstructible? StringConstructible { get; set; }
+
+        [CommandOption("str-parseable")]
+        public CustomStringParseable? StringParseable { get; set; }
+
+        [CommandOption("str-parseable-format")]
+        public CustomStringParseableWithFormatProvider? StringParseableWithFormatProvider { get; set; }
+
+        [CommandOption("obj-array")]
+        public object[]? ObjectArray { get; set; }
+
+        [CommandOption("str-array")]
+        public string[]? StringArray { get; set; }
+
+        [CommandOption("int-array")]
+        public int[]? IntArray { get; set; }
+
+        [CommandOption("enum-array")]
+        public CustomEnum[]? EnumArray { get; set; }
+
+        [CommandOption("int-nullable-array")]
+        public int?[]? IntNullableArray { get; set; }
+
+        [CommandOption("str-constructible-array")]
+        public CustomStringConstructible[]? StringConstructibleArray { get; set; }
+
+        [CommandOption("str-enumerable")]
+        public IEnumerable<string>? StringEnumerable { get; set; }
+
+        [CommandOption("str-read-only-list")]
+        public IReadOnlyList<string>? StringReadOnlyList { get; set; }
+
+        [CommandOption("str-list")]
+        public List<string>? StringList { get; set; }
+
+        [CommandOption("str-set")]
+        public HashSet<string>? StringHashSet { get; set; }
+    }
+
+    public partial class SupportedArgumentTypesCommand
+    {
+        public enum CustomEnum
+        {
+            Value1 = 1,
+            Value2 = 2,
+            Value3 = 3
+        }
+
+        public class CustomStringConstructible
+        {
+            public string Value { get; }
+
+            public CustomStringConstructible(string value) => Value = value;
+        }
+
+        public class CustomStringParseable
+        {
+            public string Value { get; }
+
+            [JsonConstructor]
+            private CustomStringParseable(string value) => Value = value;
+
+            public static CustomStringParseable Parse(string value) => new CustomStringParseable(value);
+        }
+
+        public class CustomStringParseableWithFormatProvider
+        {
+            public string Value { get; }
+
+            [JsonConstructor]
+            private CustomStringParseableWithFormatProvider(string value) => Value = value;
+
+            public static CustomStringParseableWithFormatProvider Parse(string value, IFormatProvider formatProvider) =>
+                new CustomStringParseableWithFormatProvider(value + " " + formatProvider);
+        }
+    }
+}

CliFx.Tests/Commands/UnsupportedArgumentTypesCommand.cs

@@ -0,0 +1,31 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using CliFx.Attributes;
+
+namespace CliFx.Tests.Commands
+{
+    [Command("cmd")]
+    public partial class UnsupportedArgumentTypesCommand : SelfSerializeCommandBase
+    {
+        [CommandOption("str-non-initializable")]
+        public CustomType? StringNonInitializable { get; set; }
+
+        [CommandOption("str-enumerable-non-initializable")]
+        public CustomEnumerable<string>? StringEnumerableNonInitializable { get; set; }
+    }
+
+    public partial class UnsupportedArgumentTypesCommand
+    {
+        public class CustomType
+        {
+        }
+
+        public class CustomEnumerable<T> : IEnumerable<T>
+        {
+            public IEnumerator<T> GetEnumerator() => ((IEnumerable<T>) Array.Empty<T>()).GetEnumerator();
+
+            IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
+        }
+    }
+}

CliFx.Tests/Commands/WithDefaultValuesCommand.cs

@@ -0,0 +1,44 @@
+using System;
+using CliFx.Attributes;
+
+namespace CliFx.Tests.Commands
+{
+    [Command("cmd")]
+    public class WithDefaultValuesCommand : SelfSerializeCommandBase
+    {
+        public enum CustomEnum { Value1, Value2, Value3 };
+
+        [CommandOption("obj")]
+        public object? Object { get; set; } = 42;
+
+        [CommandOption("str")]
+        public string? String { get; set; } = "foo";
+
+        [CommandOption("str-empty")]
+        public string StringEmpty { get; set; } = "";
+
+        [CommandOption("str-array")]
+        public string[]? StringArray { get; set; } = { "foo", "bar", "baz" };
+
+        [CommandOption("bool")]
+        public bool Bool { get; set; } = true;
+
+        [CommandOption("char")]
+        public char Char { get; set; } = 't';
+
+        [CommandOption("int")]
+        public int Int { get; set; } = 1337;
+
+        [CommandOption("int-nullable")]
+        public int? IntNullable { get; set; } = 1337;
+
+        [CommandOption("int-array")]
+        public int[]? IntArray { get; set; } = { 1, 2, 3 };
+
+        [CommandOption("timespan")]
+        public TimeSpan TimeSpan { get; set; } = TimeSpan.FromMinutes(123);
+
+        [CommandOption("enum")]
+        public CustomEnum Enum { get; set; } = CustomEnum.Value2;
+    }
+}

CliFx.Tests/Commands/WithDependenciesCommand.cs

@@ -0,0 +1,28 @@
+using System.Threading.Tasks;
+using CliFx.Attributes;
+
+namespace CliFx.Tests.Commands
+{
+    [Command("cmd")]
+    public class WithDependenciesCommand : ICommand
+    {
+        public class DependencyA
+        {
+        }
+
+        public class DependencyB
+        {
+        }
+
+        private readonly DependencyA _dependencyA;
+        private readonly DependencyB _dependencyB;
+
+        public WithDependenciesCommand(DependencyA dependencyA, DependencyB dependencyB)
+        {
+            _dependencyA = dependencyA;
+            _dependencyB = dependencyB;
+        }
+
+        public ValueTask ExecuteAsync(IConsole console) => default;
+    }
+}

CliFx.Tests/Commands/WithEnumArgumentsCommand.cs

@@ -0,0 +1,19 @@
+using CliFx.Attributes;
+
+namespace CliFx.Tests.Commands
+{
+    [Command("cmd")]
+    public class WithEnumArgumentsCommand : SelfSerializeCommandBase
+    {
+        public enum CustomEnum { Value1, Value2, Value3 };
+
+        [CommandParameter(0, Name = "enum")]
+        public CustomEnum EnumParameter { get; set; }
+
+        [CommandOption("enum")]
+        public CustomEnum? EnumOption { get; set; }
+
+        [CommandOption("required-enum", IsRequired = true)]
+        public CustomEnum RequiredEnumOption { get; set; }
+    }
+}

CliFx.Tests/Commands/WithEnvironmentVariablesCommand.cs

@@ -0,0 +1,15 @@
+using System.Collections.Generic;
+using CliFx.Attributes;
+
+namespace CliFx.Tests.Commands
+{
+    [Command("cmd")]
+    public class WithEnvironmentVariablesCommand : SelfSerializeCommandBase
+    {
+        [CommandOption("opt-a", 'a', EnvironmentVariableName = "ENV_OPT_A")]
+        public string? OptA { get; set; }
+
+        [CommandOption("opt-b", 'b', EnvironmentVariableName = "ENV_OPT_B")]
+        public IReadOnlyList<string>? OptB { get; set; }
+    }
+}

CliFx.Tests/Commands/WithParametersCommand.cs

@@ -0,0 +1,18 @@
+using System.Collections.Generic;
+using CliFx.Attributes;
+
+namespace CliFx.Tests.Commands
+{
+    [Command("cmd")]
+    public class WithParametersCommand : SelfSerializeCommandBase
+    {
+        [CommandParameter(0)]
+        public string? ParamA { get; set; }
+
+        [CommandParameter(1)]
+        public int? ParamB { get; set; }
+
+        [CommandParameter(2)]
+        public IReadOnlyList<string>? ParamC { get; set; }
+    }
+}

CliFx.Tests/Commands/WithRequiredOptionsCommand.cs

@@ -0,0 +1,18 @@
+using System.Collections.Generic;
+using CliFx.Attributes;
+
+namespace CliFx.Tests.Commands
+{
+    [Command("cmd")]
+    public class WithRequiredOptionsCommand : SelfSerializeCommandBase
+    {
+        [CommandOption("opt-a", 'a', IsRequired = true)]
+        public string? OptA { get; set; }
+
+        [CommandOption("opt-b", 'b')]
+        public int? OptB { get; set; }
+
+        [CommandOption("opt-c", 'c', IsRequired = true)]
+        public IReadOnlyList<char>? OptC { get; set; }
+    }
+}

CliFx.Tests/Commands/WithSingleParameterCommand.cs

@@ -0,0 +1,11 @@
+using CliFx.Attributes;
+
+namespace CliFx.Tests.Commands
+{
+    [Command("cmd")]
+    public class WithSingleParameterCommand : SelfSerializeCommandBase
+    {
+        [CommandParameter(0)]
+        public string? ParamA { get; set; }
+    }
+}

CliFx.Tests/Commands/WithSingleRequiredOptionCommand.cs

@@ -0,0 +1,14 @@
+using CliFx.Attributes;
+
+namespace CliFx.Tests.Commands
+{
+    [Command("cmd")]
+    public class WithSingleRequiredOptionCommand : SelfSerializeCommandBase
+    {
+        [CommandOption("opt-a")]
+        public string? OptA { get; set; }
+
+        [CommandOption("opt-b", IsRequired = true)]
+        public string? OptB { get; set; }
+    }
+}

CliFx.Tests/Commands/WithStringArrayOptionCommand.cs

@@ -0,0 +1,12 @@
+using System.Collections.Generic;
+using CliFx.Attributes;
+
+namespace CliFx.Tests.Commands
+{
+    [Command("cmd")]
+    public class WithStringArrayOptionCommand : SelfSerializeCommandBase
+    {
+        [CommandOption("opt", 'o')]
+        public IReadOnlyList<string>? Opt { get; set; }
+    }
+}

CliFx.Tests/ConsoleSpecs.cs

@@ -0,0 +1,75 @@
+using System;
+using System.IO;
+using System.Threading.Tasks;
+using CliWrap;
+using CliWrap.Buffered;
+using FluentAssertions;
+using Xunit;
+
+namespace CliFx.Tests
+{
+    public class ConsoleSpecs
+    {
+        [Fact]
+        public async Task Real_implementation_of_console_maps_directly_to_system_console()
+        {
+            // Arrange
+            var command = "Hello world" | Cli.Wrap("dotnet")
+                .WithArguments(a => a
+                    .Add(Dummy.Program.Location)
+                    .Add("console-test"));
+
+            // Act
+            var result = await command.ExecuteBufferedAsync();
+
+            // Assert
+            result.StandardOutput.TrimEnd().Should().Be("Hello world");
+            result.StandardError.TrimEnd().Should().Be("Hello world");
+        }
+
+        [Fact]
+        public void Fake_implementation_of_console_can_be_used_to_execute_commands_in_isolation()
+        {
+            // Arrange
+            using var stdIn = new MemoryStream(Console.InputEncoding.GetBytes("input"));
+            using var stdOut = new MemoryStream();
+            using var stdErr = new MemoryStream();
+
+            var console = new VirtualConsole(
+                input: stdIn,
+                output: stdOut,
+                error: stdErr
+            );
+
+            // Act
+            console.Output.Write("output");
+            console.Error.Write("error");
+
+            var stdInData = console.Input.ReadToEnd();
+            var stdOutData = console.Output.Encoding.GetString(stdOut.ToArray());
+            var stdErrData = console.Error.Encoding.GetString(stdErr.ToArray());
+
+            console.ResetColor();
+            console.ForegroundColor = ConsoleColor.DarkMagenta;
+            console.BackgroundColor = ConsoleColor.DarkMagenta;
+            console.CursorLeft = 42;
+            console.CursorTop = 24;
+
+            // Assert
+            stdInData.Should().Be("input");
+            stdOutData.Should().Be("output");
+            stdErrData.Should().Be("error");
+
+            console.Input.Should().NotBeSameAs(Console.In);
+            console.Output.Should().NotBeSameAs(Console.Out);
+            console.Error.Should().NotBeSameAs(Console.Error);
+
+            console.IsInputRedirected.Should().BeTrue();
+            console.IsOutputRedirected.Should().BeTrue();
+            console.IsErrorRedirected.Should().BeTrue();
+
+            console.ForegroundColor.Should().NotBe(Console.ForegroundColor);
+            console.BackgroundColor.Should().NotBe(Console.BackgroundColor);
+        }
+    }
+}

CliFx.Tests/DelegateCommandFactoryTests.Commands.cs

@@ -1,15 +0,0 @@
-using System.Threading.Tasks;
-using CliFx.Attributes;
-using CliFx.Services;
-
-namespace CliFx.Tests
-{
-    public partial class DelegateCommandFactoryTests
-    {
-        [Command]
-        private class TestCommand : ICommand
-        {
-            public Task ExecuteAsync(IConsole console) => Task.CompletedTask;
-        }
-    }
-}

CliFx.Tests/DelegateCommandFactoryTests.cs

@@ -1,39 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using CliFx.Models;
-using CliFx.Services;
-using FluentAssertions;
-using NUnit.Framework;
-
-namespace CliFx.Tests
-{
-    [TestFixture]
-    public partial class DelegateCommandFactoryTests
-    {
-        private static CommandSchema GetCommandSchema(Type commandType) =>
-            new CommandSchemaResolver().GetCommandSchemas(new[] {commandType}).Single();
-
-        private static IEnumerable<TestCaseData> GetTestCases_CreateCommand()
-        {
-            yield return new TestCaseData(
-                new Func<CommandSchema, ICommand>(schema => (ICommand) Activator.CreateInstance(schema.Type)),
-                GetCommandSchema(typeof(TestCommand))
-            );
-        }
-
-        [Test]
-        [TestCaseSource(nameof(GetTestCases_CreateCommand))]
-        public void CreateCommand_Test(Func<CommandSchema, ICommand> factoryMethod, CommandSchema commandSchema)
-        {
-            // Arrange
-            var factory = new DelegateCommandFactory(factoryMethod);
-
-            // Act
-            var command = factory.CreateCommand(commandSchema);
-
-            // Assert
-            command.Should().BeOfType(commandSchema.Type);
-        }
-    }
-}

CliFx.Tests/DependencyInjectionSpecs.cs

@@ -0,0 +1,67 @@
+using CliFx.Exceptions;
+using CliFx.Tests.Commands;
+using FluentAssertions;
+using Xunit;
+using Xunit.Abstractions;
+
+namespace CliFx.Tests
+{
+    public class DependencyInjectionSpecs
+    {
+        private readonly ITestOutputHelper _output;
+
+        public DependencyInjectionSpecs(ITestOutputHelper output) => _output = output;
+
+        [Fact]
+        public void Default_type_activator_can_initialize_a_command_if_it_has_a_parameterless_constructor()
+        {
+            // Arrange
+            var activator = new DefaultTypeActivator();
+
+            // Act
+            var obj = activator.CreateInstance(typeof(DefaultCommand));
+
+            // Assert
+            obj.Should().BeOfType<DefaultCommand>();
+        }
+
+        [Fact]
+        public void Default_type_activator_cannot_initialize_a_command_if_it_does_not_have_a_parameterless_constructor()
+        {
+            // Arrange
+            var activator = new DefaultTypeActivator();
+
+            // Act & assert
+            var ex = Assert.Throws<CliFxException>(() => activator.CreateInstance(typeof(WithDependenciesCommand)));
+            _output.WriteLine(ex.Message);
+        }
+
+        [Fact]
+        public void Delegate_type_activator_can_initialize_a_command_using_a_custom_function()
+        {
+            // Arrange
+            var activator = new DelegateTypeActivator(_ =>
+                new WithDependenciesCommand(
+                    new WithDependenciesCommand.DependencyA(),
+                    new WithDependenciesCommand.DependencyB())
+            );
+
+            // Act
+            var obj = activator.CreateInstance(typeof(WithDependenciesCommand));
+
+            // Assert
+            obj.Should().BeOfType<WithDependenciesCommand>();
+        }
+
+        [Fact]
+        public void Delegate_type_activator_throws_if_the_underlying_function_returns_null()
+        {
+            // Arrange
+            var activator = new DelegateTypeActivator(_ => null!);
+
+            // Act & assert
+            var ex = Assert.Throws<CliFxException>(() => activator.CreateInstance(typeof(WithDependenciesCommand)));
+            _output.WriteLine(ex.Message);
+        }
+    }
+}

CliFx.Tests/DirectivesSpecs.cs

@@ -0,0 +1,43 @@
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using CliFx.Tests.Commands;
+using FluentAssertions;
+using Xunit;
+using Xunit.Abstractions;
+
+namespace CliFx.Tests
+{
+    public class DirectivesSpecs
+    {
+        private readonly ITestOutputHelper _output;
+
+        public DirectivesSpecs(ITestOutputHelper output) => _output = output;
+
+        [Fact]
+        public async Task Preview_directive_can_be_specified_to_print_provided_arguments_as_they_were_parsed()
+        {
+            // Arrange
+            var (console, stdOut, _) = VirtualConsole.CreateBuffered();
+
+            var application = new CliApplicationBuilder()
+                .AddCommand<NamedCommand>()
+                .UseConsole(console)
+                .AllowPreviewMode()
+                .Build();
+
+            // Act
+            var exitCode = await application.RunAsync(
+                new[] {"[preview]", "named", "param", "-abc", "--option", "foo"},
+                new Dictionary<string, string>());
+
+            // Assert
+            exitCode.Should().Be(0);
+            stdOut.GetString().Should().ContainAll(
+                "named", "<param>", "[-a]", "[-b]", "[-c]", "[--option \"foo\"]"
+            );
+
+            _output.WriteLine(stdOut.GetString());
+        }
+    }
+}

CliFx.Tests/DummyTests.cs

@@ -1,73 +0,0 @@
-using System.Threading.Tasks;
-using CliWrap;
-using FluentAssertions;
-using NUnit.Framework;
-
-namespace CliFx.Tests
-{
-    [TestFixture]
-    public class DummyTests
-    {
-        private static string DummyFilePath => typeof(Dummy.Program).Assembly.Location;
-
-        private static string DummyVersionText => typeof(Dummy.Program).Assembly.GetName().Version.ToString();
-
-        [Test]
-        [TestCase("", "Hello world")]
-        [TestCase("-t .NET", "Hello .NET")]
-        [TestCase("-e", "Hello world!")]
-        [TestCase("sum -v 1 2", "3")]
-        [TestCase("sum -v 2.75 3.6 4.18", "10.53")]
-        [TestCase("sum -v 4 -v 16", "20")]
-        [TestCase("sum --values 2 5 --values 3", "10")]
-        [TestCase("log -v 100", "2")]
-        [TestCase("log --value 256 --base 2", "8")]
-        public async Task CliApplication_RunAsync_Test(string arguments, string expectedOutput)
-        {
-            // Arrange & Act
-            var result = await Cli.Wrap(DummyFilePath)
-                .SetArguments(arguments)
-                .EnableExitCodeValidation()
-                .EnableStandardErrorValidation()
-                .ExecuteAsync();
-
-            // Assert
-            result.StandardOutput.Trim().Should().Be(expectedOutput);
-        }
-
-        [Test]
-        [TestCase("--version")]
-        public async Task CliApplication_RunAsync_ShowVersion_Test(string arguments)
-        {
-            // Arrange & Act
-            var result = await Cli.Wrap(DummyFilePath)
-                .SetArguments(arguments)
-                .EnableExitCodeValidation()
-                .EnableStandardErrorValidation()
-                .ExecuteAsync();
-
-            // Assert
-            result.StandardOutput.Trim().Should().Be(DummyVersionText);
-        }
-
-        [Test]
-        [TestCase("--help")]
-        [TestCase("-h")]
-        [TestCase("sum -h")]
-        [TestCase("sum --help")]
-        [TestCase("log -h")]
-        [TestCase("log --help")]
-        public async Task CliApplication_RunAsync_ShowHelp_Test(string arguments)
-        {
-            // Arrange & Act
-            var result = await Cli.Wrap(DummyFilePath)
-                .SetArguments(arguments)
-                .EnableExitCodeValidation()
-                .EnableStandardErrorValidation()
-                .ExecuteAsync();
-
-            // Assert
-            result.StandardOutput.Trim().Should().NotBeNullOrWhiteSpace();
-        }
-    }
-}

CliFx.Tests/EnvironmentVariablesSpecs.cs

@@ -0,0 +1,141 @@
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using CliFx.Tests.Commands;
+using CliFx.Tests.Internal;
+using CliWrap;
+using CliWrap.Buffered;
+using FluentAssertions;
+using Xunit;
+
+namespace CliFx.Tests
+{
+    public class EnvironmentVariablesSpecs
+    {
+        // This test uses a real application to make sure environment variables are actually read correctly
+        [Fact]
+        public async Task Option_can_use_an_environment_variable_as_fallback()
+        {
+            // Arrange
+            var command = Cli.Wrap("dotnet")
+                .WithArguments(a => a
+                    .Add(Dummy.Program.Location))
+                .WithEnvironmentVariables(e => e
+                    .Set("ENV_TARGET", "Mars"));
+
+            // Act
+            var stdOut = await command.ExecuteBufferedAsync().Select(r => r.StandardOutput);
+
+            // Assert
+            stdOut.Trim().Should().Be("Hello Mars!");
+        }
+
+        // This test uses a real application to make sure environment variables are actually read correctly
+        [Fact]
+        public async Task Option_only_uses_an_environment_variable_as_fallback_if_the_value_is_not_directly_provided()
+        {
+            // Arrange
+            var command = Cli.Wrap("dotnet")
+                .WithArguments(a => a
+                    .Add(Dummy.Program.Location)
+                    .Add("--target")
+                    .Add("Jupiter"))
+                .WithEnvironmentVariables(e => e
+                    .Set("ENV_TARGET", "Mars"));
+
+            // Act
+            var stdOut = await command.ExecuteBufferedAsync().Select(r => r.StandardOutput);
+
+            // Assert
+            stdOut.Trim().Should().Be("Hello Jupiter!");
+        }
+
+        [Fact]
+        public async Task Option_only_uses_an_environment_variable_as_fallback_if_the_name_matches_case_sensitively()
+        {
+            var (console, stdOut, _) = VirtualConsole.CreateBuffered();
+
+            var application = new CliApplicationBuilder()
+                .AddCommand<WithEnvironmentVariablesCommand>()
+                .UseConsole(console)
+                .Build();
+
+            // Act
+            var exitCode = await application.RunAsync(
+                new[] {"cmd"},
+                new Dictionary<string, string>
+                {
+                    ["ENV_opt_A"] = "incorrect",
+                    ["ENV_OPT_A"] = "correct"
+                }
+            );
+
+            var commandInstance = stdOut.GetString().DeserializeJson<WithEnvironmentVariablesCommand>();
+
+            // Assert
+            exitCode.Should().Be(0);
+            commandInstance.Should().BeEquivalentTo(new WithEnvironmentVariablesCommand
+            {
+                OptA = "correct"
+            });
+        }
+
+        [Fact]
+        public async Task Option_of_non_scalar_type_can_use_an_environment_variable_as_fallback_and_extract_multiple_values()
+        {
+            var (console, stdOut, _) = VirtualConsole.CreateBuffered();
+
+            var application = new CliApplicationBuilder()
+                .AddCommand<WithEnvironmentVariablesCommand>()
+                .UseConsole(console)
+                .Build();
+
+            // Act
+            var exitCode = await application.RunAsync(
+                new[] {"cmd"},
+                new Dictionary<string, string>
+                {
+                    ["ENV_OPT_B"] = $"foo{Path.PathSeparator}bar"
+                }
+            );
+
+            var commandInstance = stdOut.GetString().DeserializeJson<WithEnvironmentVariablesCommand>();
+
+            // Assert
+            exitCode.Should().Be(0);
+            commandInstance.Should().BeEquivalentTo(new WithEnvironmentVariablesCommand
+            {
+                OptB = new[] {"foo", "bar"}
+            });
+        }
+
+        [Fact]
+        public async Task Option_of_scalar_type_can_use_an_environment_variable_as_fallback_regardless_of_separators()
+        {
+            var (console, stdOut, _) = VirtualConsole.CreateBuffered();
+
+            var application = new CliApplicationBuilder()
+                .AddCommand<WithEnvironmentVariablesCommand>()
+                .UseConsole(console)
+                .Build();
+
+            // Act
+            var exitCode = await application.RunAsync(
+                new[] {"cmd"},
+                new Dictionary<string, string>
+                {
+                    ["ENV_OPT_A"] = $"foo{Path.PathSeparator}bar"
+                }
+            );
+
+            var commandInstance = stdOut.GetString().DeserializeJson<WithEnvironmentVariablesCommand>();
+
+            // Assert
+            exitCode.Should().Be(0);
+            commandInstance.Should().BeEquivalentTo(new WithEnvironmentVariablesCommand
+            {
+                OptA = $"foo{Path.PathSeparator}bar"
+            });
+        }
+    }
+}