static LocalDeclarationSpaceVisitor GetVisitor(out TestRefactoringContext context, string input)
{
context = TestRefactoringContext.Create(input);
var visitor = new LocalDeclarationSpaceVisitor();
context.RootNode.AcceptVisitor(visitor);
return visitor;
}
protected List <CodeAction> GetActions <T> (string input) where T : CodeActionProvider, new ()
{
var ctx = TestRefactoringContext.Create(input);
ctx.FormattingOptions = formattingOptions;
return(new T().GetActions(ctx).ToList());
}
protected void TestActionDescriptions(CodeActionProvider provider, string input, params string[] expected)
{
var ctx = TestRefactoringContext.Create(input);
ctx.FormattingOptions = formattingOptions;
var actions = provider.GetActions(ctx).ToList();
Assert.AreEqual(
expected,
actions.Select(a => a.Description).ToArray());
}
protected static void TestWrongContext(ICodeActionProvider action, string input)
{
var context = TestRefactoringContext.Create(input);
bool isValid = action.GetActions(context).Any();
if (!isValid)
{
Console.WriteLine("invalid node is:" + context.GetNode());
}
Assert.IsTrue(!isValid, action.GetType() + " shouldn't be valid there.");
}
protected static void CheckFix (TestRefactoringContext ctx, IEnumerable<CodeIssue> issues, string expectedOutput)
{
using (var script = ctx.StartScript ()) {
foreach (var issue in issues) {
issue.Actions.First ().Run (script);
}
}
bool pass = expectedOutput == ctx.Text;
if (!pass) {
Console.WriteLine (ctx.Text);
}
Assert.AreEqual (expectedOutput, ctx.Text);
}
protected static string RunContextAction(ICodeActionProvider action, string input, int actionIndex = 0)
{
var context = TestRefactoringContext.Create(input);
bool isValid = action.GetActions(context).Any();
if (!isValid)
{
Console.WriteLine("invalid node is:" + context.GetNode());
}
Assert.IsTrue(isValid, action.GetType() + " is invalid.");
using (var script = context.StartScript()) {
action.GetActions(context).Skip(actionIndex).First().Run(script);
}
return(context.doc.Text);
}
public void TestBug10671()
{
var input = @"
namespace TestConsole
{
public class Test : $BaseMissing
{
}
}
";
// action allowed to create a nested class
var context = TestRefactoringContext.Create(input, false);
var actions = new CreateClassDeclarationAction().GetActions(context);
Assert.AreEqual(1, actions.Count());
}
public void TestAddBaseTypeGenerics()
{
var context = TestRefactoringContext.Create(@"
public class $Foo<T> where T : new()
{
}");
using (var script = context.StartScript()) {
var type = context.GetNode <TypeDeclaration>();
script.ChangeBaseTypes(type, new AstType[] { AstType.Create("System.Test") });
}
Assert.AreEqual(@"
public class Foo<T> : System.Test where T : new()
{
}", context.Text);
}
public void TestRemoveBaseType()
{
var context = TestRefactoringContext.Create(@"
public class $Foo : System.IDisposable
{
}");
using (var script = context.StartScript()) {
var type = context.GetNode <TypeDeclaration>();
script.ChangeBaseTypes(type, Enumerable.Empty <AstType>());
}
Assert.AreEqual(@"
public class Foo
{
}", context.Text);
}
public void TestReplaceBaseType()
{
var context = TestRefactoringContext.Create(@"
public class $Foo : System.IDisposable
{
}");
using (var script = context.StartScript()) {
var type = context.GetNode <TypeDeclaration>();
script.ChangeBaseTypes(type, new AstType[] { AstType.Create("System.Test") });
}
Assert.AreEqual(@"
public class Foo : System.Test
{
}", context.Text);
}
public void TestRenameInterfaceMethod()
{
List <string> contents = new List <string>()
{
@"interface ITest1
{
int $method ();
}
class Test2 : ITest1
{
int method ()
{
}
}", @"class Test3 : ITest1
{
int method ()
{
}
}"
};
var context = TestRefactoringContext.Create(contents, 0);
using (var script = context.StartScript()) {
var method = context.GetNode <MethodDeclaration>();
script.Rename(((MemberResolveResult)context.Resolve(method)).Member, "newName");
}
Assert.AreEqual(@"interface ITest1
{
int newName ();
}
class Test2 : ITest1
{
int newName ()
{
}
}", context.GetSideDocumentText(0));
Assert.AreEqual(@"class Test3 : ITest1
{
int newName ()
{
}
}", context.GetSideDocumentText(1));
}
public void TestGlobalOperation()
{
List <string> contents = new List <string>()
{
@"class Test1
{
public int $x;
}", @"class Test2
{
public void Foo(Test1 test1)
{
test1.x = 1;
test1.x = 2;
}
}"
};
var context = TestRefactoringContext.Create(contents, 0);
using (var script = context.StartScript()) {
var variable = context.GetNode <VariableInitializer>();
script.DoGlobalOperationOn(new List <IEntity>()
{
((MemberResolveResult)context.Resolve(variable)).Member
}, (rCtx, rScript, nodes) => {
foreach (var node in nodes)
{
rScript.Replace(node, new IdentifierExpression("replacement"));
}
});
}
Assert.AreEqual(@"class Test1
{
public int replacement;
}", context.GetSideDocumentText(0));
Assert.AreEqual(@"class Test2
{
public void Foo(Test1 test1)
{
replacement = 1;
replacement = 2;
}
}", context.GetSideDocumentText(1));
}
// TODO: Remove this when the formatter handles object and collection initializers
// This tests the expected code vs the actual code based on their ASTs instead of the text they produce.
public new void Test <T>(string input, string output, int action = 0, bool expectErrors = false)
where T : CodeActionProvider, new ()
{
string result = RunContextAction(new T(), HomogenizeEol(input), action, expectErrors);
var expectedContext = TestRefactoringContext.Create(output, expectErrors);
var actualContext = TestRefactoringContext.Create(result, expectErrors);
bool passed = expectedContext.RootNode.IsMatch(actualContext.RootNode);
if (!passed)
{
Console.WriteLine("-----------Expected:");
Console.WriteLine(output);
Console.WriteLine("-----------Got:");
Console.WriteLine(result);
}
Assert.IsTrue(passed, "The generated code and the expected code was not syntactically identical. See output for details.");
}
void DoLocalOperationOn(TestRefactoringContext localContext, IEnumerable <IEntity> entities, Action <RefactoringContext, Script, IEnumerable <AstNode> > callback)
{
List <AstNode> nodes = new List <AstNode>();
FindReferences refFinder = new FindReferences();
refFinder.FindCallsThroughInterface = true;
refFinder.FindReferencesInFile(refFinder.GetSearchScopes(entities),
localContext.UnresolvedFile,
localContext.RootNode as SyntaxTree,
localContext.Compilation,
(node, result) => {
nodes.Add(node);
},
CancellationToken.None);
using (var script = localContext.StartScript()) {
callback(localContext, script, nodes);
}
}
public void TestRename()
{
List <string> contents = new List <string>()
{
@"class Test1
{
public int $x;
}", @"class Test2
{
public void Foo(Test1 test1)
{
test1.x = 1;
test1.x = 2;
}
}"
};
var context = TestRefactoringContext.Create(contents, 0);
using (var script = context.StartScript()) {
var variable = context.GetNode <VariableInitializer>();
script.Rename(((MemberResolveResult)context.Resolve(variable)).Member, "newName");
}
Assert.AreEqual(@"class Test1
{
public int newName;
}", context.GetSideDocumentText(0));
Assert.AreEqual(@"class Test2
{
public void Foo(Test1 test1)
{
test1.newName = 1;
test1.newName = 2;
}
}", context.GetSideDocumentText(1));
}
public TestScript(TestRefactoringContext context) : base(context.doc, context.FormattingOptions, new TextEditorOptions())
{
this.context = context;
}
public static TestRefactoringContext Create(List <string> contents, int mainIndex, bool expectErrors = false)
{
List <int> indexes = new List <int>();
List <int> selectionStarts = new List <int>();
List <int> selectionEnds = new List <int>();
List <IDocument> documents = new List <IDocument>();
List <CSharpUnresolvedFile> unresolvedFiles = new List <CSharpUnresolvedFile>();
List <SyntaxTree> units = new List <SyntaxTree>();
for (int i = 0; i < contents.Count; i++)
{
string content = contents[i];
int idx = content.IndexOf("$");
if (idx >= 0)
{
content = content.Substring(0, idx) + content.Substring(idx + 1);
}
int idx1 = content.IndexOf("<-");
int idx2 = content.IndexOf("->");
int selectionStart = 0;
int selectionEnd = 0;
if (0 <= idx1 && idx1 < idx2)
{
content = content.Substring(0, idx2) + content.Substring(idx2 + 2);
content = content.Substring(0, idx1) + content.Substring(idx1 + 2);
selectionStart = idx1;
selectionEnd = idx2 - 2;
idx = selectionEnd;
}
indexes.Add(idx);
selectionStarts.Add(selectionStart);
selectionEnds.Add(selectionEnd);
var doc = new StringBuilderDocument(content);
var parser = new CSharpParser();
var unit = parser.Parse(content, "program_" + i + ".cs");
if (!expectErrors)
{
if (parser.HasErrors)
{
Console.WriteLine(content);
Console.WriteLine("----");
}
foreach (var error in parser.Errors)
{
Console.WriteLine(error.Message);
}
Assert.IsFalse(parser.HasErrors, "The file " + i + " contains unexpected parsing errors.");
}
else
{
Assert.IsTrue(parser.HasErrors, "Expected parsing errors, but the file " + i + "doesn't contain any.");
}
unit.Freeze();
CSharpUnresolvedFile unresolvedFile = unit.ToTypeSystem();
units.Add(unit);
documents.Add(doc);
unresolvedFiles.Add(unresolvedFile);
}
IProjectContent pc = new CSharpProjectContent();
pc = pc.AddOrUpdateFiles(unresolvedFiles);
pc = pc.AddAssemblyReferences(new[] { CecilLoaderTests.Mscorlib, CecilLoaderTests.SystemCore });
var compilation = pc.CreateCompilation();
List <TestRefactoringContext> contexts = new List <TestRefactoringContext>();
for (int documentIndex = 0; documentIndex < documents.Count; ++documentIndex)
{
var doc = documents [documentIndex];
var resolver = new CSharpAstResolver(compilation, units[documentIndex], unresolvedFiles[documentIndex]);
TextLocation location = TextLocation.Empty;
if (indexes[documentIndex] >= 0)
{
location = doc.GetLocation(indexes[documentIndex]);
}
var context = new TestRefactoringContext(doc, location, resolver)
{
selectionStart = selectionStarts[documentIndex],
selectionEnd = selectionEnds[documentIndex],
projectContexts = contexts
};
contexts.Add(context);
}
return(contexts [mainIndex]);
}
public TestScript(TestRefactoringContext context) : base(context.doc, FormattingOptionsFactory.CreateMono (), new TextEditorOptions ())
{
this.context = context;
}
public static TestRefactoringContext Create (List<string> contents, int mainIndex, bool expectErrors = false, CSharpParser parser = null)
{
List<int> indexes = new List<int>();
List<int> selectionStarts = new List<int>();
List<int> selectionEnds = new List<int>();
List<IDocument> documents = new List<IDocument>();
List<CSharpUnresolvedFile> unresolvedFiles = new List<CSharpUnresolvedFile>();
List<SyntaxTree> units = new List<SyntaxTree>();
for (int i = 0; i < contents.Count; i++) {
string content = contents[i];
int idx = content.IndexOf("$");
if (idx >= 0)
content = content.Substring(0, idx) + content.Substring(idx + 1);
int idx1 = content.IndexOf("<-");
int idx2 = content.IndexOf("->");
int selectionStart = 0;
int selectionEnd = 0;
if (0 <= idx1 && idx1 < idx2) {
content = content.Substring(0, idx2) + content.Substring(idx2 + 2);
content = content.Substring(0, idx1) + content.Substring(idx1 + 2);
selectionStart = idx1;
selectionEnd = idx2 - 2;
idx = selectionEnd;
}
indexes.Add(idx);
selectionStarts.Add(selectionStart);
selectionEnds.Add(selectionEnd);
var doc = new StringBuilderDocument(content);
if (parser == null)
parser = new CSharpParser();
var unit = parser.Parse(content, "program_" + i + ".cs");
if (!expectErrors) {
if (parser.HasErrors) {
Console.WriteLine(content);
Console.WriteLine("----");
}
foreach (var error in parser.ErrorsAndWarnings) {
Console.WriteLine(error.Message);
}
Assert.IsFalse(parser.HasErrors, "The file " + i + " contains unexpected parsing errors.");
}
else {
Assert.IsTrue(parser.HasErrors, "Expected parsing errors, but the file " + i + "doesn't contain any.");
}
unit.Freeze();
CSharpUnresolvedFile unresolvedFile = unit.ToTypeSystem();
units.Add(unit);
documents.Add(doc);
unresolvedFiles.Add(unresolvedFile);
}
IProjectContent pc = new CSharpProjectContent ();
pc = pc.AddOrUpdateFiles (unresolvedFiles);
pc = pc.AddAssemblyReferences (new[] { CecilLoaderTests.Mscorlib, CecilLoaderTests.SystemCore });
var compilation = pc.CreateCompilation ();
List<TestRefactoringContext> contexts = new List<TestRefactoringContext>();
for (int documentIndex = 0; documentIndex < documents.Count; ++documentIndex)
{
var doc = documents [documentIndex];
var resolver = new CSharpAstResolver (compilation, units[documentIndex], unresolvedFiles[documentIndex]);
TextLocation location = TextLocation.Empty;
if (indexes[documentIndex] >= 0)
location = doc.GetLocation (indexes[documentIndex]);
var context = new TestRefactoringContext(doc, location, resolver) {
selectionStart = selectionStarts[documentIndex],
selectionEnd = selectionEnds[documentIndex],
projectContexts = contexts,
version = parser.CompilerSettings.LanguageVersion,
defaultNamespace = "Test"
};
contexts.Add(context);
}
return contexts [mainIndex];
}
protected static void CheckFix (TestRefactoringContext ctx, CodeIssue issue, string expectedOutput)
{
using (var script = ctx.StartScript ())
issue.Actions.First ().Run (script);
Assert.AreEqual (expectedOutput, ctx.Text);
}
protected static List<CodeIssue> GetIssues (ICodeIssueProvider action, string input, out TestRefactoringContext context)
{
context = TestRefactoringContext.Create (input);
return new List<CodeIssue> (action.GetIssues (context));
}
public TestScript(TestRefactoringContext context) : base(context.doc, FormattingOptionsFactory.CreateMono(), new TextEditorOptions())
{
this.context = context;
}
public TestScript(TestRefactoringContext context)
: base(context.doc, context.FormattingOptions, new TextEditorOptions ())
{
this.context = context;
}
void DoLocalOperationOn(TestRefactoringContext localContext, IEnumerable<IEntity> entities, Action<RefactoringContext, Script, IEnumerable<AstNode>> callback)
{
List<AstNode> nodes = new List<AstNode>();
FindReferences refFinder = new FindReferences();
refFinder.FindCallsThroughInterface = true;
refFinder.FindReferencesInFile(refFinder.GetSearchScopes(entities),
localContext.UnresolvedFile,
localContext.RootNode as SyntaxTree,
localContext.Compilation,
(node, result) => {
nodes.Add(node);
},
CancellationToken.None);
using (var script = localContext.StartScript()) {
callback(localContext, script, nodes);
}
}
