package com.intellij.structuralsearch;

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 PlatformTestUtil.getCommunityPath() + "/platform/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 testUseStaticImport() {
    String in = "class X {{ Math.abs(-1); }}";
    final String what = "Math.abs('a)";
    final String by = "Math.abs($a$)";
    options.setToUseStaticImport(true);

    String expected = "import static java.lang.Math.abs;class X {{ abs(-1); }}";
    assertEquals("Replacing with static import", expected, replacer.testReplace(in, what, by, options, true));

    in = "class X { void m(java.util.Random r) { Math.abs(r.nextInt()); }}";
    expected = "import static java.lang.Math.abs;class X { void m(java.util.Random r) { abs(r.nextInt()); }}";
    assertEquals("don't add broken static imports", expected, replacer.testReplace(in, what, by, options, true));
  }

  public void testUseStaticStarImport() {
    final String in = "class ImportTest {{\n" +
                      "    Math.abs(-0.5);\n" +
                      "    Math.sin(0.5);\n" +
                      "    Math.max(1, 2);\n" +
                      "}}";
    final String what = "Math.'m('a*)";
    final String by = "Math.$m$($a$)";
    options.setToUseStaticImport(true);

    // depends on default setting being equal to 3 for names count to use import on demand
    final String expected = "import static java.lang.Math.*;class ImportTest {{\n" +
                            "    abs(-0.5);\n" +
                            "    sin(0.5);\n" +
                            "    max(1,2);\n" +
                            "}}";
    assertEquals("Replacing with static star import", expected, replacer.testReplace(in, what, by, options, true));
  }

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