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); }