File: src\Analyzers\CSharp\Tests\GenerateDefaultConstructors\GenerateDefaultConstructorsTests.cs
Web Access
Project: src\src\Features\CSharpTest\Microsoft.CodeAnalysis.CSharp.Features.UnitTests.csproj (Microsoft.CodeAnalysis.CSharp.Features.UnitTests)
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.
 
using System.Threading.Tasks;
using Microsoft.CodeAnalysis.CSharp;
using Microsoft.CodeAnalysis.CSharp.GenerateDefaultConstructors;
using Microsoft.CodeAnalysis.Editor.UnitTests.CodeActions;
using Microsoft.CodeAnalysis.GenerateDefaultConstructors;
using Microsoft.CodeAnalysis.Test.Utilities;
using Microsoft.CodeAnalysis.Testing;
using Roslyn.Test.Utilities;
using Xunit;
 
namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.GenerateDefaultConstructors;
 
using VerifyCodeFix = CSharpCodeFixVerifier<
    EmptyDiagnosticAnalyzer,
    CSharpGenerateDefaultConstructorsCodeFixProvider>;
 
#if !CODE_STYLE
using VerifyRefactoring = CSharpCodeRefactoringVerifier<
    GenerateDefaultConstructorsCodeRefactoringProvider>;
#endif
 
[UseExportProvider]
public class GenerateDefaultConstructorsTests
{
#if !CODE_STYLE
    private static async Task TestRefactoringAsync(string source, string fixedSource, int index = 0)
    {
        await TestRefactoringOnlyAsync(source, fixedSource, index);
        await TestCodeFixMissingAsync(source);
    }
 
    private static async Task TestRefactoringOnlyAsync(string source, string fixedSource, int index = 0)
    {
        await new VerifyRefactoring.Test
        {
            TestCode = source,
            FixedCode = fixedSource,
            CodeActionIndex = index,
            LanguageVersion = LanguageVersion.CSharp10,
        }.RunAsync();
    }
#endif
 
    private static async Task TestCodeFixAsync(string source, string fixedSource, int index = 0)
    {
        await new VerifyCodeFix.Test
        {
            TestCode = source.Replace("[||]", ""),
            FixedCode = fixedSource,
            CodeActionIndex = index,
            LanguageVersion = LanguageVersion.CSharp10,
        }.RunAsync();
 
#if !CODE_STYLE
        await TestRefactoringMissingAsync(source);
#endif
    }
 
#if !CODE_STYLE
    private static async Task TestRefactoringMissingAsync(string source)
    {
        await new VerifyRefactoring.Test
        {
            TestCode = source,
            LanguageVersion = LanguageVersion.CSharp10,
        }.RunAsync();
    }
#endif
 
    private static async Task TestCodeFixMissingAsync(string source)
    {
        source = source.Replace("[||]", "");
        await new VerifyCodeFix.Test
        {
            TestCode = source,
            LanguageVersion = LanguageVersion.CSharp10,
        }.RunAsync();
    }
 
    [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateDefaultConstructors)]
    public async Task TestProtectedBase()
    {
        await TestCodeFixAsync(
            """
            class {|CS7036:C|} : [||]B
            {
            }
 
            class B
            {
                protected B(int x)
                {
                }
            }
            """,
            """
            class C : B
            {
                protected C(int x) : base(x)
                {
                }
            }
 
            class B
            {
                protected B(int x)
                {
                }
            }
            """);
    }
 
    [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateDefaultConstructors)]
    public async Task TestPublicBase()
    {
        await TestCodeFixAsync(
            """
            class {|CS7036:C|} : [||]B
            {
            }
 
            class B
            {
                public B(int x)
                {
                }
            }
            """,
            """
            class C : B
            {
                public C(int x) : base(x)
                {
                }
            }
 
            class B
            {
                public B(int x)
                {
                }
            }
            """);
    }
 
    [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateDefaultConstructors)]
    public async Task TestInternalBase()
    {
        await TestCodeFixAsync(
            """
            class {|CS7036:C|} : [||]B
            {
            }
 
            class B
            {
                internal B(int x)
                {
                }
            }
            """,
            """
            class C : B
            {
                internal C(int x) : base(x)
                {
                }
            }
 
            class B
            {
                internal B(int x)
                {
                }
            }
            """);
    }
 
    [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateDefaultConstructors)]
    public async Task TestRefOutParams()
    {
        await TestCodeFixAsync(
            """
            class {|CS7036:C|} : [||]B
            {
            }
 
            class B
            {
                internal B(ref int x, out string s, params bool[] b)
                {
                    s = null;
                }
            }
            """,
            """
            class C : B
            {
                internal C(ref int x, out string s, params bool[] b) : base(ref x, out s, b)
                {
                }
            }
 
            class B
            {
                internal B(ref int x, out string s, params bool[] b)
                {
                    s = null;
                }
            }
            """);
    }
 
    [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateDefaultConstructors)]
    public async Task TestFix1()
    {
        await TestCodeFixAsync(
            """
            class {|CS1729:C|} : [||]B
            {
            }
 
            class B
            {
                internal B(int x)
                {
                }
 
                protected B(string x)
                {
                }
 
                public B(bool x)
                {
                }
            }
            """,
            """
            class C : B
            {
                internal C(int x) : base(x)
                {
                }
            }
 
            class B
            {
                internal B(int x)
                {
                }
 
                protected B(string x)
                {
                }
 
                public B(bool x)
                {
                }
            }
            """);
    }
 
    [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateDefaultConstructors)]
    public async Task TestFix2()
    {
        await TestCodeFixAsync(
            """
            class {|CS1729:C|} : [||]B
            {
            }
 
            class B
            {
                internal B(int x)
                {
                }
 
                protected B(string x)
                {
                }
 
                public B(bool x)
                {
                }
            }
            """,
            """
            class C : B
            {
                protected C(string x) : base(x)
                {
                }
            }
 
            class B
            {
                internal B(int x)
                {
                }
 
                protected B(string x)
                {
                }
 
                public B(bool x)
                {
                }
            }
            """,
index: 1);
    }
 
    [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateDefaultConstructors)]
    public async Task TestRefactoring1()
    {
        await TestCodeFixAsync(
            """
            class {|CS1729:C|} : [||]B
            {
            }
 
            class B
            {
                internal B(int x)
                {
                }
 
                protected B(string x)
                {
                }
 
                public B(bool x)
                {
                }
            }
            """,
            """
            class C : B
            {
                public C(bool x) : base(x)
                {
                }
            }
 
            class B
            {
                internal B(int x)
                {
                }
 
                protected B(string x)
                {
                }
 
                public B(bool x)
                {
                }
            }
            """,
index: 2);
    }
 
    [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateDefaultConstructors)]
    public async Task TestFixAll1()
    {
        await TestCodeFixAsync(
            """
            class {|CS1729:C|} : [||]B
            {
            }
 
            class B
            {
                internal B(int x)
                {
                }
 
                protected B(string x)
                {
                }
 
                public B(bool x)
                {
                }
            }
            """,
            """
            class C : B
            {
                public C(bool x) : base(x)
                {
                }
 
                protected C(string x) : base(x)
                {
                }
 
                internal C(int x) : base(x)
                {
                }
            }
 
            class B
            {
                internal B(int x)
                {
                }
 
                protected B(string x)
                {
                }
 
                public B(bool x)
                {
                }
            }
            """,
index: 3);
    }
 
    [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateDefaultConstructors), CompilerTrait(CompilerFeature.Tuples)]
    public async Task Tuple()
    {
        await TestCodeFixAsync(
            """
            class {|CS7036:C|} : [||]B
            {
            }
 
            class B
            {
                public B((int, string) x)
                {
                }
            }
            """,
            """
            class C : B
            {
                public C((int, string) x) : base(x)
                {
                }
            }
 
            class B
            {
                public B((int, string) x)
                {
                }
            }
            """);
    }
 
    [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateDefaultConstructors), CompilerTrait(CompilerFeature.Tuples)]
    public async Task TupleWithNames()
    {
        await TestCodeFixAsync(
            """
            class {|CS7036:C|} : [||]B
            {
            }
 
            class B
            {
                public B((int a, string b) x)
                {
                }
            }
            """,
            """
            class C : B
            {
                public C((int a, string b) x) : base(x)
                {
                }
            }
 
            class B
            {
                public B((int a, string b) x)
                {
                }
            }
            """);
    }
 
    [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateConstructor)]
    [WorkItem("https://github.com/dotnet/Roslyn/issues/6541")]
    public async Task TestGenerateFromDerivedClass()
    {
        await TestCodeFixAsync(
            """
            class Base
            {
                public Base(string value)
                {
                }
            }
 
            class [||]{|CS7036:Derived|} : Base
            {
            }
            """,
            """
            class Base
            {
                public Base(string value)
                {
                }
            }
 
            class Derived : Base
            {
                public Derived(string value) : base(value)
                {
                }
            }
            """);
    }
 
    [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateConstructor)]
    [WorkItem("https://github.com/dotnet/Roslyn/issues/6541")]
    public async Task TestGenerateFromDerivedClass2()
    {
        await TestCodeFixAsync(
            """
            class Base
            {
                public Base(int a, string value = null)
                {
                }
            }
 
            class [||]{|CS7036:Derived|} : Base
            {
            }
            """,
            """
            class Base
            {
                public Base(int a, string value = null)
                {
                }
            }
 
            class Derived : Base
            {
                public Derived(int a, string value = null) : base(a, value)
                {
                }
            }
            """);
    }
 
    [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateDefaultConstructors)]
    [WorkItem("https://github.com/dotnet/roslyn/issues/25238")]
    public async Task TestGenerateConstructorFromProtectedConstructor()
    {
        await TestCodeFixAsync(
            """
            abstract class {|CS7036:C|} : [||]B
            {
            }
 
            abstract class B
            {
                protected B(int x)
                {
                }
            }
            """,
            """
            abstract class C : B
            {
                protected C(int x) : base(x)
                {
                }
            }
 
            abstract class B
            {
                protected B(int x)
                {
                }
            }
            """);
    }
 
    [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateDefaultConstructors)]
    [WorkItem("https://github.com/dotnet/roslyn/issues/25238")]
    public async Task TestGenerateConstructorFromProtectedConstructor2()
    {
        await TestCodeFixAsync(
            """
            class {|CS7036:C|} : [||]B
            {
            }
 
            abstract class B
            {
                protected B(int x)
                {
                }
            }
            """,
            """
            class C : B
            {
                public C(int x) : base(x)
                {
                }
            }
 
            abstract class B
            {
                protected B(int x)
                {
                }
            }
            """);
    }
 
    [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateDefaultConstructors)]
    [WorkItem("https://github.com/dotnet/roslyn/issues/35208")]
    [WorkItem("https://github.com/dotnet/roslyn/issues/25238")]
    public async Task TestGenerateConstructorInAbstractClassFromPublicConstructor()
    {
        await TestCodeFixAsync(
            """
            abstract class {|CS7036:C|} : [||]B
            {
            }
 
            abstract class B
            {
                public B(int x)
                {
                }
            }
            """,
            """
            abstract class C : B
            {
                protected C(int x) : base(x)
                {
                }
            }
 
            abstract class B
            {
                public B(int x)
                {
                }
            }
            """);
    }
 
    [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateDefaultConstructors)]
    [WorkItem("https://github.com/dotnet/roslyn/issues/25238")]
    public async Task TestGenerateConstructorFromPublicConstructor2()
    {
        await TestCodeFixAsync(
            """
            class {|CS7036:C|} : [||]B
            {
            }
 
            abstract class B
            {
                public B(int x)
                {
                }
            }
            """,
            """
            class C : B
            {
                public C(int x) : base(x)
                {
                }
            }
 
            abstract class B
            {
                public B(int x)
                {
                }
            }
            """);
    }
 
    [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateDefaultConstructors)]
    [WorkItem("https://github.com/dotnet/roslyn/issues/25238")]
    public async Task TestGenerateConstructorFromInternalConstructor()
    {
        await TestCodeFixAsync(
            """
            abstract class {|CS7036:C|} : [||]B
            {
            }
 
            abstract class B
            {
                internal B(int x)
                {
                }
            }
            """,
            """
            abstract class C : B
            {
                internal C(int x) : base(x)
                {
                }
            }
 
            abstract class B
            {
                internal B(int x)
                {
                }
            }
            """);
    }
 
    [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateDefaultConstructors)]
    [WorkItem("https://github.com/dotnet/roslyn/issues/25238")]
    public async Task TestGenerateConstructorFromInternalConstructor2()
    {
        await TestCodeFixAsync(
            """
            class {|CS7036:C|} : [||]B
            {
            }
 
            abstract class B
            {
                internal B(int x)
                {
                }
            }
            """,
            """
            class C : B
            {
                public C(int x) : base(x)
                {
                }
            }
 
            abstract class B
            {
                internal B(int x)
                {
                }
            }
            """);
    }
 
    [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateDefaultConstructors)]
    [WorkItem("https://github.com/dotnet/roslyn/issues/25238")]
    public async Task TestGenerateConstructorFromProtectedInternalConstructor()
    {
        await TestCodeFixAsync(
            """
            abstract class {|CS7036:C|} : [||]B
            {
            }
 
            abstract class B
            {
                protected internal B(int x)
                {
                }
            }
            """,
            """
            abstract class C : B
            {
                protected internal C(int x) : base(x)
                {
                }
            }
 
            abstract class B
            {
                protected internal B(int x)
                {
                }
            }
            """);
    }
 
    [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateDefaultConstructors)]
    [WorkItem("https://github.com/dotnet/roslyn/issues/25238")]
    public async Task TestGenerateConstructorFromProtectedInternalConstructor2()
    {
        await TestCodeFixAsync(
            """
            class {|CS7036:C|} : [||]B
            {
            }
 
            abstract class B
            {
                protected internal B(int x)
                {
                }
            }
            """,
            """
            class C : B
            {
                public C(int x) : base(x)
                {
                }
            }
 
            abstract class B
            {
                protected internal B(int x)
                {
                }
            }
            """);
    }
 
    [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateDefaultConstructors)]
    [WorkItem("https://github.com/dotnet/roslyn/issues/25238")]
    public async Task TestGenerateConstructorFromPrivateProtectedConstructor()
    {
        await TestCodeFixAsync(
            """
            abstract class {|CS7036:C|} : [||]B
            {
            }
 
            abstract class B
            {
                private protected B(int x)
                {
                }
            }
            """,
            """
            abstract class C : B
            {
                private protected C(int x) : base(x)
                {
                }
            }
 
            abstract class B
            {
                private protected B(int x)
                {
                }
            }
            """);
    }
 
    [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateDefaultConstructors)]
    [WorkItem("https://github.com/dotnet/roslyn/issues/25238")]
    public async Task TestGenerateConstructorFromPrivateProtectedConstructor2()
    {
        await TestCodeFixAsync(
            """
            class {|CS7036:C|} : [||]B
            {
            }
 
            abstract class B
            {
                private protected internal {|CS0107:B|}(int x)
                {
                }
            }
            """,
            """
            class C : B
            {
                public C(int x) : base(x)
                {
                }
            }
 
            abstract class B
            {
                private protected internal {|CS0107:B|}(int x)
                {
                }
            }
            """);
    }
 
    [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateDefaultConstructors)]
    public async Task TestRecord()
    {
        await TestCodeFixAsync(
            """
            record {|CS1729:C|} : [||]B
            {
            }
 
            record B
            {
                public B(int x)
                {
                }
            }
            """,
            """
            record C : B
            {
                public C(int x) : base(x)
                {
                }
            }
 
            record B
            {
                public B(int x)
                {
                }
            }
            """, index: 1);
    }
 
    [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateConstructor)]
    [WorkItem("https://github.com/dotnet/roslyn/issues/58593")]
    public async Task TestStructWithFieldInitializer()
    {
        var source = """
            struct [||]{|CS8983:S|}
            {
                object X = 1;
            }
            """;
        var fixedSource = """
            struct S
            {
                object X = 1;
 
                public S()
                {
                }
            }
            """;
 
        await new VerifyCodeFix.Test
        {
            TestCode = source.Replace("[||]", ""),
            FixedCode = fixedSource,
            LanguageVersion = LanguageVersion.CSharp12,
        }.RunAsync();
 
#if !CODE_STYLE
        await TestRefactoringMissingAsync(source);
#endif
    }
 
    [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateConstructor)]
    [WorkItem("https://github.com/dotnet/roslyn/issues/58593")]
    public async Task TestMissingInStructWithoutFieldInitializer()
    {
        var source = """
            struct [||]S
            {
                object X;
            }
            """;
 
        await TestCodeFixMissingAsync(source);
 
#if !CODE_STYLE
        await TestRefactoringMissingAsync(source);
#endif
    }
 
#if !CODE_STYLE
 
    [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateDefaultConstructors)]
    public async Task TestPrivateBase()
    {
        await TestRefactoringMissingAsync(
            """
            class {|CS1729:C|} : [||]B
            {
            }
 
            class B
            {
                private B(int x)
                {
                }
            }
            """);
    }
 
    [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateDefaultConstructors)]
    public async Task TestFixAll2()
    {
        await TestRefactoringAsync(
            """
            class C : [||]B
            {
                public {|CS1729:C|}(bool x)
                {
                }
            }
 
            class B
            {
                internal B(int x)
                {
                }
 
                protected B(string x)
                {
                }
 
                public B(bool x)
                {
                }
            }
            """,
            """
            class C : B
            {
                public {|CS1729:C|}(bool x)
                {
                }
 
                protected C(string x) : base(x)
                {
                }
 
                internal C(int x) : base(x)
                {
                }
            }
 
            class B
            {
                internal B(int x)
                {
                }
 
                protected B(string x)
                {
                }
 
                public B(bool x)
                {
                }
            }
            """,
index: 2);
    }
 
    [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateDefaultConstructors)]
    public async Task TestFixAll_WithTuples()
    {
        await TestRefactoringAsync(
            """
            class C : [||]B
            {
                public {|CS1729:C|}((bool, bool) x)
                {
                }
            }
 
            class B
            {
                internal B((int, int) x)
                {
                }
 
                protected B((string, string) x)
                {
                }
 
                public B((bool, bool) x)
                {
                }
            }
            """,
            """
            class C : B
            {
                public {|CS1729:C|}((bool, bool) x)
                {
                }
 
                protected C((string, string) x) : base(x)
                {
                }
 
                internal C((int, int) x) : base(x)
                {
                }
            }
 
            class B
            {
                internal B((int, int) x)
                {
                }
 
                protected B((string, string) x)
                {
                }
 
                public B((bool, bool) x)
                {
                }
            }
            """,
index: 2);
    }
 
    [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateDefaultConstructors)]
    public async Task TestMissing1()
    {
        await TestRefactoringMissingAsync(
            """
            class C : [||]B
            {
                public {|CS7036:C|}(int x)
                {
                }
            }
 
            class B
            {
                internal B(int x)
                {
                }
            }
            """);
    }
 
    [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateDefaultConstructors)]
    [WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/889349")]
    public async Task TestDefaultConstructorGeneration_1()
    {
        await TestRefactoringAsync(
            """
            class C : [||]B
            {
                public {|CS7036:C|}(int y)
                {
                }
            }
 
            class B
            {
                internal B(int x)
                {
                }
            }
            """,
            """
            class C : B
            {
                public {|CS7036:C|}(int y)
                {
                }
 
                internal {|CS0111:C|}(int x) : base(x)
                {
                }
            }
 
            class B
            {
                internal B(int x)
                {
                }
            }
            """);
    }
 
    [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateDefaultConstructors)]
    [WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/889349")]
    public async Task TestDefaultConstructorGeneration_2()
    {
        await TestRefactoringAsync(
            """
            class C : [||]B
            {
                private {|CS7036:C|}(int y)
                {
                }
            }
 
            class B
            {
                internal B(int x)
                {
                }
            }
            """,
            """
            class C : B
            {
                internal C(int x) : base(x)
                {
                }
 
                private {|CS0111:{|CS7036:C|}|}(int y)
                {
                }
            }
 
            class B
            {
                internal B(int x)
                {
                }
            }
            """);
    }
 
    [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateDefaultConstructors)]
    [WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/544070")]
    public async Task TestException1()
    {
        await TestRefactoringAsync(
            """
            using System;
            class Program : Excep[||]tion
            {
            }
            """,
            """
            using System;
            using System.Runtime.Serialization;
            class Program : Exception
            {
                public Program()
                {
                }
 
                public Program(string message) : base(message)
                {
                }
 
                public Program(string message, Exception innerException) : base(message, innerException)
                {
                }
 
                protected Program(SerializationInfo info, StreamingContext context) : base(info, context)
                {
                }
            }
            """,
index: 4);
    }
 
    [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateDefaultConstructors)]
    public async Task TestException2()
    {
        await TestRefactoringAsync(
            """
            using System;
            using System.Collections.Generic;
            using System.Linq;
 
            class Program : [||]Exception
            {
                public Program()
                {
                }
 
                static void Main(string[] args)
                {
                }
            }
            """,
            """
            using System;
            using System.Collections.Generic;
            using System.Linq;
            using System.Runtime.Serialization;
 
            class Program : Exception
            {
                public Program()
                {
                }
 
                public Program(string message) : base(message)
                {
                }
 
                public Program(string message, Exception innerException) : base(message, innerException)
                {
                }
 
                protected Program(SerializationInfo info, StreamingContext context) : base(info, context)
                {
                }
 
                static void Main(string[] args)
                {
                }
            }
            """,
index: 3);
    }
 
    [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateDefaultConstructors)]
    public async Task TestException3()
    {
        await TestRefactoringAsync(
            """
            using System;
            using System.Collections.Generic;
            using System.Linq;
 
            class Program : [||]Exception
            {
                public Program(string message) : base(message)
                {
                }
 
                public Program(string message, Exception innerException) : base(message, innerException)
                {
                }
 
                protected Program(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) : base(info, context)
                {
                }
 
                static void Main(string[] args)
                {
                }
            }
            """,
            """
            using System;
            using System.Collections.Generic;
            using System.Linq;
 
            class Program : Exception
            {
                public Program()
                {
                }
 
                public Program(string message) : base(message)
                {
                }
 
                public Program(string message, Exception innerException) : base(message, innerException)
                {
                }
 
                protected Program(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) : base(info, context)
                {
                }
 
                static void Main(string[] args)
                {
                }
            }
            """);
    }
 
    [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateDefaultConstructors)]
    public async Task TestException4()
    {
        await TestRefactoringAsync(
            """
            using System;
            using System.Collections.Generic;
            using System.Linq;
 
            class Program : [||]Exception
            {
                public Program(string message, Exception innerException) : base(message, innerException)
                {
                }
 
                protected Program(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) : base(info, context)
                {
                }
 
                static void Main(string[] args)
                {
                }
            }
            """,
            """
            using System;
            using System.Collections.Generic;
            using System.Linq;
 
            class Program : Exception
            {
                public Program()
                {
                }
 
                public Program(string message) : base(message)
                {
                }
 
                public Program(string message, Exception innerException) : base(message, innerException)
                {
                }
 
                protected Program(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) : base(info, context)
                {
                }
 
                static void Main(string[] args)
                {
                }
            }
            """,
index: 2);
    }
 
    [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateDefaultConstructors)]
    [WorkItem("https://github.com/dotnet/roslyn/issues/19953")]
    public async Task TestNotOnEnum()
    {
        await TestRefactoringMissingAsync(
            """
            enum [||]E
            {
            }
            """);
    }
 
    [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateDefaultConstructors)]
    [WorkItem("https://github.com/dotnet/roslyn/issues/48318")]
    public async Task TestGenerateConstructorFromProtectedConstructorCursorAtTypeOpening()
    {
        await TestRefactoringOnlyAsync(
            """
            class {|CS7036:C|} : B
            {
 
            [||]
 
            }
 
            abstract class B
            {
                protected B(int x)
                {
                }
            }
            """,
            """
            class C : B
            {
                public C(int x) : base(x)
                {
                }
            }
 
            abstract class B
            {
                protected B(int x)
                {
                }
            }
            """);
    }
 
    [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateDefaultConstructors)]
    [WorkItem("https://github.com/dotnet/roslyn/issues/48318")]
    public async Task TestGenerateConstructorFromProtectedConstructorCursorBetweenTypeMembers()
    {
        await TestRefactoringOnlyAsync(
            """
            class {|CS7036:C|} : B
            {
                int X;
            [||]
                int Y;
            }
 
            abstract class B
            {
                protected B(int x)
                {
                }
            }
            """,
            """
            class C : B
            {
                int X;
 
                int Y;
 
                public C(int x) : base(x)
                {
                }
            }
 
            abstract class B
            {
                protected B(int x)
                {
                }
            }
            """);
    }
 
    [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateDefaultConstructors)]
    [WorkItem("https://github.com/dotnet/roslyn/issues/40586")]
    public async Task TestGenerateInternalConstructorInSealedClassForProtectedOrInternalBase()
    {
        await TestRefactoringAsync(
            """
            class Base
            {
                protected internal Base()
                {
                }
            }
 
            sealed class Program : [||]Base
            {
            }
            """,
            """
            class Base
            {
                protected internal Base()
                {
                }
            }
 
            sealed class Program : Base
            {
                internal Program()
                {
                }
            }
            """);
    }
 
    [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateDefaultConstructors)]
    [WorkItem("https://github.com/dotnet/roslyn/issues/40586")]
    public async Task TestGenerateInternalConstructorInSealedClassForProtectedAndInternalBase()
    {
        await TestRefactoringAsync(
            """
            class Base
            {
                private protected Base()
                {
                }
            }
 
            sealed class Program : [||]Base
            {
            }
            """,
            """
            class Base
            {
                private protected Base()
                {
                }
            }
 
            sealed class Program : Base
            {
                internal Program()
                {
                }
            }
            """);
    }
 
    [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateDefaultConstructors)]
    [WorkItem("https://github.com/dotnet/roslyn/issues/40586")]
    public async Task TestGeneratePublicConstructorInSealedClassForProtectedBase()
    {
        await TestRefactoringAsync(
            """
            class Base
            {
                protected Base()
                {
                }
            }
 
            sealed class Program : [||]Base
            {
            }
            """,
            """
            class Base
            {
                protected Base()
                {
                }
            }
 
            sealed class Program : Base
            {
                public Program()
                {
                }
            }
            """);
    }
 
#endif
}