public void AllPossiblePermutationsOfMultipleLiterals()
{
const string codeText = @"void Target() { foo(7, 7, 8, 8); }";
var target = AstMatchHelper.ParseToMethodDeclaration(codeText);
LiteralToParameterExpansion exp = new LiteralToParameterExpansion();
var perms = exp.FindCandidatesViaRefactoringPermutations(target);
foreach (var perm in perms)
{
Debug.WriteLine(perm.PermutatedMethod.Print());
}
AssertExists(perms, p => p.MatchesIgnoreVarNames(@"void Expected(int i) { foo(i, 7, 8, 8); }"));
AssertExists(perms, p => p.MatchesIgnoreVarNames(@"void Expected(int i) { foo(7, i, 8, 8); }"));
AssertExists(perms, p => p.MatchesIgnoreVarNames(@"void Expected(int i) { foo(7, 7, i, 8); }"));
AssertExists(perms, p => p.MatchesIgnoreVarNames(@"void Expected(int i) { foo(7, 7, 8, i); }"));
AssertExists(perms, p => p.MatchesIgnoreVarNames(@"void Expected(int i) { foo(i, i, 8, 8); }"));
AssertExists(perms, p => p.MatchesIgnoreVarNames(@"void Expected(int i) { foo(7, 7, i, i); }"));
AssertExists(perms, p => p.MatchesIgnoreVarNames(@"void Expected(int i, int i2) { foo(i, 7, i2, 8); }"));
AssertExists(perms, p => p.MatchesIgnoreVarNames(@"void Expected(int i, int i2) { foo(i, 7, 8, i2); }"));
AssertExists(perms, p => p.MatchesIgnoreVarNames(@"void Expected(int i, int i2) { foo(7, i, i2, 8); }"));
AssertExists(perms, p => p.MatchesIgnoreVarNames(@"void Expected(int i, int i2) { foo(7, i, 8, i2); }"));
AssertExists(perms, p => p.MatchesIgnoreVarNames(@"void Expected(int i, int i2) { foo(7, i, 8, i2); }"));
AssertExists(perms, p => p.MatchesIgnoreVarNames(@"void Expected(int i, int i2) { foo(i, 7, 8, i2); }"));
AssertExists(perms, p => p.MatchesIgnoreVarNames(@"void Expected(int i, int i2) { foo(7, i, i2, 8); }"));
AssertExists(perms, p => p.MatchesIgnoreVarNames(@"void Expected(int i, int i2) { foo(i, 7, i2, 8); }"));
AssertExists(perms, p => p.MatchesIgnoreVarNames(@"void Expected(int i, int i2) { foo(i, i, i2, i2); }"));
// I think that's all of them. 2^n-1 where n=4 is 15.
}
public void TestNodeCounts()
{
var target = AstMatchHelper.ParseToMethodDeclaration(@"void Target() { foo(7, 7, 8, 8); }");
var target2 = AstMatchHelper.ParseToMethodDeclaration(@"void Target() { foo(8, 8, 7, 7); }");
Assert.That(target.CountNodes(), Is.EqualTo(target2.CountNodes()));
}
public void SingleLiteralCanBeMultipleParams()
{
const string codeText = @"void Target() { Console.WriteLine(7); Console.Write(7); }";
var target = AstMatchHelper.ParseToMethodDeclaration(codeText);
LiteralToParameterExpansion exp = new LiteralToParameterExpansion();
var perms = exp.FindCandidatesViaRefactoringPermutations(target);
AssertExists(perms, p => p.MatchesIgnoreVarNames(@"void Expected(int i, int i1) { Console.WriteLine(i); Console.Write(i1); }"), "Expected a permutation where each literal gets it's own parameter, regardless of redundancy.");
}
public void SingleLiteralInstance()
{
const string codeText = @"void Target() { Console.WriteLine(7); }";
var target = AstMatchHelper.ParseToMethodDeclaration(codeText);
LiteralToParameterExpansion exp = new LiteralToParameterExpansion();
var perms = exp.FindCandidatesViaRefactoringPermutations(target);
Assert.IsTrue(perms.Any(p => p.PermutatedMethod.MatchesPrint(AstMatchHelper.ParseToMethodDeclaration(@"void Expected(int i) { Console.WriteLine(i); }"))));
}
public void MultipleInstancesOfDifferentLiterals()
{
const string codeText = @"void Target() { Console.WriteLine(7); Console.Write(8); Console.WriteLine(7); Console.Write(8); }";
var target = AstMatchHelper.ParseToMethodDeclaration(codeText);
LiteralToParameterExpansion exp = new LiteralToParameterExpansion();
var perms = exp.FindCandidatesViaRefactoringPermutations(target);
AssertExists(perms, p => p.PermutatedMethod.MatchesPrint(AstMatchHelper.ParseToMethodDeclaration(@"void Expected(int i, int i1) { Console.WriteLine(i); Console.Write(i1); Console.WriteLine(i); Console.Write(i1);}")), "Expected literals with same value to get the same parameter.");
}
public void MultipleCopiesOfALiteral()
{
const string codeText = @"void Target() { Console.WriteLine(7); Console.Write(7); }";
var target = AstMatchHelper.ParseToMethodDeclaration(codeText);
LiteralToParameterExpansion exp = new LiteralToParameterExpansion();
var perms = exp.FindCandidatesViaRefactoringPermutations(target);
AssertExists(perms, p => p.PermutatedMethod.MatchesPrint(AstMatchHelper.ParseToMethodDeclaration(@"void Expected(int i) { Console.WriteLine(i); Console.Write(i); }")), "Expected a permutation where all possible literals were replaced with a single parameter.");
}
public void AstComparisonIgnoreLiteralsVisitorTest()
{
var visitor = new AstComparisonIgnoreLiteralsVisitor();
var md = AstMatchHelper.ParseToMethodDeclaration(@"void foo() { int i = 1 + 2; }");
var md_different = AstMatchHelper.ParseToMethodDeclaration(@"void foo() { int i = 2 + 1; }");
md.AcceptVisitor(visitor, md_different);
Assert.That(visitor.Match, Is.True);
}
public void RenameLocalVariableExpansion_Other()
{
const string codeText1 = @"void Expected(int i, int i2) { foo(i, 7, i2, 8); }";
const string codeText2 = @"void Target(System.Int32 i, System.Int32 i1) { foo(i, 7, i1, 8); }";
var expected = AstMatchHelper.ParseToMethodDeclaration(codeText1);
var target = AstMatchHelper.ParseToMethodDeclaration(codeText2);
var r = new RenameLocalVariableExpansion();
var permutations = r.FindCandidatesViaRefactoringPermutations(new TargetInfo(expected, target), target);
Util.AssertExists(permutations, x => x.MatchesPrint(expected));
}
public void PrimitiveExpressionForNullBug()
{
const string codeText = @"public void Foo()
{
if (member != null)
{
}
}";
var exp = new LiteralToParameterExpansion();
var md = AstMatchHelper.ParseToMethodDeclaration(codeText);
exp.FindCandidatesViaRefactoringPermutations(md).ToList();
}
private void RunRenameLocalVariableRefactoringTest(string codeText, string idStart, string idEnd)
{
var foo_meth = AstMatchHelper.ParseToMethodDeclaration(codeText);
var renameTable = new Dictionary <string, string> {
{ idStart, idEnd }
};
RenameLocalVariableRefactoring r = new RenameLocalVariableRefactoring(renameTable);
foo_meth.AcceptVisitor(r, null);
var expectedCode = codeText.Replace(idStart, idEnd);
Assert.IsTrue(AstMatchHelper.ParseToMethodDeclaration(expectedCode).Matches(foo_meth), "Expected code: " + expectedCode + " did not match actual code: " + foo_meth.Print());
}
public static bool MatchesIgnoreVarNames(this CloneDesc p, string expectedCode)
{
RenameLocalVariableExpansion rename = new RenameLocalVariableExpansion();
var expected = AstMatchHelper.ParseToMethodDeclaration(expectedCode);
foreach (var prd in rename.FindCandidatesViaRefactoringPermutations(new TargetInfo(expected, p.PermutatedMethod), p.PermutatedMethod))
{
if (expected.Matches(prd))
{
return(true);
}
}
return(false);
}
private void RunWhitespaceTest(string whitespace)
{
var target = AstMatchHelper.ParseToMethodDeclaration(
string.Format(@"public void Target()
{{
int x = 7;
Console.WriteLine(x);
Console.WriteLine(x);
{0}}}", whitespace));
CSharpMethodExtractor extractor = new CSharpMethodExtractor();
extractor.Extract(target, new Window(1, 2));
Assert.AreEqual(1, extractor.ExtractedMethod.Parameters.Count, "Expected a new method with exactly one parameter.");
}
public void GotoTargetOccursBefore()
{
const string codeText = @"public void Switch()
{
fred:
return;
goto fred;
}";
var md = AstMatchHelper.ParseToMethodDeclaration(codeText);
FindJumpInstructionsVisitor v = new FindJumpInstructionsVisitor(md, new MySelection(md.Body.Children));
md.AcceptVisitor(v, null);
Assert.IsTrue(v.IsOk);
}
private void TestCounterOnSnippet(string codeText)
{
var expansion = new OscillatingExtractMethodRefactoringExpansion();
var counter = new OscillatingExtractMethodCounter();
var md = AstMatchHelper.ParseToMethodDeclaration(codeText);
var methods = expansion.GetAllPossibleExtractedMethods(md, 3);
var count = counter.CountAllExtractedMethods(md, 3);
Assert.AreEqual(methods.Count(), count);
methods = expansion.GetAllPossibleExtractedMethods(md, 1);
count = counter.CountAllExtractedMethods(md, 1);
Assert.AreEqual(methods.Count(), count);
}
public void AllPossiblePermutationsOfASingleLiteral()
{
const string codeText = @"void Target() { Console.WriteLine(7); Console.Write(7); }";
var target = AstMatchHelper.ParseToMethodDeclaration(codeText);
LiteralToParameterExpansion exp = new LiteralToParameterExpansion();
var perms = exp.FindCandidatesViaRefactoringPermutations(target);
AssertExists(perms, p => p.MatchesIgnoreVarNames(@"void Expected(int i) { Console.WriteLine(i); Console.Write(i); }"), "Expected a permutation where all possible literals were replaced with a single parameter.");
AssertExists(perms, p => p.MatchesIgnoreVarNames(@"void Expected(int i) { Console.WriteLine(i); Console.Write(7); }"), "Expected a permutation where the first literal was replaced, but not the second.");
AssertExists(perms, p => p.MatchesIgnoreVarNames(@"void Expected(int i) { Console.WriteLine(7); Console.Write(i); }"), "Expected a permutation where the second literal was replaced, but not the first.");
// Print out the permutations, just for reference.
for (int i = 0; i < perms.ToArray().Length; i++)
{
var perm = perms.ToArray()[i];
TestLog.EmbedPlainText("perm" + i, perm.PermutatedMethod.Print());
}
}
public void RenameLocalVariableExpansion_IncludesParameters()
{
const string codeText =
@"void Bar(string bar_str)
{
bar_str += ""zippy"";
Console.Write(bar_str);
}";
var foo_meth = AstMatchHelper.ParseToMethodDeclaration(codeText);
var expected_method_text = codeText.Replace("bar_str", "jibberjab");
var expected_method = AstMatchHelper.ParseToMethodDeclaration(expected_method_text);
RenameLocalVariableExpansion r = new RenameLocalVariableExpansion();
var candidates = r.FindCandidatesViaRefactoringPermutations(new TargetInfo(expected_method, foo_meth), foo_meth);
Util.AssertExists(candidates, x => expected_method.MatchesPrint(x));
}
public void GotoDefaultCase()
{
const string codeText = @"public void Switch()
{
switch (0)
{
case 0:
goto default;
default:
break;
}
}";
var md = AstMatchHelper.ParseToMethodDeclaration(codeText);
FindJumpInstructionsVisitor v = new FindJumpInstructionsVisitor(md, new MySelection(md.Body.Children));
md.AcceptVisitor(v, null);
Assert.IsTrue(v.IsOk);
}