summaryrefslogtreecommitdiff
path: root/plugins/structuralsearch/testSource/com/intellij/structuralsearch/StructuralReplaceTest.java
diff options
context:
space:
mode:
Diffstat (limited to 'plugins/structuralsearch/testSource/com/intellij/structuralsearch/StructuralReplaceTest.java')
-rw-r--r--plugins/structuralsearch/testSource/com/intellij/structuralsearch/StructuralReplaceTest.java2133
1 files changed, 0 insertions, 2133 deletions
diff --git a/plugins/structuralsearch/testSource/com/intellij/structuralsearch/StructuralReplaceTest.java b/plugins/structuralsearch/testSource/com/intellij/structuralsearch/StructuralReplaceTest.java
deleted file mode 100644
index d5848b611867..000000000000
--- a/plugins/structuralsearch/testSource/com/intellij/structuralsearch/StructuralReplaceTest.java
+++ /dev/null
@@ -1,2133 +0,0 @@
-package com.intellij.structuralsearch;
-
-import com.intellij.openapi.application.PluginPathManager;
-import com.intellij.psi.CommonClassNames;
-import com.intellij.testFramework.PlatformTestUtil;
-import com.intellij.util.ThrowableRunnable;
-import org.jetbrains.annotations.NotNull;
-
-import java.io.IOException;
-
-/**
- * @by Maxim.Mossienko
- */
-@SuppressWarnings({"ALL"})
-public class StructuralReplaceTest extends StructuralReplaceTestCase {
- public void testReplaceInLiterals() {
- String s1 = "String ID_SPEED = \"Speed\";";
- String s2 = "String 'name = \"'string\";";
- String s2_2 = "String 'name = \"'string:[regex( .* )]\";";
- String s3 = "VSegAttribute $name$ = new VSegAttribute(\"$string$\");";
- String expectedResult = "VSegAttribute ID_SPEED = new VSegAttribute(\"Speed\");";
-
- String actualResult = replacer.testReplace(s1,s2,s3,options);
- assertEquals(
- "Matching/replacing literals",
- expectedResult,
- actualResult
- );
-
- actualResult = replacer.testReplace(s1,s2_2,s3,options);
- assertEquals(
- "Matching/replacing literals",
- expectedResult,
- actualResult
- );
-
- String s4 = "params.put(\"BACKGROUND\", \"#7B528D\");";
- String s5 = "params.put(\"$FieldName$\", \"#$exp$\");";
- String s6 = "String $FieldName$ = \"$FieldName$\";\n" +
- "params.put($FieldName$, \"$exp$\");";
- String expectedResult2 = "String BACKGROUND = \"BACKGROUND\";\n" +
- "params.put(BACKGROUND, \"7B528D\");";
-
- actualResult = replacer.testReplace(s4,s5,s6,options);
-
- assertEquals(
- "string literal replacement 2",
- expectedResult2,
- actualResult
- );
-
- String s7 = "IconLoader.getIcon(\"/ant/property.png\");\n" +
- "IconLoader.getIcon(\"/ant/another/property.png\");\n";
- String s8 = "IconLoader.getIcon(\"/'module/'name:[regex( \\w+ )].png\");";
- String s9 = "Icons.$module$.$name$;";
- String expectedResult3 = "Icons.ant.property;\n" +
- "IconLoader.getIcon(\"/ant/another/property.png\");\n";
-
- actualResult = replacer.testReplace(s7,s8,s9,options);
-
- assertEquals(
- "string literal replacement 3",
- expectedResult3,
- actualResult
- );
-
- String s10 = "configureByFile(path + \"1.html\");\n" +
- " checkResultByFile(path + \"1_after.html\");\n" +
- " checkResultByFile(path + \"1_after2.html\");\n" +
- " checkResultByFile(path + \"1_after3.html\");";
- String s11 = "\"'a.html\"";
- String s12 = "\"$a$.\"+ext";
- String expectedResult4 = "configureByFile(path + \"1.\"+ext);\n" +
- " checkResultByFile(path + \"1_after.\"+ext);\n" +
- " checkResultByFile(path + \"1_after2.\"+ext);\n" +
- " checkResultByFile(path + \"1_after3.\"+ext);";
-
- actualResult = replacer.testReplace(s10,s11,s12,options);
- assertEquals(
- "string literal replacement 4",
- expectedResult4,
- actualResult
- );
- }
-
- public void testReplace2() {
- String s1 = "package com.www.xxx.yyy;\n" +
- "\n" +
- "import javax.swing.*;\n" +
- "\n" +
- "public class Test {\n" +
- " public static void main(String[] args) {\n" +
- " if (1==1)\n" +
- " JOptionPane.showMessageDialog(null, \"MESSAGE\");\n" +
- " }\n" +
- "}";
- String s2 = "JOptionPane.'showDialog(null, 'msg);";
- String s3 = "//FIXME provide a parent frame\n" +
- "JOptionPane.$showDialog$(null, $msg$);";
-
- String expectedResult = "package com.www.xxx.yyy;\n" +
- "\n" +
- "import javax.swing.*;\n" +
- "\n" +
- "public class Test {\n" +
- " public static void main(String[] args) {\n" +
- " if (1==1)\n" +
- " //FIXME provide a parent frame\n" +
- "JOptionPane.showMessageDialog(null, \"MESSAGE\");\n" +
- " }\n" +
- "}";
-
- actualResult = replacer.testReplace(s1,s2,s3,options);
- assertEquals(
- "adding comment to statement inside the if body",
- expectedResult,
- actualResult
- );
-
- String s4 = "myButton.setText(\"Ok\");";
- String s5 = "'Instance.'MethodCall:[regex( setText )]('Parameter*:[regex( \"Ok\" )]);";
- String s6 = "$Instance$.$MethodCall$(\"OK\");";
-
- String expectedResult2 = "myButton.setText(\"OK\");";
-
- actualResult = replacer.testReplace(s4,s5,s6,options);
- assertEquals(
- "adding comment to statement inside the if body",
- expectedResult2,
- actualResult
- );
- }
-
- public void testReplace() {
- String str = "// searching for several constructions\n" +
- " lastTest = \"several constructions match\";\n" +
- " matches = testMatcher.findMatches(s5,s4, options);\n" +
- " if (matches==null || matches.size()!=3) return false;\n" +
- "\n" +
- " // searching for several constructions\n" +
- " lastTest = \"several constructions 2\";\n" +
- " matches = testMatcher.findMatches(s5,s6, options);\n" +
- " if (matches.size()!=0) return false;\n" +
- "\n" +
- " //options.setLooseMatching(true);\n" +
- " // searching for several constructions\n" +
- " lastTest = \"several constructions 3\";\n" +
- " matches = testMatcher.findMatches(s7,s8, options);\n" +
- " if (matches.size()!=2) return false;";
-
- String str2=" lastTest = 'Descr;\n" +
- " matches = testMatcher.findMatches('In,'Pattern, options);\n" +
- " if (matches.size()!='Number) return false;";
- String str3 = "assertEquals($Descr$,testMatcher.findMatches($In$,$Pattern$, options).size(),$Number$);";
- String expectedResult1 = "// searching for several constructions\n" +
- " lastTest = \"several constructions match\";\n" +
- " matches = testMatcher.findMatches(s5, s4, options);\n" +
- " if (matches == null || matches.size() != 3) return false;\n" +
- "\n" +
- " // searching for several constructions\n" +
- " assertEquals(\"several constructions 2\", testMatcher.findMatches(s5, s6, options).size(), 0);\n" +
- "\n" +
- " //options.setLooseMatching(true);\n" +
- " // searching for several constructions\n" +
- " assertEquals(\"several constructions 3\", testMatcher.findMatches(s7, s8, options).size(), 2);";
-
- String str4 = "";
-
- options.setToReformatAccordingToStyle(true);
- actualResult = replacer.testReplace(str,str2,str3,options);
- options.setToReformatAccordingToStyle(false);
- assertEquals("Basic replacement with formatter",expectedResult1,actualResult);
-
- actualResult = replacer.testReplace(str,str2,str4,options);
- String expectedResult2 = "// searching for several constructions\n" +
- " lastTest = \"several constructions match\";\n" +
- " matches = testMatcher.findMatches(s5,s4, options);\n" +
- " if (matches==null || matches.size()!=3) return false;\n" +
- "\n" +
- " // searching for several constructions\n" +
- "\n" +
- " //options.setLooseMatching(true);\n" +
- " // searching for several constructions";
-
- assertEquals("Empty replacement",expectedResult2,actualResult);
-
- String str5 = "testMatcher.findMatches('In,'Pattern, options).size()";
- String str6 = "findMatchesCount($In$,$Pattern$)";
- String expectedResult3="// searching for several constructions\n" +
- " lastTest = \"several constructions match\";\n" +
- " matches = testMatcher.findMatches(s5, s4, options);\n" +
- " if (matches == null || matches.size() != 3) return false;\n" +
- "\n" +
- " // searching for several constructions\n" +
- " assertEquals(\"several constructions 2\", findMatchesCount(s5,s6), 0);\n" +
- "\n" +
- " //options.setLooseMatching(true);\n" +
- " // searching for several constructions\n" +
- " assertEquals(\"several constructions 3\", findMatchesCount(s7,s8), 2);";
- actualResult = replacer.testReplace(expectedResult1,str5,str6,options);
-
- assertEquals( "Expression replacement", expectedResult3,actualResult );
-
- String str7 = "try { a.doSomething(); b.doSomething(); } catch(IOException ex) { ex.printStackTrace(); throw new RuntimeException(ex); }";
- String str8 = "try { 'Statements+; } catch('_ '_) { 'HandlerStatements+; }";
- String str9 = "$Statements$;";
- String expectedResult4 = "a.doSomething(); b.doSomething();";
-
- actualResult = replacer.testReplace(str7,str8,str9,options);
- assertEquals( "Multi line match in replacement", expectedResult4,actualResult );
-
- String str10 = " parentNode.insert(compositeNode, i);\n" +
- " if (asyncMode) {\n" +
- " myTreeModel.nodesWereInserted(parentNode,new int[] {i} );\n" +
- " }";
- String str11 = " 'parentNode.insert('newNode, 'i);\n" +
- " if (asyncMode) {\n" +
- " myTreeModel.nodesWereInserted('parentNode,new int[] {'i} );\n" +
- " }";
- String str12 = "addChild($parentNode$,$newNode$, $i$);";
- String expectedResult5 = " addChild(parentNode,compositeNode, i);";
-
- actualResult = replacer.testReplace(str10,str11,str12,options);
- assertEquals( "Array initializer replacement", expectedResult5,actualResult);
-
- String str13 = " aaa(5,6,3,4,1,2);";
- String str14 = "aaa('t{2,2},3,4,'q{2,2});";
- String str15 = "aaa($q$,3,4,$t$);";
- String expectedResult6 = " aaa(1,2,3,4,5,6);";
-
- actualResult = replacer.testReplace(str13,str14,str15,options);
- assertEquals("Parameter multiple match",expectedResult6,actualResult);
-
- String str16 = " int c = a();";
- String str17 = "'t:a ('q*,'p*)";
- String str18 = "$t$($q$,1,$p$)";
- String expectedResult7 = " int c = a(1);";
-
- actualResult = replacer.testReplace(str16,str17,str18,options);
- assertEquals("Replacement of init in definition + empty substitution",expectedResult7,actualResult);
-
- String str19 = " aaa(bbb);";
- String str20 = "'t('_);";
- String str21 = "$t$(ccc);";
- String expectedResult8 = " aaa(ccc);";
-
- actualResult = replacer.testReplace(str19,str20,str21,options);
- assertEquals("One substition replacement",expectedResult8,actualResult);
-
- String str22 = " instance.setAAA(anotherInstance.getBBB());";
- String str23 = " 'i.'m:set(.+) ('a.'m2:get(.+) ());";
- String str24 = " $a$.set$m2_1$( $i$.get$m_1$() );";
- String expectedResult9 = " anotherInstance.setBBB( instance.getAAA() );";
-
- actualResult = replacer.testReplace(str22,str23,str24,options);
- assertEquals("Reg exp substitution replacement",expectedResult9,actualResult);
-
- String str25 = " LaterInvocator.invokeLater(new Runnable() {\n" +
- " public void run() {\n" +
- " LOG.info(\"refreshFilesAsync, modalityState=\" + ModalityState.current());\n" +
- " myHandler.getFiles().refreshFilesAsync(new Runnable() {\n" +
- " public void run() {\n" +
- " semaphore.up();\n" +
- " }\n" +
- " });\n" +
- " }\n" +
- " });";
- String str26 = " LaterInvocator.invokeLater('Params{1,10});";
- String str27 = " com.intellij.openapi.application.ApplicationManager.getApplication().invokeLater($Params$);";
- String expectedResult10 = " com.intellij.openapi.application.ApplicationManager.getApplication().invokeLater(new Runnable() {\n" +
- " public void run() {\n" +
- " LOG.info(\"refreshFilesAsync, modalityState=\" + ModalityState.current());\n" +
- " myHandler.getFiles().refreshFilesAsync(new Runnable() {\n" +
- " public void run() {\n" +
- " semaphore.up();\n" +
- " }\n" +
- " });\n" +
- " }\n" +
- " });";
-
- actualResult = replacer.testReplace(str25,str26,str27,options);
- assertEquals("Anonymous in parameter",expectedResult10,actualResult);
-
- String str28 = "UTElementNode elementNode = new UTElementNode(myProject, processedElement, psiFile,\n" +
- " processedElement.getTextOffset(), true,\n" +
- " !myUsageViewDescriptor.toMarkInvalidOrReadonlyUsages(), null);";
- String str29 = "new UTElementNode('param, 'directory, 'null, '0, 'true, !'descr.toMarkInvalidOrReadonlyUsages(),\n" +
- " 'referencesWord)";
- String str30 = "new UTElementNode($param$, $directory$, $null$, $0$, $true$, true,\n" +
- " $referencesWord$)";
-
- String expectedResult11 = "UTElementNode elementNode = new UTElementNode(myProject, processedElement, psiFile, processedElement.getTextOffset(), true, true,\n" +
- " null);";
- actualResult = replacer.testReplace(str28,str29,str30,options);
- assertEquals("Replace in def initializer",expectedResult11,actualResult);
-
- String s31 = "a = b; b = c; a=a; c=c;";
- String s32 = "'a = 'a;";
- String s33 = "1 = 1;";
- String expectedResult12 = "a = b; b = c; 1 = 1; 1 = 1;";
-
- actualResult = replacer.testReplace(s31,s32,s33,options);
- assertEquals(
- "replace silly assignments",
- expectedResult12,
- actualResult
- );
-
- String s34 = "ParamChecker.isTrue(1==1, \"!!!\");";
- String s35 = "ParamChecker.isTrue('expr, 'msg)";
- String s36 = "assert $expr$ : $msg$";
-
- String expectedResult13 = "assert 1==1 : \"!!!\";";
- actualResult = replacer.testReplace(s34,s35,s36,options);
- assertEquals(
- "replace with assert",
- expectedResult13,
- actualResult
- );
-
- String s37 = "try { \n" +
- " ParamChecker.isTrue(1==1, \"!!!\");\n \n" +
- " // comment we want to leave\n \n" +
- " ParamChecker.isTrue(2==2, \"!!!\");\n" +
- "} catch(Exception ex) {}";
- String s38 = "try {\n" +
- " 'Statement{0,100};\n" +
- "} catch(Exception ex) {}";
- String s39 = "$Statement$;";
-
- String expectedResult14 = "ParamChecker.isTrue(1==1, \"!!!\");\n \n" +
- " // comment we want to leave\n \n" +
- " ParamChecker.isTrue(2==2, \"!!!\");";
- actualResult = replacer.testReplace(s37,s38,s39,options);
- assertEquals(
- "remove try with comments inside",
- expectedResult14,
- actualResult
- );
-
- String s40 = "ParamChecker.instanceOf(queryKey, GroupBySqlTypePolicy.GroupKey.class);";
- String s41 = "ParamChecker.instanceOf('obj, 'class.class);";
- String s42 = "assert $obj$ instanceof $class$ : \"$obj$ is an instance of \" + $obj$.getClass() + \"; expected \" + $class$.class;";
- String expectedResult15 = "assert queryKey instanceof GroupBySqlTypePolicy.GroupKey : \"queryKey is an instance of \" + queryKey.getClass() + \"; expected \" + GroupBySqlTypePolicy.GroupKey.class;";
-
- actualResult = replacer.testReplace(s40,s41,s42,options);
- assertEquals(
- "Matching/replacing .class literals",
- expectedResult15,
- actualResult
- );
-
- String s43 = "class Wpd {\n" +
- " static final String TAG_BEAN_VALUE = \"\";\n" +
- "}\n" +
- "XmlTag beanTag = rootTag.findSubTag(Wpd.TAG_BEAN_VALUE);";
- String s44 = "'Instance?.findSubTag( 'Parameter:[exprtype( *String ) ])";
- String s45 = "jetbrains.fabrique.util.XmlApiUtil.findSubTag($Instance$, $Parameter$)";
- String expectedResult16 = "class Wpd {\n" +
- " static final String TAG_BEAN_VALUE = \"\";\n" +
- "}\n" +
- "XmlTag beanTag = jetbrains.fabrique.util.XmlApiUtil.findSubTag(rootTag, Wpd.TAG_BEAN_VALUE);";
-
- actualResult = replacer.testReplace(s43,s44,s45,options);
- assertEquals(
- "Matching/replacing static fields",
- expectedResult16,
- actualResult
- );
-
- String s46 = "Rectangle2D rec = new Rectangle2D.Double(\n" +
- " drec.getX(),\n" +
- " drec.getY(),\n" +
- " drec.getWidth(),\n" +
- " drec.getWidth());";
- String s47 = "$Instance$.$MethodCall$()";
- String s48 = "OtherClass.round($Instance$.$MethodCall$(),5)";
- String expectedResult17 = "Rectangle2D rec = new Rectangle2D.Double(\n" +
- " OtherClass.round(drec.getX(),5),\n" +
- " OtherClass.round(drec.getY(),5),\n" +
- " OtherClass.round(drec.getWidth(),5),\n" +
- " OtherClass.round(drec.getWidth(),5));";
- actualResult = replacer.testReplace(s46,s47,s48,options);
-
- assertEquals(
- "Replace in constructor",
- expectedResult17,
- actualResult
- );
-
- String s49 = "class A {}\n" +
- "class B extends A {}\n" +
- "A a = new B();";
- String s50 = "A 'b = new 'B:*A ();";
- String s51 = "A $b$ = new $B$(\"$b$\");";
- String expectedResult18 = "class A {}\n" +
- "class B extends A {}\n" +
- "A a = new B(\"a\");";
-
- actualResult = replacer.testReplace(s49,s50,s51,options);
-
- assertEquals(
- "Class navigation",
- expectedResult18,
- actualResult
- );
-
- String s52 = "try {\n" +
- " aaa();\n" +
- "} finally {\n" +
- " System.out.println();" +
- "}\n" +
- "try {\n" +
- " aaa2();\n" +
- "} catch(Exception ex) {\n" +
- " aaa3();\n" +
- "}\n" +
- "finally {\n" +
- " System.out.println();\n" +
- "}\n" +
- "try {\n" +
- " aaa4();\n" +
- "} catch(Exception ex) {\n" +
- " aaa5();\n" +
- "}\n";
- String s53 = "try { 'a; } finally {\n" +
- " 'b;" +
- "}";
- String s54 = "$a$;";
- String expectedResult19 = "aaa();\n" +
- "try {\n" +
- " aaa2();\n" +
- "} catch(Exception ex) {\n" +
- " aaa3();\n" +
- "}\n" +
- "finally {\n" +
- " System.out.println();\n" +
- "}\n" +
- "try {\n" +
- " aaa4();\n" +
- "} catch(Exception ex) {\n" +
- " aaa5();\n" +
- "}\n";
-
- actualResult = replacer.testReplace(s52,s53,s54,options);
-
- assertEquals(
- "Try/ catch/ finally is replace with try/finally",
- expectedResult19,
- actualResult
- );
-
- String s55 = "for(Iterator<String> iterator = stringlist.iterator(); iterator.hasNext();) {\n" +
- " String str = iterator.next();\n" +
- " System.out.println( str );\n" +
- "}";
- String s56 = "for (Iterator<$Type$> $variable$ = $container$.iterator(); $variable$.hasNext();) {\n" +
- " $Type$ $var$ = $variable$.next();\n" +
- " $Statements$;\n" +
- "}";
- String s57 = "for($Type$ $var$:$container$) {\n" +
- " $Statements$;\n" +
- "}";
- String expectedResult20 = "for(String str :stringlist) {\n" +
- " System.out.println( str );\n" +
- "}";
-
- actualResult = replacer.testReplace(s55,s56,s57,options);
-
- assertEquals(
- "for with foreach",
- expectedResult20,
- actualResult
- );
-
- String s58 = "class A {\n" +
- " static Set<String> b_MAP = new HashSet<String>();\n" +
- " int c;\n" +
- "}";
- String s59 = "'a:[ regex( (.*)_MAP ) ]";
- String s60 = "$a_1$_SET";
- String expectedResult21 = "class A {\n" +
- " static Set<String> b_SET = new HashSet<String>();\n" +
- " int c;\n" +
- "}";
-
- actualResult = replacer.testReplace(s58,s59,s60,options);
-
- assertEquals(
- "replace symbol in definition",
- expectedResult21,
- actualResult
- );
-
- String s64 = "int x = 42;\n" +
- "int y = 42; // Stuff";
- String s65 = "'Type 'Variable = 'Value; // 'Comment";
- String s66 = "/**\n" +
- " *$Comment$\n" +
- " */\n" +
- "$Type$ $Variable$ = $Value$;";
- String expectedResult23 = "int x = 42;\n" +
- "/**\n" +
- " * Stuff\n" +
- " */\n" +
- "int y = 42;";
-
- actualResult = replacer.testReplace(s64,s65,s66,options);
-
- assertEquals(
- "Replacement of the comment with javadoc",
- expectedResult23,
- actualResult
- );
-
- String s61 = "try { 1=1; } catch(Exception e) { 1=1; } catch(Throwable t) { 2=2; }";
- String s62 = "try { 'a; } catch(Exception e) { 'b; }";
- String s63 = "try { $a$; } catch(Exception1 e) { $b$; } catch(Exception2 e) { $b$; }";
- String expectedResult22 = "try { 1=1; } catch(Exception1 e) { 1=1; } catch(Exception2 e) { 1=1; } catch (Throwable t) { 2=2; }";
-
- actualResult = replacer.testReplace(s61,s62,s63,options);
-
- assertEquals(
- "try replacement by another try will leave the unmatched catch",
- expectedResult22,
- actualResult
- );
-
- }
-
- public void testReplaceExpr() {
- String s1 = "new SimpleDateFormat(\"yyyyMMddHHmmss\")";
- String s2 = "'expr";
- String s3 = "new AtomicReference<DateFormat>($expr$)";
- String expectedResult = "new AtomicReference<DateFormat>(new SimpleDateFormat(\"yyyyMMddHHmmss\"))";
-
- actualResult = replacer.testReplace(s1, s2, s3, options);
-
- assertEquals("Replacement of top-level expression only", expectedResult, actualResult);
-
- String s4 = "get(\"smth\")";
- String s5 = "'expr";
- String s6 = "new Integer($expr$)";
- String expectedResult1 = "new Integer(get(\"smth\"))";
-
- actualResult = replacer.testReplace(s4, s5, s6, options);
- assertEquals("Replacement of top-level expression only", expectedResult1, actualResult);
- }
-
- public void testReplaceParameter() {
- String s1 = "class A { void b(int c, int d, int e) {} }";
- String s2 = "int d";
- String s3 = "int d2";
- String expectedResult = "class A { void b(int c, int d2, int e) {} }";
-
- actualResult = replacer.testReplace(s1,s2,s3,options);
-
- assertEquals(
- "replace method parameter",
- expectedResult,
- actualResult
- );
- }
-
- public void testReplaceWithComments() {
- String s1 = "map.put(key, value); // line 1";
- String s2 = "map.put(key, value); // line 1";
- String s3 = "map.put(key, value); // line 1";
- String expectedResult = "map.put(key, value); // line 1";
-
- actualResult = replacer.testReplace(s1,s2,s3,options);
-
- assertEquals(
- "replace self with comment after",
- expectedResult,
- actualResult
- );
-
- String s4 = "if (true) System.out.println(\"1111\"); else System.out.println(\"2222\");\n" +
- "while(true) System.out.println(\"1111\");";
- String s5 = "System.out.println('Test);";
- String s6 = "/* System.out.println($Test$); */";
- actualResult = replacer.testReplace(s4,s5,s6,options);
- String expectedResult2 = "if (true) /* System.out.println(\"1111\"); */; else /* System.out.println(\"2222\"); */;\n" +
- "while(true) /* System.out.println(\"1111\"); */;";
-
- assertEquals(
- "replace with comment",
- expectedResult2,
- actualResult
- );
- }
-
- public void testSeveralStatements() {
- String s1 = "{\n" +
- " System.out.println(1);\n" +
- " System.out.println(2);\n" +
- " System.out.println(3);\n" +
- " }\n" +
- "{\n" +
- " System.out.println(1);\n" +
- " System.out.println(2);\n" +
- " System.out.println(3);\n" +
- " }\n" +
- "{\n" +
- " System.out.println(1);\n" +
- " System.out.println(2);\n" +
- " System.out.println(3);\n" +
- " }";
- String s2 =
- " System.out.println(1);\n" +
- " System.out.println(2);\n" +
- " System.out.println(3);\n";
- String s3 = " System.out.println(3);\n" +
- " System.out.println(2);\n" +
- " System.out.println(1);\n";
- String expectedResult1 = " {\n" +
- " System.out.println(3);\n" +
- " System.out.println(2);\n" +
- " System.out.println(1);\n" +
- " }\n" +
- " {\n" +
- " System.out.println(3);\n" +
- " System.out.println(2);\n" +
- " System.out.println(1);\n" +
- " }\n" +
- " {\n" +
- " System.out.println(3);\n" +
- " System.out.println(2);\n" +
- " System.out.println(1);\n" +
- " }";
- options.setToReformatAccordingToStyle(true);
- actualResult = replacer.testReplace(s1,s2,s3,options);
- options.setToReformatAccordingToStyle(false);
- assertEquals(
- "three statements replacement",
- expectedResult1,
- actualResult
- );
-
- String s4 = "ProgressManager.getInstance().startNonCancelableAction();\n" +
- " try {\n" +
- " read(id, READ_PARENT);\n" +
- " return myViewport.parent;\n" +
- " }\n" +
- " finally {\n" +
- " ProgressManager.getInstance().finishNonCancelableAction();\n" +
- " }";
- String s5 = "ProgressManager.getInstance().startNonCancelableAction();\n" +
- " try {\n" +
- " '_statement{2,2};\n" +
- " }\n" +
- " finally {\n" +
- " ProgressManager.getInstance().finishNonCancelableAction();\n" +
- " }";
- String s6 = "$statement$;";
- String expectedResult2 = "read(id, READ_PARENT);\n" +
- " return myViewport.parent;";
- actualResult = replacer.testReplace(s4,s5,s6,options);
- assertEquals(
- "extra ;",
- expectedResult2,
- actualResult
- );
-
- String s7 = "public class A {\n" +
- " void f() {\n" +
- " new Runnable() {\n" +
- " public void run() {\n" +
- " l();\n" +
- " }\n" +
- "\n" +
- " private void l() {\n" +
- " int i = 9;\n" +
- " int j = 9;\n" +
- " }\n" +
- " };\n" +
- " new Runnable() {\n" +
- " public void run() {\n" +
- " l();\n" +
- " }\n" +
- "\n" +
- " private void l() {\n" +
- " l();\n" +
- " l();\n" +
- " }\n" +
- " };\n" +
- " }\n" +
- "\n" +
- "}";
- String s8 = "new Runnable() {\n" +
- " public void run() {\n" +
- " 'l ();\n" +
- " }\n" +
- " private void 'l () {\n" +
- " 'st{2,2};\n" +
- " }\n" +
- "};";
- String s9 = "new My() {\n" +
- " public void f() {\n" +
- " $st$;\n" +
- " }\n" +
- "};";
-
- String expectedResult3 = "public class A {\n" +
- " void f() {\n" +
- " new My() {\n" +
- " public void f() {\n" +
- " int i = 9;\n" +
- " int j = 9;\n" +
- " }\n" +
- " };\n" +
- " new My() {\n" +
- " public void f() {\n" +
- " l();\n" +
- " l();\n" +
- " }\n" +
- " };\n" +
- " }\n" +
- "\n" +
- "}";
- boolean formatAccordingToStyle = options.isToReformatAccordingToStyle();
- options.setToReformatAccordingToStyle(true);
- actualResult = replacer.testReplace(s7,s8,s9,options);
- assertEquals(
- "extra ; 2",
- expectedResult3,
- actualResult
- );
-
- String s10 = "public class A {\n" +
- " void f() {\n" +
- " new Runnable() {\n" +
- " public void run() {\n" +
- " l();\n" +
- " l();\n" +
- " }\n" +
- " public void run2() {\n" +
- " l();\n" +
- " l();\n" +
- " }\n" +
- "\n" +
- " };\n" +
- " new Runnable() {\n" +
- " public void run() {\n" +
- " l();\n" +
- " l();\n" +
- " }\n" +
- " public void run2() {\n" +
- " l();\n" +
- " l();\n" +
- " }\n" +
- "\n" +
- " };\n" +
- "new Runnable() {\n" +
- " public void run() {\n" +
- " l();\n" +
- " l();\n" +
- " }\n" +
- " public void run2() {\n" +
- " l2();\n" +
- " l2();\n" +
- " }\n" +
- "\n" +
- " };\n" +
- " }\n" +
- "\n" +
- " private void l() {\n" +
- " int i = 9;\n" +
- " int j = 9;\n" +
- " }\n" +
- "}\n" +
- "\n" +
- "abstract class My {\n" +
- " abstract void f();\n" +
- "}";
- String s11 = "new Runnable() {\n" +
- " public void run() {\n" +
- " 'l{2,2};\n" +
- " }\n" +
- " public void run2() {\n" +
- " 'l{2,2};\n" +
- " }\n" +
- "\n" +
- " };";
- String s12 = "new My() {\n" +
- " public void f() {\n" +
- " $l$;\n" +
- " }\n" +
- " };";
- String expectedResult4 = "public class A {\n" +
- " void f() {\n" +
- " new My() {\n" +
- " public void f() {\n" +
- " l();\n" +
- " l();\n" +
- " }\n" +
- " };\n" +
- " new My() {\n" +
- " public void f() {\n" +
- " l();\n" +
- " l();\n" +
- " }\n" +
- " };\n" +
- " new Runnable() {\n" +
- " public void run() {\n" +
- " l();\n" +
- " l();\n" +
- " }\n" +
- "\n" +
- " public void run2() {\n" +
- " l2();\n" +
- " l2();\n" +
- " }\n" +
- "\n" +
- " };\n" +
- " }\n" +
- "\n" +
- " private void l() {\n" +
- " int i = 9;\n" +
- " int j = 9;\n" +
- " }\n" +
- "}\n" +
- "\n" +
- "abstract class My {\n" +
- " abstract void f();\n" +
- "}";
-
- actualResult = replacer.testReplace(s10,s11,s12,options);
- assertEquals(
- "same multiple occurences 2 times",
- expectedResult4,
- actualResult
- );
-
- options.setToReformatAccordingToStyle(formatAccordingToStyle);
-
- String s13 = " PsiLock.LOCK.acquire();\n" +
- " try {\n" +
- " return value;\n" +
- " }\n" +
- " finally {\n" +
- " PsiLock.LOCK.release();\n" +
- " }";
- String s13_2 = " PsiLock.LOCK.acquire();\n" +
- " try {\n" +
- " if (true) { return value; }\n" +
- " }\n" +
- " finally {\n" +
- " PsiLock.LOCK.release();\n" +
- " }";
- String s13_3 = " PsiLock.LOCK.acquire();\n" +
- " try {\n" +
- " if (true) { return value; }\n\n" +
- " if (true) { return value; }\n" +
- " }\n" +
- " finally {\n" +
- " PsiLock.LOCK.release();\n" +
- " }";
- String s14 = " PsiLock.LOCK.acquire();\n" +
- " try {\n" +
- " 'T{1,1000};\n" +
- " }\n" +
- " finally {\n" +
- " PsiLock.LOCK.release();\n" +
- " }";
- String s15 = "synchronized(PsiLock.LOCK) {\n" +
- " $T$;\n" +
- "}";
-
- String expectedResult5 = " synchronized (PsiLock.LOCK) {\n" +
- " return value;\n" +
- " }";
- options.setToReformatAccordingToStyle(true);
- actualResult = replacer.testReplace(s13,s14,s15,options);
- options.setToReformatAccordingToStyle(false);
-
- assertEquals(
- "extra ; over return",
- expectedResult5,
- actualResult
- );
-
- String expectedResult6 = " synchronized (PsiLock.LOCK) {\n" +
- " if (true) {\n" +
- " return value;\n" +
- " }\n" +
- " }";
- options.setToReformatAccordingToStyle(true);
- actualResult = replacer.testReplace(s13_2,s14,s15,options);
- options.setToReformatAccordingToStyle(false);
-
- assertEquals(
- "extra ; over if",
- expectedResult6,
- actualResult
- );
-
- String expectedResult7 = " synchronized (PsiLock.LOCK) {\n" +
- " if (true) {\n" +
- " return value;\n" +
- " }\n" +
- "\n" +
- " if (true) {\n" +
- " return value;\n" +
- " }\n" +
- " }";
- options.setToReformatAccordingToStyle(true);
- actualResult = replacer.testReplace(s13_3,s14,s15,options);
- options.setToReformatAccordingToStyle(false);
- assertEquals(
- "newlines in matches of several lines",
- expectedResult7,
- actualResult
- );
-
- String s16 = "public class SSTest {\n" +
- " Object lock;\n" +
- " public Object getProducts (String[] productNames) {\n" +
- " synchronized (lock) {\n" +
- " Object o = new Object ();\n" +
- " assert o != null;\n" +
- " return o;\n" +
- " }\n" +
- " }\n" +
- "}";
- String s16_2 = "public class SSTest {\n" +
- " Object lock;\n" +
- " public void getProducts (String[] productNames) {\n" +
- " synchronized (lock) {\n" +
- " boolean[] v = {true};\n" +
- " }\n" +
- " }\n" +
- "}";
-
- String s17 = "synchronized(lock) {\n" +
- " 'Statement*;\n" +
- "}";
-
- String s18 = "$Statement$;";
- String expectedResult8 = "public class SSTest {\n" +
- " Object lock;\n" +
- " public Object getProducts (String[] productNames) {\n" +
- " Object o = new Object ();\n" +
- " assert o != null;\n" +
- " return o;\n" +
- " }\n" +
- "}";
- String expectedResult8_2 = "public class SSTest {\n" +
- " Object lock;\n" +
- " public void getProducts (String[] productNames) {\n" +
- " boolean[] v = {true};\n" +
- " }\n" +
- "}";
-
- actualResult = replacer.testReplace(s16,s17,s18,options);
- assertEquals(
- "extra ;",
- expectedResult8,
- actualResult
- );
-
- actualResult = replacer.testReplace(s16_2,s17,s18,options);
- assertEquals(
- "missed ;",
- expectedResult8_2,
- actualResult
- );
- }
-
- public void testClassReplacement() {
- boolean formatAccordingToStyle = options.isToReformatAccordingToStyle();
- options.setToReformatAccordingToStyle(true);
-
- String s1 = "class A { public void b() {} }";
- String s2 = "class 'a { 'Other* }";
- String s3 = "class $a$New { Logger LOG; $Other$ }";
- String expectedResult = " class ANew {\n" +
- " Logger LOG;\n\n" +
- " public void b() {\n" +
- " }\n" +
- " }";
- String actualResult;
- actualResult = replacer.testReplace(s1,s2,s3,options);
- assertEquals(
- "Basic class replacement",
- expectedResult,
- actualResult
- );
-
- String s4 = "class A { class C {} public void b() {} int f; }";
- String s5 = "class 'a { 'Other* }";
- String s6 = "class $a$ { Logger LOG; $Other$ }";
- String expectedResult2 = " class A {\n" +
- " Logger LOG;\n\n" +
- " class C {\n" +
- " }\n\n" +
- " public void b() {\n" +
- " }\n\n" +
- " int f;\n" +
- " }";
-
- actualResult = replacer.testReplace(s4,s5,s6,options);
- assertEquals(
- "Order of members in class replacement",
- expectedResult2,
- actualResult
- );
-
- String s7 = "class A extends B { int c; void b() {} { a = 1; } }";
- String s8 = "class 'A extends B { 'Other* }";
- String s9 = "class $A$ extends B2 { $Other$ }";
- String expectedResult3 = " class A extends B2 {\n" +
- " int c;\n\n" +
- " void b() {\n" +
- " }\n\n" +
- " {\n" +
- " a = 1;\n" +
- " }\n" +
- " }";
-
- actualResult = replacer.testReplace(s7,s8,s9,options);
- assertEquals("Unsupported pattern exception",actualResult,expectedResult3);
- options.setToReformatAccordingToStyle(formatAccordingToStyle);
-
- String s10 = "/** @example */\n" +
- "class A {\n" +
- " class C {}\n" +
- " public void b() {}\n" +
- " int f;\n" +
- "}";
- String s11 = "class 'a { 'Other* }";
- String s12 = "public class $a$ {\n" +
- " $Other$\n" +
- "}";
- String expectedResult4 = "/** @example */\n" +
- " public class A {\n" +
- " class C {\n" +
- " }\n\n" +
- " public void b() {\n" +
- " }\n\n" +
- " int f;\n" +
- " }";
-
- options.setToReformatAccordingToStyle(true);
- actualResult = replacer.testReplace(s10,s11,s12,options);
- options.setToReformatAccordingToStyle(false);
- assertEquals("Make class public",expectedResult4,actualResult);
-
- String s13 = "class CustomThread extends Thread {\n" +
- "public CustomThread(InputStream in, OutputStream out, boolean closeOutOnExit) {\n" +
- " super(CustomThreadGroup.getThreadGroup(), \"CustomThread\");\n" +
- " setDaemon(true);\n" +
- " if (in instanceof BufferedInputStream) {\n" +
- " bis = (BufferedInputStream)in;\n" +
- " } else {\n" +
- " bis = new BufferedInputStream(in);\n" +
- " }\n" +
- " this.out = out;\n" +
- " this.closeOutOnExit = closeOutOnExit;\n" +
- "}\n" +
- "}";
- String s14 = "class 'Class extends Thread {\n" +
- " 'Class('ParameterType* 'ParameterName*) {\n" +
- "\t super (CustomThreadGroup.getThreadGroup(), 'superarg* );\n" +
- " 'Statement*;\n" +
- " }\n" +
- "}";
- String s15 = "class $Class$ extends CustomThread {\n" +
- " $Class$($ParameterType$ $ParameterName$) {\n" +
- "\t super($superarg$);\n" +
- " $Statement$;\n" +
- " }\n" +
- "}";
-
- String expectedResult5 = " class CustomThread extends CustomThread {\n" +
- " CustomThread(InputStream in, OutputStream out, boolean closeOutOnExit) {\n" +
- " super(\"CustomThread\");\n" +
- " setDaemon(true);\n" +
- " if (in instanceof BufferedInputStream) {\n" +
- " bis = (BufferedInputStream) in;\n" +
- " } else {\n" +
- " bis = new BufferedInputStream(in);\n" +
- " }\n" +
- " this.out = out;\n" +
- " this.closeOutOnExit = closeOutOnExit;\n" +
- " }\n" +
- " }";
- options.setToReformatAccordingToStyle(true);
- actualResult = replacer.testReplace(s13,s14,s15,options);
- options.setToReformatAccordingToStyle(false);
- assertEquals("Constructor replacement",expectedResult5,actualResult);
-
- String s16 = "public class A {}\n" +
- "final class B {}";
- String s17 = "class 'A { 'Other* }";
- String s17_2 = "class 'A { private Log log = LogFactory.createLog(); 'Other* }";
- String s18 = "class $A$ { private Log log = LogFactory.createLog(); $Other$ }";
- String s18_2 = "class $A$ { $Other$ }";
-
- actualResult = replacer.testReplace(s16,s17,s18,options);
- String expectedResult6 = "public class A { private Log log = LogFactory.createLog(); }\n" +
- "final class B { private Log log = LogFactory.createLog(); }";
- assertEquals("Modifier list for class",expectedResult6,actualResult);
-
- actualResult = replacer.testReplace(actualResult,s17_2,s18_2,options);
- String expectedResult7 = "public class A { }\n" +
- "final class B { }";
- assertEquals("Removing field",expectedResult7,actualResult);
-
- String s19 = "public class A extends Object implements Cloneable {}\n";
- String s20 = "class 'A { 'Other* }";
- String s21 = "class $A$ { private Log log = LogFactory.createLog(); $Other$ }";
-
- actualResult = replacer.testReplace(s19,s20,s21,options);
- String expectedResult8 = "public class A extends Object implements Cloneable { private Log log = LogFactory.createLog(); }\n";
- assertEquals("Extends / implements list for class",expectedResult8,actualResult);
-
- String s22 = "public class A<T> { int Afield; }\n";
- String s23 = "class 'A { 'Other* }";
- String s24 = "class $A$ { private Log log = LogFactory.createLog(); $Other$ }";
-
- actualResult = replacer.testReplace(s22,s23,s24,options);
- String expectedResult9 = "public class A<T> { private Log log = LogFactory.createLog(); int Afield; }\n";
- assertEquals("Type parameters for the class",expectedResult9,actualResult);
-
- String s25 = "class A {\n" +
- " // comment before\n" +
- " protected short a; // comment after\n" +
- "}";
- String s26 = "short a;";
- String s27 = "Object a;";
- String expectedResult10 = "class A {\n" +
- " // comment before\n" +
- " protected Object a; // comment after\n" +
- "}";
-
- actualResult = replacer.testReplace(s25,s26,s27,options);
-
- assertEquals(
- "Replacing dcl with saving access modifiers",
- expectedResult10,
- actualResult
- );
-
- String s28 = "aaa";
- String s29 = "class 'Class {\n" +
- " 'Class('ParameterType 'ParameterName) {\n" +
- " 'Class('ParameterName);\n" +
- " }\n" +
- "}";
- String s30 = "class $Class$ {\n" +
- " $Class$($ParameterType$ $ParameterName$) {\n" +
- " this($ParameterName$);\n" +
- " }\n" +
- "}";
- String expectedResult11 = "aaa";
-
- actualResult = replacer.testReplace(s28,s29,s30,options);
-
- assertEquals(
- "Complex class replacement",
- expectedResult11,
- actualResult
- );
-
- String s31 = "class A {\n" +
- " int a; // comment\n" +
- " char b;\n" +
- " int c; // comment2\n" +
- "}";
-
- String s32 = "'Type 'Variable = 'Value?; //'Comment";
- String s33 = "/**$Comment$*/\n" +
- "$Type$ $Variable$ = $Value$;";
-
- String expectedResult12 = " class A {\n" +
- " /**\n" +
- " * comment\n" +
- " */\n" +
- " int a;\n" +
- " char b;\n" +
- " /**\n" +
- " * comment2\n" +
- " */\n" +
- " int c;\n" +
- " }";
- options.setToReformatAccordingToStyle(true);
- actualResult = replacer.testReplace(s31,s32,s33,options);
- options.setToReformatAccordingToStyle(false);
-
- assertEquals(
- "Replacing comments with javadoc for fields",
- expectedResult12,
- actualResult
- );
-
- String s34 = "/**\n" +
- " * This interface stores XXX\n" +
- " * <p/>\n" +
- " */\n" +
- "public interface X {\n" +
- " public static final String HEADER = Headers.HEADER;\n" +
- "\n" +
- "}";
-
- String s35 = "public interface 'MessageInterface {\n" +
- " public static final String 'X = 'VALUE;\n" +
- " 'blah*" +
- "}";
- String s36 = "public interface $MessageInterface$ {\n" +
- " public static final String HEADER = $VALUE$;\n" +
- " $blah$\n" +
- "}";
-
- String expectedResult13 = "/**\n" +
- " * This interface stores XXX\n" +
- " * <p/>\n" +
- " */\n" +
- "public interface X {\n" +
- " public static final String HEADER = Headers.HEADER;\n" +
- " \n" +
- "}";
-
- actualResult = replacer.testReplace(s34,s35,s36,options, true);
-
- assertEquals(
- "Replacing interface with interface, saving comments properly",
- expectedResult13,
- actualResult
- );
- }
-
- public void testClassReplacement3() {
- if (true) return;
- final String actualResult;
- String s37 = "class A { int a = 1; void B() {} int C(char ch) { int z = 1; } int b = 2; }";
-
- String s38 = "class 'A { 'T* 'M*('PT* 'PN*) { 'S*; } 'O* }";
- String s39 = "class $A$ { $T$ $M$($PT$ $PN$) { System.out.println(\"$M$\"); $S$; } $O$ }";
-
- String expectedResult14 = "class A { int a = 1; void B( ) { System.out.println(\"B\"); } int C(char ch) { System.out.println(\"C\"); int z = 1; } int b = 2;}";
- String expectedResult14_2 = "class A { int a = 1; void B( ) { System.out.println(\"B\"); } int C(char ch) { System.out.println(\"C\"); int z = 1; } int b = 2;}";
-
- actualResult = replacer.testReplace(s37,s38,s39,options, true);
-
- assertEquals(
- "Multiple methods replacement",
- expectedResult14,
- actualResult
- );
- }
-
- public void testClassReplacement4() {
- final String actualResult;
- String s1 = "class A {\n" +
- " int a = 1;\n" +
- " int b;\n" +
- " private int c = 2;\n" +
- "}";
-
- String s2 = "@Modifier(\"PackageLocal\") 'Type 'Instance = 'Init?;";
- String s3 = "public $Type$ $Instance$ = $Init$;";
-
- String expectedResult = "class A {\n" +
- " public int a = 1;\n" +
- " public int b ;\n" +
- " private int c = 2;\n" +
- "}";
-
- actualResult = replacer.testReplace(s1,s2,s3,options, true);
-
- assertEquals(
- "Multiple fields replacement",
- expectedResult,
- actualResult
- );
- }
-
- public void testClassReplacement5() {
- final String actualResult;
- String s1 = "public class X {\n" +
- " /**\n" +
- " * zzz\n" +
- " */\n" +
- " void f() {\n" +
- "\n" +
- " }\n" +
- "}";
-
- String s2 = "class 'c {\n" +
- " /**\n" +
- " * zzz\n" +
- " */\n" +
- " void f(){}\n" +
- "}";
- String s3 = "class $c$ {\n" +
- " /**\n" +
- " * ppp\n" +
- " */\n" +
- " void f(){}\n" +
- "}";
-
- String expectedResult = "public class X {\n" +
- " /**\n" +
- " * ppp\n" +
- " */\n" +
- " void f(){}\n" +
- "}";
-
- actualResult = replacer.testReplace(s1,s2,s3,options, true);
-
- assertEquals(
- "Not preserving comment if it is present",
- expectedResult,
- actualResult
- );
- }
-
- public void testClassReplacement6() {
- String actualResult;
- String s1 = "public class X {\n" +
- " /**\n" +
- " * zzz\n" +
- " */\n" +
- " private void f(int i) {\n" +
- " //s\n" +
- " }\n" +
- "}";
- String s1_2 = "public class X {\n" +
- " /**\n" +
- " * zzz\n" +
- " */\n" +
- " private void f(int i) {\n" +
- " int a = 1;\n" +
- " //s\n" +
- " }\n" +
- "}";
-
- String s2 = "class 'c {\n" +
- " /**\n" +
- " * zzz\n" +
- " */\n" +
- " void f('t 'p){'s+;}\n" +
- "}";
- String s3 = "class $c$ {\n" +
- " /**\n" +
- " * ppp\n" +
- " */\n" +
- " void f($t$ $p$){$s$;}\n" +
- "}";
-
- String expectedResult = "public class X {\n" +
- " /**\n" +
- " * ppp\n" +
- " */\n" +
- " private void f(int i ){//s\n" +
- "}\n" +
- "}";
-
- actualResult = replacer.testReplace(s1,s2,s3,options);
-
- assertEquals(
- "Correct class replacement",
- expectedResult,
- actualResult
- );
-
- String expectedResult2 = "public class X {\n" +
- " /**\n" +
- " * ppp\n" +
- " */\n" +
- " private void f(int i ){int a = 1;\n" +
- " //s\n" +
- "}\n" +
- "}";
-
- actualResult = replacer.testReplace(s1_2,s2,s3,options);
-
- assertEquals(
- "Correct class replacement, 2",
- expectedResult2,
- actualResult
- );
- }
-
- public void testClassReplacement7() {
- String s1 = "/**\n" +
- "* Created by IntelliJ IDEA.\n" +
- "* User: cdr\n" +
- "* Date: Nov 15, 2005\n" +
- "* Time: 4:23:29 PM\n" +
- "* To change this template use File | Settings | File Templates.\n" +
- "*/\n" +
- "public class CC {\n" +
- " /** My Comment */ int a = 3; // aaa\n" +
- " // bbb\n" +
- " long c = 2;\n" +
- " void f() {\n" +
- " }\n" +
- "}";
- String s2 = "/**\n" +
- "* Created by IntelliJ IDEA.\n" +
- "* User: 'USER\n" +
- "* Date: 'DATE\n" +
- "* Time: 'TIME\n" +
- "* To change this template use File | Settings | File Templates.\n" +
- "*/\n" +
- "class 'c {\n" +
- " 'other*\n" +
- "}";
- String s3 = "/**\n" +
- "* by: $USER$\n" +
- "*/\n" +
- "class $c$ {\n" +
- " $other$\n" +
- "}";
- String expectedResult = "/**\n" +
- "* by: cdr\n" +
- "*/\n" +
- "public class CC {\n" +
- " /** My Comment */ int a = 3; // aaa\n" +
- "// bbb\n" +
- " long c = 2;\n" +
- "void f() {\n" +
- " }\n" +
- "}";
-
- actualResult = replacer.testReplace(s1,s2,s3,options,true);
-
- assertEquals(
- "Class with comment replacement",
- expectedResult,
- actualResult
- );
- }
-
- public void testClassReplacement8() {
- String s1 = "public class CC {\n" +
- " /** AAA*/ int b = 1; // comment\n" +
- "}";
- String s2 = "int b = 1;";
- String s3 = "long c = 2;";
- String expectedResult = "public class CC {\n" +
- " /** AAA*/ long c = 2; // comment\n" +
- "}";
-
- actualResult = replacer.testReplace(s1,s2,s3,options,true);
-
- assertEquals(
- "Class field replacement with simple pattern",
- expectedResult,
- actualResult
- );
- }
-
- @NotNull
- @Override
- protected String getTestDataPath() {
- return PluginPathManager.getPluginHomePath("structuralsearch") + "/testData/";
- }
-
- public void testClassReplacement9() throws IOException {
- String s1 = loadFile("before1.java");
- String s2 = "class 'A extends 'TestCaseCass:[regex( .*TestCase ) ] {\n" +
- " 'OtherStatement*;\n" +
- " public void 'testMethod*:[regex( test.* )] () {\n" +
- " }\n" +
- " 'OtherStatement2*;\n" +
- "}";
- String s3 = "class $A$ extends $TestCaseCass$ {\n" +
- " $OtherStatement$;\n" +
- " $OtherStatement2$;\n" +
- "}";
- String expectedResult = loadFile("after1.java");
-
- options.setToReformatAccordingToStyle(true);
- actualResult = replacer.testReplace(s1,s2,s3,options,true);
-
- assertEquals(
- "Class replacement 9",
- expectedResult,
- actualResult
- );
- }
-
- public void testReplaceReturnWithArrayInitializer() {
- String searchIn = "return ( new String[]{CoreVars.CMUAudioPort + \"\"} );";
- String searchFor = "return ( 'A );";
- String replaceBy = "return $A$;";
- String expectedResult = "return new String[]{CoreVars.CMUAudioPort + \"\"};";
-
- actualResult = replacer.testReplace(searchIn,searchFor,replaceBy,options);
-
- assertEquals(
- "ReplaceReturnWithArrayInitializer",
- expectedResult,
- actualResult
- );
- }
-
- public void _testClassReplacement10() throws IOException {
- String s1 = loadFile("before2.java");
- String s2 = "class '_Class {\n" +
- " '_ReturnType+ '_MethodName+('_ParameterType* '_Parameter*){\n" +
- " '_content*;\n" +
- " }\n" +
- " '_remainingclass*" +
- "}";
- String s3 = "class $Class$ {\n" +
- " $remainingclass$\n" +
- " @Override $ReturnType$ $MethodName$($ParameterType$ $Parameter$){\n" +
- " $content$;\n" +
- " }\n" +
- "}";
- String expectedResult = loadFile("after2.java");
-
- options.setToReformatAccordingToStyle(true);
- actualResult = replacer.testReplace(s1,s2,s3,options,true);
-
- assertEquals(
- "Class replacement 10",
- expectedResult,
- actualResult
- );
- }
-
- public void testCatchReplacement() throws Exception {
- String s1 = "try {\n" +
- " aaa();\n" +
- "} catch(Exception ex) {\n" +
- " LOG.assertTrue(false);\n" +
- "}";
- String s2 = "{ LOG.assertTrue(false); }";
- String s3 = "{ if (false) LOG.assertTrue(false); }";
- String expectedResult = "try {\n" +
- " aaa();\n" +
- "} catch (Exception ex) {\n" +
- " if (false) LOG.assertTrue(false);\n" +
- "}";
- options.setToReformatAccordingToStyle(true);
- actualResult = replacer.testReplace(s1,s2,s3,options);
- options.setToReformatAccordingToStyle(false);
-
- assertEquals(
- "Catch replacement by block",
- expectedResult,
- actualResult
- );
- }
-
- public void testSavingAccessModifiersDuringClassReplacement() {
- String actualResult;
-
- String s43 = "public @Deprecated class Foo implements Comparable<Foo> {\n int x;\n void m(){}\n }";
- String s44 = "class 'Class implements 'Interface { 'Content* }";
- String s45 = "@MyAnnotation\n" +
- "class $Class$ implements $Interface$ {$Content$}";
- String expectedResult16 = "@MyAnnotation public @Deprecated\n" +
- "class Foo implements Comparable<Foo> {int x;\n" +
- "void m(){}}";
-
- actualResult = replacer.testReplace(s43,s44,s45,options, true);
- assertEquals(
- "Preserving var modifiers and generic information in type during replacement",
- expectedResult16,
- actualResult
- );
- }
-
- public void testDontRequireSpecialVarsForUnmatchedContent() {
- String actualResult;
-
- String s43 = "public @Deprecated class Foo implements Comparable<Foo> {\n int x;\n void m(){}\n }";
- String s44 = "class 'Class implements 'Interface {}";
- String s45 = "@MyAnnotation\n" +
- "class $Class$ implements $Interface$ {}";
- String expectedResult16 = "@MyAnnotation public @Deprecated\n" +
- "class Foo implements Comparable<Foo> {int x;\nvoid m(){}}";
-
- actualResult = replacer.testReplace(s43,s44,s45,options, true);
- assertEquals(
- "Preserving class modifiers and generic information in type during replacement",
- expectedResult16,
- actualResult
- );
- }
-
- public void _testClassReplacement2() {
- final String actualResult;
- String s40 = "class A {\n" +
- " /* special comment*/\n" +
- " private List<String> a = new ArrayList();\n" +
- " static {\n" +
- " int a = 1;" +
- " }\n" +
- "}";
- String s41 = "class 'Class {\n" +
- " 'Stuff2*\n" +
- " 'FieldType 'FieldName = 'Init?;\n" +
- " static {\n" +
- " 'Stmt*;\n" +
- " }\n" +
- " 'Stuff*\n" +
- "}";
- String s42 = "class $Class$ {\n" +
- " $Stuff2$\n" +
- " $FieldType$ $FieldName$ = build$FieldName$Map();\n" +
- " private static $FieldType$ build$FieldName$Map() {\n" +
- " $FieldType$ $FieldName$ = $Init$;\n" +
- " $Stmt$;\n" +
- " return $FieldName$;\n" +
- " }\n" +
- " $Stuff$\n" +
- "}";
- String expectedResult15 = "class A {\n" +
- " \n" +
- " /* special comment*/\n" +
- " private List<String> a = buildaMap();\n" +
- " private static List<String> buildaMap() {\n" +
- " List<String> a = new ArrayList();\n" +
- " int a = 1;\n" +
- " return a;\n" +
- " }\n" +
- " \n" +
- "}";
-
- actualResult = replacer.testReplace(s40,s41,s42,options, true);
-
- assertEquals(
- "Preserving var modifiers and generic information in type during replacement",
- expectedResult15,
- actualResult
- );
-
- String s46 = "class Foo { int xxx; void foo() { assert false; } void yyy() {}}";
- String s47 = "class 'Class { void 'foo:[regex( foo )](); }";
- String s48 = "class $Class$ { void $foo$(int a); }";
- String expectedResult17 = "class Foo { int xxx; void foo(int a) { assert false; } void yyy() {}}";
-
- String actualResult2 = replacer.testReplace(s46,s47,s48,options, true);
- assertEquals(
- "Preserving method bodies",
- expectedResult17,
- actualResult2
- );
- }
-
- public void testReplaceExceptions() {
- String s1 = "a=a;";
- String s2 = "'a";
- String s3 = "$b$";
-
- try {
- replacer.testReplace(s1,s2,s3,options);
- assertTrue("Undefined replace variable is not checked",false);
- } catch(UnsupportedPatternException ex) {
-
- }
-
- String s4 = "a=a;";
- String s5 = "a=a;";
- String s6 = "a=a";
-
- try {
- replacer.testReplace(s4,s5,s6,options);
- assertTrue("Undefined no ; in replace",false);
- } catch(UnsupportedPatternException ex) {
- }
-
- try {
- replacer.testReplace(s4,s6,s5,options);
- assertTrue("Undefined no ; in search",false);
- } catch(UnsupportedPatternException ex) {
- }
- }
-
- public void testActualParameterReplacementInConstructorInvokation() {
- String s1 = "filterActions[0] = new Action(TEXT,\n" +
- " LifeUtil.getIcon(\"search\")) {\n" +
- " void test() {\n" +
- " int a = 1;\n" +
- " }\n" +
- "};";
- String s2 = "LifeUtil.getIcon(\"search\")";
- String s3 = "StdIcons.SEARCH_LIFE";
- String expectedResult = "filterActions[0] = new Action(TEXT,\n" +
- " StdIcons.SEARCH_LIFE) {\n" +
- " void test() {\n" +
- " int a = 1;\n" +
- " }\n" +
- "};";
- options.setToReformatAccordingToStyle(true);
- options.setToShortenFQN(true);
-
- String actualResult = replacer.testReplace(s1, s2, s3, options);
- assertEquals("Replace in anonymous class parameter", expectedResult, actualResult);
- options.setToShortenFQN(false);
- options.setToReformatAccordingToStyle(false);
- }
-
- public void testRemove() {
- String s1 = "class A {\n" +
- " /* */\n" +
- " void a() {\n" +
- " }\n" +
- " /*\n" +
- " */\n" +
- " int b = 1;\n" +
- " /*\n" +
- " *\n" +
- " */\n" +
- " class C {}\n" +
- " {\n" +
- " /* aaa */\n" +
- " int a;\n" +
- " /* */\n" +
- " a = 1;\n" +
- " }\n" +
- "}";
- String s2 = "/* 'a:[regex( .* )] */";
- String s2_2 = "/* */";
- String s3 = "";
- String expectedResult = "class A {\n" +
- " void a() {\n" +
- " }\n" +
- "\n" +
- " int b = 1;\n" +
- "\n" +
- " class C {\n" +
- " }\n" +
- "\n" +
- " {\n" +
- " int a;\n" +
- " a = 1;\n" +
- " }\n" +
- "}";
- options.setToReformatAccordingToStyle(true);
- actualResult = replacer.testReplace(s1,s2,s3,options);
- options.setToReformatAccordingToStyle(false);
-
- assertEquals(
- "Removing comments",
- expectedResult,
- actualResult
- );
-
- String expectedResult2 = "class A {\n" +
- " void a() {\n" +
- " }\n" +
- " /*\n" +
- " */\n" +
- " int b = 1;\n" +
- " /*\n" +
- " *\n" +
- " */\n" +
- " class C {}\n" +
- " {\n" +
- " /* aaa */\n" +
- " int a;\n" +
- " a = 1;\n" +
- " }\n" +
- "}";
-
- actualResult = replacer.testReplace(s1,s2_2,s3,options);
-
- assertEquals(
- "Removing comments",
- expectedResult2,
- actualResult
- );
- }
-
- public void testTryCatchInLoop() throws Exception {
- String code = "for (int i = 0; i < MIMEHelper.MIME_MAP.length; i++)\n" +
- "{\n" +
- " String s = aFileNameWithOutExtention + MIMEHelper.MIME_MAP[i][0][0];\n" +
- " try\n" +
- " {\n" +
- " if (ENABLE_Z107_READING)\n" +
- " { in = aFileNameWithOutExtention.getClass().getResourceAsStream(s); }\n" +
- " else\n" +
- " { data = ResourceHelper.readResource(s); }\n" +
- " mime = MIMEHelper.MIME_MAP[i][1][0];\n" +
- " break;\n" +
- " }\n" +
- " catch (final Exception e)\n" +
- " { continue; }\n" +
- "}";
- String toFind = "try { 'TryStatement*; } catch(Exception 'ExceptionDcl) { 'CatchStatement*; }";
- String replacement = "try { $TryStatement$; }\n" + "catch(Throwable $ExceptionDcl$) { $CatchStatement$; }";
- String expectedResult = "for (int i = 0; i < MIMEHelper.MIME_MAP.length; i++)\n" +
- "{\n" +
- " String s = aFileNameWithOutExtention + MIMEHelper.MIME_MAP[i][0][0];\n" +
- " try { if (ENABLE_Z107_READING)\n" +
- " { in = aFileNameWithOutExtention.getClass().getResourceAsStream(s); }\n" +
- " else\n" +
- " { data = ResourceHelper.readResource(s); }\n" +
- " mime = MIMEHelper.MIME_MAP[i][1][0];\n" +
- " break; }\n" +
- "catch(final Throwable e) { continue; }\n" +
- "}";
-
- actualResult = replacer.testReplace(code,toFind,replacement,options);
-
- assertEquals(
- "Replacing try/catch in loop",
- expectedResult,
- actualResult
- );
- }
-
- public void testReformatAndShortenClassRefPerformance() throws IOException {
- final String testName = getTestName(false);
- final String ext = "java";
- final String message = "Reformat And Shorten Class Ref Performance";
-
- options.setToReformatAccordingToStyle(true);
- options.setToShortenFQN(true);
-
- PlatformTestUtil.startPerformanceTest("SSR should work fast", 3500, new ThrowableRunnable() {
- public void run() {
- doTest(testName, ext, message);
- }
- }
- ).cpuBound().assertTiming();
-
- options.setToReformatAccordingToStyle(false);
- options.setToShortenFQN(false);
- }
-
- private void doTest(final String testName, final String ext, final String message) {
- try {
- String source = loadFile(testName + "_source." + ext);
- String pattern = loadFile(testName + "_pattern." + ext);
- String replacement = loadFile(testName + "_replacement." + ext);
- String expected = loadFile(testName + "_result." + ext);
-
- actualResult = replacer.testReplace(source,pattern,replacement,options);
-
- assertEquals(
- message,
- expected,
- actualResult
- );
- }
- catch (IOException e) {
- throw new RuntimeException(e);
- }
- }
-
- public void testLeastSurprise() {
- String s1 = "@Nullable (a=String.class) @String class Test {\n" +
- " void aaa(String t) {\n" +
- " String a = String.valueOf(' ');" +
- " String2 a2 = String2.valueOf(' ');" +
- " }\n" +
- "}";
- String s2 = "'String:String";
- String s2_2 = "String";
- String s2_3 = "'String:java\\.lang\\.String";
- String s2_4 = "java.lang.String";
- String replacement = CommonClassNames.JAVA_UTIL_LIST;
- String expected = "@Nullable (a=java.util.List.class) @java.util.List class Test {\n" +
- " void aaa(java.util.List t) {\n" +
- " java.util.List a = java.util.List.valueOf(' ');" +
- " String2 a2 = String2.valueOf(' ');" +
- " }\n" +
- "}";
-
- actualResult = replacer.testReplace(s1,s2,replacement,options);
-
- assertEquals(
- expected,
- actualResult
- );
-
- actualResult = replacer.testReplace(s1,s2_2,replacement,options);
-
- assertEquals(
- expected,
- actualResult
- );
-
- actualResult = replacer.testReplace(s1,s2_3,replacement,options);
-
- assertEquals(
- expected,
- actualResult
- );
-
- actualResult = replacer.testReplace(s1,s2_4,replacement,options);
-
- assertEquals(
- expected,
- actualResult
- );
- }
-
- public void testLeastSurprise2() {
- String s1 = "class B { int s(int a) { a = 1; a = 2; c(a); } }";
- String s2 = "a";
- String replacement = "a2";
- String expected = "class B { int s(int a2) { a2 = 1; a2 = 2; c(a2); } }";
-
- actualResult = replacer.testReplace(s1,s2,replacement,options);
-
- assertEquals(
- expected,
- actualResult
- );
- }
-
- public void testReplaceTry() {
- String s1 = "try {\n" +
- " em.persist(p);\n" +
- " } catch (PersistenceException e) {\n" +
- " // good\n" +
- " }";
- String s2 = "try { 'TryStatement; } catch('ExceptionType 'ExceptionDcl) { /* 'CommentContent */ }";
- String replacement = "try { $TryStatement$; } catch($ExceptionType$ $ExceptionDcl$) { _logger.warning(\"$CommentContent$\", $ExceptionDcl$); }";
- String expected = "try { em.persist(p); } catch(PersistenceException e) { _logger.warning(\" good\", e); }";
-
- actualResult = replacer.testReplace(s1,s2,replacement,options);
-
- assertEquals(
- expected,
- actualResult
- );
- }
-
- public void testReplaceExtraSemicolon() {
- String s1 = "try {\n" +
- " String[] a = {\"a\"};\n" +
- " System.out.println(\"blah\");\n" +
- "} finally {\n" +
- "}\n";
- String s2 = "try {\n" + " 'statement*;\n" + "} finally {\n" + " \n" + "}";
- String replacement = "$statement$;";
- String expected = "String[] a = {\"a\"};\n" +
- " System.out.println(\"blah\");\n";
-
- actualResult = replacer.testReplace(s1,s2,replacement,options);
-
- assertEquals(
- expected,
- actualResult
- );
-
- String s1_2 = "try {\n" +
- " if (args == null) return ;\n" +
- " while(true) return ;\n" +
- " System.out.println(\"blah2\");\n" +
- "} finally {\n" +
- "}";
- String expected_2 = "if (args == null) return ;\n" +
- " while(true) return ;\n" +
- " System.out.println(\"blah2\");";
-
- actualResult = replacer.testReplace(s1_2,s2,replacement,options);
-
- assertEquals(
- expected_2,
- actualResult
- );
-
- String s1_3 = "{\n" +
- " try {\n" +
- " System.out.println(\"blah1\");\n" +
- "\n" +
- " System.out.println(\"blah2\");\n" +
- " } finally {\n" +
- " }\n" +
- "}";
- String expected_3 = "{\n" +
- " System.out.println(\"blah1\");\n" +
- "\n" +
- " System.out.println(\"blah2\");\n" +
- "}";
- actualResult = replacer.testReplace(s1_3,s2,replacement,options);
-
- assertEquals(
- expected_3,
- actualResult
- );
-
- String s1_4 = "{\n" +
- " try {\n" +
- " System.out.println(\"blah1\");\n" +
- " // indented comment\n" +
- " System.out.println(\"blah2\");\n" +
- " } finally {\n" +
- " }\n" +
- "}";
- String expected_4 = "{\n" +
- " System.out.println(\"blah1\");\n" +
- " // indented comment\n" +
- " System.out.println(\"blah2\");\n" +
- "}";
- actualResult = replacer.testReplace(s1_4,s2,replacement,options);
-
- assertEquals(
- expected_4,
- actualResult
- );
- }
-
- public void _testReplaceFinalModifier() throws Exception {
- String s1 = "class Foo {\n" +
- " void foo(final int i,final int i2, final int i3) {\n" +
- " final int x = 5;\n" +
- " }\n" +
- "}";
- String s2 = "final '_type 'var = '_init?";
- String s3 = "$type$ $var$ = $init$";
-
- String expected = "2 = 1;\nint b = a;\nb2 = 3;";
-
- actualResult = replacer.testReplace(s1,s2,s3,options);
-
- assertEquals(
- expected,
- actualResult
- );
- }
-
- public void testRemovingRedundancy() throws Exception {
- String s1 = "int a = 1;\n" +
- "a = 2;\n" +
- "int b = a;\n" +
- "b2 = 3;";
- String s2 = "int 'a = 'i;\n" +
- "'st*;\n" +
- "'a = 'c;";
- String s3 = "$st$;\n" +
- "$c$ = $i$;";
-
- String expected = "2 = 1;\nint b = a;\nb2 = 3;";
-
- actualResult = replacer.testReplace(s1,s2,s3,options);
-
- assertEquals(
- expected,
- actualResult
- );
-
- String s2_2 = "int 'a = 'i;\n" +
- "'st*;\n" +
- "int 'c = 'a;";
- String s3_2 = "$st$;\n" +
- "int $c$ = $i$;";
- String expected_2 = "a = 2;\nint b = 1;\nb2 = 3;";
-
- actualResult = replacer.testReplace(s1,s2_2,s3_2,options);
-
- assertEquals(
- expected_2,
- actualResult
- );
- }
-
- public void testReplaceWithEmptyString() {
- String source = "public class Peepers {\n public long serialVersionUID = 1L; \n}";
- String search = "long serialVersionUID = $value$;";
- String replace = "";
- String expectedResult = "public class Peepers { \n}";
-
- String actualResult = replacer.testReplace(source, search, replace, options, true);
-
- assertEquals(
- expectedResult,
- actualResult
- );
- }
-
- public void testReplaceMultipleFieldsInSingleDeclaration() {
- String source = "abstract class MyClass implements java.util.List {\n private String a, b;\n}";
- String search = "class 'Name implements java.util.List {\n 'ClassContent*\n}";
- String replace = "class $Name$ {\n $ClassContent$\n}";
- String expectedResult = "abstract class MyClass {\n private String a,b;\n}";
-
- String actualResult = replacer.testReplace(source, search, replace, options, true);
-
- assertEquals(
- expectedResult,
- actualResult
- );
- }
-
- public void testReplaceInImplementsList() {
- String source = "import java.io.Externalizable;\n" +
- "import java.io.Serializable;\n" +
- "abstract class MyClass implements Serializable, java.util.List, Externalizable {}";
- String search = "class 'TestCase implements java.util.List, 'others* {\n 'MyClassContent\n}";
- String replace = "class $TestCase$ implements $others$ {\n $MyClassContent$\n}";
- String expectedResult = "import java.io.Externalizable;\n" +
- "import java.io.Serializable;\n" +
- "abstract class MyClass implements Externalizable,Serializable {\n \n}";
-
- String actualResult = replacer.testReplace(source, search, replace, options, true);
- assertEquals(
- expectedResult,
- actualResult
- );
- }
-
- public void testReplaceFieldWithEndOfLineComment() {
- String source = "class MyClass {\n" +
- " private String b;// comment\n" +
- " public void foo() {\n" +
- " }\n" +
- "}";
- String search = "class 'Class {\n 'Content*\n}";
- String replace = "class $Class$ {\n" +
- " void x() {}\n" +
- " $Content$\n" +
- " void bar() {}\n" +
- "}";
- String expectedResult = "class MyClass {\n" +
- " void x() {}\n" +
- " private String b;// comment\n" +
- "public void foo() {\n" +
- " }\n" +
- " void bar() {}\n" +
- "}";
-
- String actualResult = replacer.testReplace(source, search, replace, options, true);
- assertEquals(
- expectedResult,
- actualResult
- );
- }
-} \ No newline at end of file
generated by cgit v1.2.3 (git 2.25.1) at 2024-05-24 03:12:34 +0000