CSharpFileBuilderTests.cs

// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.

#nullable disable

using System.Runtime.CompilerServices;
using Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.CSharp;
using Microsoft.DotNet.ApiSymbolExtensions;
using Microsoft.DotNet.ApiSymbolExtensions.Filtering;
using Microsoft.DotNet.ApiSymbolExtensions.Logging;
using Moq;

namespace Microsoft.DotNet.GenAPI.Tests
{
    public class CSharpFileBuilderTests
    {
        class AllowAllFilter : ISymbolFilter
        {
            public bool Include(ISymbol symbol) => true;
        }

        private static MetadataReference[] MetadataReferences { get; } = new[] { MetadataReference.CreateFromFile(typeof(object).Assembly!.Location!) };

        private static SyntaxTree GetSyntaxTree(string syntax) =>
            CSharpSyntaxTree.ParseText(syntax);

        private void RunTest(string original,
            string expected,
            bool includeInternalSymbols = true,
            bool includeEffectivelyPrivateSymbols = true,
            bool includeExplicitInterfaceImplementationSymbols = true,
            bool allowUnsafe = false,
            string[] excludedAttributeList = null,
            [CallerMemberName] string assemblyName = "",
            // Empty string is considered a valid header, null causes to use the default CSharpFileBuilder header
            string header = "")
        {
            using StringWriter stringWriter = new();

            Mock<ILog> log = new();

            (IAssemblySymbolLoader loader, Dictionary<string, IAssemblySymbol> assemblySymbols) = TestAssemblyLoaderFactory
                .CreateFromTexts(log.Object, assemblyTexts: [(assemblyName, original)], respectInternals: includeInternalSymbols, allowUnsafe: allowUnsafe);

            ISymbolFilter symbolFilter = SymbolFilterFactory.GetFilterFromList([], null, includeInternalSymbols, includeEffectivelyPrivateSymbols, includeExplicitInterfaceImplementationSymbols);
            ISymbolFilter attributeDataSymbolFilter = SymbolFilterFactory.GetFilterFromList(excludedAttributeList, null, includeInternalSymbols, includeEffectivelyPrivateSymbols, includeExplicitInterfaceImplementationSymbols);

            IAssemblySymbolWriter csharpFileBuilder = new CSharpFileBuilder(
                log.Object,
                stringWriter,
                loader,
                symbolFilter,
                attributeDataSymbolFilter,
                header: header,
                exceptionMessage: null,
                includeAssemblyAttributes: false,
                MetadataReferences,
                addPartialModifier: true);

            csharpFileBuilder.WriteAssembly(assemblySymbols.First().Value);

            StringBuilder stringBuilder = stringWriter.GetStringBuilder();
            string resultedString = stringBuilder.ToString();

            stringBuilder.Remove(0, stringBuilder.Length);

            SyntaxTree resultedSyntaxTree = GetSyntaxTree(resultedString);
            SyntaxTree expectedSyntaxTree = GetSyntaxTree(expected);

            // compare SyntaxTree and not string representation
            Assert.True(resultedSyntaxTree.IsEquivalentTo(expectedSyntaxTree),
                $"Expected:\n{expected}\nResulted:\n{resultedString}");
        }

        [Fact]
        public void TestDefaultHeader()
        {
            RunTest(original: """
                namespace A
                {
                namespace B {}

                namespace C.D { public struct Bar {} }
                }
                """,
                expected: $@"
                {CSharpFileBuilder.DefaultFileHeader}
                namespace A.C.D {{ public partial struct Bar {{}} }}
                ",
                header: null);
        }

        [Fact]
        public void TestCustomHeader()
        {
            string customHeader = """
            // Licensed to the .NET Foundation under one or more agreements.
            // The .NET Foundation licenses this file to you under the MIT license.

            """;

            RunTest(original: """
                namespace A
                {
                namespace B {}

                namespace C.D { public struct Bar {} }
                }
                """,
                expected: $@"
                {customHeader}
                namespace A.C.D {{ public partial struct Bar {{}} }}
                ",
                header: customHeader);
        }

        [Fact]
        public void TestNamespaceDeclaration()
        {
            RunTest(original: """
                namespace A
                {
                namespace B {}

                namespace C.D { public struct Bar {} }
                }
                """,
                expected: """
                namespace A.C.D { public partial struct Bar {} }
                """);
        }

        [Fact]
        public void TestClassDeclaration()
        {
            RunTest(original: """
                namespace Foo
                {
                    public class PublicClass { }

                    class InternalClass { }

                    public sealed class PublicSealedClass { }

                    public partial class ProtectedPartialClass { }
                }
                """,
                expected: """
                namespace Foo
                {
                    internal partial class InternalClass { }

                    /// `partial` keyword is not added!
                    public partial class ProtectedPartialClass { }

                    public partial class PublicClass { }

                    public sealed partial class PublicSealedClass { }
                }
                """);
        }

        [Fact]
        public void TestStructDeclaration()
        {
            RunTest(original: """
                namespace Foo
                {
                    public struct PublicStruct { }

                    struct InternalStruct { }

                    readonly struct ReadonlyStruct { }

                    public readonly struct PublicReadonlyStruct { }

                    record struct RecordStruct { }

                    readonly record struct ReadonlyRecordStruct { }

                    public ref struct PublicRefStruct { }

                    public readonly ref struct PublicReadonlyRefStruct { }
                }
                """,
                // It's expected that record structs are expanded - they're effectively syntactic sugar that is not persisted in metadata
                expected: """
                namespace Foo
                {
                    internal partial struct InternalStruct
                    {
                    }

                    public readonly ref partial struct PublicReadonlyRefStruct
                    {
                    }

                    public readonly partial struct PublicReadonlyStruct
                    {
                    }

                    public ref partial struct PublicRefStruct
                    {
                    }

                    public partial struct PublicStruct
                    {
                    }

                    internal readonly partial struct ReadonlyRecordStruct : System.IEquatable<ReadonlyRecordStruct>
                    {
                        [System.Runtime.CompilerServices.CompilerGenerated]
                        public readonly bool Equals(ReadonlyRecordStruct other) { throw null; }

                        [System.Runtime.CompilerServices.CompilerGenerated]
                        public override readonly bool Equals(object obj) { throw null; }

                        [System.Runtime.CompilerServices.CompilerGenerated]
                        public override readonly int GetHashCode() { throw null; }

                        [System.Runtime.CompilerServices.CompilerGenerated]
                        public static bool operator ==(ReadonlyRecordStruct left, ReadonlyRecordStruct right) { throw null; }

                        [System.Runtime.CompilerServices.CompilerGenerated]
                        public static bool operator !=(ReadonlyRecordStruct left, ReadonlyRecordStruct right) { throw null; }

                        [System.Runtime.CompilerServices.CompilerGenerated]
                        public override readonly string ToString() { throw null; }
                    }

                    internal readonly partial struct ReadonlyStruct
                    {
                    }

                    internal partial struct RecordStruct : System.IEquatable<RecordStruct>
                    {
                        [System.Runtime.CompilerServices.CompilerGenerated]
                        public readonly bool Equals(RecordStruct other) { throw null; }

                        [System.Runtime.CompilerServices.CompilerGenerated]
                        public override readonly bool Equals(object obj) { throw null; }

                        [System.Runtime.CompilerServices.CompilerGenerated]
                        public override readonly int GetHashCode() { throw null; }

                        [System.Runtime.CompilerServices.CompilerGenerated]
                        public static bool operator ==(RecordStruct left, RecordStruct right) { throw null; }

                        [System.Runtime.CompilerServices.CompilerGenerated]
                        public static bool operator !=(RecordStruct left, RecordStruct right) { throw null; }

                        [System.Runtime.CompilerServices.CompilerGenerated]
                        public override readonly string ToString() { throw null; }
                    }
                }
                """);
        }

        [Fact]
        public void TestRecordDeclaration()
        {
            RunTest(original: """
                namespace Foo
                {
                    public record RecordClass;
                    public record RecordClass1(int i);
                    public record RecordClass2(string s, int i);
                    public record DerivedRecord(string s, int i, double d) : RecordClass2(s, i);
                    public record DerivedRecord2(string x, int i, double d) : RecordClass2(default(string)!, i);
                    public record DerivedRecord3(string x, int i, double d) : RecordClass2(default(string)!, i);
                    public record DerivedRecord4(double d) : RecordClass2(default(string)!, default);
                    public record DerivedRecord5() : RecordClass2(default(string)!, default);

                    public record RecordClassWithMethods(int i)
                    {
                        public void DoSomething() { }
                        public static void DoSomethingStatic() { }
                    }

                    public record RecordClassWithProperties(int i)
                    {
                        public int AddI { get; set; }
                        public int AddIinit { get; init; }
                        public int AddIro { get; }
                    }
                    public record RecordClassWithConstructors(int i)
                    {
                        public RecordClassWithConstructors() : this(1) { }
                        public RecordClassWithConstructors(string s) : this(int.Parse(s)) { }
                    }
                    public record RecordWithPrivateDefaultConstructor
                    {
                        private RecordWithPrivateDefaultConstructor() { }
                    }
                    public sealed record SealedRecordWithPrivateDefaultConstructor
                    {
                        private SealedRecordWithPrivateDefaultConstructor() { }
                    }
                }
                """,
                expected: """
                namespace Foo
                {
                    public partial record DerivedRecord(string s, int i, double d) : RecordClass2(default!, default)
                    {
                    }

                    public partial record DerivedRecord2(string x, int i, double d) : RecordClass2(default!, default)
                    {
                    }

                    public partial record DerivedRecord3(string x, int i, double d) : RecordClass2(default!, default)
                    {
                    }

                    public partial record DerivedRecord4(double d) : RecordClass2(default!, default)
                    {
                    }

                    public partial record DerivedRecord5() : RecordClass2(default!, default)
                    {
                    }

                    public partial record RecordClass()
                    {
                    }

                    public partial record RecordClass1(int i)
                    {
                    }

                    public partial record RecordClass2(string s, int i)
                    {
                    }

                    public partial record RecordClassWithConstructors(int i)
                    {
                        public RecordClassWithConstructors() { }

                        public RecordClassWithConstructors(string s) { }
                    }

                    public partial record RecordClassWithMethods(int i)
                    {
                        public void DoSomething() { }

                        public static void DoSomethingStatic() { }
                    }

                    public partial record RecordClassWithProperties(int i)
                    {
                        public int AddI { get { throw null; } set { } }

                        public int AddIinit { get { throw null; } init { } }

                        public int AddIro { get { throw null; } }
                    }

                    public partial record RecordWithPrivateDefaultConstructor
                    {
                        private RecordWithPrivateDefaultConstructor() { }
                    }

                    public sealed partial record SealedRecordWithPrivateDefaultConstructor
                    {
                        private SealedRecordWithPrivateDefaultConstructor() { }
                    }
                }
                """);
        }

        [Fact]
        public void TestRecordStructDeclaration()
        {
            RunTest(original: """
                namespace Foo
                {

                    public record struct RecordStruct;
                    public record struct RecordStruct1(int i);
                    public record struct RecordStruct2(string s, int i);

                    public record struct RecordStructWithMethods(int i)
                    {
                        public void DoSomething() { }
                        public static void DoSomethingStatic() { }
                    }

                    public record struct RecordStructWithProperties(int i)
                    {
                        public int AddI { get; set; }
                        public int AddIinit { get; init; }
                        public int AddIro { get; }
                    }
                    public record struct RecordStructWithConstructors(int i)
                    {
                        public RecordStructWithConstructors() : this(1) { }
                        public RecordStructWithConstructors(string s) : this(int.Parse(s)) { }
                    }

                }
                """,
                expected: """
                namespace Foo
                {
                    public partial struct RecordStruct : System.IEquatable<RecordStruct>
                    {
                        [System.Runtime.CompilerServices.CompilerGenerated]
                        public readonly bool Equals(RecordStruct other) { throw null; }

                        [System.Runtime.CompilerServices.CompilerGenerated]
                        public override readonly bool Equals(object obj) { throw null; }

                        [System.Runtime.CompilerServices.CompilerGenerated]
                        public override readonly int GetHashCode() { throw null; }

                        [System.Runtime.CompilerServices.CompilerGenerated]
                        public static bool operator ==(RecordStruct left, RecordStruct right) { throw null; }

                        [System.Runtime.CompilerServices.CompilerGenerated]
                        public static bool operator !=(RecordStruct left, RecordStruct right) { throw null; }

                        [System.Runtime.CompilerServices.CompilerGenerated]
                        public override readonly string ToString() { throw null; }
                    }

                    public partial struct RecordStruct1 : System.IEquatable<RecordStruct1>
                    {
                        private int _dummyPrimitive;
                        public RecordStruct1(int i) { }

                        public int i { get { throw null; } set { } }

                        [System.Runtime.CompilerServices.CompilerGenerated]
                        public readonly void Deconstruct(out int i) { throw null; }

                        [System.Runtime.CompilerServices.CompilerGenerated]
                        public readonly bool Equals(RecordStruct1 other) { throw null; }

                        [System.Runtime.CompilerServices.CompilerGenerated]
                        public override readonly bool Equals(object obj) { throw null; }

                        [System.Runtime.CompilerServices.CompilerGenerated]
                        public override readonly int GetHashCode() { throw null; }

                        [System.Runtime.CompilerServices.CompilerGenerated]
                        public static bool operator ==(RecordStruct1 left, RecordStruct1 right) { throw null; }

                        [System.Runtime.CompilerServices.CompilerGenerated]
                        public static bool operator !=(RecordStruct1 left, RecordStruct1 right) { throw null; }

                        [System.Runtime.CompilerServices.CompilerGenerated]
                        public override readonly string ToString() { throw null; }
                    }

                    public partial struct RecordStruct2 : System.IEquatable<RecordStruct2>
                    {
                        private object _dummy;
                        private int _dummyPrimitive;
                        public RecordStruct2(string s, int i) { }

                        public int i { get { throw null; } set { } }

                        public string s { get { throw null; } set { } }

                        [System.Runtime.CompilerServices.CompilerGenerated]
                        public readonly void Deconstruct(out string s, out int i) { throw null; }

                        [System.Runtime.CompilerServices.CompilerGenerated]
                        public readonly bool Equals(RecordStruct2 other) { throw null; }

                        [System.Runtime.CompilerServices.CompilerGenerated]
                        public override readonly bool Equals(object obj) { throw null; }

                        [System.Runtime.CompilerServices.CompilerGenerated]
                        public override readonly int GetHashCode() { throw null; }

                        [System.Runtime.CompilerServices.CompilerGenerated]
                        public static bool operator ==(RecordStruct2 left, RecordStruct2 right) { throw null; }

                        [System.Runtime.CompilerServices.CompilerGenerated]
                        public static bool operator !=(RecordStruct2 left, RecordStruct2 right) { throw null; }

                        [System.Runtime.CompilerServices.CompilerGenerated]
                        public override readonly string ToString() { throw null; }
                    }

                    public partial struct RecordStructWithConstructors : System.IEquatable<RecordStructWithConstructors>
                    {
                        private int _dummyPrimitive;
                        public RecordStructWithConstructors() { }

                        public RecordStructWithConstructors(int i) { }

                        public RecordStructWithConstructors(string s) { }

                        public int i { get { throw null; } set { } }

                        [System.Runtime.CompilerServices.CompilerGenerated]
                        public readonly void Deconstruct(out int i) { throw null; }

                        [System.Runtime.CompilerServices.CompilerGenerated]
                        public readonly bool Equals(RecordStructWithConstructors other) { throw null; }

                        [System.Runtime.CompilerServices.CompilerGenerated]
                        public override readonly bool Equals(object obj) { throw null; }

                        [System.Runtime.CompilerServices.CompilerGenerated]
                        public override readonly int GetHashCode() { throw null; }

                        [System.Runtime.CompilerServices.CompilerGenerated]
                        public static bool operator ==(RecordStructWithConstructors left, RecordStructWithConstructors right) { throw null; }

                        [System.Runtime.CompilerServices.CompilerGenerated]
                        public static bool operator !=(RecordStructWithConstructors left, RecordStructWithConstructors right) { throw null; }

                        [System.Runtime.CompilerServices.CompilerGenerated]
                        public override readonly string ToString() { throw null; }
                    }

                    public partial struct RecordStructWithMethods : System.IEquatable<RecordStructWithMethods>
                    {
                        private int _dummyPrimitive;
                        public RecordStructWithMethods(int i) { }

                        public int i { get { throw null; } set { } }

                        [System.Runtime.CompilerServices.CompilerGenerated]
                        public readonly void Deconstruct(out int i) { throw null; }

                        public void DoSomething() { }

                        public static void DoSomethingStatic() { }

                        [System.Runtime.CompilerServices.CompilerGenerated]
                        public readonly bool Equals(RecordStructWithMethods other) { throw null; }

                        [System.Runtime.CompilerServices.CompilerGenerated]
                        public override readonly bool Equals(object obj) { throw null; }

                        [System.Runtime.CompilerServices.CompilerGenerated]
                        public override readonly int GetHashCode() { throw null; }

                        [System.Runtime.CompilerServices.CompilerGenerated]
                        public static bool operator ==(RecordStructWithMethods left, RecordStructWithMethods right) { throw null; }

                        [System.Runtime.CompilerServices.CompilerGenerated]
                        public static bool operator !=(RecordStructWithMethods left, RecordStructWithMethods right) { throw null; }

                        [System.Runtime.CompilerServices.CompilerGenerated]
                        public override readonly string ToString() { throw null; }
                    }

                    public partial struct RecordStructWithProperties : System.IEquatable<RecordStructWithProperties>
                    {
                        private int _dummyPrimitive;
                        public RecordStructWithProperties(int i) { }

                        public int AddI { get { throw null; } set { } }

                        public int AddIinit { get { throw null; } init { } }

                        public int AddIro { get { throw null; } }

                        public int i { get { throw null; } set { } }

                        [System.Runtime.CompilerServices.CompilerGenerated]
                        public readonly void Deconstruct(out int i) { throw null; }

                        [System.Runtime.CompilerServices.CompilerGenerated]
                        public readonly bool Equals(RecordStructWithProperties other) { throw null; }

                        [System.Runtime.CompilerServices.CompilerGenerated]
                        public override readonly bool Equals(object obj) { throw null; }

                        [System.Runtime.CompilerServices.CompilerGenerated]
                        public override readonly int GetHashCode() { throw null; }

                        [System.Runtime.CompilerServices.CompilerGenerated]
                        public static bool operator ==(RecordStructWithProperties left, RecordStructWithProperties right) { throw null; }

                        [System.Runtime.CompilerServices.CompilerGenerated]
                        public static bool operator !=(RecordStructWithProperties left, RecordStructWithProperties right) { throw null; }

                        [System.Runtime.CompilerServices.CompilerGenerated]
                        public override readonly string ToString() { throw null; }
                    }
                }
                """);
        }

        [Fact]
        public void TestInterfaceGeneration()
        {
            RunTest(original: """
                namespace Foo
                {
                    public interface IPoint
                    {
                        // Property signatures:
                        int X { get; set; }
                        int Y { get; set; }

                        double CalculateDistance(IPoint p);
                    }
                }
                """,
                expected: """
                namespace Foo
                {
                    public partial interface IPoint
                    {
                        // Property signatures:
                        int X { get; set; }
                        int Y { get; set; }

                        double CalculateDistance(IPoint p);
                    }
                }
                """);
        }

        [Fact]
        public void TestEnumGeneration()
        {
            RunTest(original: """
                namespace Foo
                {
                    public enum Color
                    {
                        White = 0,
                        Green = 100,
                        Blue = 200
                    }
                }
                """,
                expected: """
                namespace Foo
                {
                    public enum Color
                    {
                        White = 0,
                        Green = 100,
                        Blue = 200
                    }
                }
                """);
        }

        [Fact]
        public void TestPropertyGeneration()
        {
            RunTest(original: """
                namespace Foo
                {
                    public class Car
                    {
                        public int? Drivers { get; }
                        public int Wheels { get => 4; }
                        public bool IsRunning { get; set; }
                        public bool Is4x4 { get => false; set { } }
                    }
                }
                """,
                expected: """
                namespace Foo
                {
                    public partial class Car
                    {
                        public int? Drivers { get { throw null; } }
                        public bool Is4x4 { get { throw null; } set { } }
                        public bool IsRunning { get { throw null; } set { } }
                        public int Wheels { get { throw null; } }
                    }
                }
                """);
        }

        [Fact]
        public void TestAbstractPropertyGeneration()
        {
            RunTest(original: """
                namespace Foo
                {
                    abstract class Car
                    {
                        abstract protected int? Wheels { get; }
                        abstract public bool IsRunning { get; set; }
                    }
                }
                """,
                expected: """
                namespace Foo
                {
                    internal abstract partial class Car
                    {
                        public abstract bool IsRunning { get; set; }
                        protected abstract int? Wheels { get; }
                    }
                }
                """);
        }

        [Fact]
        public void TestExplicitInterfaceImplementation()
        {
            RunTest(original: """
                namespace Foo
                {
                    public interface IControl
                    {
                        void Paint();
                    }
                    public interface ISurface
                    {
                        void Paint();
                    }

                    public class SampleClass : IControl, ISurface
                    {
                        public void Paint()
                        {
                        }
                    }
                }
                """,
                expected: """
                namespace Foo
                {
                    public partial interface IControl
                    {
                        void Paint();
                    }
                    public partial interface ISurface
                    {
                        void Paint();
                    }

                    public partial class SampleClass : IControl, ISurface
                    {
                        public void Paint()
                        {
                        }
                    }
                }
                """);
        }

        [Fact]
        public void TestPartiallySpecifiedGenericClassGeneration()
        {
            RunTest(original: """
                namespace Foo
                {
                    public class BaseNodeMultiple<T, U> { }

                    public class Node4<T> : BaseNodeMultiple<T, int> { }

                    public class Node5<T, U> : BaseNodeMultiple<T, U> { }
                }
                """,
                expected: """
                namespace Foo
                {
                    public partial class BaseNodeMultiple <T, U> { }

                    public partial class Node4 <T> : BaseNodeMultiple<T, int> { }

                    public partial class Node5 <T, U> : BaseNodeMultiple<T, U> { }
                }
                """);
        }

        [Fact]
        public void TestGenericClassWitConstraintsParameterGeneration()
        {
            RunTest(original: """
                namespace Foo
                {
                    public class SuperKeyType<K, V, U>
                        where U : System.IComparable<U>
                        where V : new()
                    { }
                }
                """,
                expected: """
                namespace Foo
                {
                    public partial class SuperKeyType <K, V, U> where V : new()
                        where U : System.IComparable<U>
                    {
                    }
                }
                """);
        }

        [Fact]
        public void TestPublicMembersGeneration()
        {
            RunTest(original: """
                namespace Foo
                {
                    public enum Kind
                    {
                        None = 0,
                        Disable = 1
                    }

                    public readonly struct Options
                    {
                        public readonly bool BoolMember = true;
                        public readonly Kind KindMember = Kind.Disable;

                        public Options(Kind kindVal)
                            : this(kindVal, false)
                        {
                        }

                        public Options(Kind kindVal, bool boolVal)
                        {
                            BoolMember = boolVal;
                            KindMember = kindVal;
                        }
                    }
                }
                """,
                expected: """
                namespace Foo
                {
                    public enum Kind
                    {
                        None = 0,
                        Disable = 1
                    }

                    public readonly partial struct Options
                    {
                        public readonly bool BoolMember;
                        public readonly Kind KindMember;
                        public Options(Kind kindVal, bool boolVal) { }
                        public Options(Kind kindVal) { }
                    }
                }
                """);
        }

        [Fact]
        public void TestDelegateGeneration()
        {
            RunTest(original: """
                namespace Foo
                {
                    public delegate bool SyntaxReceiverCreator(int a, bool b);
                }
                """,
                expected: """
                namespace Foo
                {
                    public delegate bool SyntaxReceiverCreator(int a, bool b);
                }
                """);
        }

        [Fact]
        public void TestAbstractEventGeneration()
        {
            RunTest(original: """
                namespace Foo
                {
                    public abstract class AbstractEvents
                    {
                        public abstract event System.EventHandler<bool> TextChanged;
                    }

                    public class Events
                    {
                        public event System.EventHandler<string> OnNewMessage { add { } remove { } }
                    }
                }
                """,
                expected: """
                namespace Foo
                {
                    public abstract partial class AbstractEvents
                    {
                        public abstract event System.EventHandler<bool> TextChanged;
                    }

                    public partial class Events
                    {
                        public event System.EventHandler<string> OnNewMessage { add { } remove { } }
                    }
                }
                """);
        }

        [Fact]
        public void TestCustomAttributeGeneration()
        {
            RunTest(original: """
                using System;
                using System.Diagnostics;

                namespace Foo
                {
                    public enum Animal
                    {
                        Dog = 1,
                        Cat,
                        Bird,
                    }

                    public class AnimalTypeAttribute : Attribute
                    {
                        protected Animal thePet;

                        public AnimalTypeAttribute(Animal pet)
                        {
                            thePet = pet;
                        }

                        public Animal Pet
                        {
                            get { return thePet; }
                            set { thePet = value; }
                        }
                    }

                    [AnimalType(Animal.Cat)]
                    public class Creature
                    {
                        [AnimalType(Animal.Cat)]
                        [Conditional("DEBUG"), Conditional("TEST1")]
                        public void SayHello() { }
                    }
                }
                """,
                expected: """
                namespace Foo
                {
                    public enum Animal
                    {
                        Dog = 1,
                        Cat = 2,
                        Bird = 3
                    }

                    public partial class AnimalTypeAttribute : System.Attribute
                    {
                        protected Animal thePet;
                        public AnimalTypeAttribute(Animal pet) { }
                        public Animal Pet { get { throw null; } set { } }
                    }

                    [AnimalType(Animal.Cat)]
                    public partial class Creature
                    {
                        [AnimalType(Animal.Cat)]
                        [System.Diagnostics.Conditional("DEBUG")]
                        [System.Diagnostics.Conditional("TEST1")]
                        public void SayHello() { }
                    }
                }
                """);
        }

        [Fact]
        public void TestFullyQualifiedNamesForDefaultEnumParameters()
        {
            RunTest(original: """
                namespace Foo
                {
                    public enum Animal
                    {
                        Dog = 1,
                        Cat = 2,
                        Bird = 3
                    }

                    public class AnimalProperty {
                        public Animal _animal;

                        public AnimalProperty(Animal animal = Animal.Cat)
                        {
                            _animal = animal;
                        }

                        public int Execute(int p = 42) { return p; }
                    }
                }
                """,
                expected: """
                namespace Foo
                {
                    public enum Animal
                    {
                        Dog = 1,
                        Cat = 2,
                        Bird = 3
                    }

                    public partial class AnimalProperty {
                        public Animal _animal;

                        public AnimalProperty(Animal animal = Animal.Cat) { }

                        public int Execute(int p = 42) { throw null; }
                    }
                }
                """);
        }

        [Fact]
        public void TestCustomComparisonOperatorGeneration()
        {
            RunTest(original: """
                namespace Foo
                {
                    public class Car : System.IEquatable<Car>
                    {
                        public bool Equals(Car? c) { return true; }
                        public override bool Equals(object? o) { return true; }
                        public override int GetHashCode() => 0;
                        public static bool operator ==(Car lhs, Car rhs) { return true; }
                        public static bool operator !=(Car lhs, Car rhs) { return false; }
                    }
                }
                """,
                expected: """
                namespace Foo
                {
                    public partial class Car : System.IEquatable<Car>
                    {
                        public bool Equals(Car? c) { throw null; }
                        public override bool Equals(object? o) { throw null; }
                        public override int GetHashCode() { throw null; }
                        public static bool operator ==(Car lhs, Car rhs) { throw null; }
                        public static bool operator !=(Car lhs, Car rhs) { throw null; }
                    }
                }
                """);
        }

        [Fact]
        public void TestNestedClassGeneration()
        {
            RunTest(original: """
                namespace Foo
                {
                    public class Car
                    {
                        public class Engine
                        {
                            public class Cylinder
                            { }
                        }
                    }
                }
                """,
                expected: """
                namespace Foo
                {
                    public partial class Car
                    {
                        public partial class Engine
                        {
                            public partial class Cylinder
                            { }
                        }
                    }
                }
                """);
        }
        [Fact]
        public void TestExplicitInterfaceImplementationMethodGeneration()
        {
            RunTest(original: """
                namespace Foo
                {
                    public abstract class MemoryManager : System.IDisposable
                    {
                        void System.IDisposable.Dispose() { }
                    }
                }
                """,
                expected: """
                namespace Foo
                {
                    public abstract partial class MemoryManager : System.IDisposable
                    {
                        void System.IDisposable.Dispose() { }
                    }
                }
                """);
        }

        [Fact]
        public void TestNullabilityGeneration()
        {
            RunTest(original: """
                namespace Foo
                {
                    public class Bar
                    {
                        public int? AMember { get; set; }
                        public string? BMember { get; }

                        public string? Execute(string? a, int? b) { return null; }
                    }
                }
                """,
                expected: """
                namespace Foo
                {
                    public partial class Bar
                    {
                        public int? AMember { get { throw null; } set { } }
                        public string? BMember { get { throw null; } }

                        public string? Execute(string? a, int? b) { throw null; }
                    }
                }
                """);
        }

        [Fact]
        public void TestExtensionMethodsGeneration()
        {
            RunTest(original: """
                namespace Foo
                {
                    public static class MyExtensions
                    {
                        public static int WordCount(this string str) { return 42; }
                    }
                }
                """,
                expected: """
                namespace Foo
                {
                    public static partial class MyExtensions
                    {
                        public static int WordCount(this string str) { throw null; }
                    }
                }
                """);
        }

        [Fact]
        public void TestMethodsWithVariableNumberOfArgumentsGeneration()
        {
            RunTest(original: """
                namespace Foo
                {
                    public class Bar
                    {
                        public void Execute(params int[] list) { }
                    }
                }
                """,
                expected: """
                namespace Foo
                {
                    public partial class Bar
                    {
                        public void Execute(params int[] list) { }
                    }
                }
                """);
        }

        [Fact]
        public void TestConversionOperatorGeneration()
        {
            RunTest(original: """
                namespace Foo
                {
                    public readonly struct Digit
                    {
                        private readonly byte digit;

                        public Digit(byte digit)
                        {
                            this.digit = digit;
                        }

                        public static implicit operator byte(Digit d) => d.digit;
                        public static explicit operator Digit(byte b) => new Digit(b);
                    }
                }
                """,
                expected: """
                namespace Foo
                {
                    public readonly partial struct Digit
                    {
                        private readonly int _dummyPrimitive;

                        public Digit(byte digit) { }
                        public static explicit operator Digit(byte b) { throw null; }

                        public static implicit operator byte(Digit d) { throw null; }
                    }
                }
                """);
        }

        [Fact]
        public void TestDestructorGeneration()
        {
            RunTest(original: """
                namespace Foo
                {
                    public class Bar
                    {
                        ~Bar() {}
                    }
                }
                """,
                expected: """
                namespace Foo
                {
                    public partial class Bar
                    {
                        ~Bar() {}
                    }
                }
                """);
        }

        [Fact]
        public void TestExplicitInterfaceImplementationPropertyGeneration()
        {
            RunTest(original: """
                    namespace Foo
                    {
                        public interface IFoo
                        {
                            int FooField { get; set; }
                            void FooMethod();
                        }

                        public class Bar : IFoo
                        {
                            int BarField { get; set; }
                            int IFoo.FooField { get; set; }

                            void IFoo.FooMethod() { }
                        }
                    }
                    """,
                expected: """
                    namespace Foo
                    {
                        public partial class Bar : IFoo
                        {
                            int IFoo.FooField { get { throw null; } set { } }
                            void IFoo.FooMethod() { }
                        }

                        public partial interface IFoo
                        {
                            int FooField { get; set; }
                            void FooMethod();
                        }
                    }
                    """);
        }

        [Fact]
        public void TestAccessibilityGenerationForPropertyAccessors()
        {
            RunTest(original: """
                    namespace Foo
                    {
                        public class Bar
                        {
                            public int P { get; protected set; }
                        }
                    }
                    """,
                expected: """
                    namespace Foo
                    {
                        public partial class Bar
                        {
                            public int P { get { throw null; } protected set { } }
                        }
                    }
                    """);
        }

        [Fact]
        public void TestConstantFieldGeneration()
        {
            RunTest(original: """
                namespace Foo
                {
                    public class Bar
                    {
                        public const int CurrentEra = 0;
                    }
                }
                """,
                expected: """
                namespace Foo
                {
                    public partial class Bar
                    {
                        public const int CurrentEra = 0;
                    }
                }
                """
            );
        }

        [Fact]
        public void TestTypeParameterVarianceGeneration()
        {
            RunTest(original: """
                namespace Foo
                {
                    public delegate void Action<in T>(T obj);
                    public partial interface IAsyncEnumerable<out T>
                    {
                    }
                }
                """,
                expected: """
                namespace Foo
                {
                    public delegate void Action<in T>(T obj);
                    public partial interface IAsyncEnumerable<out T>
                    {
                    }
                }
                """
            );
        }

        [Fact]
        public void TestRefMembersGeneration()
        {
            RunTest(original: """
                namespace Foo
                {
                    public class Bar<T>
                    {
                    #pragma warning disable CS8597
                        public ref T GetPinnableReference() { throw null; }
                        public ref readonly T this[int index] { get { throw null; } }
                        public ref int P { get { throw null; } }
                    #pragma warning restore CS8597
                    }
                }
                """,
                expected: """
                namespace Foo
                {
                    public partial class Bar<T>
                    {
                    #pragma warning disable CS8597
                        public ref readonly T this[int index] { get { throw null; } }
                        public ref int P { get { throw null; } }
                        public ref T GetPinnableReference() { throw null; }
                    #pragma warning restore CS8597
                    }
                }
                """
            );
        }

        [Fact]
        public void TestDefaultConstraintOnOverrideGeneration()
        {
            RunTest(original: """
                namespace Foo
                {
                    public abstract partial class A
                    {
                        public abstract TResult? Accept<TResult>(int a);
                    }

                    public sealed partial class B : A
                    {
                    #pragma warning disable CS8597
                        public override TResult? Accept<TResult>(int a) where TResult : default { throw null; }
                    #pragma warning restore CS8597
                    }
                }
                """,
                expected: """
                namespace Foo
                {
                    public abstract partial class A
                    {
                        public abstract TResult? Accept<TResult>(int a);
                    }

                    public sealed partial class B : A
                    {
                    #pragma warning disable CS8597
                        public override TResult? Accept<TResult>(int a) where TResult : default { throw null; }
                    #pragma warning restore CS8597
                    }
                }
                """
            );
        }

        [Fact]
        public void TestSynthesizePrivateFieldsForValueTypes()
        {
            RunTest(original: """
                using System;

                namespace Foo
                {
                    public struct Bar
                    {
                        #pragma warning disable 0169
                        private IntPtr intPtr;
                    }
                }
                """,
                expected: """
                namespace Foo
                {
                    public partial struct Bar
                    {
                        private int _dummyPrimitive;
                    }
                }
                """);
        }

        [Fact]
        public void TestSynthesizePrivateFieldsForReferenceTypes()
        {
            RunTest(original: """
                namespace Foo
                {
                    public struct Bar
                    {
                        #pragma warning disable 0169
                        private object field;
                    }
                }
                """,
                expected: """
                namespace Foo
                {
                    public partial struct Bar
                    {
                        private object _dummy;
                        private int _dummyPrimitive;
                    }
                }
                """);
        }

        [Fact]
        public void TestSynthesizePrivateFieldsForGenericTypes()
        {
            RunTest(original: """
                namespace Foo
                {
                    public struct Bar<T>
                    {
                        #pragma warning disable 0169
                        private T _field;
                    }
                }
                """,
            expected: """
                namespace Foo
                {
                    public partial struct Bar<T>
                    {
                        private T _field;
                    }
                }
                """);
        }

        [Fact]
        public void TestSynthesizePrivateFieldsForNestedGenericTypes()
        {
            RunTest(original: """
                using System.Collections.Generic;

                namespace Foo
                {
                    public struct Bar<T> where T : notnull
                    {
                        #pragma warning disable 0169
                        private Dictionary<int, List<T>> _field;
                    }
                }
                """,
            expected: """
                namespace Foo
                {
                    public partial struct Bar<T>
                    {
                        private System.Collections.Generic.Dictionary<int, System.Collections.Generic.List<T>> _field;
                        private object _dummy;
                        private int _dummyPrimitive;
                    }
                }
                """);
        }

        [Fact]
        public void TestSynthesizePrivateFieldsAngleBrackets()
        {
            RunTest(original: """
                using System.Collections.Generic;

                namespace Foo
                {
                    public readonly struct Bar<T> where T : notnull
                    {
                        public List<Bar<T>> Baz { get; }
                    }
                }
                """,
            expected: """
                namespace Foo
                {
                    public readonly partial struct Bar<T>
                    {
                        private readonly System.Collections.Generic.List<Bar<T>> _Baz_k__BackingField;
                        private readonly object _dummy;
                        private readonly int _dummyPrimitive;
                        public System.Collections.Generic.List<Bar<T>> Baz { get { throw null; } }
                    }
                }
                """);
        }

        [Fact]
        public void TestSynthesizePrivateFieldsForInaccessibleNestedGenericTypes()
        {
            RunTest(original: """
                namespace A
                {
                    internal class Bar<T> {}

                    public struct Foo<T>
                    {
                        #pragma warning disable 0169
                        // as the includeInternalSymbols field is set to false and the Bar<> class is internal -
                        //   we must skip generation of the `_field` private field.
                        private Bar<T> _field;
                    }
                }
                """,
            expected: """
                namespace A
                {
                    public partial struct Foo<T>
                    {
                        private object _dummy;
                        private int _dummyPrimitive;
                    }
                }
                """,
                includeInternalSymbols: false);
        }

        [Fact]
        public void TestBaseTypeWithoutExplicitDefault()
        {
            RunTest(original: """
                    namespace A
                    {
                        public class B
                        {
                        }

                        public class C : B
                        {
                            public C() {}
                        }
                    }
                    """,
                expected: """
                    namespace A
                    {
                        public partial class B
                        {
                        }

                        public partial class C : B
                        {
                        }
                    }
                    """);
        }

        [Fact]
        public void TestBaseTypeWithExplicitDefaultConstructor()
        {
            RunTest(original: """
                    namespace A
                    {
                        public class B
                        {
                            public B() {}
                        }

                        public class C : B
                        {
                            public C() {}
                        }
                    }
                    """,
                expected: """
                    namespace A
                    {
                        public partial class B
                        {
                        }

                        public partial class C : B
                        {
                        }
                    }
                    """);
        }

        [Fact]
        public void TestInternalParameterlessConstructors()
        {
            RunTest(original: """
                    namespace A
                    {
                        public class B
                        {
                            internal B() {}
                        }

                        public class C : B
                        {
                            internal C() : base() {}
                        }
                    }
                    """,
                expected: """
                    namespace A
                    {
                        public partial class B
                        {
                            internal B() {}
                        }

                        public partial class C : B
                        {
                            internal C() {}
                        }
                    }
                    """,
                    includeInternalSymbols: false);
        }

        [Fact]
        public void TestInternalParameterizedConstructors()
        {
            RunTest(original: """
                    namespace A
                    {
                        public class B
                        {
                            public B(int i) {}
                        }

                        public class C : B
                        {
                            internal C() : base(0) {}
                        }

                        public class D : B
                        {
                            internal D(int i) : base(i) {}
                        }

                        public class E
                        {
                            internal E(int i) {}
                            internal E(string s) {}
                            internal E(P p) {}
                        }

                        internal class P { }
                    }
                    """,
                expected: """
                    namespace A
                    {
                        public partial class B
                        {
                            public B(int i) {}
                        }

                        public partial class C : B
                        {
                            internal C() : base(default) {}
                        }

                        public partial class D : B
                        {
                            internal D() : base(default) {}
                        }

                        public partial class E
                        {
                            internal E() {}
                        }
                    }
                    """,
                    includeInternalSymbols: false);
        }

        [Fact]
        public void TestInternalParameterizedConstructorsPreserveInternals()
        {
            RunTest(original: """
                    namespace A
                    {
                        public class B
                        {
                            public B(int i) {}
                        }

                        public class C : B
                        {
                            internal C() : base(0) {}
                        }

                        public class D : B
                        {
                            internal D(int i) : base(i) {}
                        }

                        public class E
                        {
                            internal E(int i) {}
                            internal E(string s) {}
                            internal E(P p) {}
                        }

                        internal class P { }
                    }
                    """,
                expected: """
                    namespace A
                    {
                        public partial class B
                        {
                            public B(int i) { }
                        }

                        public partial class C : B
                        {
                            internal C() : base(default) { }
                        }

                        public partial class D : B
                        {
                            internal D(int i) : base(default) { }
                        }

                        public partial class E
                        {
                            internal E(P p) { }

                            internal E(int i) { }

                            internal E(string s) { }
                        }

                        internal partial class P
                        {
                        }
                    }
                    """,
                    includeInternalSymbols: true);
        }

        [Fact]
        public void TestInternalConstructorCallingProtected()
        {
            RunTest(original: """
                    namespace A
                    {
                        public class B
                        {
                            protected B() {}
                        }

                        public class C : B
                        {
                            internal C() {}
                        }
                    }
                    """,
                expected: """
                    namespace A
                    {
                        public partial class B
                        {
                            protected B() {}
                        }

                        public partial class C : B
                        {
                            internal C() {}
                        }
                    }
                    """,
                    includeInternalSymbols: false);
        }

        [Fact]
        public void TestBaseTypeWithoutDefaultConstructor()
        {
            RunTest(original: """
                    namespace Foo
                    {
                        public class A
                        {
                        }

                        public class B
                        {
                            public B(int p1, string p2, A p3) { }
                        }

                        public class C : B
                        {
                            public C() : base(1, "", new A()) {}
                        }
                    }
                    """,
                expected: """
                    namespace Foo
                    {
                        public partial class A
                        {
                        }

                        public partial class B
                        {
                            public B(int p1, string p2, A p3) { }
                        }

                        public partial class C : B
                        {
                            public C() : base(default, default!, default!) {}
                        }
                    }
                    """);
        }

        [Fact]
        public void TestBaseTypeWithMultipleNonDefaultConstructors()
        {
            RunTest(original: """
                    namespace Foo
                    {
                        public class A
                        {
                        }

                        public class B
                        {
                            public B(int p1, string p2, A p3) { }
                            public B(int p1, string p2) { }
                            public B(int p1) { }
                        }

                        public class C : B
                        {
                            public C() : base(1, "", new A()) {}
                        }
                    }
                    """,
                expected: """
                    namespace Foo
                    {
                        public partial class A
                        {
                        }

                        public partial class B
                        {
                            public B(int p1, string p2, A p3) { }
                            public B(int p1, string p2) { }
                            public B(int p1) { }
                        }

                        public partial class C : B
                        {
                            public C() : base(default) {}
                        }
                    }
                    """);
        }

        [Fact]
        public void TestBaseTypeWithAmbiguousNonDefaultConstructors()
        {
            RunTest(original: """
                    namespace Foo
                    {
                        public class A
                        {
                            public A(char c) { }
                            public A(int i) { }
                            public A(string s) { }
                        }

                        public class B : A
                        {
                            public B() : base("") {}
                        }
                    }
                    """,
                expected: """
                    namespace Foo
                    {
                        public partial class A
                        {
                            public A(char c) { }
                            public A(int i) { }
                            public A(string s) { }
                        }

                        public partial class B : A
                        {
                            public B() : base(default(char)) {}
                        }
                    }
                    """);
        }

        [Fact()]
        public void TestBaseTypeWithAmbiguousNonDefaultConstructorsRegression31655()
        {
            RunTest(original: """
                    namespace Foo
                    {
                        public class A
                        {
                            public A(Id id, System.Collections.Generic.IEnumerable<D> deps) { }
                            public A(string s, V v) { }
                        }

                        public class B : A
                        {
                            public B() : base(new Id(), new D[0]) {}
                        }

                        public class D { }

                        public class Id { }

                        public class V { }
                    }
                    """,
                expected: """
                    namespace Foo
                    {
                        public partial class A
                        {
                            public A(Id id, System.Collections.Generic.IEnumerable<D> deps) { }
                            public A(string s, V v) { }
                        }

                        public partial class B : A
                        {
                            public B() : base(default!, default(System.Collections.Generic.IEnumerable<D>)!) {}
                        }

                        public partial class D { }

                        public partial class Id { }

                        public partial class V { }
                    }
                    """);
        }

        [Fact]
        public void TestBaseTypeConstructorWithObsoleteAttribute()
        {
            RunTest(original: """
                    namespace Foo
                    {
                        public class B
                        {
                            public B(int p1, string p2) { }
                            [System.Obsolete("Constructor is deprecated.", true)]
                            public B(int p1) { }
                        }

                        public class C : B
                        {
                            public C() : base(1, "") { }
                        }
                    }
                    """,
                expected: """
                    namespace Foo
                    {
                        public partial class B
                        {
                            public B(int p1, string p2) { }
                            [System.Obsolete("Constructor is deprecated.", true)]
                            public B(int p1) { }
                        }

                        public partial class C : B
                        {
                            public C() : base(default, default!) { }
                        }
                    }
                    """);
        }

        [Fact]
        public void TestObsoleteBaseTypeConstructorWithoutErrorParameter()
        {
            RunTest(original: """
                    namespace Foo
                    {
                        public class B
                        {
                            public B(int p1, string p2) { }
                            [System.Obsolete("Constructor is deprecated.")]
                            public B(int p1) { }
                        }

                        public class C : B
                        {
                            public C() : base(1, "") { }
                        }
                    }
                    """,
                expected: """
                    namespace Foo
                    {
                        public partial class B
                        {
                            public B(int p1, string p2) { }
                            [System.Obsolete("Constructor is deprecated.")]
                            public B(int p1) { }
                        }

                        public partial class C : B
                        {
                            public C() : base(default) { }
                        }
                    }
                    """);
        }

        [Fact]
        public void TestObsoleteBaseTypeConstructorWithoutMessageParameter()
        {
            RunTest(original: """
                    namespace Foo
                    {
                        public class B
                        {
                            public B(int p1, string p2) { }
                            [System.Obsolete(null)]
                            public B(int p1) { }
                        }

                        public class C : B
                        {
                            public C() : base(1, "") { }
                        }
                    }
                    """,
                expected: """
                    namespace Foo
                    {
                        public partial class B
                        {
                            public B(int p1, string p2) { }
                            [System.Obsolete(null)]
                            public B(int p1) { }
                        }

                        public partial class C : B
                        {
                            public C() : base(default) { }
                        }
                    }
                    """);
        }

        [Fact]
        public void TestFilterOutInternalExplicitInterfaceImplementation()
        {
            RunTest(original: """
                    namespace A
                    {
                        internal interface Foo
                        {
                            void XYZ();
                            int ABC { get; set; }
                        }

                        public class Bar : Foo
                        {
                            int Foo.ABC { get => 1; set { } }
                            void Foo.XYZ() { }
                        }
                    }
                    """,
                expected: """
                    namespace A
                    {
                        public partial class Bar
                        {
                        }
                    }
                    """,
                includeInternalSymbols: false);
        }

        [Fact]
        public void TestMethodsWithReferenceParameterGeneration()
        {
            RunTest(original: """
                    namespace A
                    {
                        public class foo
                        {
                            public void Execute(out int i) { i = 1; }
                        }
                    }
                    """,
                expected: """
                    namespace A
                    {
                        public partial class foo
                        {
                            public void Execute(out int i) { throw null; }
                        }
                    }
                    """,
                includeInternalSymbols: false);
        }

        [Fact(Skip = "https://github.com/dotnet/roslyn/issues/74109")]
        public void TestInterfaceWithOperatorGeneration()
        {
            RunTest(original: """
                    namespace A
                    {
                        public interface IntType
                        {
                            public static IntType operator +(IntType left, IntType right) => left + right;
                        }
                    }
                    """,
                expected: """
                    namespace A
                    {
                        public partial interface IntType
                        {
                            public static IntType operator +(IntType left, IntType right) => left + right;
                        }
                    }
                    """,
                 includeInternalSymbols: false);
        }

        [Fact(Skip = "https://github.com/dotnet/roslyn/issues/74109")]
        public void TestInterfaceWithCheckedOperatorGeneration()
        {
            RunTest(original: """
                    namespace A
                    {
                        public interface IAdditionOperators<TSelf, TOther, TResult>
                            where TSelf : IAdditionOperators<TSelf, TOther, TResult>?
                        {
                            static abstract TResult operator +(TSelf left, TOther right);
                            static virtual TResult operator checked +(TSelf left, TOther right) => left + right;
                        }
                    }
                    """,
                expected: """
                    namespace A
                    {
                        public interface IAdditionOperators<TSelf, TOther, TResult>
                            where TSelf : IAdditionOperators<TSelf, TOther, TResult>?
                        {
                            static abstract TResult operator +(TSelf left, TOther right);
                            static virtual TResult operator checked +(TSelf left, TOther right) { throw null; }
                        }
                    }
                    """,
                 includeInternalSymbols: false);
        }

        [Fact]
        public void TestUnsafeFieldGeneration()
        {
            RunTest(original: """
                    namespace A
                    {
                        public struct Node
                        {
                            public unsafe Node* Left;
                            public unsafe Node* Right;
                            public int Value;
                        }
                    }
                    """,
                expected: """
                    namespace A
                    {
                        public partial struct Node
                        {
                            public unsafe Node* Left;
                            public unsafe Node* Right;
                            public int Value;
                        }
                    }
                    """,
                includeInternalSymbols: false,
                allowUnsafe: true);
        }

        [Fact]
        public void TestUnsafeMethodGeneration()
        {
            RunTest(original: """
                    namespace A
                    {
                        public unsafe class A
                        {
                            public virtual void F(char* p) {}
                        }

                        public class B: A
                        {
                            public unsafe override void F(char* p) {}
                        }
                    }
                    """,
                expected: """
                    namespace A
                    {
                        public partial class A
                        {
                            public virtual unsafe void F(char* p) { }
                        }

                        public partial class B : A
                        {
                            public override unsafe void F(char* p) { }
                        }
                    }
                    """,
                includeInternalSymbols: false,
                allowUnsafe: true);
        }

        [Fact]
        public void TestUnsafeConstructorGeneration()
        {
            RunTest(original: """
                    namespace A
                    {
                        public class Bar
                        {
                            public unsafe Bar(char* f) { }
                        }

                        public class Foo : Bar
                        {
                            public unsafe Foo(char* f) : base(f) { }
                        }
                    }
                    """,
                expected: """
                    namespace A
                    {
                        public partial class Bar
                        {
                            public unsafe Bar(char* f) { }
                        }

                        public partial class Foo : Bar
                        {
                            public unsafe Foo(char* f) : base(default) { }
                        }
                    }
                    """,
                includeInternalSymbols: false,
                allowUnsafe: true);
        }

        [Fact]
        public void TestUnsafeBaseConstructorGeneration()
        {
            RunTest(original: """
                    namespace A
                    {
                        public class Bar
                        {
                            public unsafe Bar(char* f) { }
                        }

                        public class Foo : Bar
                        {
                            public unsafe Foo() : base(default) { }
                        }
                    }
                    """,
                expected: """
                    namespace A
                    {
                        public partial class Bar
                        {
                            public unsafe Bar(char* f) { }
                        }

                        public partial class Foo : Bar
                        {
                            public unsafe Foo() : base(default) { }
                        }
                    }
                    """,
                includeInternalSymbols: false,
                allowUnsafe: true);
        }

        [Fact]
        public void TestInternalDefaultConstructorGeneration()
        {
            RunTest(original: """
                    namespace A
                    {
                        public class Bar
                        {
                            public Bar(int a) { }
                        }

                        public class Foo : Bar
                        {
                            internal Foo() : base(1) { }
                        }
                    }
                    namespace B
                    {
                        public class Bar
                        {
                            public Bar(int a) { }
                        }

                        public class Foo : Bar
                        {
                            private Foo() : base(1) { }
                        }
                    }
                    """,
                expected: """
                    namespace A
                    {
                        public partial class Bar
                        {
                            public Bar(int a) { }
                        }

                        public partial class Foo : Bar
                        {
                            internal Foo() : base(default) { }
                        }
                    }
                    namespace B
                    {
                        public partial class Bar
                        {
                            public Bar(int a) { }
                        }

                        public partial class Foo : Bar
                        {
                            internal Foo() : base(default) { }
                        }
                    }
                    """,
                includeInternalSymbols: false);
        }

        [Fact]
        public void TestPrivateDefaultConstructorGeneration()
        {
            RunTest(original: """
                    namespace A
                    {
                        public class Bar
                        {
                            public Bar(int a) { }
                        }

                        public class Foo : Bar
                        {
                            private Foo() : base(1) { }
                        }
                    }
                    """,
                expected: """
                    namespace A
                    {
                        public partial class Bar
                        {
                            public Bar(int a) { }
                        }

                        public partial class Foo : Bar
                        {
                            private Foo() : base(default) { }
                        }
                    }
                    """,
                includeInternalSymbols: true,
                includeEffectivelyPrivateSymbols: true);
        }

        [Fact]
        public void TestInternalDefaultConstructorGenerationForGenericType()
        {
            RunTest(original: """
                    namespace A
                    {
                        public class Bar
                        {
                            public Bar(int a) { }
                        }

                        public class Foo<T> : Bar
                        {
                            internal Foo() : base(1) { }
                        }
                    }
                    """,
                expected: """
                    namespace A
                    {
                        public partial class Bar
                        {
                            public Bar(int a) { }
                        }

                        public partial class Foo<T> : Bar
                        {
                            internal Foo() : base(default) { }
                        }
                    }
                    """,
                includeInternalSymbols: false);
        }

        [Fact]
        public void TestExplicitParameterlessConstructorNotRemoved()
        {
            RunTest(original: """
                    namespace A
                    {
                        public class Bar
                        {
                            public Bar() { }
                            public Bar(int a) { }
                        }
                    }
                    """,
                expected: """
                    namespace A
                    {
                        public partial class Bar
                        {
                            public Bar() { }
                            public Bar(int a) { }
                        }
                    }
                    """,
                includeInternalSymbols: false);
        }

        [Fact]
        public void TestBaseClassWithExplicitDefaultConstructor()
        {
            RunTest(original: """
                    namespace A
                    {
                        public class Bar
                        {
                            public Bar() { }
                        }

                        public class Foo : Bar
                        {
                        }
                    }
                    """,
                expected: """
                    namespace A
                    {
                        public partial class Bar
                        {
                        }

                        public partial class Foo : Bar
                        {
                        }
                    }
                    """,
                includeInternalSymbols: false);
        }

        [Fact]
        public void TestGenericBaseInterfaceWithInaccessibleTypeArguments()
        {
            RunTest(original: """
                    namespace A
                    {
                        internal class IOption2
                        {
                        }

                        public interface IOption
                        {
                        }

                        public interface AreEqual<T>
                        {
                            bool Compare(T other);
                        }

                        public class PerLanguageOption : AreEqual<IOption2>, IOption
                        {
                            bool AreEqual<IOption2>.Compare(IOption2 other) => false;
                        }
                    }
                    """,
                expected: """
                    namespace A
                    {
                        public partial interface AreEqual<T>
                        {
                            bool Compare(T other);
                        }

                        public partial interface IOption
                        {
                        }

                        public partial class PerLanguageOption : IOption
                        {
                        }
                    }
                    """,
                includeInternalSymbols: false);
        }

        [Fact]
        public void NewKeywordWhenBaseMethodIsHidden()
        {
            RunTest(original: """
                    namespace A
                    {
                        using System;
                        public partial class C : IFun, IExplicit, IExplicit2 {
                            public int Foo;
                            public const int Bar = 29;
                            public int Baz { get; }
                            public int ExplicitProperty { get; }
                            #pragma warning disable 8618
                            public event EventHandler MyEvent;
                            void IExplicit.Explicit() {}
                            #pragma warning disable 8625
                            public void Do() => MyEvent(default(object), default(EventArgs));
                            public void Do(float f) {}
                            public static void DoStatic() {}
                            public void Explicit2() {}
                            public void Fun() {}
                            public void Gen<T>() {}
                            public void Zoo() {}
                            public class MyNestedClass {}
                            public struct MyNestedStruct {}
                            public class MyNestedGenericClass<T> {}
                            public struct MyNestedGenericStruct<T> {}
                            public C this[int i]
                            {
                              get => default(C)!;
                              set {}
                            }
                        }
                        public class D : C, IExplicit, IExplicit2 {
                            public new int Foo;
                            public new const int Bar = 30;
                            int IExplicit2.ExplicitProperty { get; }
                            public new int Baz { get; set; }
                            public new event EventHandler MyEvent;
                            void IExplicit2.Explicit2() {}
                            public new void Do() => MyEvent(default(object), default(EventArgs));
                            public void Do(int i) {}
                            public new static void DoStatic() {}
                            public void Explicit() {}
                            public new void Fun() {}
                            public new void Gen<T>() where T : IComparable {}
                            public new class MyNestedClass {}
                            public new struct MyNestedStruct {}
                            public new class MyNestedGenericClass<T> {}
                            public new struct MyNestedGenericStruct<T> {}
                            public new D this[int i]
                            {
                              get => default(D)!;
                              set {}
                            }
                        }
                        public class E : C, IExplicit, IExplicit2 {
                            public new int Bar;
                            public new const int Do = 30;
                            int IExplicit2.ExplicitProperty { get; }
                            public new int Foo { get; set; }
                            public new event EventHandler MyNestedClass;
                            void IExplicit.Explicit() {}
                            void IExplicit2.Explicit2() {}
                            public new void Baz() => MyNestedClass(default(object), default(EventArgs));
                            public new void MyNestedStruct(double d) {}
                            public new void Zoo() {}
                        }
                        public interface IExplicit {
                            void Explicit();
                        }
                        public interface IExplicit2 {
                            int ExplicitProperty { get; }
                            void Explicit2();
                        }
                        public interface IFun {
                            void Fun();
                        }
                    }
                    """,
                    expected: """
                    namespace A
                    {
                        public partial class C : IFun, IExplicit, IExplicit2
                        {
                            public const int Bar = 29;
                            public int Foo;
                            public int Baz { get { throw null; } }
                            public int ExplicitProperty { get { throw null; } }
                            public C this[int i] { get { throw null; } set {} }
                            public event System.EventHandler MyEvent { add {} remove {} }
                            void IExplicit.Explicit() {}
                            public void Do() {}
                            public void Do(float f) {}
                            public static void DoStatic() {}
                            public void Explicit2() {}
                            public void Fun() {}
                            public void Gen<T>() {}
                            public void Zoo() {}
                            public partial class MyNestedClass {}
                            public partial class MyNestedGenericClass<T> {}
                            public partial struct MyNestedGenericStruct<T> {}
                            public partial struct MyNestedStruct {}
                        }
                        public partial class D : C, IExplicit, IExplicit2
                        {
                            public new const int Bar = 30;
                            public new int Foo;
                            int IExplicit2.ExplicitProperty { get { throw null; } }
                            public new int Baz { get { throw null; } set {} }
                            public new D this[int i] { get { throw null; } set {} }
                            public new event System.EventHandler MyEvent { add {} remove {} }
                            void IExplicit2.Explicit2() {}
                            public new void Do() {}
                            public void Do(int i) {}
                            public new static void DoStatic() {}
                            public void Explicit() {}
                            public new void Fun() {}
                            public new void Gen<T>() where T : System.IComparable {}
                            public new partial class MyNestedClass {}
                            public new partial class MyNestedGenericClass<T> {}
                            public new partial struct MyNestedGenericStruct<T> {}
                            public new partial struct MyNestedStruct {}
                        }
                        public partial class E : C, IExplicit, IExplicit2
                        {
                            public new int Bar;
                            public new const int Do = 30;
                            int IExplicit2.ExplicitProperty { get { throw null; } }
                            public new int Foo { get { throw null; } set {} }
                            public new event System.EventHandler MyNestedClass { add {} remove {} }
                            void IExplicit.Explicit() {}
                            void IExplicit2.Explicit2() {}
                            public new void Baz() {}
                            public new void MyNestedStruct(double d) {}
                            public new void Zoo() {}
                        }
                        public partial interface IExplicit {
                            void Explicit();
                        }
                        public partial interface IExplicit2 {
                            int ExplicitProperty { get; }
                            void Explicit2();
                        }
                        public partial interface IFun {
                            void Fun();
                        }
                    }
                    """);
        }

        [Theory]
        [InlineData(true)]
        [InlineData(false)]
        public void TestAttributeWithInternalTypeArgumentOmitted(bool includeInternalSymbols)
        {
            string expected = includeInternalSymbols ? """
                    namespace A
                    {
                        public partial class AnyTestAttribute : System.Attribute
                        {
                            public AnyTestAttribute(System.Type xType) { }

                            public System.Type XType { get { throw null; } set { } }
                        }

                        internal partial class InternalClass
                        {
                        }

                        [AnyTest(typeof(InternalClass))]
                        [System.Obsolete]
                        public partial class PublicClass
                        {
                        }
                    }
                    """ : """
                    namespace A
                    {
                        public partial class AnyTestAttribute : System.Attribute
                        {
                            public AnyTestAttribute(System.Type xType) { }

                            public System.Type XType { get { throw null; } set { } }
                        }

                        [System.Obsolete]
                        public partial class PublicClass
                        {
                        }
                    }
                    """;

            RunTest(original: """
                    namespace A
                    {
                        internal class InternalClass { }
                        public partial class AnyTestAttribute : System.Attribute
                        {
                            public AnyTestAttribute(System.Type xType)
                            {
                                XType = xType;
                            }

                            public System.Type XType { get; set; }
                        }

                        [AnyTest(typeof(InternalClass))]
                        [System.Obsolete]
                        public class PublicClass { }
                    }
                    """,
                expected: expected,
                includeInternalSymbols: includeInternalSymbols);
        }

        [Fact]
        public void TestAttributesExcludedWithFilter()
        {
            RunTest(original: """
                    namespace A
                    {
                        public partial class AnyTestAttribute : System.Attribute
                        {
                            public AnyTestAttribute(System.Type xType)
                            {
                                XType = xType;
                            }

                            public System.Type XType { get; set; }
                        }

                        [AnyTest(typeof(string))]
                        [System.Obsolete]
                        public class PublicClass { }
                    }
                    """,
                expected: """
                    namespace A
                    {
                        public partial class AnyTestAttribute : System.Attribute
                        {
                            public AnyTestAttribute(System.Type xType) { }

                            public System.Type XType { get { throw null; } set { } }
                        }

                        [System.Obsolete]
                        public partial class PublicClass
                        {
                        }
                    }
                    """,
                includeInternalSymbols: false,
                excludedAttributeList: ["T:A.AnyTestAttribute"]);
        }

        [Fact]
        public void TestGenericClassImplementsGenericInterface()
        {
            RunTest(original: """
                    using System;
                    namespace A
                    {
                        public class Foo<T> : System.Collections.ICollection, System.Collections.Generic.ICollection<T>
                        {
                            int System.Collections.Generic.ICollection<T>.Count => throw new NotImplementedException();
                            bool System.Collections.Generic.ICollection<T>.IsReadOnly => throw new NotImplementedException();
                            int System.Collections.ICollection.Count => throw new NotImplementedException();
                            bool System.Collections.ICollection.IsSynchronized => throw new NotImplementedException();
                            object System.Collections.ICollection.SyncRoot => throw new NotImplementedException();
                            void System.Collections.Generic.ICollection<T>.Add(T item) => throw new NotImplementedException();
                            void System.Collections.Generic.ICollection<T>.Clear() => throw new NotImplementedException();
                            bool System.Collections.Generic.ICollection<T>.Contains(T item) => throw new NotImplementedException();
                            void System.Collections.Generic.ICollection<T>.CopyTo(T[] array, int arrayIndex) => throw new NotImplementedException();
                            bool System.Collections.Generic.ICollection<T>.Remove(T item) => throw new NotImplementedException();
                            System.Collections.Generic.IEnumerator<T> System.Collections.Generic.IEnumerable<T>.GetEnumerator() => throw new NotImplementedException();
                            void System.Collections.ICollection.CopyTo(System.Array array, int index) => throw new NotImplementedException();
                            System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() => throw new NotImplementedException();

                        }
                    }

                    """,
                // https://github.com/dotnet/sdk/issues/32195 tracks interface expansion
                expected: """
                    namespace A
                    {
                        public partial class Foo<T> : System.Collections.ICollection, System.Collections.IEnumerable, System.Collections.Generic.ICollection<T>, System.Collections.Generic.IEnumerable<T>
                        {
                            int System.Collections.Generic.ICollection<T>.Count { get { throw null; } }
                            bool System.Collections.Generic.ICollection<T>.IsReadOnly { get { throw null; } }
                            int System.Collections.ICollection.Count { get { throw null; } }
                            bool System.Collections.ICollection.IsSynchronized { get { throw null; } }
                            object System.Collections.ICollection.SyncRoot { get { throw null; } }
                            void System.Collections.Generic.ICollection<T>.Add(T item) { }
                            void System.Collections.Generic.ICollection<T>.Clear() { }
                            bool System.Collections.Generic.ICollection<T>.Contains(T item) { throw null; }
                            void System.Collections.Generic.ICollection<T>.CopyTo(T[] array, int arrayIndex) { }
                            bool System.Collections.Generic.ICollection<T>.Remove(T item) { throw null; }
                            System.Collections.Generic.IEnumerator<T> System.Collections.Generic.IEnumerable<T>.GetEnumerator() { throw null; }
                            void System.Collections.ICollection.CopyTo(System.Array array, int index) { }
                            System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() { throw null; }
                        }
                    }
                    """,
                includeInternalSymbols: false);
        }

        [Fact]
        public void TestTypeForwardsToGenericTypesRegression31250()
        {
            RunTest(original: """
                    [assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Action))]
                    [assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Action<,>))]
                    [assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Action<,,>))]
                    [assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Action<,,,>))]
                    [assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Action<,,,,>))]
                    [assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Action<,,,,,>))]
                    [assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Action<,,,,,,>))]
                    [assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Action<,,,,,,,>))]
                    [assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Action<,,,,,,,,>))]
                    [assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.ValueTuple))]
                    [assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.ValueTuple<>))]
                    [assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.ValueTuple<,>))]
                    [assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.ValueTuple<,,>))]
                    [assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.ValueTuple<,,,>))]
                    [assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.ValueTuple<,,,,>))]
                    [assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.ValueTuple<,,,,,>))]
                    [assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.ValueTuple<,,,,,,>))]
                    [assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.ValueTuple<,,,,,,,>))]
                    """,
                expected: """
                    [assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Action))]
                    [assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Action<,>))]
                    [assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Action<,,>))]
                    [assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Action<,,,>))]
                    [assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Action<,,,,>))]
                    [assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Action<,,,,,>))]
                    [assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Action<,,,,,,>))]
                    [assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Action<,,,,,,,>))]
                    [assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Action<,,,,,,,,>))]
                    [assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.ValueTuple))]
                    [assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.ValueTuple<>))]
                    [assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.ValueTuple<,>))]
                    [assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.ValueTuple<,,>))]
                    [assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.ValueTuple<,,,>))]
                    [assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.ValueTuple<,,,,>))]
                    [assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.ValueTuple<,,,,,>))]
                    [assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.ValueTuple<,,,,,,>))]
                    [assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.ValueTuple<,,,,,,,>))]
                    """,
                includeInternalSymbols: false);
        }

        [Fact]
        public void ReservedAttributesAreOmitted()
        {
            RunTest(original: """
                namespace N {
                    public ref struct C<T>
                        where T : unmanaged
                    {
                        public required (string? k, dynamic v, nint n) X { get; init; }
                    }

                    public static class E
                    {
                        public static void M<T>(this object c, scoped System.ReadOnlySpan<T> values) { }
                    }
                }
                """,
                expected: """
                namespace N
                {
                    public ref partial struct C<T>
                        where T : unmanaged
                    {
                        public required (string? k, dynamic v, nint n) X { get { throw null; } init { } }
                    }

                    public static partial class E
                    {
                        public static void M<T>(this object c, scoped System.ReadOnlySpan<T> values) { }
                    }
                }
                """);
        }

        [Fact]
        public void TestExplicitInterfaceIndexer()
        {
            RunTest(original: """
                    namespace a
                    {
                        public interface IFooList
                        {
                             object this[int index] { get; set; }
                        }

                        public struct Bar : IFooList
                        {
                        #pragma warning disable CS8597
                            public string this[int index] { get { throw null; } set { } }
                            object IFooList.this[int index] { get { throw null; } set { } }
                        #pragma warning restore CS8597
                        }
                    }
                    """,
                expected: """
                    namespace a
                    {
                        public partial struct Bar : IFooList
                        {
                            object IFooList.this[int index] { get { throw null; } set { } }
                            public string this[int index] { get { throw null; } set { } }
                        }

                        public partial interface IFooList
                        {
                            object this[int index] { get; set; }
                        }
                    }
                    """,
                includeInternalSymbols: false);
        }

        [Fact]
        public void TestExplicitInterfaceNonGenericCollections()
        {
            RunTest(original: """
                    using System;
                    using System.Collections;
                    namespace a
                    {
                        #pragma warning disable CS8597

                        public partial class MyStringCollection : ICollection, IEnumerable, IList
                        {
                            public int Count { get { throw null; } }
                            public string this[int index] { get { throw null; } set { } }
                            bool ICollection.IsSynchronized { get { throw null; } }
                            object ICollection.SyncRoot { get { throw null; } }
                            bool IList.IsFixedSize { get { throw null; } }
                            bool IList.IsReadOnly { get { throw null; } }
                            object? IList.this[int index] { get { throw null; } set { } }
                            public int Add(string value) { throw null; }
                            public void AddRange(string[] value) { }
                            public void AddRange(MyStringCollection value) { }
                            public void Clear() { }
                            public bool Contains(string value) { throw null; }
                            public void CopyTo(string[] array, int index) { }
                            public override int GetHashCode() { throw null; }
                            public int IndexOf(string value) { throw null; }
                            public void Insert(int index, string value) { }
                            public void Remove(string value) { }
                            public void RemoveAt(int index) { }
                            void ICollection.CopyTo(Array array, int index) { }
                            IEnumerator IEnumerable.GetEnumerator() { throw null; }
                            int IList.Add(object? value) { throw null; }
                            bool IList.Contains(object? value) { throw null; }
                            int IList.IndexOf(object? value) { throw null; }
                            void IList.Insert(int index, object? value) { }
                            void IList.Remove(object? value) { }
                        }

                        #pragma warning restore CS8597
                    }
                    """,
                expected: """
                    namespace a
                    {
                        public partial class MyStringCollection : System.Collections.ICollection, System.Collections.IEnumerable, System.Collections.IList
                        {
                            public int Count { get { throw null; } }
                            public string this[int index] { get { throw null; } set { } }
                            bool System.Collections.ICollection.IsSynchronized { get { throw null; } }
                            object System.Collections.ICollection.SyncRoot { get { throw null; } }
                            bool System.Collections.IList.IsFixedSize { get { throw null; } }
                            bool System.Collections.IList.IsReadOnly { get { throw null; } }
                            object? System.Collections.IList.this[int index] { get { throw null; } set { } }
                            public int Add(string value) { throw null; }
                            public void AddRange(MyStringCollection value) { }
                            public void AddRange(string[] value) { }
                            public void Clear() { }
                            public bool Contains(string value) { throw null; }
                            public void CopyTo(string[] array, int index) { }
                            public override int GetHashCode() { throw null; }
                            public int IndexOf(string value) { throw null; }
                            public void Insert(int index, string value) { }
                            public void Remove(string value) { }
                            public void RemoveAt(int index) { }
                            void System.Collections.ICollection.CopyTo(System.Array array, int index) { }
                            System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() { throw null; }
                            int System.Collections.IList.Add(object? value) { throw null; }
                            bool System.Collections.IList.Contains(object? value) { throw null; }
                            int System.Collections.IList.IndexOf(object? value) { throw null; }
                            void System.Collections.IList.Insert(int index, object? value) { }
                            void System.Collections.IList.Remove(object? value) { }
                        }
                    }
                    """,
                includeInternalSymbols: false);
        }
    }
}