public async Task RenameTrackingNotInBlankFile()
 {
     var code = @"$$";
     using (var state = new RenameTrackingTestState(code, LanguageNames.CSharp))
     {
         state.EditorOperations.InsertText("d");
         await state.AssertNoTag().ConfigureAwait(true);
     }
 }
 public void RenameTrackingNotInBlankFile()
 {
     var code = @"$$";
     using (var state = new RenameTrackingTestState(code, LanguageNames.CSharp))
     {
         state.EditorOperations.InsertText("d");
         state.AssertNoTag();
     }
 }
        public async Task RenameTrackingNotOnCreation()
        {
            var code = @"
class C$$
{
}";
            using (var state = new RenameTrackingTestState(code, LanguageNames.CSharp))
            {
                await state.AssertNoTag().ConfigureAwait(true);
            }
        }
        public void RenameTrackingNotOnCreation()
        {
            var code = @"
class C$$
{
}";
            using (var state = new RenameTrackingTestState(code, LanguageNames.CSharp))
            {
                state.AssertNoTag();
            }
        }
        public async Task RenameTrackingTypingInMiddle()
        {
            var code = @"
class AB$$CD
{
}";
            using (var state = new RenameTrackingTestState(code, LanguageNames.CSharp))
            {
                state.EditorOperations.InsertText("ZZ");
                await state.AssertTag("ABCD", "ABZZCD").ConfigureAwait(true);
            }
        }
        public async Task RenameTrackingTypingAtBeginning()
        {
            var code = @"
class $$C
{
}";
            using (var state = new RenameTrackingTestState(code, LanguageNames.CSharp))
            {
                state.EditorOperations.InsertText("AB");
                await state.AssertTag("C", "ABC").ConfigureAwait(true);
            }
        }
        public void RenameTrackingTypingAtBeginning()
        {
            var code = @"
class $$C
{
}";
            using (var state = new RenameTrackingTestState(code, LanguageNames.CSharp))
            {
                state.EditorOperations.InsertText("AB");
                state.AssertTag("C", "ABC");
            }
        }
        public void RenameTrackingTypingInMiddle()
        {
            var code = @"
class AB$$CD
{
}";
            using (var state = new RenameTrackingTestState(code, LanguageNames.CSharp))
            {
                state.EditorOperations.InsertText("ZZ");
                state.AssertTag("ABCD", "ABZZCD");
            }
        }
        public void RenameTrackingTypingAtEnd()
        {
            var code = @"
class C$$
{
}";
            using (var state = new RenameTrackingTestState(code, LanguageNames.CSharp))
            {
                state.EditorOperations.InsertText("at");
                state.AssertTag("C", "Cat");
            }
        }
Ejemplo n.º 10
0
        public async Task RenameImplicitTupleFieldExtended()
        {
            var code = @"
class C
{
    void M()
    {
        (int, int, int, int, int, int, int, int, int, int) x = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
        var y = x.Item9$$;
    }
}
";

            using (var state = RenameTrackingTestState.Create(code, LanguageNames.CSharp))
            {
                state.EditorOperations.Backspace();
                state.EditorOperations.Backspace();
                await state.AssertNoTag();

                Assert.Empty(await state.GetDocumentDiagnosticsAsync());
            }
        }
Ejemplo n.º 11
0
        public async Task RenameTrackingUndoTwiceAndContinueSession()
        {
            var code = @"
class Cat$$
{
}";

            using (var state = RenameTrackingTestState.Create(code, LanguageNames.CSharp))
            {
                state.EditorOperations.InsertText("abc");
                await state.AssertTag("Cat", "Catabc", invokeAction : true);

                await state.AssertNoTag();

                // Resume rename tracking session
                state.Undo(2);
                await state.AssertTag("Cat", "Catabc");

                state.EditorOperations.InsertText("xyz");
                await state.AssertTag("Cat", "Catabcxyz");
            }
        }
Ejemplo n.º 12
0
        public async Task RenameTrackingUndoOnceAndStartNewSession()
        {
            var code = @"
class Cat$$
{
}";

            using (var state = RenameTrackingTestState.Create(code, LanguageNames.CSharp))
            {
                state.EditorOperations.InsertText("abc");
                await state.AssertTag("Cat", "Catabc", invokeAction : true);

                await state.AssertNoTag();

                // Back to original
                state.Undo();
                await state.AssertNoTag();

                state.EditorOperations.InsertText("xyz");
                await state.AssertTag("Cat", "Catxyz");
            }
        }
        public async Task RenameTracking_Nameof_FromMethodGroupReference()
        {
            var code = @"
class C
{
    void M()
    {
        nameof(M$$).ToString();
    }

    void M(int x)
    {
    }
}";

            using (var state = await RenameTrackingTestState.CreateAsync(code, LanguageNames.CSharp))
            {
                state.EditorOperations.InsertText("at");

                await state.AssertTag("M", "Mat", invokeAction : true);

                // Make sure the rename completed
                var expectedCode = @"
class C
{
    void Mat()
    {
        nameof(Mat).ToString();
    }

    void Mat(int x)
    {
    }
}";
                Assert.Equal(expectedCode, state.HostDocument.TextBuffer.CurrentSnapshot.GetText());
                await state.AssertNoTag();
            }
        }
        public void RenameTracking_Nameof_FromMethodDefinition_WithOverloads()
        {
            var code = @"
class C
{
    void M$$()
    {
        nameof(M).ToString();
    }

    void M(int x)
    {
    }
}";

            using (var state = new RenameTrackingTestState(code, LanguageNames.CSharp))
            {
                state.EditorOperations.InsertText("at");

                state.AssertTag("M", "Mat", invokeAction: true);

                // Make sure the rename completed
                var expectedCode = @"
class C
{
    void Mat()
    {
        nameof(M).ToString();
    }

    void M(int x)
    {
    }
}";
                Assert.Equal(expectedCode, state.HostDocument.TextBuffer.CurrentSnapshot.GetText());
                state.AssertNoTag();
            }
        }
Ejemplo n.º 15
0
        public async Task RenameTrackingRedoAlwaysClearsState()
        {
            var code = @"
class Cat$$
{
}";

            using var state = RenameTrackingTestState.Create(code, LanguageNames.CSharp);
            state.EditorOperations.InsertText("s");
            await state.AssertTag("Cat", "Cats", invokeAction : true);

            await state.AssertNoTag();

            // Resume rename tracking session
            state.Undo(2);
            await state.AssertTag("Cat", "Cats");

            state.Redo();
            await state.AssertNoTag();

            state.Redo();
            await state.AssertNoTag();
        }
Ejemplo n.º 16
0
        public async Task RenameTrackingOnReference_Attribute_CSharp()
        {
            var code = @"
using System;

class [|$$ustom|]Attribute : Attribute
{
}
";

            using var state = RenameTrackingTestState.Create(code, LanguageNames.CSharp);
            state.EditorOperations.InsertText("C");
            await state.AssertTag("ustomAttribute", "CustomAttribute", invokeAction : true);

            var expectedCode = @"
using System;

class CustomAttribute : Attribute
{
}
";

            Assert.Equal(expectedCode, state.HostDocument.GetTextBuffer().CurrentSnapshot.GetText());
        }
Ejemplo n.º 17
0
        public async Task RenameTrackingOnReference_Not_Capitalized_Attribute_VB()
        {
            var code = @"
Import System;

Public Class [|$$ustom|]attribute 
        Inherits Attribute
End Class
";

            using var state = RenameTrackingTestState.Create(code, LanguageNames.VisualBasic);
            state.EditorOperations.InsertText("C");
            await state.AssertTag("ustomattribute", "Customattribute", invokeAction : true);

            var expectedCode = @"
Import System;

Public Class Customattribute 
        Inherits Attribute
End Class
";

            Assert.Equal(expectedCode, state.HostDocument.GetTextBuffer().CurrentSnapshot.GetText());
        }
        public void RenameTrackingCancelPreviewChanges()
        {
            var code = @"
class C$$
{
}";

            var expected = @"
class Cat
{
}";

            using (var state = new RenameTrackingTestState(code, LanguageNames.CSharp))
            {
                var mockPreview = state.Workspace.Services.GetService <IPreviewDialogService>() as MockPreviewDialogService;
                mockPreview.Called      = false;
                mockPreview.ReturnsNull = true;
                state.EditorOperations.InsertText("at");
                state.AssertTag("C", "Cat", invokeAction: true, actionIndex: 1);
                Assert.True(mockPreview.Called);
                Assert.Equal(expected, state.HostDocument.TextBuffer.CurrentSnapshot.GetText());
                state.AssertTag("C", "Cat");
            }
        }
        public void RenameTrackingNotWhenNewIdentifierReferenceBinds()
        {
            var code = @"
Module Program
    Sub Main()
        $$[|main|]()
    End Sub
    Sub Foo()
    End Sub
End Module";
            using (var state = new RenameTrackingTestState(code, LanguageNames.VisualBasic))
            {
                var textSpan = state.HostDocument.SelectedSpans.Single();
                state.EditorOperations.ReplaceText(new Span(textSpan.Start, textSpan.Length), "Fo");
                state.AssertTag("main", "Fo");
                state.EditorOperations.InsertText("o");
                state.AssertNoTag();
            }
        }
        public void RenameTrackingNotWhenCaseCorrectingReference()
        {
            var code = @"
Module Program
    Sub Main()
        $$main()
    End Sub
End Module";
            using (var state = new RenameTrackingTestState(code, LanguageNames.VisualBasic))
            {
                state.EditorOperations.Delete();
                state.AssertTag("main", "ain");
                state.EditorOperations.InsertText("M");
                state.AssertNoTag();
            }
        }
        public void RenameTrackingNotWhenStartedFromTextualWordInTrivia()
        {
            var code = @"
Module Program
    Sub Main()
        Dim [x$$ = 1
    End Sub
End Module";
            using (var state = new RenameTrackingTestState(code, LanguageNames.VisualBasic))
            {
                state.EditorOperations.InsertText("]");
                state.AssertNoTag();
            }
        }
        public void RenameTrackingReplaceIdentifierPrefix()
        {
            var code = @"
class $$[|Ident|]ifier
{
}";
            using (var state = new RenameTrackingTestState(code, LanguageNames.CSharp))
            {
                var textSpan = state.HostDocument.SelectedSpans.Single();
                state.EditorOperations.ReplaceText(new Span(textSpan.Start, textSpan.Length), "Complex");
                state.AssertTag("Identifier", "Complexifier");
            }
        }
        public void RenameTrackingAlertsAboutThirdPartyRequestsForCancellationAfterRename()
        {
            var code = @"
class Cat$$
{
    public Cat()
    {
    }
}";
            using (var state = new RenameTrackingTestState(code, LanguageNames.CSharp, onAfterGlobalSymbolRenamedReturnValue: false))
            {
                state.EditorOperations.InsertText("s");
                state.AssertTag("Cat", "Cats", invokeAction: true);

                Assert.Equal(1, state.RefactorNotifyService.OnBeforeSymbolRenamedCount);
                Assert.Equal(1, state.RefactorNotifyService.OnAfterSymbolRenamedCount);
                state.AssertNotificationMessage();

                // Make sure the rename completed            
                var expectedCode = @"
class Cats
{
    public Cats()
    {
    }
}";
                Assert.Equal(expectedCode, state.HostDocument.TextBuffer.CurrentSnapshot.GetText());
                state.AssertNoTag();
            }
        }
        public void RenameTrackingNotifiesThirdPartiesOfRenameOperation()
        {
            var code = @"
class Cat$$
{
    public Cat()
    {
    }
}";
            using (var state = new RenameTrackingTestState(code, LanguageNames.CSharp))
            {
                state.EditorOperations.InsertText("s");
                state.AssertTag("Cat", "Cats", invokeAction: true);
                Assert.Equal(1, state.RefactorNotifyService.OnBeforeSymbolRenamedCount);
                Assert.Equal(1, state.RefactorNotifyService.OnAfterSymbolRenamedCount);

                var expectedCode = @"
class Cats
{
    public Cats()
    {
    }
}";
                Assert.Equal(expectedCode, state.HostDocument.TextBuffer.CurrentSnapshot.GetText());

                state.AssertNoNotificationMessage();
                state.AssertNoTag();
            }
        }
        public void CancelRenameTracking()
        {
            var code = @"
class C$$
{
}";
            using (var state = new RenameTrackingTestState(code, LanguageNames.CSharp))
            {
                state.EditorOperations.InsertText("at");
                state.AssertTag("C", "Cat");
                state.SendEscape();
                state.AssertNoTag();
            }
        }
        public void RenameTrackingOnReference_ParameterAsNamedArgument()
        {
            var code = @"
class C
{
    void M(int x)
    {
        M(x$$: x);
    }
}";
            using (var state = new RenameTrackingTestState(code, LanguageNames.CSharp))
            {
                state.EditorOperations.InsertText("yz");
                state.AssertTag("x", "xyz");
            }
        }
        public void RenameTrackingNotThroughEmptyStringResumeOnDifferentSpace()
        {
            var code = @"
class  C$$
{
}";
            using (var state = new RenameTrackingTestState(code, LanguageNames.CSharp))
            {
                state.EditorOperations.Backspace();

                // Move to previous space
                state.MoveCaret(-1);

                state.EditorOperations.InsertText("D");
                state.AssertNoTag();
            }
        }
        public void RenameTrackingUndoTwiceRedoTwiceUndoStillWorks()
        {
            var code = @"
class Cat$$
{
}";
            using (var state = new RenameTrackingTestState(code, LanguageNames.CSharp))
            {
                state.EditorOperations.InsertText("s");
                state.AssertTag("Cat", "Cats", invokeAction: true);

                state.AssertNoTag();

                // Resume rename tracking session
                state.Undo(2);
                state.AssertTag("Cat", "Cats");

                state.Redo(2);
                state.AssertNoTag();

                // Back to original
                state.Undo();
                state.AssertNoTag();

                // Resume rename tracking session
                state.Undo();
                state.AssertTag("Cat", "Cats");
            }
        }
        public void RenameTrackingRedoAlwaysClearsState()
        {
            var code = @"
class Cat$$
{
}";
            using (var state = new RenameTrackingTestState(code, LanguageNames.CSharp))
            {
                state.EditorOperations.InsertText("s");
                state.AssertTag("Cat", "Cats", invokeAction: true);

                state.AssertNoTag();

                // Resume rename tracking session
                state.Undo(2);
                state.AssertTag("Cat", "Cats");

                state.Redo();
                state.AssertNoTag();

                state.Redo();
                state.AssertNoTag();
            }
        }
        public void RenameTrackingUndoTwiceAndContinueSession()
        {
            var code = @"
class Cat$$
{
}";
            using (var state = new RenameTrackingTestState(code, LanguageNames.CSharp))
            {
                state.EditorOperations.InsertText("abc");
                state.AssertTag("Cat", "Catabc", invokeAction: true);

                state.AssertNoTag();

                // Resume rename tracking session
                state.Undo(2);
                state.AssertTag("Cat", "Catabc");

                state.EditorOperations.InsertText("xyz");
                state.AssertTag("Cat", "Catabcxyz");
            }
        }
        public void RenameTrackingUndoOnceAndStartNewSession()
        {
            var code = @"
class Cat$$
{
}";
            using (var state = new RenameTrackingTestState(code, LanguageNames.CSharp))
            {
                state.EditorOperations.InsertText("abc");
                state.AssertTag("Cat", "Catabc", invokeAction: true);

                state.AssertNoTag();

                // Back to original
                state.Undo();
                state.AssertNoTag();

                state.EditorOperations.InsertText("xyz");
                state.AssertTag("Cat", "Catxyz");
            }
        }
        public void RenameTrackingPreviewChanges()
        {
            var code = @"
class C$$
{
}";

            using (var state = new RenameTrackingTestState(code, LanguageNames.CSharp))
            {
                var mockPreview = state.Workspace.Services.GetService<IPreviewDialogService>() as MockPreviewDialogService;
                mockPreview.Called = false;
                mockPreview.ReturnsNull = false;
                state.EditorOperations.InsertText("at");
                state.AssertTag("C", "Cat", invokeAction: true, actionIndex: 1);
                Assert.True(mockPreview.Called);
                Assert.Equal("Rename 'C' to 'Cat':", mockPreview.Description);
                Assert.Equal("Preview Changes - Rename", mockPreview.Title);
                Assert.Equal("C", mockPreview.TopLevelName);
                Assert.Equal(Glyph.ClassInternal, mockPreview.TopLevelGlyph);
            }
        }
        public void RenameTrackingOnReference_Namespace()
        {
            var code = @"
namespace NS
{
    class C
    {
        static void M()
        {
            NS$$.C.M();
        }
    }
}";
            using (var state = new RenameTrackingTestState(code, LanguageNames.CSharp))
            {
                state.EditorOperations.InsertText("A");
                state.AssertTag("NS", "NSA");
            }
        }
        public void RenameTrackingCancelPreviewChanges()
        {
            var code = @"
class C$$
{
}";

            var expected = @"
class Cat
{
}";
            using (var state = new RenameTrackingTestState(code, LanguageNames.CSharp))
            {
                var mockPreview = state.Workspace.Services.GetService<IPreviewDialogService>() as MockPreviewDialogService;
                mockPreview.Called = false;
                mockPreview.ReturnsNull = true;
                state.EditorOperations.InsertText("at");
                state.AssertTag("C", "Cat", invokeAction: true, actionIndex: 1);
                Assert.True(mockPreview.Called);
                Assert.Equal(expected, state.HostDocument.TextBuffer.CurrentSnapshot.GetText());
                state.AssertTag("C", "Cat");
            }
        }
        public void RenameTrackingDeleteFromEnd()
        {
            var code = @"
class ABC$$
{
}";
            using (var state = new RenameTrackingTestState(code, LanguageNames.CSharp))
            {
                state.EditorOperations.Backspace();
                state.AssertTag("ABC", "AB");
            }
        }
        public void RenameTrackingNotFromReferenceWithWrongNumberOfArguments()
        {
            var code = @"
class C
{
    void M(int x)
    {
        M$$();
    }
}";

            using (var state = new RenameTrackingTestState(code, LanguageNames.CSharp))
            {
                state.EditorOperations.InsertText("eow");
                state.AssertNoTag();
            }
        }
        public void RenameTrackingReplaceIdentifierCompletely()
        {
            var code = @"
class [|Cat|]$$
{
}";
            using (var state = new RenameTrackingTestState(code, LanguageNames.CSharp))
            {
                var textSpan = state.HostDocument.SelectedSpans.Single();
                state.EditorOperations.ReplaceText(new Span(textSpan.Start, textSpan.Length), "Dog");
                state.AssertTag("Cat", "Dog");
            }
        }
        public void RenameTrackingNotWhenDeclaringEnumMembersEvenAfterCancellation()
        {
            var code = @"
Enum E
$$    
End Enum";
            using (var state = new RenameTrackingTestState(code, LanguageNames.VisualBasic))
            {
                state.EditorOperations.InsertText("    a");
                state.EditorOperations.InsertText("b");
                state.AssertNoTag();
                state.SendEscape();
                state.EditorOperations.InsertText("c");
                state.AssertNoTag();
            }
        }
        public void RenameTrackingInvokeAndChangeBackToOriginal()
        {
            var code = @"
class Cat$$
{
}";
            using (var state = new RenameTrackingTestState(code, LanguageNames.CSharp))
            {
                state.EditorOperations.InsertText("s");
                state.AssertTag("Cat", "Cats", invokeAction: true);

                state.AssertNoTag();

                state.EditorOperations.Backspace();
                state.AssertTag("Cats", "Cat");
            }
        }