public async Task RenameTrackingHandlesAtSignAsCSharpEscape()
        {
            var code = @"
class $$C
{
}";

            using (var state = await RenameTrackingTestState.CreateAsync(code, LanguageNames.CSharp))
            {
                state.EditorOperations.InsertText("@");
                await state.AssertTag("C", "@C");
            }
        }
        public async Task RenameTrackingDeleteFromMiddle()
        {
            var code = @"
class AB$$C
{
}";

            using (var state = await RenameTrackingTestState.CreateAsync(code, LanguageNames.CSharp))
            {
                state.EditorOperations.Backspace();
                await state.AssertTag("ABC", "AC");
            }
        }
        public async Task RenameTrackingHandlesUnicode()
        {
            var code = @"
class C$$
{
}";

            using (var state = await RenameTrackingTestState.CreateAsync(code, LanguageNames.CSharp))
            {
                state.EditorOperations.InsertText("ДѮѪÛÊÛÄÁÍäጟõàŸüĵÁiÛEêàêèäåíòèôèêàòîðñëîâî");
                await state.AssertTag("C", "CДѮѪÛÊÛÄÁÍäጟõàŸüĵÁiÛEêàêèäåíòèôèêàòîðñëîâî");
            }
        }
        public async Task RenameTrackingNotOnClassKeyword()
        {
            var code = @"
class$$ ABCD
{
}";

            using (var state = await RenameTrackingTestState.CreateAsync(code, LanguageNames.CSharp))
            {
                state.EditorOperations.InsertText("d");
                await state.AssertNoTag();
            }
        }
Ejemplo n.º 5
0
        public async Task RenameTrackingTypingInMiddle()
        {
            var code = @"
class AB$$CD
{
}";

            using (var state = await RenameTrackingTestState.CreateAsync(code, LanguageNames.CSharp))
            {
                state.EditorOperations.InsertText("ZZ");
                await state.AssertTag("ABCD", "ABZZCD");
            }
        }
        public async Task RenameTrackingDeleteFromBeginning()
        {
            var code = @"
class $$ABC
{
}";

            using (var state = await RenameTrackingTestState.CreateAsync(code, LanguageNames.CSharp))
            {
                state.EditorOperations.Delete();
                await state.AssertTag("ABC", "BC");
            }
        }
Ejemplo n.º 7
0
        public async Task RenameTrackingTypingAtBeginning()
        {
            var code = @"
class $$C
{
}";

            using (var state = await RenameTrackingTestState.CreateAsync(code, LanguageNames.CSharp))
            {
                state.EditorOperations.InsertText("AB");
                await state.AssertTag("C", "ABC");
            }
        }
Ejemplo n.º 8
0
        public async Task RenameTrackingHandlesUnicode()
        {
            var code = @"
class C$$
{
}";

            using (var state = await RenameTrackingTestState.CreateAsync(code, LanguageNames.CSharp))
            {
                state.EditorOperations.InsertText("\u0414\u046E\u046A\u00DB\u00CA\u00DB\u00C4\u00C1\u00CD\u00E4\u00E1\u0152\u0178\u00F5\u00E0\u0178\u00FC\u00C4\u00B5\u00C1i\u00DBE\u00EA\u00E0\u00EA\u00E8\u00E4\u00E5\u00ED\u00F2\u00E8\u00F4\u00E8\u00EA\u00E0\u00F2\u00EE\u00F0\u00F1\u00EB\u00EE\u00E2\u00EE");
                await state.AssertTag("C", "C\u0414\u046E\u046A\u00DB\u00CA\u00DB\u00C4\u00C1\u00CD\u00E4\u00E1\u0152\u0178\u00F5\u00E0\u0178\u00FC\u00C4\u00B5\u00C1i\u00DBE\u00EA\u00E0\u00EA\u00E8\u00E4\u00E5\u00ED\u00F2\u00E8\u00F4\u00E8\u00EA\u00E0\u00F2\u00EE\u00F0\u00F1\u00EB\u00EE\u00E2\u00EE");
            }
        }
        public async Task RenameTrackingReplaceIdentifierCompletely()
        {
            var code = @"
class [|Cat|]$$
{
}";

            using (var state = await RenameTrackingTestState.CreateAsync(code, LanguageNames.CSharp))
            {
                var textSpan = state.HostDocument.SelectedSpans.Single();
                state.EditorOperations.ReplaceText(new Span(textSpan.Start, textSpan.Length), "Dog");
                await state.AssertTag("Cat", "Dog");
            }
        }
        public async Task RenameTrackingNotWhenDeclaringEnumMembers()
        {
            var code = @"
Enum E
$$    
End Enum";

            using (var state = await RenameTrackingTestState.CreateAsync(code, LanguageNames.VisualBasic))
            {
                state.EditorOperations.InsertText("    a");
                state.EditorOperations.InsertText("b");
                await state.AssertNoTag();
            }
        }
        public async Task RenameTrackingNotWhenStartedFromTextualWordInTrivia()
        {
            var code = @"
Module Program
    Sub Main()
        Dim [x$$ = 1
    End Sub
End Module";

            using (var state = await RenameTrackingTestState.CreateAsync(code, LanguageNames.VisualBasic))
            {
                state.EditorOperations.InsertText("]");
                await state.AssertNoTag();
            }
        }
Ejemplo n.º 12
0
        public async Task RenameTrackingNotOnExplicitTupleElementsInDeclarations_VB()
        {
            var code = @"
Class C
    Sub M()
        Dim t = (x$$:=1, y:=2)
    End Sub
End Class";

            using (var state = await RenameTrackingTestState.CreateAsync(code, LanguageNames.VisualBasic))
            {
                state.EditorOperations.InsertText("2");
                await state.AssertNoTag();
            }
        }
        public async Task RenameTrackingNotAfterInvoke()
        {
            var code = @"
class Cat$$
{
}";

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

                await state.AssertNoTag();
            }
        }
        public async Task RenameTrackingHandlesSquareBracketsAsVisualBasicEscape()
        {
            var code = @"
Class $$C
End Class";

            using (var state = await RenameTrackingTestState.CreateAsync(code, LanguageNames.VisualBasic))
            {
                state.EditorOperations.InsertText("[");
                await state.AssertNoTag();

                state.MoveCaret(1);
                state.EditorOperations.InsertText("]");
                await state.AssertTag("C", "[C]");
            }
        }
        public async Task RenameTrackingSessionContinuesAfterViewingTag()
        {
            var code = @"
class C$$
{
}";

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

                state.EditorOperations.InsertText("s");
                await state.AssertTag("C", "Cats");
            }
        }
        public async Task RenameTrackingThroughEmptyString()
        {
            var code = @"
class C$$
{
}";

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

                state.EditorOperations.InsertText("D");
                await state.AssertTag("C", "D");
            }
        }
        public async Task CancelRenameTracking()
        {
            var code = @"
class C$$
{
}";

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

                state.SendEscape();
                await state.AssertNoTag();
            }
        }
        public async Task RenameTrackingOnBothSidesOfIdentifier()
        {
            var code = @"
class $$Def
{
}";

            using (var state = await RenameTrackingTestState.CreateAsync(code, LanguageNames.CSharp))
            {
                state.EditorOperations.InsertText("Abc");
                await state.AssertTag("Def", "AbcDef");

                state.MoveCaret(3);
                state.EditorOperations.InsertText("Ghi");
                await state.AssertTag("Def", "AbcDefGhi");
            }
        }
        public async Task RenameTrackingThroughIllegalStartCharacter()
        {
            var code = @"
class $$abc
{
}";

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

                state.MoveCaret(-1);
                state.EditorOperations.InsertText("t");
                await state.AssertTag("abc", "t9abc");
            }
        }
        public async Task RenameTracking_Nameof_FromReferenceToMetadata_NoTag()
        {
            var code = @"
class C
{
    void M()
    {
        var x = nameof(ToString$$);
    }
}";

            using (var state = await RenameTrackingTestState.CreateAsync(code, LanguageNames.CSharp))
            {
                state.EditorOperations.InsertText("z");
                await state.AssertNoTag();
            }
        }
        public async Task RenameTrackingNotInString()
        {
            var code = @"
class C
{
    void Foo()
    {
        string s = ""abc$$""
    }
}";

            using (var state = await RenameTrackingTestState.CreateAsync(code, LanguageNames.CSharp))
            {
                state.EditorOperations.InsertText("d");
                await state.AssertNoTag();
            }
        }
Ejemplo n.º 22
0
        public async Task RenameTrackingNotOnExplicitTupleElementsInDeclarations_CSharp()
        {
            var code = @"
class C
{
    void M()
    {
        var t = (x$$: 1, y: 2);
    }
}";

            using (var state = await RenameTrackingTestState.CreateAsync(code, LanguageNames.CSharp))
            {
                state.EditorOperations.InsertText("2");
                await state.AssertNoTag();
            }
        }
        public async Task RenameTrackingNotOnSquareBracketsInCSharp()
        {
            var code = @"
class $$C
{
}";

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

                state.MoveCaret(1);
                state.EditorOperations.InsertText("]");
                await state.AssertNoTag();
            }
        }
        public async Task RenameTrackingNotFromReferenceWithWrongNumberOfArguments()
        {
            var code = @"
class C
{
    void M(int x)
    {
        M$$();
    }
}";

            using (var state = await RenameTrackingTestState.CreateAsync(code, LanguageNames.CSharp))
            {
                state.EditorOperations.InsertText("eow");
                await state.AssertNoTag();
            }
        }
        public async Task RenameTrackingOnReference_ParameterAsNamedArgument()
        {
            var code = @"
class C
{
    void M(int x)
    {
        M(x$$: x);
    }
}";

            using (var state = await RenameTrackingTestState.CreateAsync(code, LanguageNames.CSharp))
            {
                state.EditorOperations.InsertText("yz");
                await state.AssertTag("x", "xyz");
            }
        }
Ejemplo n.º 26
0
        public async Task RenameTrackingNotOnExplicitTupleFieldReference_VB()
        {
            var code = @"
class C
    Sub M()
        Dim x as (abc as integer, int Item2 as integer) = (1, 2)
        Dim y = x.abc$$
    End Sub
End Class";

            using (var state = await RenameTrackingTestState.CreateAsync(code, LanguageNames.VisualBasic))
            {
                state.EditorOperations.Backspace();
                state.EditorOperations.Backspace();

                await state.AssertNoTag();
            }
        }
        public async Task RenameTrackingNotWhenCaseCorrectingReference()
        {
            var code = @"
Module Program
    Sub Main()
        $$main()
    End Sub
End Module";

            using (var state = await RenameTrackingTestState.CreateAsync(code, LanguageNames.VisualBasic))
            {
                state.EditorOperations.Delete();
                await state.AssertTag("main", "ain");

                state.EditorOperations.InsertText("M");
                await state.AssertNoTag();
            }
        }
        public async Task RenameTrackingNotThroughEmptyStringResumeOnDifferentSpace()
        {
            var code = @"
class  C$$
{
}";

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

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

                state.EditorOperations.InsertText("D");
                await state.AssertNoTag();
            }
        }
        public async Task RenameTracking_CanRenameToVarInVisualBasic()
        {
            var code = @"
Class C
    Sub M()
        Dim x as C$$
    End Sub
End Class";

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

                await state.AssertTag("C", "var");

                Assert.NotEmpty(await state.GetDocumentDiagnosticsAsync());
            }
        }
        public async Task RenameTrackingThroughKeyword()
        {
            var code = @"
class i$$
{
}";

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

                state.EditorOperations.InsertText("t");
                await state.AssertNoTag();

                state.EditorOperations.InsertText("s");
                await state.AssertTag("i", "ints");
            }
        }