GeneratorTests.cs

using System;
using System.Linq;
using AutomaticInterface;
using FluentAssertions;
using Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.CSharp;
using Xunit;

namespace Tests;

public partial class GeneratorTests
{
    private static string GenerateCode(string code)
    {
        var syntaxTree = CSharpSyntaxTree.ParseText(code);
        var references = AppDomain
            .CurrentDomain.GetAssemblies()
            .Where(assembly => !assembly.IsDynamic)
            .Select(assembly => MetadataReference.CreateFromFile(assembly.Location))
            .Cast<MetadataReference>();

        var compilation = CSharpCompilation.Create(
            "SourceGeneratorTests",
            new[] { syntaxTree },
            references,
            new(OutputKind.DynamicallyLinkedLibrary)
        );

        // defensive check to avoid errors in the source text, which can happen with manually written code
        var sourceDiagnostics = compilation.GetDiagnostics();
        sourceDiagnostics
            .Where(d => d.Severity == DiagnosticSeverity.Error)
            .Where(x => x.Id != "CS0246") // missing references are ok
            .Should()
            .BeEmpty();

        var generator = new AutomaticInterfaceGenerator();

        CSharpGeneratorDriver
            .Create(generator)
            .RunGeneratorsAndUpdateCompilation(
                compilation,
                out var outputCompilation,
                out var diagnostics
            );

        diagnostics.Where(d => d.Severity == DiagnosticSeverity.Error).Should().BeEmpty();

        return outputCompilation.SyntaxTrees.Skip(1).LastOrDefault()?.ToString();
    }

    [Fact]
    public void WorksWithOptionalParameters()
    {
        const string code = """

            using AutomaticInterface;

            namespace AutomaticInterfaceExample;

            [GenerateAutomaticInterface]
            public class DemoClass
            {
                    public bool TryStartTransaction(
                        string file = "",
                        string member = "",
                        int line = 0,
                        bool notify = true)
                    {
            return true;
            }
            }


            """;
        const string expected = """
            //--------------------------------------------------------------------------------------------------
            // <auto-generated>
            //     This code was generated by a tool.
            //
            //     Changes to this file may cause incorrect behavior and will be lost if the code is regenerated.
            // </auto-generated>
            //--------------------------------------------------------------------------------------------------

            namespace AutomaticInterfaceExample
            {
                [global::System.CodeDom.Compiler.GeneratedCode("AutomaticInterface", "")]
                public partial interface IDemoClass
                {
                    /// <inheritdoc cref="AutomaticInterfaceExample.DemoClass.TryStartTransaction(string, string, int, bool)" />
                    bool TryStartTransaction(string file = "", string member = "", int line = 0, bool notify = true);
                    
                }
            }

            """;
        GenerateCode(code).Should().Be(expected);
    }

    [Fact]
    public void WorksWithParamsParameters()
    {
        const string code = """

            using AutomaticInterface;

            namespace AutomaticInterfaceExample;

            [GenerateAutomaticInterface]
            public class DemoClass
            {
                public void AMethod(params int[] numbers)
                {
                }
            }


            """;
        const string expected = """
            //--------------------------------------------------------------------------------------------------
            // <auto-generated>
            //     This code was generated by a tool.
            //
            //     Changes to this file may cause incorrect behavior and will be lost if the code is regenerated.
            // </auto-generated>
            //--------------------------------------------------------------------------------------------------

            namespace AutomaticInterfaceExample
            {
                [global::System.CodeDom.Compiler.GeneratedCode("AutomaticInterface", "")]
                public partial interface IDemoClass
                {
                    /// <inheritdoc cref="AutomaticInterfaceExample.DemoClass.AMethod(params int[])" />
                    void AMethod(params int[] numbers);
                    
                }
            }

            """;
        GenerateCode(code).Should().Be(expected);
    }

    [Fact]
    public void WorksWithOptionalStructParameters()
    {
        const string code = """

            using AutomaticInterface;

            namespace AutomaticInterfaceExample;

            public struct MyStruct
            {
                private int Bar;
            }

            [GenerateAutomaticInterface]
            public class DemoClass
            {
                    public bool TryStartTransaction(MyStruct data = default(MyStruct))
                    {
            return true;
            }
            }


            """;
        const string expected = """
            //--------------------------------------------------------------------------------------------------
            // <auto-generated>
            //     This code was generated by a tool.
            //
            //     Changes to this file may cause incorrect behavior and will be lost if the code is regenerated.
            // </auto-generated>
            //--------------------------------------------------------------------------------------------------

            namespace AutomaticInterfaceExample
            {
                [global::System.CodeDom.Compiler.GeneratedCode("AutomaticInterface", "")]
                public partial interface IDemoClass
                {
                    /// <inheritdoc cref="AutomaticInterfaceExample.DemoClass.TryStartTransaction(AutomaticInterfaceExample.MyStruct)" />
                    bool TryStartTransaction(global::AutomaticInterfaceExample.MyStruct data = default(global::AutomaticInterfaceExample.MyStruct));
                    
                }
            }

            """;
        GenerateCode(code).Should().Be(expected);
    }

    [Fact]
    public void WorksWithOptionalNullParameters()
    {
        const string code = """

            using AutomaticInterface;

            namespace AutomaticInterfaceExample;

            [GenerateAutomaticInterface]
            public class DemoClass
            {
                    public bool TryStartTransaction(string data = null)
                    {
            return true;
            }
            }


            """;
        const string expected = """
            //--------------------------------------------------------------------------------------------------
            // <auto-generated>
            //     This code was generated by a tool.
            //
            //     Changes to this file may cause incorrect behavior and will be lost if the code is regenerated.
            // </auto-generated>
            //--------------------------------------------------------------------------------------------------

            namespace AutomaticInterfaceExample
            {
                [global::System.CodeDom.Compiler.GeneratedCode("AutomaticInterface", "")]
                public partial interface IDemoClass
                {
                    /// <inheritdoc cref="AutomaticInterfaceExample.DemoClass.TryStartTransaction(string)" />
                    bool TryStartTransaction(string data = null);
                    
                }
            }

            """;
        GenerateCode(code).Should().Be(expected);
    }

    [Fact]
    public void GeneratesEmptyInterface()
    {
        const string code = """

            using AutomaticInterface;

            namespace AutomaticInterfaceExample
            {
                [GenerateAutomaticInterface]
                class DemoClass
                {
                                 }
            }

            """;

        const string expected = """
            //--------------------------------------------------------------------------------------------------
            // <auto-generated>
            //     This code was generated by a tool.
            //
            //     Changes to this file may cause incorrect behavior and will be lost if the code is regenerated.
            // </auto-generated>
            //--------------------------------------------------------------------------------------------------

            namespace AutomaticInterfaceExample
            {
                [global::System.CodeDom.Compiler.GeneratedCode("AutomaticInterface", "")]
                public partial interface IDemoClass
                {
                }
            }

            """;

        GenerateCode(code).Should().Be(expected);
    }

    [Fact]
    public void AddsPublicMethodToInterface()
    {
        const string code = """

            using AutomaticInterface;

            namespace AutomaticInterfaceExample
            {

                [GenerateAutomaticInterface]
                class DemoClass
                {
                              
                    public string Hello(){return "";}
                }
            }

            """;

        const string expected = """
            //--------------------------------------------------------------------------------------------------
            // <auto-generated>
            //     This code was generated by a tool.
            //
            //     Changes to this file may cause incorrect behavior and will be lost if the code is regenerated.
            // </auto-generated>
            //--------------------------------------------------------------------------------------------------

            namespace AutomaticInterfaceExample
            {
                [global::System.CodeDom.Compiler.GeneratedCode("AutomaticInterface", "")]
                public partial interface IDemoClass
                {
                    /// <inheritdoc cref="AutomaticInterfaceExample.DemoClass.Hello()" />
                    string Hello();
                    
                }
            }

            """;
        GenerateCode(code).Should().Be(expected);
    }

    [Fact]
    public void AddsPublicTaskMethodToInterface()
    {
        const string code = """

            using AutomaticInterface;
            using System.IO;
            using System.Threading.Tasks;

            namespace AutomaticInterfaceExample
            {

                [GenerateAutomaticInterface]
                class DemoClass
                {
                   public async Task<string> Hello(){return "";}
                }
            }

            """;

        const string expected = """
            //--------------------------------------------------------------------------------------------------
            // <auto-generated>
            //     This code was generated by a tool.
            //
            //     Changes to this file may cause incorrect behavior and will be lost if the code is regenerated.
            // </auto-generated>
            //--------------------------------------------------------------------------------------------------

            namespace AutomaticInterfaceExample
            {
                [global::System.CodeDom.Compiler.GeneratedCode("AutomaticInterface", "")]
                public partial interface IDemoClass
                {
                    /// <inheritdoc cref="AutomaticInterfaceExample.DemoClass.Hello()" />
                    global::System.Threading.Tasks.Task<string> Hello();
                    
                }
            }

            """;
        GenerateCode(code).Should().Be(expected);
    }

    [Fact]
    public void AddsPublicWithParamsMethodToInterface()
    {
        const string code = """

            using AutomaticInterface;
            using System.IO;

            namespace AutomaticInterfaceExample
            {

                [GenerateAutomaticInterface]
                class DemoClass
                {
                              
                    public string Hello(string x){return x;}
                }
            }

            """;

        const string expected = """
            //--------------------------------------------------------------------------------------------------
            // <auto-generated>
            //     This code was generated by a tool.
            //
            //     Changes to this file may cause incorrect behavior and will be lost if the code is regenerated.
            // </auto-generated>
            //--------------------------------------------------------------------------------------------------

            namespace AutomaticInterfaceExample
            {
                [global::System.CodeDom.Compiler.GeneratedCode("AutomaticInterface", "")]
                public partial interface IDemoClass
                {
                    /// <inheritdoc cref="AutomaticInterfaceExample.DemoClass.Hello(string)" />
                    string Hello(string x);
                    
                }
            }

            """;
        GenerateCode(code).Should().Be(expected);
    }

    [Fact]
    public void AddsPublicWithParamsGenericMethodToInterface()
    {
        const string code = """

            using AutomaticInterface;
            using System.IO;
            using System.Threading.Tasks;

            namespace AutomaticInterfaceExample
            {

                [GenerateAutomaticInterface]
                class DemoClass
                {
                    public string Hello(Task<string> x){return "";}
                }
            }

            """;

        const string expected = """
            //--------------------------------------------------------------------------------------------------
            // <auto-generated>
            //     This code was generated by a tool.
            //
            //     Changes to this file may cause incorrect behavior and will be lost if the code is regenerated.
            // </auto-generated>
            //--------------------------------------------------------------------------------------------------

            namespace AutomaticInterfaceExample
            {
                [global::System.CodeDom.Compiler.GeneratedCode("AutomaticInterface", "")]
                public partial interface IDemoClass
                {
                    /// <inheritdoc cref="AutomaticInterfaceExample.DemoClass.Hello(System.Threading.Tasks.Task{string})" />
                    string Hello(global::System.Threading.Tasks.Task<string> x);
                    
                }
            }

            """;
        GenerateCode(code).Should().Be(expected);
    }

    [Fact]
    public void AddsPublicWithMultipleParamsMethodToInterface()
    {
        const string code = """

            using AutomaticInterface;
            using System.IO;

            namespace AutomaticInterfaceExample
            {

                [GenerateAutomaticInterface]
                class DemoClass
                {
                    public string Hello(string x, int y, double z){return x;}
                }
            }

            """;

        const string expected = """
            //--------------------------------------------------------------------------------------------------
            // <auto-generated>
            //     This code was generated by a tool.
            //
            //     Changes to this file may cause incorrect behavior and will be lost if the code is regenerated.
            // </auto-generated>
            //--------------------------------------------------------------------------------------------------

            namespace AutomaticInterfaceExample
            {
                [global::System.CodeDom.Compiler.GeneratedCode("AutomaticInterface", "")]
                public partial interface IDemoClass
                {
                    /// <inheritdoc cref="AutomaticInterfaceExample.DemoClass.Hello(string, int, double)" />
                    string Hello(string x, int y, double z);
                    
                }
            }

            """;
        GenerateCode(code).Should().Be(expected);
    }

    [Fact]
    public void IgnoresNotPublicMethodToInterface()
    {
        const string code = """

            using AutomaticInterface;
            using System.IO;

            namespace AutomaticInterfaceExample
            {

                [GenerateAutomaticInterface]
                class DemoClass
                {
                    private string Hello(string x, int y, double z){return x;}
                    internal string Hello2(string x, int y, double z){return x;}
                }
            }

            """;

        const string expected = """
            //--------------------------------------------------------------------------------------------------
            // <auto-generated>
            //     This code was generated by a tool.
            //
            //     Changes to this file may cause incorrect behavior and will be lost if the code is regenerated.
            // </auto-generated>
            //--------------------------------------------------------------------------------------------------

            namespace AutomaticInterfaceExample
            {
                [global::System.CodeDom.Compiler.GeneratedCode("AutomaticInterface", "")]
                public partial interface IDemoClass
                {
                }
            }

            """;
        GenerateCode(code).Should().Be(expected);
    }

    [Fact]
    public void IgnoresMembersAttributedWithIgnore()
    {
        const string code = """

            using AutomaticInterface;
            using System;
            using System.IO;

            namespace AutomaticInterfaceExample
            {

                [GenerateAutomaticInterface]
                class DemoClass
                {
                    [IgnoreAutomaticInterface] public string Hello1(string x, int y, double z){return x;}
                    [IgnoreAutomaticInterface] public string Hello2 { get; set; }
                    [IgnoreAutomaticInterface] public event EventHandler Hello3;
                }
            }

            """;

        const string expected = """
            //--------------------------------------------------------------------------------------------------
            // <auto-generated>
            //     This code was generated by a tool.
            //
            //     Changes to this file may cause incorrect behavior and will be lost if the code is regenerated.
            // </auto-generated>
            //--------------------------------------------------------------------------------------------------

            namespace AutomaticInterfaceExample
            {
                [global::System.CodeDom.Compiler.GeneratedCode("AutomaticInterface", "")]
                public partial interface IDemoClass
                {
                }
            }

            """;
        GenerateCode(code).Should().Be(expected);
    }

    [Fact]
    public void AddsDescriptionFromMethodToInterface()
    {
        const string code = """

            using AutomaticInterface;
            using System.IO;

            namespace AutomaticInterfaceExample
            {

                [GenerateAutomaticInterface]
                class DemoClass
                {

                    /// <summary>
                    /// TEST
                    /// </summary>
                    /// <returns></returns>
                    public string Hello(string x){return x;}
                }
            }

            """;

        const string expected = """
            //--------------------------------------------------------------------------------------------------
            // <auto-generated>
            //     This code was generated by a tool.
            //
            //     Changes to this file may cause incorrect behavior and will be lost if the code is regenerated.
            // </auto-generated>
            //--------------------------------------------------------------------------------------------------

            namespace AutomaticInterfaceExample
            {
                [global::System.CodeDom.Compiler.GeneratedCode("AutomaticInterface", "")]
                public partial interface IDemoClass
                {
                    /// <inheritdoc cref="AutomaticInterfaceExample.DemoClass.Hello(string)" />
                    string Hello(string x);
                    
                }
            }

            """;
        GenerateCode(code).Should().Be(expected);
    }

    [Fact]
    public void AddsMultiLineDescriptionFromMethodToInterface()
    {
        const string code = """

            using AutomaticInterface;
            using System.IO;

            namespace AutomaticInterfaceExample
            {

                [GenerateAutomaticInterface]
                class DemoClass
                {

                    /**
                     * <summary>Hello World!</summary>
                     */
                    public string Hello(string x){return x;}
                }
            }

            """;

        const string expected = """
            //--------------------------------------------------------------------------------------------------
            // <auto-generated>
            //     This code was generated by a tool.
            //
            //     Changes to this file may cause incorrect behavior and will be lost if the code is regenerated.
            // </auto-generated>
            //--------------------------------------------------------------------------------------------------

            namespace AutomaticInterfaceExample
            {
                [global::System.CodeDom.Compiler.GeneratedCode("AutomaticInterface", "")]
                public partial interface IDemoClass
                {
                    /// <inheritdoc cref="AutomaticInterfaceExample.DemoClass.Hello(string)" />
                    string Hello(string x);
                    
                }
            }

            """;
        GenerateCode(code).Should().Be(expected);
    }

    [Fact]
    public void CopiesDocumentationOfClassToInterface()
    {
        const string code = """

            using AutomaticInterface;

            namespace AutomaticInterfaceExample
            {
                    /// <summary>
                    /// Bla bla
                    /// </summary>
                [GenerateAutomaticInterface]
                class DemoClass
                {
                    public string Hello { get; private set; }
                }
            }

            """;

        const string expected = """
            //--------------------------------------------------------------------------------------------------
            // <auto-generated>
            //     This code was generated by a tool.
            //
            //     Changes to this file may cause incorrect behavior and will be lost if the code is regenerated.
            // </auto-generated>
            //--------------------------------------------------------------------------------------------------

            namespace AutomaticInterfaceExample
            {
                /// <summary>
                /// Bla bla
                /// </summary>
                [global::System.CodeDom.Compiler.GeneratedCode("AutomaticInterface", "")]
                public partial interface IDemoClass
                {
                    /// <inheritdoc cref="AutomaticInterfaceExample.DemoClass.Hello" />
                    string Hello { get; }
                    
                }
            }

            """;
        GenerateCode(code).Should().Be(expected);
    }

    [Fact]
    public void DoesNotCopyCtorToToInterface()
    {
        const string code = """

            using AutomaticInterface;

            namespace AutomaticInterfaceExample
            {
                    /// <summary>
                    /// Bla bla
                    /// </summary>
                [GenerateAutomaticInterface]
                class DemoClass
                {
                    DemoClass(string x)
                    {

                    }

                    public string Hello { get; private set; }
                }
            }

            """;

        const string expected = """
            //--------------------------------------------------------------------------------------------------
            // <auto-generated>
            //     This code was generated by a tool.
            //
            //     Changes to this file may cause incorrect behavior and will be lost if the code is regenerated.
            // </auto-generated>
            //--------------------------------------------------------------------------------------------------

            namespace AutomaticInterfaceExample
            {
                /// <summary>
                /// Bla bla
                /// </summary>
                [global::System.CodeDom.Compiler.GeneratedCode("AutomaticInterface", "")]
                public partial interface IDemoClass
                {
                    /// <inheritdoc cref="AutomaticInterfaceExample.DemoClass.Hello" />
                    string Hello { get; }
                    
                }
            }

            """;
        GenerateCode(code).Should().Be(expected);
    }

    [Fact]
    public void DoesNotCopyStaticMethodsToInterface()
    {
        const string code = """

            using AutomaticInterface;

            namespace AutomaticInterfaceExample
            {
                    /// <summary>
                    /// Bla bla
                    /// </summary>
                [GenerateAutomaticInterface]
                class DemoClass
                {
                    public static string Hello => "abc"; // property

                    public static string StaticMethod()  // method
                    {
                        return "static";
                   }
                }
            }

            """;

        const string expected = """
            //--------------------------------------------------------------------------------------------------
            // <auto-generated>
            //     This code was generated by a tool.
            //
            //     Changes to this file may cause incorrect behavior and will be lost if the code is regenerated.
            // </auto-generated>
            //--------------------------------------------------------------------------------------------------

            namespace AutomaticInterfaceExample
            {
                /// <summary>
                /// Bla bla
                /// </summary>
                [global::System.CodeDom.Compiler.GeneratedCode("AutomaticInterface", "")]
                public partial interface IDemoClass
                {
                }
            }

            """;
        GenerateCode(code).Should().Be(expected);
    }

    [Fact]
    public void MakesGenericInterface()
    {
        const string code = """

            using AutomaticInterface;

            namespace AutomaticInterfaceExample
            {
                    /// <summary>
                    /// Bla bla
                    /// </summary>
                [GenerateAutomaticInterface]
                class DemoClass<T,U> where T:class
                {
                }
            }

            """;

        const string expected = """
            //--------------------------------------------------------------------------------------------------
            // <auto-generated>
            //     This code was generated by a tool.
            //
            //     Changes to this file may cause incorrect behavior and will be lost if the code is regenerated.
            // </auto-generated>
            //--------------------------------------------------------------------------------------------------

            namespace AutomaticInterfaceExample
            {
                /// <summary>
                /// Bla bla
                /// </summary>
                [global::System.CodeDom.Compiler.GeneratedCode("AutomaticInterface", "")]
                public partial interface IDemoClass<T,U> where T:class
                {
                }
            }

            """;
        GenerateCode(code).Should().Be(expected);
    }

    [Fact]
    public void CopiesEventsToInterface()
    {
        const string code = """

            using AutomaticInterface;
            using System;

            namespace AutomaticInterfaceExample
            {
                    /// <summary>
                    /// Bla bla
                    /// </summary>
                [GenerateAutomaticInterface]
                class DemoClass
                {

                    /// <summary>
                    /// Bla bla
                    /// </summary>
                    public event EventHandler ShapeChanged;  // included

                    private event EventHandler ShapeChanged2; // ignored because not public
                }
            }

            """;

        const string expected = """
            //--------------------------------------------------------------------------------------------------
            // <auto-generated>
            //     This code was generated by a tool.
            //
            //     Changes to this file may cause incorrect behavior and will be lost if the code is regenerated.
            // </auto-generated>
            //--------------------------------------------------------------------------------------------------

            namespace AutomaticInterfaceExample
            {
                /// <summary>
                /// Bla bla
                /// </summary>
                [global::System.CodeDom.Compiler.GeneratedCode("AutomaticInterface", "")]
                public partial interface IDemoClass
                {
                    /// <inheritdoc cref="AutomaticInterfaceExample.DemoClass.ShapeChanged" />
                    event global::System.EventHandler ShapeChanged;
                    
                }
            }

            """;
        GenerateCode(code).Should().Be(expected);
    }

    [Fact]
    public void DoesNotCopyIndexerToInterface()
    {
        const string code = """

            using AutomaticInterface;
            using System;

            namespace AutomaticInterfaceExample
            {
                    /// <summary>
                    /// Bla bla
                    /// </summary>
                [GenerateAutomaticInterface]
                class DemoClass
                {

                    private int[] arr = new int[100];

                    /// <summary>
                    /// Bla bla
                    /// </summary>
                    public int this[int index] // currently ignored
                    {
                        get => arr[index];
                        set => arr[index] = value;
                    }
                }
            }

            """;

        const string expected = """
            //--------------------------------------------------------------------------------------------------
            // <auto-generated>
            //     This code was generated by a tool.
            //
            //     Changes to this file may cause incorrect behavior and will be lost if the code is regenerated.
            // </auto-generated>
            //--------------------------------------------------------------------------------------------------

            namespace AutomaticInterfaceExample
            {
                /// <summary>
                /// Bla bla
                /// </summary>
                [global::System.CodeDom.Compiler.GeneratedCode("AutomaticInterface", "")]
                public partial interface IDemoClass
                {
                }
            }

            """;
        GenerateCode(code).Should().Be(expected);
    }

    [Fact]
    public void FullExample()
    {
        const string code = """

            using AutomaticInterface;
            using System;

            namespace AutomaticInterfaceExample
            {
                    /// <summary>
                    /// Bla bla
                    /// </summary>
                [GenerateAutomaticInterface]
                class DemoClass
                {
                    /// <summary>
                    /// Property Documentation will be copied
                    /// </summary>
                    public string Hello { get; set; }  // included, get and set are copied to the interface when public

                    public string OnlyGet { get; } // included, get and set are copied to the interface when public

                    /// <summary>
                    /// Method Documentation will be copied
                    /// </summary>
                    public string AMethod(string x, string y) // included
                    {
                        return BMethod(x,y);
                    }

                    private string BMethod(string x, string y) // ignored because not public
                    {
                        return x + y;
                    }

                    public static string StaticProperty => "abc"; // static property, ignored

                    public static string StaticMethod()  // static method, ignored
                        {
                            return "static" + DateTime.Now;
                        }

                    /// <summary>
                    /// event Documentation will be copied
                    /// </summary>

                    public event EventHandler ShapeChanged;  // included

                    private event EventHandler ShapeChanged2; // ignored because not public

                    private readonly int[] arr = new int[100];

                    public int this[int index] // currently ignored
                    {
                        get => arr[index];
                        set => arr[index] = value;
                    }
                }
            }

            """;

        const string expected = """
            //--------------------------------------------------------------------------------------------------
            // <auto-generated>
            //     This code was generated by a tool.
            //
            //     Changes to this file may cause incorrect behavior and will be lost if the code is regenerated.
            // </auto-generated>
            //--------------------------------------------------------------------------------------------------

            namespace AutomaticInterfaceExample
            {
                /// <summary>
                /// Bla bla
                /// </summary>
                [global::System.CodeDom.Compiler.GeneratedCode("AutomaticInterface", "")]
                public partial interface IDemoClass
                {
                    /// <inheritdoc cref="AutomaticInterfaceExample.DemoClass.Hello" />
                    string Hello { get; set; }
                    
                    /// <inheritdoc cref="AutomaticInterfaceExample.DemoClass.OnlyGet" />
                    string OnlyGet { get; }
                    
                    /// <inheritdoc cref="AutomaticInterfaceExample.DemoClass.AMethod(string, string)" />
                    string AMethod(string x, string y);
                    
                    /// <inheritdoc cref="AutomaticInterfaceExample.DemoClass.ShapeChanged" />
                    event global::System.EventHandler ShapeChanged;
                    
                }
            }

            """;
        GenerateCode(code).Should().Be(expected);
    }

    [Fact]
    public void WorksWithGenericMethods()
    {
        const string code = """

            using AutomaticInterface;

            namespace AutomaticInterfaceExample;

            [GenerateAutomaticInterface]
            public class DemoClass
            {
                /// <inheritdoc />
                public string CMethod<T, T1, T2, T3, T4, T5>(string x, string y)
                    where T : class
                    where T1 : struct
                    where T3 : DemoClass
                    where T4 : IDemoClass
                    where T5 : new()
                {
                    return "Ok";
                }
            }


            """;

        const string expected = """
            //--------------------------------------------------------------------------------------------------
            // <auto-generated>
            //     This code was generated by a tool.
            //
            //     Changes to this file may cause incorrect behavior and will be lost if the code is regenerated.
            // </auto-generated>
            //--------------------------------------------------------------------------------------------------

            namespace AutomaticInterfaceExample
            {
                [global::System.CodeDom.Compiler.GeneratedCode("AutomaticInterface", "")]
                public partial interface IDemoClass
                {
                    /// <inheritdoc cref="AutomaticInterfaceExample.DemoClass.CMethod{T, T1, T2, T3, T4, T5}(string, string)" />
                    string CMethod<T, T1, T2, T3, T4, T5>(string x, string y) where T : class where T1 : struct where T3 : global::AutomaticInterfaceExample.DemoClass where T4 : IDemoClass where T5 : new();
                    
                }
            }

            """;
        GenerateCode(code).Should().Be(expected);
    }

    [Fact]
    public void GeneratesOverloadedMethodInterface()
    {
        const string code = """

            using AutomaticInterface;

            namespace AutomaticInterfaceExample
            {

                [GenerateAutomaticInterface]
                class DemoClass
                {
                    public string AMethod(string x, string y)
                    {
                        return string.Empty;
                    }

                    public string AMethod(string x, string y, string crash)
                    {
                        return string.Empty;
                    }
                }
            }

            """;

        const string expected = """
            //--------------------------------------------------------------------------------------------------
            // <auto-generated>
            //     This code was generated by a tool.
            //
            //     Changes to this file may cause incorrect behavior and will be lost if the code is regenerated.
            // </auto-generated>
            //--------------------------------------------------------------------------------------------------

            namespace AutomaticInterfaceExample
            {
                [global::System.CodeDom.Compiler.GeneratedCode("AutomaticInterface", "")]
                public partial interface IDemoClass
                {
                    /// <inheritdoc cref="AutomaticInterfaceExample.DemoClass.AMethod(string, string)" />
                    string AMethod(string x, string y);
                    
                    /// <inheritdoc cref="AutomaticInterfaceExample.DemoClass.AMethod(string, string, string)" />
                    string AMethod(string x, string y, string crash);
                    
                }
            }

            """;
        GenerateCode(code).Should().Be(expected);
    }

    [Fact]
    public void WorksWithNullableContext()
    {
        const string code = """

            using AutomaticInterface;
            namespace AutomaticInterfaceExample;
            [GenerateAutomaticInterface]
            public class DemoClass
            {
                public string AMethod(DemoClass? x, string y)
                {
                    return "Ok";
                }
            }

            """;

        const string expected = """
            //--------------------------------------------------------------------------------------------------
            // <auto-generated>
            //     This code was generated by a tool.
            //
            //     Changes to this file may cause incorrect behavior and will be lost if the code is regenerated.
            // </auto-generated>
            //--------------------------------------------------------------------------------------------------

            #nullable enable
            namespace AutomaticInterfaceExample
            {
                [global::System.CodeDom.Compiler.GeneratedCode("AutomaticInterface", "")]
                public partial interface IDemoClass
                {
                    /// <inheritdoc cref="AutomaticInterfaceExample.DemoClass.AMethod(AutomaticInterfaceExample.DemoClass?, string)" />
                    string AMethod(global::AutomaticInterfaceExample.DemoClass? x, string y);
                    
                }
            }
            #nullable restore

            """;
        GenerateCode(code).Should().Be(expected);
    }

    [Fact]
    public void WorksWithNullableReturn()
    {
        const string code = """

            using AutomaticInterface;
            namespace AutomaticInterfaceExample;
            [GenerateAutomaticInterface]
            public class DemoClass
            {
                public string? AMethod(DemoClass x, string y)
                {
                    return "Ok";
                }
            }

            """;

        const string expected = """
            //--------------------------------------------------------------------------------------------------
            // <auto-generated>
            //     This code was generated by a tool.
            //
            //     Changes to this file may cause incorrect behavior and will be lost if the code is regenerated.
            // </auto-generated>
            //--------------------------------------------------------------------------------------------------

            #nullable enable
            namespace AutomaticInterfaceExample
            {
                [global::System.CodeDom.Compiler.GeneratedCode("AutomaticInterface", "")]
                public partial interface IDemoClass
                {
                    /// <inheritdoc cref="AutomaticInterfaceExample.DemoClass.AMethod(AutomaticInterfaceExample.DemoClass, string)" />
                    string? AMethod(global::AutomaticInterfaceExample.DemoClass x, string y);
                    
                }
            }
            #nullable restore

            """;
        GenerateCode(code).Should().Be(expected);
    }

    [Fact]
    public void NullableEvent()
    {
        const string code = """

            using AutomaticInterface;
            using System;

            namespace AutomaticInterfaceExample
            {
                    /// <summary>
                    /// Bla bla
                    /// </summary>
                [GenerateAutomaticInterface]
                class DemoClass
                {

                    /// <summary>
                    /// Bla bla
                    /// </summary>
                    public event EventHandler? ShapeChangedNullable;
                }
            }

            """;

        const string expected = """
            //--------------------------------------------------------------------------------------------------
            // <auto-generated>
            //     This code was generated by a tool.
            //
            //     Changes to this file may cause incorrect behavior and will be lost if the code is regenerated.
            // </auto-generated>
            //--------------------------------------------------------------------------------------------------

            #nullable enable
            namespace AutomaticInterfaceExample
            {
                /// <summary>
                /// Bla bla
                /// </summary>
                [global::System.CodeDom.Compiler.GeneratedCode("AutomaticInterface", "")]
                public partial interface IDemoClass
                {
                    /// <inheritdoc cref="AutomaticInterfaceExample.DemoClass.ShapeChangedNullable" />
                    event global::System.EventHandler? ShapeChangedNullable;
                    
                }
            }
            #nullable restore

            """;
        GenerateCode(code).Should().Be(expected);
    }

    [Fact]
    public void NullableEvent2()
    {
        const string code = """

            using AutomaticInterface;
            using System;

            namespace AutomaticInterfaceExample
            {
                    /// <summary>
                    /// Bla bla
                    /// </summary>
                [GenerateAutomaticInterface]
                class DemoClass
                {

                    /// <summary>
                    /// Bla bla
                    /// </summary>
                    public event EventHandler<string?> ShapeChangedNullable;
                }
            }

            """;

        const string expected = """
            //--------------------------------------------------------------------------------------------------
            // <auto-generated>
            //     This code was generated by a tool.
            //
            //     Changes to this file may cause incorrect behavior and will be lost if the code is regenerated.
            // </auto-generated>
            //--------------------------------------------------------------------------------------------------

            #nullable enable
            namespace AutomaticInterfaceExample
            {
                /// <summary>
                /// Bla bla
                /// </summary>
                [global::System.CodeDom.Compiler.GeneratedCode("AutomaticInterface", "")]
                public partial interface IDemoClass
                {
                    /// <inheritdoc cref="AutomaticInterfaceExample.DemoClass.ShapeChangedNullable" />
                    event global::System.EventHandler<string?> ShapeChangedNullable;
                    
                }
            }
            #nullable restore

            """;
        GenerateCode(code).Should().Be(expected);
    }

    [Fact]
    public void BooleanWithNonNull()
    {
        const string code = """

            using AutomaticInterface;
            using System;
            using System.IO;
            using System.Threading;
            using System.Threading.Tasks;

            namespace AutomaticInterfaceExample
            {
                    /// <summary>
                    /// Bla bla
                    /// </summary>
                [GenerateAutomaticInterface]
                class DemoClass
                {

                   public async Task<Stream?> GetFinalDocumentsByIDFails(
                                   string agreementID, 
                                   string docType, 
                                   bool amt = false , 
                                   bool? attachSupportingDocuments = true, 
                                   CancellationToken cancellationToken = default)
                  {
                      await Task.Delay(100);
                      return default(Stream?);

                  }
                }
            }

            """;

        const string expected = """
            //--------------------------------------------------------------------------------------------------
            // <auto-generated>
            //     This code was generated by a tool.
            //
            //     Changes to this file may cause incorrect behavior and will be lost if the code is regenerated.
            // </auto-generated>
            //--------------------------------------------------------------------------------------------------

            #nullable enable
            namespace AutomaticInterfaceExample
            {
                /// <summary>
                /// Bla bla
                /// </summary>
                [global::System.CodeDom.Compiler.GeneratedCode("AutomaticInterface", "")]
                public partial interface IDemoClass
                {
                    /// <inheritdoc cref="AutomaticInterfaceExample.DemoClass.GetFinalDocumentsByIDFails(string, string, bool, bool?, System.Threading.CancellationToken)" />
                    global::System.Threading.Tasks.Task<global::System.IO.Stream?> GetFinalDocumentsByIDFails(string agreementID, string docType, bool amt = false, bool? attachSupportingDocuments = true, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken));
                    
                }
            }
            #nullable restore

            """;
        GenerateCode(code).Should().Be(expected);
    }

    [Fact]
    public void CustomNameSpace()
    {
        const string code = """

            using AutomaticInterface;
            using System;
            using System.IO;
            using System.Threading;
            using System.Threading.Tasks;

            namespace AutomaticInterfaceExample
            {
                /// <summary>
                /// Bla bla
                /// </summary>
                [GenerateAutomaticInterface("CustomNameSpace")]
                class DemoClass
                {

                   public async Task<Stream?> GetFinalDocumentsByIDFails(
                                   string agreementID, 
                                   string docType, 
                                   bool amt = false , 
                                   bool? attachSupportingDocuments = true, 
                                   CancellationToken cancellationToken = default)
                  {
                      await Task.Delay(100);
                      return default(Stream?);

                  }
                }
            }

            """;

        const string expected = """
            //--------------------------------------------------------------------------------------------------
            // <auto-generated>
            //     This code was generated by a tool.
            //
            //     Changes to this file may cause incorrect behavior and will be lost if the code is regenerated.
            // </auto-generated>
            //--------------------------------------------------------------------------------------------------

            #nullable enable
            namespace CustomNameSpace
            {
                /// <summary>
                /// Bla bla
                /// </summary>
                [global::System.CodeDom.Compiler.GeneratedCode("AutomaticInterface", "")]
                public partial interface IDemoClass
                {
                    /// <inheritdoc cref="AutomaticInterfaceExample.DemoClass.GetFinalDocumentsByIDFails(string, string, bool, bool?, System.Threading.CancellationToken)" />
                    global::System.Threading.Tasks.Task<global::System.IO.Stream?> GetFinalDocumentsByIDFails(string agreementID, string docType, bool amt = false, bool? attachSupportingDocuments = true, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken));
                    
                }
            }
            #nullable restore

            """;
        GenerateCode(code).Should().Be(expected);
    }

    [Fact]
    public void WorksWithNullableGeneric()
    {
        const string code = """

            using AutomaticInterface;
            using System.Threading.Tasks;

            namespace AutomaticInterfaceExample;
            [GenerateAutomaticInterface]
            public class DemoClass
            {
                public Task<string?> AMethodAsync(DemoClass x, string y)
                {
                    return Task.FromResult("Ok");
                }
            }

            """;

        const string expected = """
            //--------------------------------------------------------------------------------------------------
            // <auto-generated>
            //     This code was generated by a tool.
            //
            //     Changes to this file may cause incorrect behavior and will be lost if the code is regenerated.
            // </auto-generated>
            //--------------------------------------------------------------------------------------------------

            #nullable enable
            namespace AutomaticInterfaceExample
            {
                [global::System.CodeDom.Compiler.GeneratedCode("AutomaticInterface", "")]
                public partial interface IDemoClass
                {
                    /// <inheritdoc cref="AutomaticInterfaceExample.DemoClass.AMethodAsync(AutomaticInterfaceExample.DemoClass, string)" />
                    global::System.Threading.Tasks.Task<string?> AMethodAsync(global::AutomaticInterfaceExample.DemoClass x, string y);
                    
                }
            }
            #nullable restore

            """;
        GenerateCode(code).Should().Be(expected);
    }

    [Fact]
    public void WorksWithNullableGeneric2()
    {
        const string code = """

            using AutomaticInterface;
            using System.Threading.Tasks;

            namespace AutomaticInterfaceExample;
            [GenerateAutomaticInterface]
            public class DemoClass
            {
                public string AMethod(Task<DemoClass?> x, string y)
                {
                    return "Ok";
                }
            }

            """;

        const string expected = """
            //--------------------------------------------------------------------------------------------------
            // <auto-generated>
            //     This code was generated by a tool.
            //
            //     Changes to this file may cause incorrect behavior and will be lost if the code is regenerated.
            // </auto-generated>
            //--------------------------------------------------------------------------------------------------

            #nullable enable
            namespace AutomaticInterfaceExample
            {
                [global::System.CodeDom.Compiler.GeneratedCode("AutomaticInterface", "")]
                public partial interface IDemoClass
                {
                    /// <inheritdoc cref="AutomaticInterfaceExample.DemoClass.AMethod(System.Threading.Tasks.Task{AutomaticInterfaceExample.DemoClass?}, string)" />
                    string AMethod(global::System.Threading.Tasks.Task<global::AutomaticInterfaceExample.DemoClass?> x, string y);
                    
                }
            }
            #nullable restore

            """;
        GenerateCode(code).Should().Be(expected);
    }

    [Fact]
    public void WorksWithRef()
    {
        const string code = """

            using AutomaticInterface;
            using System.Threading.Tasks;

            namespace AutomaticInterfaceExample;
            [GenerateAutomaticInterface]
            public class DemoClass
            {
                private string _aProperty;
                public ref string AProperty => ref _aProperty;
            }

            """;

        const string expected = """
            //--------------------------------------------------------------------------------------------------
            // <auto-generated>
            //     This code was generated by a tool.
            //
            //     Changes to this file may cause incorrect behavior and will be lost if the code is regenerated.
            // </auto-generated>
            //--------------------------------------------------------------------------------------------------

            namespace AutomaticInterfaceExample
            {
                [global::System.CodeDom.Compiler.GeneratedCode("AutomaticInterface", "")]
                public partial interface IDemoClass
                {
                    /// <inheritdoc cref="AutomaticInterfaceExample.DemoClass.AProperty" />
                    ref string AProperty { get; }
                    
                }
            }

            """;
        GenerateCode(code).Should().Be(expected);
    }

    [Fact]
    public void WorksWithReservedNames()
    {
        const string code = """

            using AutomaticInterface;
            using System.Threading.Tasks;

            namespace AutomaticInterfaceExample;
            [GenerateAutomaticInterface]
            public class DemoClass
            {
                public void AMethod(int @event)
                {
                }
            }

            """;

        const string expected = """
            //--------------------------------------------------------------------------------------------------
            // <auto-generated>
            //     This code was generated by a tool.
            //
            //     Changes to this file may cause incorrect behavior and will be lost if the code is regenerated.
            // </auto-generated>
            //--------------------------------------------------------------------------------------------------

            namespace AutomaticInterfaceExample
            {
                [global::System.CodeDom.Compiler.GeneratedCode("AutomaticInterface", "")]
                public partial interface IDemoClass
                {
                    /// <inheritdoc cref="AutomaticInterfaceExample.DemoClass.AMethod(int)" />
                    void AMethod(int @event);
                    
                }
            }

            """;
        GenerateCode(code).Should().Be(expected);
    }

    [Fact]
    public void WorksWithMethodOverrides()
    {
        const string code = """

            using AutomaticInterface;

            namespace AutomaticInterfaceExample;

            public class BaseClass
            {
                public virtual bool AMethod() => true;
            }

            [GenerateAutomaticInterface]
            public class DemoClass : BaseClass
            {
                public override bool AMethod() => true;
            }

            """;

        const string expected = """
            //--------------------------------------------------------------------------------------------------
            // <auto-generated>
            //     This code was generated by a tool.
            //
            //     Changes to this file may cause incorrect behavior and will be lost if the code is regenerated.
            // </auto-generated>
            //--------------------------------------------------------------------------------------------------

            namespace AutomaticInterfaceExample
            {
                [global::System.CodeDom.Compiler.GeneratedCode("AutomaticInterface", "")]
                public partial interface IDemoClass
                {
                    /// <inheritdoc cref="AutomaticInterfaceExample.DemoClass.AMethod()" />
                    bool AMethod();
                    
                }
            }

            """;
        GenerateCode(code).Should().Be(expected);
    }

    [Fact]
    public void WorksWithMethodShadowing()
    {
        const string code = """

            using AutomaticInterface;

            namespace AutomaticInterfaceExample;

            public class BaseClass
            {
                public bool AMethod() => true;
            }

            [GenerateAutomaticInterface]
            public class DemoClass : BaseClass
            {
                public new bool AMethod() => true;
            }

            """;

        const string expected = """
            //--------------------------------------------------------------------------------------------------
            // <auto-generated>
            //     This code was generated by a tool.
            //
            //     Changes to this file may cause incorrect behavior and will be lost if the code is regenerated.
            // </auto-generated>
            //--------------------------------------------------------------------------------------------------

            namespace AutomaticInterfaceExample
            {
                [global::System.CodeDom.Compiler.GeneratedCode("AutomaticInterface", "")]
                public partial interface IDemoClass
                {
                    /// <inheritdoc cref="AutomaticInterfaceExample.DemoClass.AMethod()" />
                    bool AMethod();
                    
                }
            }

            """;
        GenerateCode(code).Should().Be(expected);
    }

    [Fact]
    public void WorksWithParameterDirectionOverloads()
    {
        const string code = """

            using AutomaticInterface;

            namespace AutomaticInterfaceExample;

            [GenerateAutomaticInterface]
            public class DemoClass
            {
                public void AMethod(int val) {}
                
                public void AMethod(ref int val){}
            }

            """;

        const string expected = """
            //--------------------------------------------------------------------------------------------------
            // <auto-generated>
            //     This code was generated by a tool.
            //
            //     Changes to this file may cause incorrect behavior and will be lost if the code is regenerated.
            // </auto-generated>
            //--------------------------------------------------------------------------------------------------

            namespace AutomaticInterfaceExample
            {
                [global::System.CodeDom.Compiler.GeneratedCode("AutomaticInterface", "")]
                public partial interface IDemoClass
                {
                    /// <inheritdoc cref="AutomaticInterfaceExample.DemoClass.AMethod(int)" />
                    void AMethod(int val);
                    
                    /// <inheritdoc cref="AutomaticInterfaceExample.DemoClass.AMethod(ref int)" />
                    void AMethod(ref int val);
                    
                }
            }

            """;
        GenerateCode(code).Should().Be(expected);
    }

    [Fact]
    public void WorksWithGenericParameterOverloads()
    {
        const string code = """

            using AutomaticInterface;

            namespace AutomaticInterfaceExample;

            [GenerateAutomaticInterface]
            public class DemoClass
            {
                public void AMethod(Func<Task<int>> getValue) {}
                
                public void AMethod(Func<Task<float>> getValue) {}
            }

            """;

        const string expected = """
            //--------------------------------------------------------------------------------------------------
            // <auto-generated>
            //     This code was generated by a tool.
            //
            //     Changes to this file may cause incorrect behavior and will be lost if the code is regenerated.
            // </auto-generated>
            //--------------------------------------------------------------------------------------------------

            namespace AutomaticInterfaceExample
            {
                [global::System.CodeDom.Compiler.GeneratedCode("AutomaticInterface", "")]
                public partial interface IDemoClass
                {
                    /// <inheritdoc cref="AutomaticInterfaceExample.DemoClass.AMethod(Func{Task{int}})" />
                    void AMethod(Func<Task<int>> getValue);
                    
                    /// <inheritdoc cref="AutomaticInterfaceExample.DemoClass.AMethod(Func{Task{float}})" />
                    void AMethod(Func<Task<float>> getValue);
                    
                }
            }

            """;
        GenerateCode(code).Should().Be(expected);
    }

    [Fact]
    public void WorksWithGenericParameterOverloadsWithIdenticalTypeNames()
    {
        const string code = """

            using AutomaticInterface;

            namespace AutomaticInterfaceExample
            {
                namespace Types1 {
                    public class Model;
                }

                namespace Types2 {
                    public class Model;
                }

                [GenerateAutomaticInterface]
                public class DemoClass
                {
                    public void AMethod(Func<Task<Types1.Model>> getValue) {}
                    
                    public void AMethod(Func<Task<Types2.Model>> getValue) {}
                }
            }

            """;

        const string expected = """
            //--------------------------------------------------------------------------------------------------
            // <auto-generated>
            //     This code was generated by a tool.
            //
            //     Changes to this file may cause incorrect behavior and will be lost if the code is regenerated.
            // </auto-generated>
            //--------------------------------------------------------------------------------------------------

            namespace AutomaticInterfaceExample
            {
                [global::System.CodeDom.Compiler.GeneratedCode("AutomaticInterface", "")]
                public partial interface IDemoClass
                {
                    /// <inheritdoc cref="AutomaticInterfaceExample.DemoClass.AMethod(Func{Task{AutomaticInterfaceExample.Types1.Model}})" />
                    void AMethod(Func<Task<global::AutomaticInterfaceExample.Types1.Model>> getValue);
                    
                    /// <inheritdoc cref="AutomaticInterfaceExample.DemoClass.AMethod(Func{Task{AutomaticInterfaceExample.Types2.Model}})" />
                    void AMethod(Func<Task<global::AutomaticInterfaceExample.Types2.Model>> getValue);
                    
                }
            }

            """;
        GenerateCode(code).Should().Be(expected);
    }

    [Fact]
    public void WorksWithEventOverrides()
    {
        const string code = """

            using AutomaticInterface;
            using System;

            namespace AutomaticInterfaceExample;

            public class BaseClass
            {
                public virtual event EventHandler AnEvent;
            }

            [GenerateAutomaticInterface]
            public class DemoClass : BaseClass
            {
                public override event EventHandler AnEvent;
            }

            """;

        const string expected = """
            //--------------------------------------------------------------------------------------------------
            // <auto-generated>
            //     This code was generated by a tool.
            //
            //     Changes to this file may cause incorrect behavior and will be lost if the code is regenerated.
            // </auto-generated>
            //--------------------------------------------------------------------------------------------------

            namespace AutomaticInterfaceExample
            {
                [global::System.CodeDom.Compiler.GeneratedCode("AutomaticInterface", "")]
                public partial interface IDemoClass
                {
                    /// <inheritdoc cref="AutomaticInterfaceExample.DemoClass.AnEvent" />
                    event global::System.EventHandler AnEvent;
                    
                }
            }

            """;
        GenerateCode(code).Should().Be(expected);
    }

    [Fact]
    public void WorksWithEventShadowing()
    {
        const string code = """

            using AutomaticInterface;
            using System;

            namespace AutomaticInterfaceExample;

            public class BaseClass
            {
                public event EventHandler AnEvent;
            }

            [GenerateAutomaticInterface]
            public class DemoClass : BaseClass
            {
                public new event EventHandler AnEvent;
            }

            """;

        const string expected = """
            //--------------------------------------------------------------------------------------------------
            // <auto-generated>
            //     This code was generated by a tool.
            //
            //     Changes to this file may cause incorrect behavior and will be lost if the code is regenerated.
            // </auto-generated>
            //--------------------------------------------------------------------------------------------------

            namespace AutomaticInterfaceExample
            {
                [global::System.CodeDom.Compiler.GeneratedCode("AutomaticInterface", "")]
                public partial interface IDemoClass
                {
                    /// <inheritdoc cref="AutomaticInterfaceExample.DemoClass.AnEvent" />
                    event global::System.EventHandler AnEvent;
                    
                }
            }

            """;
        GenerateCode(code).Should().Be(expected);
    }

    [Fact]
    public void WorksWithByteEnums()
    {
        const string code = """

            using AutomaticInterface;
            using System;

            namespace AutomaticInterfaceExample;

            public enum EnumWithByteType : byte { A = 1, B = 2, C = 3 };

            [GenerateAutomaticInterface]
            public class DemoClass
            {
                public void MethodWithDefaultParameter(EnumWithByteType a = EnumWithByteType.B) { }
            }

            """;

        const string expected = """
            //--------------------------------------------------------------------------------------------------
            // <auto-generated>
            //     This code was generated by a tool.
            //
            //     Changes to this file may cause incorrect behavior and will be lost if the code is regenerated.
            // </auto-generated>
            //--------------------------------------------------------------------------------------------------

            namespace AutomaticInterfaceExample
            {
                [global::System.CodeDom.Compiler.GeneratedCode("AutomaticInterface", "")]
                public partial interface IDemoClass
                {
                    /// <inheritdoc cref="AutomaticInterfaceExample.DemoClass.MethodWithDefaultParameter(AutomaticInterfaceExample.EnumWithByteType)" />
                    void MethodWithDefaultParameter(global::AutomaticInterfaceExample.EnumWithByteType a = global::AutomaticInterfaceExample.EnumWithByteType.B);
                    
                }
            }

            """;
        GenerateCode(code).Should().Be(expected);
    }
}