public async Task FixesAreReportedForCompilerErrors()
        {
            var diagnostics = new ExpectedDiagnostic [] {
                new ExpectedDiagnostic(6, DiagnosticSeverity.Hidden, "Accessibility modifiers required"),
                new ExpectedDiagnostic(16, DiagnosticSeverity.Error, "'MyClass' does not implement interface member 'IDisposable.Dispose()'"),
                new ExpectedDiagnostic(36, DiagnosticSeverity.Hidden, "Fix formatting"),
            };

            var expected = new ExpectedCodeFixes {
                CodeFixData = new CodeActionData [] {
                    new CodeActionData {
                        Message = "Implement interface"
                    },
                    new CodeActionData {
                        Message = "Implement interface with Dispose pattern"
                    },
                    new CodeActionData {
                        Message = "Implement interface explicitly"
                    },
                    new CodeActionData {
                        Message = "Implement interface explicitly with Dispose pattern"
                    },
                    new CodeActionData {
                        Message = "Add accessibility modifiers"
                    },
                    new CodeActionData {
                        Message = "Fix formatting"
                    },
                }.OrderBy(d => d.Message).ToArray(),
                CodeRefactoringData = new CodeActionData [] {
                    // NOTE: This will return when we implement UI for it
                    //new CodeActionData { Message = "Move to namespace..." },
                    new CodeActionData {
                        Message = "Rename file to MyClass.cs"
                    },
                    new CodeActionData {
                        Message = "Rename type to a"
                    },
                },
            };

            await RunTest(3, IDisposableImplement, async (remainingUpdates, doc) => {
                if (remainingUpdates == 0)
                {
                    AssertExpectedDiagnostics(diagnostics, doc);

                    doc.Editor.CaretOffset = diagnostics [2].Location;
                    await AssertExpectedCodeFixes(expected, doc);
                }
            });
        }
Esempio n. 2
0
        public async Task FixesAreReportedByExtension()
        {
            var diagnostic = new ExpectedDiagnostic [] {
                new ExpectedDiagnostic(6, DiagnosticSeverity.Hidden, "Accessibility modifiers required"),
            };

            var expected = new ExpectedCodeFixes {
                CodeFixData = new CodeActionData [] {
                    new CodeActionData {
                        Message = "Add accessibility modifiers"
                    },
                },
                CodeRefactoringData = new CodeActionData [] {
                    new CodeActionData {
                        Message = "To public"
                    },
                    new CodeActionData {
                        Message = "Move to namespace..."
                    },
                    new CodeActionData {
                        Message = "Generate overrides..."
                    },
                    new CodeActionData {
                        Message = "Generate constructor 'MyClass()'"
                    },
                    new CodeActionData {
                        Message = "Rename file to MyClass.cs"
                    },
                    new CodeActionData {
                        Message = "Rename type to a"
                    },
                }.OrderBy(d => d.Message).ToArray(),
            };

            await RunTest(1, SimpleClass, async (remainingUpdates, doc) => {
                if (remainingUpdates == 0)
                {
                    AssertExpectedDiagnostics(diagnostic, doc);

                    doc.Editor.CaretOffset = diagnostic [0].Location;
                    await AssertExpectedCodeFixes(expected, doc);
                }
            });
        }
Esempio n. 3
0
        public async Task FixesAreReportedForCompilerErrors()
        {
            var diagnostics = new ExpectedDiagnostic [] {
                new ExpectedDiagnostic(6, DiagnosticSeverity.Hidden, "Accessibility modifiers required"),
                new ExpectedDiagnostic(16, DiagnosticSeverity.Error, "'MyClass' does not implement interface member 'IDisposable.Dispose()'"),
            };

            var expected = new ExpectedCodeFixes {
                CodeFixData = new CodeActionData [] {
                    new CodeActionData {
                        Message = "Implement interface"
                    },
                    new CodeActionData {
                        Message = "Implement interface with Dispose pattern"
                    },
                    new CodeActionData {
                        Message = "Implement interface explicitly"
                    },
                    new CodeActionData {
                        Message = "Implement interface explicitly with Dispose pattern"
                    },
                },
                CodeRefactoringData = new CodeActionData [] {
                    new CodeActionData {
                        Message = "To public"
                    },
                },
            };

            await RunTest(2, IDisposableImplement, async (remainingUpdates, doc) => {
                if (remainingUpdates == 0)
                {
                    AssertExpectedDiagnostics(diagnostics, doc);

                    doc.Editor.CaretOffset = diagnostics [1].Location;
                    await AssertExpectedCodeFixes(expected, doc);
                }
            });
        }