Google Git
Sign in
android / platform / tools / idea / refs/heads/main / . / platform / structuralsearch / testSource / com / intellij / structuralsearch / StructuralSearchTest.java
blob: 735147b85bfbda0370c77f4e40543dcd71ff918c [file] [log] [blame]
package com.intellij.structuralsearch;
import com.intellij.idea.Bombed;
import com.intellij.openapi.application.PluginPathManager;
import com.intellij.openapi.fileTypes.StdFileTypes;
import com.intellij.psi.*;
import com.intellij.structuralsearch.impl.matcher.MatcherImplUtil;
import com.intellij.testFramework.PlatformTestUtil;
import org.jetbrains.annotations.NotNull;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.List;
/**
* @author Maxim.Mossienko
*/
@SuppressWarnings({"HardCodedStringLiteral"})
public class StructuralSearchTest extends StructuralSearchTestCase {
private static final String s1 =
"debug(\"In action performed:\"+event);"+
"project = (Project)event.getDataContext().getData(DataConstants.PROJECT);" +
"CodeEditorManager.getInstance(project).commitAllToPsiFile();" +
"file = (PsiFile) event.getDataContext().getData(\"psi.File\"); " +
"((dialog==null)?" +
" (dialog = new SearchDialog()):" +
" dialog" +
").show();";
private static final String s2 = "((dialog==null)? (dialog = new SearchDialog()): dialog).show();";
private static final String s3 = "dialog = new SearchDialog()";
private static final String s4 =
" do { " +
" pattern = pattern.getNextSibling(); " +
" } " +
" while (pattern!=null && filterLexicalNodes(pattern));";
private static final String s5 =
"{ System.out.println();" +
" while(false) { " +
" do { " +
" pattern = pattern.getNextSibling(); " +
" } " +
" while (pattern!=null && filterLexicalNodes(pattern)); " +
" } " +
" do { " +
" pattern = pattern.getNextSibling(); " +
" } while (pattern!=null && filterLexicalNodes(pattern));" +
" { { " +
" do { " +
" pattern = pattern.getNextSibling(); " +
" } while (pattern!=null && filterLexicalNodes(pattern));" +
" } }" +
"}";
private static final String s6 =
" do { " +
" pattern.getNextSibling(); " +
" } " +
" while (pattern!=null && filterLexicalNodes(pattern));";
private static final String s7 =
" if (true) throw new UnsupportedPatternException(statement.toString());" +
" if (true) { " +
" throw new UnsupportedPatternException(statement.toString());" +
" } ";
private static final String s8 =
" if (true) { " +
" throw new UnsupportedPatternException(statement.toString());" +
" } ";
private static final String s9 = " if (true) throw new UnsupportedPatternException(statement.toString());";
private static final String s10 = "listener.add(new Runnable() { public void run() {} });";
private static final String s11 = " new XXX()";
private static final String s12 =
"new Runnable() {" +
" public void run() {" +
" matchContext.getSink().matchingFinished();" +
" } " +
" }";
private static final String s13 = "new Runnable() {}";
private static final String s14_1 = "if (true) { aaa(var); }";
private static final String s14_2 = "if (true) { aaa(var); bbb(var2); }\n if(1==1) { system.out.println('o'); }";
private static final String s15 = "'T;";
private static final String s16 = "if('_T) { '_T2; }";
private static final String s17 =
"token.getText().equals(token2.getText());" +
"token.getText().equals(token2.getText2());" +
"token.a.equals(token2.b);" +
"token.a.equals(token2.a);";
private static final String s18_1 = "'_T1.'_T2.equals('_T3.'_T2);";
private static final String s18_2 = "'_T1.'_T2().equals('_T3.'_T2());";
private static final String s18_3 = "'_T1.'_T2";
private static final String s19 = "Aaa a = (Aaa)b; Aaa c = (Bbb)d;";
private static final String s20 = "'_T1 'T2 = ('_T1)'_T3;";
private static final String s20_2 = "'_T1 '_T2 = ('_T1)'_T3;";
private static final String s21_1 = "'_T1:Aa* 'T2 = ('_T1)'_T3;";
private static final String s21_2 = "'_T1:A* 'T2 = ( '_T1:A+ )'_T3;";
private static final String s21_3 = "'_T1:Aa* 'T2 = ( '_T1:Aa* )'_T3;";
private static final String s22 = "Aaa a = (Aaa)b; Bbb c = (Bbb)d;";
private static final String s23 = "a[i] = 1; b[a[i]] = f(); if (a[i]==1) return b[c[i]];";
private static final String s24_1 = "'T['_T2:.*i.* ] = '_T3;";
private static final String s24_2 = "'T['_T2:.*i.* ]";
private static final String s25 = "class MatcherImpl { void doMatch(int a) {} }\n" +
"class Matcher { abstract void doMatch(int a);}\n " +
"class Matcher2Impl { void doMatch(int a, int b) {} } ";
private static final String s26 = "class 'T:.*Impl { '_T2 '_T3('_T4 '_T5) {\n\n} } ";
private static final String s27 = "class A {} interface B {}";
private static final String s28 = "interface 'T {}";
private static final String s29 = "class A { void B(int C) {} } class D { void E(double e) {} }";
private static final String s30 = "class '_ { void '_('_:int '_); } ";
private static final String s31 = "class A extends B { } class D extends B { } class C extends C {}";
private static final String s32 = "class '_ extends B { } ";
private static final String s33 = "class A implements B,C { } class D implements B,D { } class C2 implements C,B {}";
private static final String s34 = "class '_ implements B,C { } ";
private static final String s35 = "class A { int b; double c; void d() {} int e() {} } " +
"class A2 { int b; void d() {} }";
private static final String s36 = "class '_ { double '_; int '_; int '_() {} void '_() {} } ";
private static final String s37 = "class A { void d() throws B,C,D {} } class A2 { void d() throws B,C {} }";
private static final String s38 = "class 'T { '_ '_() throws D,C {} } ";
private static final String s39 = "class A extends B { } class A2 { }";
private static final String s40 = "class 'T { } ";
private static final String s41 = "class A extends B { int a = 1; } class B { int[] c= new int[2]; } " +
"class D { double e; } class E { int d; } ";
private static final String s42_1 = "class '_ { '_T '_T2 = '_T3; } ";
private static final String s42_2 = "class '_ { '_T '_T2; } ";
private static final String s43 = "interface A extends B { int B = 1; } " +
"interface D { public final static double e = 1; } " +
"interface E { final static ind d = 2; } " +
"interface F { } ";
private static final String s44 = "interface '_ { '_T 'T2 = '_T3; } ";
private static final String s45 = "class A extends B { private static final int B = 1; } " +
"class C extends D { int B = 1; }" +
"class E { }";
private static final String s46 = "class '_ { final static private '_T 'T2 = '_T3; } ";
private static final String s46_2 = "class '_ { '_T 'T2 = '_T3; } ";
private static final String s47 = "class C { java.lang.String t; } class B { BufferedString t2;} class A { String p;} ";
private static final String s48 = "class '_ { String '_; }";
private static final String s49 = "class C { void a() throws java.lang.RuntimeException {} } class B { BufferedString t2;}";
private static final String s50 = "class '_ { '_ '_() throws RuntimeException; }";
private static final String s51 = "class C extends B { } class B extends A { } class E {}";
private static final String s52 = "class '_ extends '_ { }";
private static final String s53 = "class C { " +
" String a = System.getProperty(\"abcd\"); " +
" static { String s = System.getProperty(a); }" +
" static void b() { String s = System.getProperty(a); }" +
" }";
private static final String s54 = "System.getProperty('T)";
private static final String s55 = " a = b.class; ";
private static final String s56 = "'T.class";
private static final String s57 = "{ /** @author Maxim */ class C { " +
"} " +
"class D {" +
"/** @serializable */ private int value; " +
"/** @since 1.4 */ void a() {} "+
"}" +
"class F { " +
"/** @since 1.4 */ void a() {} "+
"/** @serializable */ private int value2; " +
"}" +
"class G { /** @param a*/ void a() {} } }";
private static final String s57_2 = "/** @author Maxim */ class C { " +
"} " +
"class D {" +
"/** @serializable */ private int value; " +
"/** @since 1.4 */ void a() {} "+
"}" +
"class F { " +
"/** @since 1.4 */ void a() {} "+
"/** @serializable */ private int value2; " +
"}" +
"class G { /** @param a*/ void a() {} }";
private static final String s58 = "/** @'T '_T2 */ class '_ { }";
private static final String s58_2 = "class '_ { /** @serializable '_ */ '_ '_; }";
private static final String s58_3 = "class '_ { /** @'T 1.4 */ '_ '_() {} }";
private static final String s58_4 = "/** @'T '_T2 */";
private static final String s58_5 = "/** @'T '_T2? */";
private static final String s59 = "interface A { void B(); }";
private static final String s60 = "interface '_ { void '_(); }";
private static final String s61 = "{ a=b; c=d; return; } { e=f; } {}";
private static final String s62_1 = "{ 'T*; }";
private static final String s62_2 = "{ 'T+; }";
private static final String s62_3 = "{ 'T?; }";
private static final String s62_4 = "{ '_*; }";
private static final String s62_5 = "{ '_+; }";
private static final String s62_6 = "{ '_?; }";
private static final String s63 = " class A { A() {} } class B { public void run() {} }";
private static final String s63_2 = " class A { A() {} " +
"class B { public void run() {} } " +
"class D { public void run() {} } " +
"} " +
"class C {}";
private static final String s64 = " class 'T { public void '_T2:run () {} }";
private static final String s64_2 = "class '_ { class 'T { public void '_T2:run () {} } }";
private static final String s65 = " if (A instanceof B) {} else if (B instanceof C) {}";
private static final String s66 = " '_T instanceof '_T2:B";
private static final String s67 = " buf.append((VirtualFile)a);";
private static final String s68 = " (VirtualFile)'T";
private static final String s69 = " System.getProperties(); System.out.println(); java.lang.System.out.println(); some.other.System.out.println();";
private static final String s70 = " System.out ";
private static final String s70_2 = " java.lang.System.out ";
private static final String s71 = " class A { " +
"class D { D() { c(); } }" +
"void a() { c(); new MouseListenener() { void b() { c(); } } }" +
" }";
private static final String s72 = " c(); ";
private static final String s73 = " class A { int A; static int B=5; public abstract void a(int c); void q() { ind d=7; } }";
private static final String s74 = " '_Type 'Var = '_Init?; ";
private static final String s75 = "{ /** @class aClass\n @author the author */ class A {}\n" +
" /** */ class B {}\n" +
" /** @class aClass */ class C {} }";
private static final String s76 = " /** @'_tag+ '_value+ */";
private static final String s76_2 = " /** @'_tag* '_value* */";
private static final String s76_3 = " /** @'_tag? '_value? */ class 't {}";
private static final String s77 = " new ActionListener() {} ";
private static final String s78 = " class 'T:.*aaa {} ";
private static final String s79 = " class A { static { int c; } void a() { int b; b=1; }} ";
private static final String s80 = " { '_T 'T3 = '_T2?; '_*; } ";
private static final String s81 = "class Pair<First,Second> {" +
" <C,F> void a(B<C> b, D<F> e) throws C {" +
" P<Q> r = (S<T>)null;"+
" Q q = null; "+
" if (r instanceof S<T>) {}"+
" } " +
"} class Q { void b() {} } ";
private static final String s81_2 = "class Double<T> {} class T {} class Single<First extends A & B> {}";
private static final String s82 = "class '_<'T+> {}";
private static final String s82_2 = "'_Expr instanceof '_Type<'_Parameter+>";
private static final String s82_3 = "( '_Type<'_Parameter+> ) '_Expr";
private static final String s82_4 = "'_Type<'_Parameter+> 'a = '_Init?;";
private static final String s82_5 = "class '_ { <'_+> '_Type 'Method('_* '_*); }";
private static final String s82_6 = "class '_<'_+ extends 'res+> {}";
private static final String s82_7 = "'Type";
private static final String s83 = "/**\n" +
" * @hibernate.class\n" +
" * table=\"CATS\"\n" +
" */\n" +
"public class Cat {\n" +
" private Long id; // identifier\n" +
" private Date birthdate;\n" +
" /**\n" +
" * @hibernate.id\n" +
" * generator-class=\"native\"\n" +
" * column=\"CAT_ID\"\n" +
" */\n" +
" public Long getId() {\n" +
" return id;\n" +
" }\n" +
" private void setId(Long id) {\n" +
" this.id=id;\n" +
" }\n" +
"\n" +
" /**\n" +
" * @hibernate.property\n" +
" * column=\"BIRTH_DATE\"\n" +
" */\n" +
" public Date getBirthdate() {\n" +
" return birthdate;\n" +
" }\n" +
" void setBirthdate(Date date) {\n" +
" birthdate = date;\n" +
" }\n" +
" /**\n" +
" * @hibernate.property\n" +
" * column=\"SEX\"\n" +
" * not-null=\"true\"\n" +
" * update=\"false\"\n" +
" */\n" +
" public char getSex() {\n" +
" return sex;\n" +
" }\n" +
" void setSex(char sex) {\n" +
" this.sex=sex;\n" +
" }\n" +
"}";
private static final String s84 = " /**\n" +
" * @hibernate.property\n" +
" * 'Property+\n" +
" */\n";
private static final String s84_2 = " /**\n" +
" * @hibernate.property\n" +
" * update=\"fa.se\"\n" +
" */\n";
private static final String s85 = "{ int a; a=1; a=1; return a; }";
private static final String s86 = "'T; 'T;";
private static final String s87 = " getSomething(\"1\"); a.call(); ";
private static final String s88 = " '_Instance.'Call('_*); ";
private static final String s88_2 = " 'Call('_*); ";
private static final String s88_3 = " '_Instance?.'Call('_*); ";
private static final String s89 = "{ a = 1; b = 2; c=3; }";
private static final String s90 = "{ '_T*; '_T2*; }";
private static final String s90_2 = " { '_T*; '_T2*; '_T3+; } ";
private static final String s90_3 = " { '_T+; '_T2+; '_T3+; '_T4+; } ";
private static final String s90_4 = " { '_T{1,3}; '_T2{2}; } ";
private static final String s90_5 = " { '_T{1}?; '_T2*?; '_T3+?; } ";
private static final String s90_6 = " { '_T{1}?; '_T2{1,2}?; '_T3+?; '_T4+?; } ";
private static final String s91 = "class a {\n" +
" void b() {\n" +
" int c;\n" +
"\n" +
" c = 1;\n" +
" b();\n" +
" a a1;\n" +
" }\n" +
"}";
private static final String s92 = "'T:a";
private static final String s92_2 = "'T:b";
private static final String s92_3 = "'T:c";
private static final String s93 = " class A {" +
"private int field;" +
"public void b() {}" +
"}";
private static final String s94 = " class '_ {" +
"private void b() {}" +
"}";
private static final String s94_2 = " class '_ {" +
"public void b() {}" +
"}";
private static final String s94_3 = " class '_ {" +
"protected int field;" +
"}";
private static final String s94_4 = " class '_ {" +
"private int field;" +
"}";
private static final String s95 = " class Clazz {" +
"private int field;" +
"private int field2;" +
"private int fiel-d2;" +
"}";
private static final String s96 = " class '_ {" +
"private int 'T+:field.* ;" +
"}";
public void testSearchExpressions() {
assertFalse("subexpr match",findMatchesCount(s2,s3)==0);
assertEquals("search for new ",findMatchesCount(s10,s11),0);
assertEquals("search for anonymous classes",findMatchesCount(s12,s13),1);
// expr in definition initializer
assertEquals(
"expr in def initializer",
3,
findMatchesCount(s53,s54)
);
// a.class expression search
assertEquals(
"a.class pattern",
findMatchesCount(s55,s56),
1
);
String complexCode = "interface I { void b(); } interface I2 extends I {} class I3 extends I {} " +
"class A implements I2 { void b() {} } class B implements I3 { void b() {}} " +
"I2 a; I3 b; a.b(); b.b(); b.b(); A c; B d; c.b(); d.b(); d.b(); ";
String exprTypePattern1 = "'t:[exprtype( I2 )].b();";
String exprTypePattern2 = "'t:[!exprtype( I2 )].b();";
String exprTypePattern3 = "'t:[exprtype( *I2 )].b();";
String exprTypePattern4 = "'t:[!exprtype( *I2 )].b();";
assertEquals(
"expr type condition",
findMatchesCount(complexCode,exprTypePattern1),
1
);
assertEquals(
"expr type condition 2",
5,
findMatchesCount(complexCode,exprTypePattern2)
);
assertEquals(
"expr type condition 3",
findMatchesCount(complexCode,exprTypePattern3),
2
);
assertEquals(
"expr type condition 4",
findMatchesCount(complexCode,exprTypePattern4),
4
);
String complexCode2 = "enum X { XXX, YYY }\n class C { static void ordinal() {} void test() { C c; c.ordinal(); c.ordinal(); X.XXX.ordinal(); } }";
assertEquals(
"expr type condition with enums",
findMatchesCount(complexCode2, "'t:[exprtype( *java\\.lang\\.Enum )].ordinal()"),
1
);
assertEquals(
"no smart detection of search target",
findMatchesCount("processInheritors(1,2,3,4); processInheritors(1,2,3); processInheritors(1,2,3,4,5,6);","'instance?.processInheritors('_param1{1,6});"),
3
);
String arrays = "int[] a = new int[20];\n" +
"byte[] b = new byte[30]";
String arrayPattern = "new int[$a$]";
assertEquals(
"Improper array search",
1,
findMatchesCount(arrays,arrayPattern)
);
String someCode = "a *= 2; a+=2;";
String otherCode = "a *= 2;";
assertEquals(
"Improper *= 2 search",
1,
findMatchesCount(someCode,otherCode)
);
String s1 = "Thread t = new Thread(\"my thread\",\"my another thread\") {\n" +
" public void run() {\n" +
" // do stuff\n" +
" }\n" +
"}";
String s2 = "new Thread('args*) { '_Other* }";
assertEquals(
"Find inner class parameters",
2,
findMatchesCount(s1,s2)
);
String s3 = "Thread t = new Thread(\"my thread\") {\n" +
" public void run() {\n" +
" // do stuff\n" +
" }\n" +
"};";
String s4 = "new Thread($args$)";
assertEquals(
"Find inner class by new",
1,
findMatchesCount(s3,s4)
);
String s5 = "class A {\n" +
"public static <T> T[] copy(T[] array, Class<T> aClass) {\n" +
" int i = (int)0;\n" +
" int b = (int)0;\n" +
" return (T[])array.clone();\n" +
" }\n" +
"}";
String s6 = "($T$[])$expr$";
assertEquals(
"Find cast to array",
1,
findMatchesCount(s5,s6)
);
String s7 = "import java.math.BigDecimal;\n" +
"\n" +
"public class Prorator {\n" +
" public void prorate(BigDecimal[] array) {\n" +
" // do nothing\n" +
" }\n" +
" public void prorate2(java.math.BigDecimal[] array) {\n" +
" // do nothing\n" +
" }\n" +
" public void prorate(BigDecimal bd) {\n" +
" // do nothing\n" +
" }\n" +
"\n" +
" public static void main(String[] args) {\n" +
" BigDecimal[] something = new BigDecimal[2];\n" +
" java.math.BigDecimal[] something2 = new BigDecimal[2];\n" +
" something[0] = new BigDecimal(1.0);\n" +
" something[1] = new BigDecimal(1.0);\n" +
"\n" +
" Prorator prorator = new Prorator();\n" +
"\n" +
"// ---------------------------------------------------\n" +
"// the line below should've been found, in my opinion.\n" +
"// --------------------------------------------------\n" +
" prorator.prorate(something);\n" +
" prorator.prorate(something2);\n" +
" prorator.prorate(something[0]);\n" +
" prorator.prorate(something[1]);\n" +
" prorator.prorate(something[0]);\n" +
" }\n" +
"}";
String s8 = "'_Instance.'_MethodCall:[regex( prorate )]('_Param:[exprtype( BigDecimal\\[\\] )]) ";
assertEquals(
"Find method call with array for parameter expr type",
2,
findMatchesCount(s7,s8,true)
);
String s13 = "try { } catch(Exception e) { e.printStackTrace(); }";
String s14 = "'_Instance.'_MethodCall('_Parameter*)";
assertEquals(
"Find statement in catch",
1,
findMatchesCount(s13,s14)
);
String s9 = "int a[] = new int[] { 1,2,3,4};\n" +
"int b[] = { 2,3,4,5 };\n" +
"Object[] c = new Object[] { \"\", null};";
String s10 = "new '_ []{ '_* }";
String s10_2 = "new int []{ '_* }";
assertEquals(
"Find array instatiation",
3,
findMatchesCount(s9,s10)
);
assertEquals(
"Find array instatiation, 2",
2,
findMatchesCount(s9,s10_2)
);
}
public void testLiteral() {
String s = "class A {\n" +
" static String a = 1;\n" +
" static String s = \"aaa\";\n" +
" static String s2;\n" +
"}";
String s2 = "static String '_FieldName = '_Init?:[!regex( \".*\" )];";
String s2_2 = "static String '_FieldName = '_Init:[!regex( \".*\" )];";
assertEquals(
"Literal",
2,
findMatchesCount(s,s2)
);
assertEquals(
"Literal, 2",
1,
findMatchesCount(s,s2_2)
);
}
public void testCovariantArraySearch() {
String s1 = "String[] argv;";
String s2 = "String argv;";
String s3 = "'T[] argv;";
String s3_2 = "'T:*Object [] argv;";
assertEquals(
"Find array types",
0,
findMatchesCount(s1,s2)
);
assertEquals(
"Find array types, 2",
0,
findMatchesCount(s2,s1)
);
assertEquals(
"Find array types, 3",
0,
findMatchesCount(s2,s3)
);
assertEquals(
"Find array types, 3",
1,
findMatchesCount(s1,s3_2)
);
String s11 = "class A {\n" +
" void main(String[] argv);" +
" void main(String argv[]);" +
" void main(String argv);" +
"}";
String s12 = "'_t:[regex( *Object\\[\\] ) ] '_t2";
String s12_2 = "'_t:[regex( *Object ) ] '_t2 []";
String s12_3 = "'_t:[regex( *Object ) ] '_t2";
assertEquals(
"Find array covariant types",
2,
findMatchesCount(s11,s12)
);
assertEquals(
"Find array covariant types, 2",
2,
findMatchesCount(s11,s12_2)
);
assertEquals(
"Find array covariant types, 3",
1,
findMatchesCount(s11,s12_3)
);
String source = "class A { String ss[][]; }";
String target = "String[][] $s$;";
assertEquals(
"should find multi dimensional c-style array declarations",
1,
findMatchesCount(source, target)
);
}
// @todo support back references (\1 in another reg exp or as fild member)
//private static final String s1002 = " setSSS( instance.getSSS() ); " +
// " setSSS( instance.SSS ); ";
//private static final String s1003 = " 't:set(.+) ( '_.get't_1() ); ";
//private static final String s1003_2 = " 't:set(.+) ( '_.'t_1 ); ";
public void testSearchStatements() {
assertEquals("statement search",findMatchesCount(s1,s2),1);
assertEquals("several constructions match",findMatchesCount(s5,s4),3);
assertFalse("several constructions 2",(findMatchesCount(s5,s6))!=0);
assertEquals("several constructions 3",findMatchesCount(s7,s8),2);
assertEquals("several constructions 4",findMatchesCount(s7,s9),2);
final String s1000 = "{ lastTest = \"search for parameterized pattern\";\n" +
" matches = testMatcher.findMatches(s14_1,s15, options);\n" +
" if (matches.size()!=2 ) return false;\n" +
"lastTest = \"search for parameterized pattern\";\n" +
" matches = testMatcher.findMatches(s14_1,s15, options);\n" +
" if (matches.size()!=2 ) return false; }";
final String s1001 = "lastTest = '_Descr; " +
" matches = testMatcher.findMatches('_In,'_Pattern, options);\n" +
" if (matches.size()!='_Number ) return false;";
assertEquals("several operators 5",findMatchesCount(s1000,s1001),2);
assertEquals(
"two the same statements search",
findMatchesCount(s85,s86),
1
);
assertEquals(
"search for simple call",
findMatchesCount(s87,s88),
1
);
assertEquals(
"search for simple call 2",
findMatchesCount(s87,s88_2),
1
);
assertEquals(
"search for simple call 3",
findMatchesCount(s87,s88_3),
2
);
String s10015 = "DocumentListener[] listeners = getCachedListeners();";
String s10016 = "'_Type 'Var = '_Call();";
assertEquals(
"search for definition with init",
1,
findMatchesCount(s10015,s10016)
);
String s10017 = "a = b; b = c; a=a; c=c;";
String s10018 = "'_a = '_a;";
assertEquals(
"search silly assignments",
2,
findMatchesCount(s10017,s10018)
);
String s10019 = "a.b(); a.b(null); a.b(null, 1);";
String s10020 = "a.b(null);";
assertEquals(
"search parameter",
1,
findMatchesCount(s10019,s10020)
);
String s1008 = "int a, b, c, d; int a,b,c; int c,d; int e;";
String s1009 = "int '_a{3,4};";
assertEquals(
"search many declarations",
2,
findMatchesCount(s1008,s1009)
);
String s1 = "super(1,1); call(1,1); call(2,2);";
String s2 = "super('_t*);";
assertEquals(
"search super",
1,
findMatchesCount(s1,s2)
);
String s10021 = "short a = 1;\n" +
"short b = 2;\n" +
"short c = a.b();";
String s10022 = "short '_a = '_b.b();";
assertEquals(
"search def init bug",
1,
findMatchesCount(s10021,s10022)
);
String s10023 = "abstract class A { public abstract short getType(); }\n" +
"A a;\n" +
"switch(a.getType()) {\n" +
" default:\n" +
" return 0;\n" +
"}\n" +
"switch(a.getType()) {\n" +
" case 1:\n" +
" { return 0; }\n" +
"}";
String s10024 = "switch('_a:[exprtype( short )]) { '_statement*; }";
assertEquals(
"finding switch",
2,
findMatchesCount(s10023,s10024)
);
String s10025 = "A[] a;\n" +
"A b[];\n" +
"A c;";
String s10026 = "A[] 'a;";
String s10026_2 = "A 'a[];";
assertEquals(
"array types in dcl",
2,
findMatchesCount(s10025,s10026)
);
assertEquals(
"array types in dcl 2",
2,
findMatchesCount(s10025,s10026_2)
);
String s10027 = "try { a(); } catch(Exception ex) {}\n" +
"try { a(); } finally {}\n" +
"try { a(); } catch(Exception ex) {} finally {} \n";
String s10028 = "try { a(); } finally {}\n";
assertEquals(
"finally matching",
2,
findMatchesCount(s10027,s10028)
);
String s10029 = "for(String a:b) { System.out.println(a); }";
String s10030 = "for(String a:b) { '_a; }";
assertEquals(
"for each matching",
1,
findMatchesCount(s10029,s10030)
);
String s10031 = "try { a(); } catch(Exception ex) {} catch(Error error) { 1=1; }\n" +
"try { a(); } catch(Exception ex) {}";
String s10032 = "try { a(); } catch('_Type+ 'Arg+) { 'Statements*; }\n";
assertEquals(
"finally matching",
2,
findMatchesCount(s10031,s10032)
);
String s10033 = "return x;\n" +
"return !x;\n" +
"return (x);\n" +
"return (x);\n" +
"return !(x);";
String s10034 = "return ('a);";
assertEquals("Find statement with parenthesized expr",2,findMatchesCount(s10033,s10034));
}
public void testSearchClass() {
// no modifier list in interface vars
assertEquals(
"no modifier for interface vars",
findMatchesCount(s43,s44),
3
);
// different order of access modifiers
assertEquals(
"different order of access modifiers",
findMatchesCount(s45,s46),
1
);
// no access modifiers
assertEquals(
"no access modifier",
findMatchesCount(s45,s46_2),
2
);
// type could differ with package
assertEquals(
"type differs with package",
findMatchesCount(s47,s48),
2
);
// reference element could differ in package
assertEquals(
"reference could differ in package",
findMatchesCount(s49,s50),
1
);
String s51 = "class C extends java.awt.List {} class A extends java.util.List {} class B extends java.awt.List {} ";
String s52 = "class 'B extends '_C:java\\.awt\\.List {}";
assertEquals(
"reference could differ in package 2",
findMatchesCount(s51,s52),
2
);
assertEquals(
"method access modifier",
findMatchesCount(s93,s94),
0
);
assertEquals(
"method access modifier 2",
findMatchesCount(s93,s94_2),
1
);
assertEquals(
"field access modifier",
findMatchesCount(s93,s94_3),
0
);
assertEquals(
"field access modifier 2",
findMatchesCount(s93,s94_4),
1
);
final String s127 = "class a { void b() { new c() {}; } }";
final String s128 = "class 't {}";
assertEquals(
"class finds anonymous class",
findMatchesCount(s127,s128),
2
);
final String s129 = "class a { public void run() {} }\n" +
"class a2 { public void run() { run(); } }\n" +
"class a3 { public void run() { run(); } }\n" +
"class a4 { public void run(); }";
final String s130 = "class 'a { public void run() {} }";
final String s130_2 = "class 'a { public void run() { '_statement; } }";
final String s130_3 = "class 'a { public void run(); }";
assertEquals(
"empty method finds empty method only",
findMatchesCount(s129,s130),
1
);
assertEquals(
"nonempty method finds nonempty method",
findMatchesCount(s129,s130_2),
2
);
assertEquals(
"nonempty method finds nonempty method",
findMatchesCount(s129,s130_3),
4
);
final String s133 = "class S {\n" +
"void cc() {\n" +
" new Runnable() {\n" +
" public void run() {\n" +
" f();\n" +
" }\n" +
" private void f() {\n" +
" //To change body of created methods use File | Settings | File Templates.\n" +
" }\n" +
" };\n" +
" new Runnable() {\n" +
" public void run() {\n" +
" f();\n" +
" }\n" +
" private void g() {\n" +
" //To change body of created methods use File | Settings | File Templates.\n" +
" }\n" +
" };\n" +
" new Runnable() {\n" +
" public void run() {\n" +
" f();\n" +
" }\n" +
" };\n" +
" }\n" +
" private void f() {\n" +
" //To change body of created methods use File | Settings | File Templates.\n" +
" }\n" +
"} ";
final String s134 = "new Runnable() {\n" +
" public void run() {\n" +
" '_f ();\n" +
" }\n" +
" private void '_f ();\n" +
" }";
assertEquals(
"complex expr matching",
1,
findMatchesCount(s133,s134)
);
final String s135 = "abstract class My {\n" +
" abstract void f();\n" +
"}\n" +
"abstract class My2 {\n" +
" abstract void f();\n" +
" void fg() {}\n" +
"}";
final String s136 = "class 'm {\n" +
" void f();\n" +
" '_type '_method{0,0} ('_paramtype* '_paramname* );\n" +
"}";
assertEquals(
"reject method with 0 max occurence",
findMatchesCount(s135,s136),
1
);
final String s137 = "abstract class My {\n" +
" int a;\n" +
"}\n" +
"abstract class My2 {\n" +
" Project b;\n" +
"}" +
"abstract class My3 {\n" +
" Class clazz;"+
" Project b = null;\n" +
"}" +
"abstract class My {\n" +
" int a = 1;\n" +
"}\n";
final String s138 = "class 'm {\n" +
" Project '_f{0,0} = '_t?;\n" +
"}";
assertEquals(
"reject field with 0 max occurence",
findMatchesCount(s137,s138),
2
);
final String s139 = "class My { boolean equals(Object o); int hashCode(); }";
final String s139_2 = "class My { boolean equals(Object o); }";
final String s140 = "class 'A { boolean equals(Object '_o ); int '_hashCode{0,0}:hashCode (); }";
assertEquals(
"reject method with constraint",
findMatchesCount(s139,s140),
0
);
assertEquals(
"reject field with 0 max occurence",
findMatchesCount(s139_2,s140),
1
);
final String s141 = "class A { static { a = 10 } }\n" +
"class B { { a = 10; } }\n" +
"class C { { a = 10; } }";
final String s142 = "class '_ { static { a = 10; } } ";
assertEquals(
"static block search",
findMatchesCount(s141,s142),
1
);
}
public void testParameterlessContructorSearch() {
final String s143 = "class A { A() {} };\n" +
"class B { B(int a) {} };\n" +
"class C { C() {} C(int a) {} };\n" +
"class D {}\n" +
"class E {}";
final String s144 = "class '_a { '_d{0,0}:[ script( \"__context__.constructor\" ) ]('_b+ '_c+); }";
assertEquals(
"parameterless contructor search",
3,
findMatchesCount(s143,s144)
);
}
public void testCheckScriptValidation() {
final String s1 = "";
final String s2 = "'_b:[script( \"^^^\" )]";
try {
final int count = findMatchesCount(s1, s2);
assertFalse("Validation does not work", true);
} catch (MalformedPatternException ex) {}
}
//public void testRelationBetweenVars() {
// final String s1 = "public class Foo {\n" +
// " public static final Logger log = Logger.getInstance(Foo.class);\n" +
// " public static final Logger log2 = Logger.getInstance(Foo2.class);\n" +
// " public static final Logger log3 = Logger.getInstance(Foo2.class);\n" +
// "}";
// final String s2 = "class '_a { static Logger 'log+ = Logger.getInstance('_b:[script( \"_a != _b\" )].class); }";
// assertEquals(
// "relation between vars in script",
// 2,
// findMatchesCount(s1,s2)
// );
//}
public void testExprTypeWithObject() {
String s1 = "import java.util.*;\n" +
"class A {\n" +
" void b() {\n" +
" Map map = new HashMap();" +
" class AppPreferences {}\n" +
" String key = \"key\";\n" +
" AppPreferences value = new AppPreferences();\n" +
" map.put(key, value );\n" +
" map.put(value, value );\n" +
" map.put(\"key\", value );\n" +
" map.put(\"key\", new AppPreferences());\n" +
" }\n" +
"}";
String s2 = "'_map:[exprtype( *java\\.util\\.Map )].put('_key:[ exprtype( *Object ) ], '_value:[ exprtype( *AppPreferences ) ]);";
assertEquals(
"expr type with object",
4,
findMatchesCount(s1,s2,true)
);
}
public void testInterfaceImplementationsSearch() {
String in = "class A implements Cloneable {\n" +
" \n" +
" }\n" +
" \n" +
" class B implements Serializable {\n" +
" \n" +
" }\n" +
" \n" +
" class C implements Cloneable,Serializable {\n" +
" \n" +
" }\n" +
" class C2 implements Serializable,Cloneable {\n" +
" \n" +
" }\n" +
" \n" +
" class E extends B implements Cloneable {\n" +
" \n" +
" }\n" +
" \n" +
" class F extends A implements Serializable {\n" +
" \n" +
" }\n" +
" \n" +
" class D extends C {\n" +
" \n" +
" }";
String what = "class 'A implements '_B:*Serializable , '_C:*Cloneable {}";
assertEquals(
"search interface within hierarchy",
5,
findMatchesCount(in, what)
);
}
public void testSearchBacktracking() {
assertEquals(
"backtracking greedy regexp",
findMatchesCount(s89,s90),
1
);
assertEquals(
"backtracking greedy regexp 2",
findMatchesCount(s89,s90_2),
1
);
assertEquals(
"backtracking greedy regexp 3",
findMatchesCount(s89,s90_3),
0
);
assertEquals(
"counted regexp (with back tracking)",
findMatchesCount(s89,s90_4),
1
);
assertEquals(
"nongreedy regexp (counted, with back tracking)",
findMatchesCount(s89,s90_5),
1
);
assertEquals(
"nongreedy regexp (counted, with back tracking) 2",
findMatchesCount(s89,s90_6),
0
);
String s1000 = "class A {\n" +
" void _() {}\n" +
" void a(String in, String pattern) {}\n" +
" }";
String s1001 = "class '_Class { \n" +
" '_ReturnType+ 'MethodName+ ('_ParameterType* '_Parameter* );\n" +
"}";
assertEquals(
"handling of no match",
findMatchesCount(s1000,s1001),
2
);
}
public void testSearchSymbol() {
final String s131 = "a.b(); c.d = 1; ";
final String s132 = "'T:b|d";
assertEquals(
"symbol match",
2,
findMatchesCount(s131,s132)
);
final String s129 = "A a = new A();";
final String s130 = "'Sym:A";
options.setCaseSensitiveMatch(true);
assertEquals(
"case sensitive match",
findMatchesCount(s129,s130),
2
);
options.setDistinct(true);
assertEquals(
"case sensitive disitinct match",
findMatchesCount(s129,s130),
1
);
options.setDistinct(false);
final String s133 = "class C { int a; int A() { a = 1; }} void c(int a) { a = 2; }";
final String s133_2 = "class C { int a() {} int A() { a(1); }}";
final String s134 = "a";
List<MatchResult> results = findMatches(s133, s134, true, StdFileTypes.JAVA);
assertEquals(
"find sym finds declaration",
4, results.size()
);
assertEquals(
"find sym finds declaration",
2, findMatchesCount(s133_2, s134, true)
);
}
public void testSearchGenerics() {
assertEquals(
"parameterized class match",
findMatchesCount(s81,s82),
2
);
assertEquals(
"parameterized instanceof match",
findMatchesCount(s81,s82_2),
1
);
assertEquals(
"parameterized cast match",
findMatchesCount(s81,s82_3),
1
);
assertEquals(
"parameterized definition match",
findMatchesCount(s81,s82_4),
3
);
assertEquals(
"parameterized method match",
findMatchesCount(s81,s82_5),
1
);
assertEquals(
"parameterized constraint match",
findMatchesCount(s81_2,s82_6),
2
);
assertEquals(
"symbol matches parameterization",
findMatchesCount(s81,s82_7),
29
);
assertEquals(
"symbol matches parameterization 2",
findMatchesCount(s81_2,s82_7),
7
);
String s81_3 = " class A {\n" +
" public static <T> Collection<T> unmodifiableCollection(int c) {\n" +
" return new d<T>(c);\n" +
" }\n" +
" static class d<E> implements Collection<E>, Serializable {\n" +
" public <T> T[] toArray(T[] a) {return c.toArray(a);}\n" +
" }\n" +
"}";
assertEquals(
"typed symbol symbol",
findMatchesCount(s81_3,s82_5),
2
);
String s81_4="class A<B> { \n" +
" static <C> void c(D<E> f) throws R<S> {\n" +
" if ( f instanceof G<H>) {\n" +
" ((I<G<K>>)l).a();\n" +
" throw new P<Q>();" +
" }\n" +
" }\n" +
"} " +
"class C {\n" +
" void d(E f) throws Q {\n" +
" if (g instanceof H) { a.c(); b.d(new A() {}); throw new Exception(((I)k)); }"+
" }\n" +
"}";
String s82_8 = "'T<'_Subst+>";
assertEquals(
"typed symbol",
findMatchesCount(s81_4,s82_8),
6
);
String s81_5 = "class A { HashMap<String, Integer> variable = new HashMap<String, Integer>(\"aaa\");}";
String s82_9 = "'_Type<'_GType, '_GType2> '_instance = new '_Type<'_GType, '_GType2>('_Param);";
assertEquals(
"generic vars in new",
findMatchesCount(s81_5,s82_9),
1
);
String source1 = "class Comparator<T> { private Comparator<String> c; private Comparator d; }";
String target1 = "java.util.Comparator 'a;";
assertEquals(
"qualified type should not match 1",
0,
findMatchesCount(source1, target1)
);
String target2 = "java.util.Comparator<String> 'a;";
assertEquals(
"qualified type should not match 2",
0,
findMatchesCount(source1, target2)
);
// @todo typed vars constrains (super),
// @todo generic method invocation
//String s83 = "class A {} List<A> a; List b;";
//String s84 = "'a:List 'c;";
//String s84_2 = "'a:List\\<'_\\> 'c;";
//String s84_3 = "'a:List(?>\\<'_\\>) 'c;";
//
//assertEquals(
// "finding list",
// findMatchesCount(s83,s84),
// 2
//);
//
//assertEquals(
// "finding list 2",
// findMatchesCount(s83,s84_2),
// 1
//);
//
//assertEquals(
// "finding list 3",
// findMatchesCount(s83,s84_3),
// 1
//);
}
public void testSearchSubstitutions() {
// searching for parameterized pattern
assertEquals("search for parameterized pattern",findMatchesCount(s14_1,s15),2);
assertEquals("search for parameterized pattern 2",findMatchesCount(s14_2,s15),5);
options.setRecursiveSearch(false);
assertEquals("search for parameterized pattern-non-recursive",findMatchesCount(s14_1,s15),1);
assertEquals("search for parameterized pattern 2-non-recursive",findMatchesCount(s14_2,s15),2);
// typed vars with arrays
assertEquals("typed pattern with array 2-non-recursive",findMatchesCount(s23,s24_2),4);
options.setRecursiveSearch(true);
// searching for parameterized pattern
assertEquals("search for parameterized pattern 3",findMatchesCount(s14_2,s16),1);
// searching for parameterized pattern in complex expr (with field selection)
assertEquals("search for parameterized pattern in field selection",findMatchesCount(s17,s18_1),1);
// searching for parameterized pattern in complex expr (with method call)
assertEquals("search for parameterized pattern with method call",findMatchesCount(s17,s18_2),1);
// searching for parameterized pattern in complex expr (with method call)
assertEquals("search for parameterized pattern with method call ep.2",findMatchesCount(s17,s18_3),4);
// searching for parameterized pattern in definition with initializer
assertEquals("search for same var constraint",findMatchesCount(s19,s20),1);
// searching for semi anonymous parameterized pattern in definition with initializer
assertEquals("search for same var constraint for semi anonymous typed vars",findMatchesCount(s19,s20_2),1);
// support for type var constraint
assertEquals("search for typed var constraint",findMatchesCount(s22,s21_1),1);
// noncompatible same typed var constraints
try {
findMatchesCount(s22,s21_2);
assertFalse("search for noncompatible typed var constraint",false);
} catch(MalformedPatternException e) {
}
// compatible same typed var constraints
assertEquals("search for same typed var constraint",findMatchesCount(s22,s21_3),1);
// typed var with instanceof
assertEquals("typed instanceof",findMatchesCount(s65,s66),1);
// typed vars with arrays
assertEquals("typed pattern with array",findMatchesCount(s23,s24_1),2);
// typed vars with arrays
assertEquals("typed pattern with array 2",findMatchesCount(s23,s24_2),6);
// typed vars in class name, method name, its return type, parameter type and name
assertEquals("typed pattern in class name, method name, return type, parameter type and name",findMatchesCount(s25,s26),1);
assertEquals(
"finding interface",
findMatchesCount(s27,s28),
1
);
// finding anonymous type vars
assertEquals(
"anonymous typed vars",
findMatchesCount(s29,s30),
1
);
// finding descedants
assertEquals(
"finding class descendants",
findMatchesCount(s31,s32),
2
);
// finding interface implementation
assertEquals(
"interface implementation",
findMatchesCount(s33,s34),
2
);
// different order of fields and methods
assertEquals(
"different order of fields and methods",
findMatchesCount(s35,s36),
1
);
// different order of exceptions in throws
assertEquals(
"differend order in throws",
findMatchesCount(s37,s38),
1
);
// class pattern without extends matches pattern with extends
assertEquals(
"match of class without extends to class with it",
findMatchesCount(s39,s40),
2
);
// class pattern without extends matches pattern with extends
assertEquals(
"match of class without extends to class with it, ep. 2",
findMatchesCount(s41,s42_1),
2
);
// class pattern without extends matches pattern with extends
assertEquals(
"match of class without extends to class with it, ep 3",
findMatchesCount(s41,s42_2),
2
);
// typed reference element
assertEquals(
"typed reference element",
findMatchesCount(s51,s52),
2
);
// empty name of type var
assertEquals(
"empty name for typed var",
findMatchesCount(s59,s60),
1
);
// comparing method with constructor
assertEquals(
"comparing method with constructor",
findMatchesCount(s63,s64),
1
);
// comparing method with constructor
assertEquals(
"finding nested class",
findMatchesCount(s63_2,s64),
2
);
// comparing method with constructor
assertEquals(
"finded nested class by special pattern",
findMatchesCount(s63_2,s64_2),
1
);
assertEquals(
"* regexp for typed var",
findMatchesCount(s61,s62_1),
5
);
assertEquals(
"+ regexp for typed var",
findMatchesCount(s61,s62_2),
4
);
assertEquals(
"? regexp for typed var",
findMatchesCount(s61,s62_3),
2
);
assertEquals(
"cast in method parameters",
findMatchesCount(s67,s68),
1
);
assertEquals(
"searching for static field in static call",
2,
findMatchesCount(s69,s70)
);
assertEquals(
"searching for static field in static call, 2",
2,
findMatchesCount(s69,s70_2)
);
assertEquals(
"* regexp for anonymous typed var",
findMatchesCount(s61,s62_4),
3
);
assertEquals(
"+ regexp for anonymous typed var",
findMatchesCount(s61,s62_5),
2
);
assertEquals(
"? regexp for anonymous typed var",
findMatchesCount(s61,s62_6),
2
);
assertEquals(
"statement inside anonymous class",
findMatchesCount(s71,s72),
3
);
assertEquals(
"clever regexp match",
findMatchesCount(s91,s92),
2
);
assertEquals(
"clever regexp match 2",
findMatchesCount(s91,s92_2),
2
);
assertEquals(
"clever regexp match 3",
findMatchesCount(s91,s92_3),
2
);
}
public void testSearchJavaDoc() {
// javadoc comment in class
assertEquals(
"java doc comment in class",
1,
findMatchesCount(s57,s58)
);
assertEquals(
"java doc comment in class in file",
1,
findMatchesCount(s57_2,s58,true)
);
// javadoc comment for field
assertEquals(
"javadoc comment for field",
2,
findMatchesCount(s57, s58_2)
);
// javadoc comment for method
assertEquals(
"javadoc comment for method",
3,
findMatchesCount(s57, s58_3)
);
// just javadoc comment search
assertEquals(
"just javadoc comment search",
4,
findMatchesCount(s57,s58_4)
);
assertEquals(
"XDoclet metadata",
2,
findMatchesCount(s83,s84)
);
assertEquals(
"XDoclet metadata 2",
1,
findMatchesCount(s83,s84_2)
);
assertEquals(
"optional tag value match",
6,
findMatchesCount(s57, s58_5)
);
assertEquals(
"multiple tags match +",
2,
findMatchesCount(s75,s76)
);
assertEquals(
"multiple tags match *",
3,
findMatchesCount(s75, s76_2)
);
assertEquals(
"multiple tags match ?",
3,
findMatchesCount(s75, s76_3)
);
}
public void testNamedPatterns() {
String s133 = "class String1 implements java.io.Serializable { " +
"private static final long serialVersionUID = -6849794470754667710L;" +
"private static final ObjectStreamField[] serialPersistentFields = new ObjectStreamField[0];" +
"}" +
"class StringBuilder1 implements java.io.Serializable {" +
" private void writeObject(java.io.ObjectOutputStream s)\n" +
" throws java.io.IOException {\n" +
" s.defaultWriteObject();\n" +
" }" +
"private void readObject(java.io.ObjectInputStream s)\n" +
" throws java.io.IOException, ClassNotFoundException {\n" +
" s.defaultReadObject();\n" +
" }" +
" static final long serialVersionUID = 4383685877147921099L;" +
"}";
String s134 = "class '_ implements '_:*Serializable {\n" +
" static final long 'VersionField?:serialVersionUID = '_?;\n" +
" private static final ObjectStreamField[] '_?:serialPersistentFields = '_?; \n" +
" private void '_SerializationWriteHandler?:writeObject (ObjectOutputStream s) throws IOException;\n" +
" private void '_SerializationReadHandler?:readObject (ObjectInputStream s) throws IOException, ClassNotFoundException;\n" +
" Object '_SpecialSerializationReadHandler?:readResolve () throws ObjectStreamException;" +
" Object '_SpecialSerializationWriteHandler?:writeReplace () throws ObjectStreamException;" +
"}";
assertEquals(
"serialization match",
findMatchesCount(s133,s134),
2
);
String s135 = "class SimpleStudentEventActionImpl extends Action { " +
" public ActionForward execute(ActionMapping mapping,\n" +
" ActionForm _form,\n" +
" HttpServletRequest _request,\n" +
" HttpServletResponse _response)" +
" throws Exception {}" +
"} " +
"public class DoEnrollStudent extends SimpleStudentEventActionImpl { }" +
"public class DoCancelStudent extends SimpleStudentEventActionImpl { }";
String s136 = "public class 'StrutsActionClass extends '_*:Action {" +
" public ActionForward '_AnActionMethod:*execute (ActionMapping '_,\n" +
" ActionForm '_,\n" +
" HttpServletRequest '_,\n" +
" HttpServletResponse '_);" +
"}";
assertEquals(
"Struts actions",
findMatchesCount(s135,s136),
2
);
final String s123 = "class NodeFilter {} public class MethodFilter extends NodeFilter {\n" +
" private MethodFilter() {}\n" +
"\n" +
" public static NodeFilter getInstance() {\n" +
" if (instance==null) instance = new MethodFilter();\n" +
" return instance;\n" +
" }\n" +
" private static NodeFilter instance;\n" +
"}";
final String s124 = "class 'Class {\n" +
" private 'Class('_* '_*) {\n" +
" '_*;\n" +
" }\n" +
" private static '_Class2:* '_Instance;\n" +
" static '_Class2:* '_GetInstance() {\n" +
" '_*;\n" +
" return '_Instance;\n" +
" }\n" +
"}";
assertEquals(
"singleton search",
findMatchesCount(s123,s124),
1
);
String s1111 = "if (true) { a=1; b=1; } else { a=1; }\n" +
"if(true) { a=1; } else { a=1; b=1; }\n" +
"if(true) { a=1; b=2; } else { a = 1; b=2; }";
String s1112 = "if (true) { '_a{1,2}; } else { '_a; }";
assertEquals(
"same multiple name pattern",
findMatchesCount(s1111,s1112),
1
);
}
public void testHierarchy() {
final String s105 = "class B {} class A extends B { }";
final String s106 = "class '_ extends '_:[ref('T)] {}";
assertEquals(
"extends match",
findMatchesCount(s105,s106),
1
);
final String s107 = "interface IA {} interface IB extends IA { } interface IC extends IB {} interface ID extends IC {}" +
"class A implements IA {} class B extends A { } class C extends B implements IC {} class D extends C {}";
final String s108 = "class '_ extends 'Type:+A {}";
final String s108_2 = "class '_ implements 'Type:+IA {}";
assertEquals(
"extends navigation match",
findMatchesCount(s107,s108),
2
);
assertEquals(
"implements navigation match",
3,
findMatchesCount(s107,s108_2)
);
final String s109 = "interface I {} interface I2 extends I {} class A implements I2 {} class B extends A { } class C extends B {} class D { void e() { C c; B b; A a;} }";
final String s110 = "'_:*A '_;";
final String s110_2 = "'_:*I '_;";
final String s110_3 = "'_:*[regex( I ) && ref('T)] '_;";
final String s110_4 = "'_:*[regex( I ) && ref2('T)] '_;";
assertEquals(
"extends navigation match in definition",
findMatchesCount(s109,s110),
3
);
assertEquals(
"implements navigation match in definition 2",
findMatchesCount(s109,s110_2),
3
);
assertEquals(
"implements navigation match in definition 2 with nested conditions",
findMatchesCount(s109,s110_3),
1
);
try {
findMatchesCount(s109,s110_4);
assertFalse("implements navigation match in definition 2 with nested conditions - incorrect cond",false);
} catch(UnsupportedPatternException ex) {}
final String s111 = "interface E {} class A implements E {} class B extends A { int f = 0; } class C extends B {} class D { void e() { C c; B b; A a;} }";
final String s112 = "'_";
assertEquals(
"symbol match",
findMatchesCount(s111,s112),
17
);
final String s113 = "class B {int c; void d() {} } int a; B b; a = 1; b.d(); ++a; int c=a; System.out.println(a); " +
"b.c = 1; System.out.println(b.c); b.c++;";
final String s114 = "'_:[read]";
final String s114_2 = "'_:[write]";
assertEquals(
"read symbol match",
findMatchesCount(s113,s114),
11
);
assertEquals(
"write symbol match",
findMatchesCount(s113,s114_2),
5
);
final String s115 = "class B {} public class C {}";
final String s116 = "public class '_ {}";
assertEquals(
"public modifier for class",
findMatchesCount(s115,s116),
1
);
final String s117 = "class A { int b; void c() { int e; b=1; this.b=1; e=5; " +
"System.out.println(e); " +
"System.out.println(b); System.out.println(this.b);} }";
final String s118 = "this.'Field";
final String s118_2 = "this.'Field:[read]";
final String s118_3 = "this.'Field:[write]";
assertEquals(
"fields of class",
4,
findMatchesCount(s117,s118)
);
assertEquals(
"fields of class read",
findMatchesCount(s117,s118_2),
2
);
assertEquals(
"fields of class written",
findMatchesCount(s117,s118_3),
2
);
final String s119 = "try { a.b(); } catch(IOException e) { c(); } catch(Exception ex) { d(); }";
final String s120 = "try { '_; } catch('_ '_) { '_; }";
final String s120_2 = "try { '_; } catch(Throwable '_) { '_; }";
assertEquals(
"catches loose matching",
findMatchesCount(s119,s120),
1
);
assertEquals(
"catches loose matching 2",
findMatchesCount(s119,s120_2),
0
);
final String s121 = "class A { private int a; class Inner {} } " +
"class B extends A { private int a; class Inner2 {} }";
final String s122 = "class '_ { int '_:* ; }";
final String s122_2 = "class '_ { int '_:+hashCode (); }";
final String s122_3 = "class '_ { class '_:* {} }";
assertEquals(
"hierarchical matching",
findMatchesCount(s121,s122),
2
);
assertEquals(
"hierarchical matching 2",
findMatchesCount(s121,s122_2),
4
);
assertEquals(
"hierarchical matching 3",
findMatchesCount(s121,s122_3),
2
);
}
public void testSearchInCommentsAndLiterals() {
String s1 = "{" +
"// This is some comment\n" +
"/* This is another\n comment*/\n" +
"// Some garbage\n"+
"/** And now third comment*/\n" +
"/** Some garbage*/ }";
String s2 = "// 'Comment:[regex( .*(?:comment).* )]";
String s3 = "/** 'Comment:[regex( .*(?:comment).* )] */";
String s2_2 = "/* 'Comment:[regex( .*(?:comment).* )] */";
assertEquals(
"Comment matching",
findMatchesCount(s1,s2),
3
);
assertEquals(
"Comment matching, 2",
3,
findMatchesCount(s1,s2_2)
);
assertEquals(
"Java doc matching",
findMatchesCount(s1,s3),
1
);
String s4 = "\"'test\", \"another test\", \"garbage\"";
String s5 = "\"'test:[regex( .*test.* )]\"";
String s6 = "\"''test\"";
assertEquals(
"Literal content",
findMatchesCount(s4,s5),
2
);
assertEquals(
"Literal content with escaping",
findMatchesCount(s4,s6),
1
);
String s7 = "\"aaa\"";
String s8 = "\"'test:[regex( aaa )]\"";
assertEquals(
"Simple literal content",
findMatchesCount(s7,s8),
1
);
String s9 = "\" aaa \" \" bbb \" \" ccc ccc aaa\"";
String s10 = "\"'test:[regexw( aaa|ccc )]\"";
String s11 = "\"'test:[regexw( bbb )]\"";
assertEquals(
"Whole word literal content with alternations",
findMatchesCount(s9,s10),
2
);
assertEquals(
"Whole word literal content",
findMatchesCount(s9,s11),
1
);
String s12 = "assert agentInfo != null : \"agentInfo is null\";\n" +
"assert addresses != null : \"addresses is null\";";
String s13 = "assert $exp$ != null : \"$exp$ is null\";";
assertEquals(
"reference to substitution in comment",
findMatchesCount(s12,s13),
2
);
String s14 = "\"(some text with special chars)\"," +
"\" some\"," +
"\"(some)\"";
String s15 = "\"('a:[regexw( some )])\"";
assertEquals(
"meta char in literal",
2,
findMatchesCount(s14,s15)
);
String s16 = "/**\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 Y {\n" +
"}";
String s17 = "/**\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" +
"}";
assertEquals(
"complete comment match",
1,
findMatchesCount(s16,s17,true)
);
String s18 = "public class A {\n" +
" private void f(int i) {\n" +
" int g=0; //sss\n" +
" }\n" +
"}";
String s19 = "class $c$ {\n" +
" $type$ $f$($t$ $p$){\n" +
" $s$; // sss\n" +
" }\n" +
"}";
assertEquals(
"statement match with comment",
1,
findMatchesCount(s18,s19)
);
}
public void testOther() {
assertEquals(
"optional init match in definition",
findMatchesCount(s73,s74),
4
);
assertEquals(
"null match",
findMatchesCount(s77,s78),
0
);
assertEquals(
"body of method by block search",
findMatchesCount(s79,s80),
2
);
assertEquals(
"first matches, next not",
findMatchesCount(s95,s96),
2
);
final String s97 = "class A { int c; void b() { C d; } } class C { C() { A a; a.b(); a.c=1; } }";
final String s98 = "'_.'_:[ref('T)] ()";
final String s98_2 = "'_.'_:[ref('T)]";
final String s98_3 = "'_:[ref('T)].'_ ();";
final String s98_4 = "'_:[ref('T)] '_;";
assertEquals(
"method predicate match",
findMatchesCount(s97,s98),
1
);
assertEquals(
"field predicate match",
findMatchesCount(s97,s98_2),
1
);
assertEquals(
"dcl predicate match",
findMatchesCount(s97,s98_3),
1
);
final String s99 = " char s = '\\u1111'; char s1 = '\\n'; ";
final String s100 = " char 'var = '\\u1111'; ";
final String s100_2 = " char 'var = '\\n'; ";
assertEquals(
"char constants in pattern",
findMatchesCount(s99,s100),
1
);
assertEquals(
"char constants in pattern 2",
findMatchesCount(s99,s100_2),
1
);
assertEquals(
"class predicate match (from definition)",
findMatchesCount(s97,s98_4),
3
);
final String s125 = "a=1;";
final String s126 = "'t:[regex(a)]";
try {
findMatchesCount(s125,s126);
assertFalse("spaces around reg exp check",false);
} catch(MalformedPatternException ex) {}
options.setDistinct(true);
final String s101 = "class A { void b() { String d; String e; String[] f; f.length=1; f.length=1; } }";
final String s102 = "'_:[ref('T)] '_;";
assertEquals(
"distinct match",
findMatchesCount(s101,s102),
1
);
options.setDistinct(false);
final String s103 = " a=1; ";
final String s104 = "'T:{ ;";
try {
findMatchesCount(s103,s104);
assertFalse("incorrect reg exp",false);
} catch(MalformedPatternException ex) {
}
final String s106 = "$_ReturnType$ $MethodName$($_ParameterType$ $_Parameter$);";
final String s105 = " aaa; ";
try {
findMatchesCount(s105,s106);
assertFalse("incorrect reg exp 2",false);
} catch(UnsupportedPatternException ex) {
}
String s107 = "class A {\n" +
" /* */\n" +
" void a() {\n" +
" }" +
" /* */\n" +
" int b = 1;\n" +
" /*" +
" *" +
" */\n" +
" class C {}" +
"}";
String s108 = " /*" +
" *" +
" */";
assertEquals("finding comments without typed var", 1, findMatchesCount(s107,s108));
String s109 = "class A { void b(); int b(int c); char d(char e); }\n" +
"A a; a.b(1); a.b(2); a.b(); a.d('e'); a.d('f'); a.d('g');";
String s110 = "'_a.'_b:[exprtype( int ) ]('_c*);";
assertEquals("caring about method return type", 2, findMatchesCount(s109,s110));
String s111 = "class A { void getManager() { getManager(); } };\n" +
"class B { void getManager() { getManager(); getManager(); } };";
String s112 = "'Instance?:[exprtype( B )].getManager()";
assertEquals("caring about missing qualifier type", 2, findMatchesCount(s111,s112));
String s112a = "'Instance?:[regex( B )].getManager()";
assertEquals("static query should not match instance method", 0, findMatchesCount(s111, s112a));
String s112b = "B.getManager()";
assertEquals("static query should not match instance method 2", 0, findMatchesCount(s111, s112b));
String s113 = "class A { static void a() { a(); }}\n" +
"class B { static void a() { a(); a(); }}\n";
String s114 = "'_Q?:[regex( B )].a()";
assertEquals("should care about implicit class qualifier", 2, findMatchesCount(s113, s114));
String s114a = "B.a()";
assertEquals("should match simple implicit class qualifier query", 2, findMatchesCount(s113, s114a));
String s114b = "'_Q?:[exprtype( B )].a()";
assertEquals("instance query should not match static method", 0, findMatchesCount(s113, s114b));
String s115 = "class A { int a; int f() { return a; }}\n" +
"class B { int a; int g() { return a + a; }}\n";
String s116 = "'_Instance?:[exprtype( B )].a";
assertEquals("should care about implicit instance qualifier", 2, findMatchesCount(s115, s116));
String s116a = "A.a";
assertEquals("should not match instance method", 0, findMatchesCount(s115, s116a));
String s117 = "class A { static int a; static int f() { return a; }}\n" +
"class B { static int a; static int g() { return a + a; }}\n";
String s118 = "'_Q?:[regex( B )].a";
assertEquals("should care about implicit class qualifier for field", 2, findMatchesCount(s117, s118));
// b) hierarchy navigation support
// c) or search support
// e) xml search (down-up, nested query), navigation from xml representation <-> java code
// f) impl data conversion (jdk 1.5 style) <-> other from (replace support)
// Directions:
// @todo different navigation on sub/supertyping relation (fixed depth), methods implementing interface,
// g. like predicates
// i. performance
// more context for top level classes, difference with interface, etc
// global issues:
// @todo matches out of context
// @todo proper regexp support
// @todo define strict equality of the matches
// @todo search for field selection retrieves packages also
}
public void testFQNInPatternAndVariableConstraints() {
String s1 = "import java.awt.List;\n" +
"class A { List l; }";
String s1_2 = "import java.util.List;\n" +
"class A { List l; }";
String s2 = "class '_ { 'Type:java\\.util\\.List '_Field; }";
assertEquals("No matches for qualified class",findMatchesCount(s1,s2,true),0);
assertEquals("Matches for qualified class",findMatchesCount(s1_2,s2,true),1);
String s3 = "import java.util.ArrayList;\n" +
"class A { ArrayList l; }";
String s4 = "class '_ { 'Type:*java\\.util\\.Collection '_Field; }";
assertEquals("Matches for qualified class in hierarchy",findMatchesCount(s3,s4,true),1);
String s5 = "import java.util.List;\n" +
"class A { { List l = new List(); l.add(\"1\"); } }";
String s5_2 = "import java.awt.List;\n" +
"class A { { List l = new List(); l.add(\"1\"); } }";
String s6 = "'a:[exprtype( java\\.util\\.List )]";
String s6_2 = "'a:[exprtype( *java\\.util\\.Collection )]";
String s6_3 = "java.util.List '_a = '_b?;";
assertEquals("Matches for qualified expr type",findMatchesCount(s5,s6,true), 2);
assertEquals("No matches for qualified expr type",findMatchesCount(s5_2,s6,true),0);
assertEquals("Matches for qualified expr type in hierarchy",findMatchesCount(s5,s6_2,true), 2);
assertEquals("Matches for qualified var type in pattern",findMatchesCount(s5,s6_3,true),1);
assertEquals("No matches for qualified var type in pattern",findMatchesCount(s5_2,s6_3,true),0);
String s7 = "import java.util.List;\n" +
"class A extends List { }";
String s7_2 = "import java.awt.List;\n" +
"class A extends List {}";
String s8 = "class 'a extends java.util.List {}";
assertEquals("Matches for qualified type in pattern",findMatchesCount(s7,s8,true),1);
assertEquals("No matches for qualified type in pattern",findMatchesCount(s7_2,s8,true),0);
String s9 = "String.intern(\"1\");\n" +
"java.util.Collections.sort(null);" +
"java.util.Collections.sort(null);";
String s10 = "java.lang.String.'_method ( '_params* )";
assertEquals("FQN in class name",1,findMatchesCount(s9,s10,false));
}
public void testAnnotations() throws Exception {
String s1 = "@MyBean(\"\")\n" +
"@MyBean2(\"\")\n" +
"public class TestBean {}\n" +
"@MyBean2(\"\")\n" +
"@MyBean(value=\"\")\n" +
"public class TestBean2 {}\n" +
"public class TestBean3 {}\n" +
"@MyBean(\"a\")\n" +
"@MyBean2(\"a\")\n" +
"public class TestBean4";
String s2 = "@MyBean(\"\")\n" +
"@MyBean2(\"\")\n" +
"public class $a$ {}\n";
assertEquals("Simple find annotated class",2,findMatchesCount(s1,s2,false));
assertEquals("Match value of anonymous name value pair 1", 1, findMatchesCount(s1, "@MyBean(\"a\") class $a$ {}"));
assertEquals("Match value of anonymous name value pair 2", 2, findMatchesCount(s1, "@MyBean(\"\") class $a$ {}"));
String s3 = "@VisualBean(\"????????? ?????????? ? ??\")\n" +
"public class TestBean\n" +
"{\n" +
" @VisualBeanField(\n" +
" name = \"??? ????????????\",\n" +
" initialValue = \"?????????????\"\n" +
" )\n" +
" public String user;\n" +
"\n" +
" @VisualBeanField(\n" +
" name = \"??????\",\n" +
" initialValue = \"\",\n" +
" fieldType = FieldTypeEnum.PASSWORD_FIELD\n" +
" )\n" +
" public String password;\n" +
"\n" +
" @VisualBeanField(\n" +
" initialValue = \"User\",\n" +
" name = \"????? ???????\",\n" +
" name = \"Second name\",\n" +
" fieldType = FieldTypeEnum.COMBOBOX_FIELD,\n" +
" comboValues = {\n" +
" @ComboFieldValue(\"Administrator\"),\n" +
" @ComboFieldValue(\"User\"),\n" +
" @ComboFieldValue(\"Guest\")}\n" +
" ) \n" +
" public String accessRights;\n" +
" \n" +
" public String otherField;\n" +
"}";
String s4 = "class '_a {\n" +
" @'_Annotation+ ( 'AnnotationMember*:name = '_AnnotationValue* )\n" +
" String '_field* ;\n" +
"}";
String s4_2 = "class '_a {\n" +
" @'_Annotation+ ()\n" +
" String 'field* ;\n" +
"}";
assertEquals("Find annotation members of annotated field class",4,findMatchesCount(s3,s4,false));
assertEquals("Find annotation fields",3,findMatchesCount(s3,s4_2,false));
String s5 = "class A {" +
" @NotNull private static Collection<PsiElement> resolveElements(final PsiReference reference, final Project project) {}\n" +
" @NotNull private static Collection resolveElements2(final PsiReference reference, final Project project) {}\n" +
"}";
String s6 = "class '_c {@NotNull '_rt 'method* ('_pt* '_p*){ '_inst*; } }";
String s6_2 = "class '_c {@'_:NotNull '_rt 'method* ('_pt* '_p*){ '_inst*; } }";
assertEquals("Find annotated methods",2,findMatchesCount(s5,s6));
assertEquals("Find annotated methods, 2",2,findMatchesCount(s5,s6_2));
String s7 = "class A { void message(@NonNls String msg); }\n" +
"class B { void message2(String msg); }\n" +
"class C { void message2(String msg); }";
String s8 = "class '_A { void 'b( @'_Ann{0,0}:NonNls String '_); }";
assertEquals("Find not annotated methods",2,findMatchesCount(s7,s8));
String s9 = "class A {\n" +
" Object[] method1() {}\n" +
" Object method1_2() {}\n" +
" Object method1_3() {}\n" +
" Object method1_4() {}\n" +
" @MyAnnotation Object[] method2(int a) {}\n" +
" @NonNls Object[] method3() {}\n" +
"}";
String s10 = "class '_A { @'_Ann{0,0}:NonNls '_Type:Object\\[\\] 'b+( '_pt* '_p* ); }";
String s10_2 = "class '_A { @'_Ann{0,0}:NonNls '_Type [] 'b+( '_pt* '_p* ); }";
String s10_3 = "class '_A { @'_Ann{0,0}:NonNls '_Type:Object [] 'b+( '_pt* '_p* ); }";
assertEquals("Find not annotated methods, 2",2,findMatchesCount(s9,s10));
assertEquals("Find not annotated methods, 2",2,findMatchesCount(s9,s10_2));
assertEquals("Find not annotated methods, 2",2,findMatchesCount(s9,s10_3));
String s11 = "class A {\n" +
"@Foo(value=baz) int a;\n" +
"@Foo(value=baz2) int a2;\n" +
"@Foo(value=baz2) int a3;\n" +
"@Foo(value2=baz3) int a3;\n" +
"@Foo(value2=baz3) int a3;\n" +
"@Foo(value2=baz3) int a3;\n" +
"@Foo(value2=baz4) int a3;\n" +
"}";
String s12 = "@Foo(value=baz) int 'a;)";
String s12_2 = "@Foo(value='baz:baz2 ) int 'a;)";
String s12_3 = "@Foo('value:value2 = baz3 ) int 'a;)";
String s12_4 = "@Foo('value:value2 = 'baz3:baz3 ) int 'a;)";
String s12_5 = "@Foo('value:value2 = 'baz3:baz ) int 'a;)";
String s12_6 = "@Foo('value:value2 = 'baz3 ) int 'a;)";
String s12_7 = "@Foo('value:value2 = ) int 'a;";
assertEquals("Find anno parameter value",1,findMatchesCount(s11,s12));
assertEquals("Find anno parameter value",2,findMatchesCount(s11,s12_2));
assertEquals("Find anno parameter value",3,findMatchesCount(s11,s12_3));
assertEquals("Find anno parameter value",3,findMatchesCount(s11,s12_4));
assertEquals("Find anno parameter value",0,findMatchesCount(s11,s12_5));
assertEquals("Find anno parameter value",4,findMatchesCount(s11,s12_6));
assertEquals("Find anno parameter value",4,findMatchesCount(s11,s12_7));
}
public void testBoxingAndUnboxing() {
String s1 = " class A { void b(Integer i); void b2(int i); void c(int d); void c2(Integer d); }\n" +
"A a;\n" +
"a.b2(1)\n;" +
"a.b2(1)\n;" +
"a.b(1)\n;" +
"a.b( new Integer(0) )\n;" +
"a.b( new Integer(0) )\n;" +
"a.c(new Integer(2));\n" +
"a.c(new Integer(3));\n" +
"a.c2(new Integer(3));\n" +
"a.c(3);";
String s2 = "a.'b('_Params:[formal( Integer ) && exprtype( int ) ])";
String s2_2 = "a.c('_Params:[formal( int ) && exprtype( Integer ) ])";
assertEquals("Find boxing in method call",1,findMatchesCount(s1,s2,false));
assertEquals("Find unboxing in method call",2,findMatchesCount(s1,s2_2,false));
}
public void testCommentsInDclSearch() {
String s1 = "class A {\n" +
" int a; // comment\n" +
" char b;\n" +
" int c; // comment2\n" +
"}";
String s1_2 = "class A {\n" +
" // comment\n" +
" int a;\n" +
" char b;\n" +
" // comment2\n" +
" int c;\n" +
"}";
String s2 = "'_Type '_Variable = '_Value?; //'Comment";
String s2_2 = "//'Comment\n" +
"'_Type '_Variable = '_Value?;";
assertEquals("Find field by dcl with comment",2,findMatchesCount(s1,s2));
assertEquals("Find field by dcl with comment 2",2,findMatchesCount(s1_2,s2_2));
}
public void testSearchingEmptyModifiers() {
String s1 = "class A {\n" +
" int a;\n" +
" private char b;\n" +
" private char b2;\n" +
" public int c;\n" +
" public int c2;\n" +
"}";
String s2 = "@Modifier(\"packageLocal\") '_Type '_Variable = '_Value?;";
String s2_2 = "@Modifier({\"packageLocal\",\"private\"}) '_Type '_Variable = '_Value?;";
String s2_3 = "@Modifier({\"PackageLocal\",\"private\"}) '_Type '_Variable = '_Value?;";
assertEquals("Finding package local dcls",1,findMatchesCount(s1,s2));
assertEquals("Finding package local dcls",3,findMatchesCount(s1,s2_2));
try {
findMatchesCount(s1,s2_3);
assertTrue("Finding package local dcls",false);
} catch(MalformedPatternException ex) {
}
String s3 = "class A {\n" +
" int a;\n" +
" static char b;\n" +
" static char b2;\n" +
"}";
String s4 = "@Modifier(\"Instance\") '_Type '_Variable = '_Value?;";
String s4_2 = "@Modifier({\"static\",\"Instance\"}) '_Type '_Variable = '_Value?;";
assertEquals("Finding instance fields",1,findMatchesCount(s3,s4));
assertEquals("Finding all fields",3,findMatchesCount(s3,s4_2));
String s5 = "class A {}\n" +
"abstract class B {}\n" +
"final class C {}\n" +
"class D {}";
String s6 = "@Modifier(\"Instance\") class 'Type {}";
String s6_2 = "@Modifier({\"abstract\",\"final\",\"Instance\"}) class 'Type {}";
assertEquals("Finding instance classes",3,findMatchesCount(s5,s6));
assertEquals("Finding all classes",4,findMatchesCount(s5,s6_2));
}
public void testSearchTransientFieldsWithModifier() {
String source =
"public class TestClass {\n" +
" transient private String field1;\n" +
" transient String field2;\n" +
" String field3;\n" +
"}";
String template = "transient @Modifier(\"packageLocal\") '_Type '_Variable = '_Value?;";
assertEquals("Finding package-local transient fields", 1, findMatchesCount(source, template));
}
public void test() {
String s1 = "if (LOG.isDebugEnabled()) {\n" +
" int a = 1;\n" +
" int a = 1;\n" +
"}";
String s2 = "if ('_Log.isDebugEnabled()) {\n" +
" '_ThenStatement;\n" +
" '_ThenStatement;\n" +
"}";
assertEquals("Comparing declarations",1,findMatchesCount(s1,s2));
}
public void testFindStaticMethodsWithinHierarchy() {
String s1 = "class A {}\n" +
"class B extends A { static void foo(); }\n" +
"class B2 extends A { static void foo(int a); }\n" +
"class B3 extends A { static void foo(int a, int b); }\n" +
"class C { static void foo(); }\n" +
"B.foo();\n" +
"B2.foo(1);\n" +
"B3.foo(2,3);\n" +
"C.foo();";
String s2 = "'_Instance:[regex( *A )].'_Method:[regex( foo )] ( '_Params* )";
assertEquals("Find static methods within expr type hierarchy", 3, findMatchesCount(s1,s2));
}
public void testFindClassesWithinHierarchy() {
String s1 = "class A implements I {}\n" +
"interface I {}\n" +
"class B extends A implements I { }\n" +
"class B2 implements I { }\n" +
"class B3 extends A { }\n" +
"class C extends B2 { static void foo(); }\n";
String s2 = "class '_ extends '_Extends:[!regex( *A )] implements '_Implements:[regex( I )] {}";
String s2_2 = "class '_ extends '_Extends:[!regex( *A )]{}";
assertEquals("Find class within type hierarchy with not", 1, findMatchesCount(s1,s2));
assertEquals("Find class within type hierarchy with not, 2", 1, findMatchesCount(s1,s2_2));
}
public void testFindTryWithoutProperFinally() {
String s1 = "try {\n" +
" conn = 1;\n" +
"} finally {\n" +
" conn.close();\n" +
"}\n" +
"try {\n" +
" conn = 1;\n" +
"} finally {\n" +
" int a = 1;\n" +
"}\n" +
"try {\n" +
" conn = 1;\n" +
"} finally {\n" +
" int a = 1;\n" +
"}";
String s2 = "try { '_StatementBefore*; '_Dcl:[regex( conn = 1 )]; '_StatementAfter*; } finally { '_Finally*:[!regex( .*conn.* ) ]; }";
assertEquals("FindTryWithoutProperFinally", 2, findMatchesCount(s1,s2));
}
public void testBug() {
String s1 = "public class DiallingNumber extends DataGroup\n" + "{\n" + " protected static byte [] CLEAR = { };\n" + "\n" +
" private static DataItemTemplate template;\n" + "\n" + "\tprotected DataTemplate createDefaultTemplate()\n" + "\t{\n" +
" return null;\n" + " }\n" + "}";
String s2 = "class '_Class {\n" + " static '_FieldType '_FieldName:.*template.* = '_FieldInitial?;\n" +
" '_RetType createDefaultTemplate() { '_Statements*; }\n" + "\t'_Content*\n" + "}";
assertEquals("Bug in class matching", 1, findMatchesCount(s1,s2));
}
//public void testFindFieldUsageByQName() {
// String s1 = "{ class A { int b; { b = 1; } } class B extends A { { this.b = 2} } { B i; i.b = 3; } }";
// String s2 = "A.b";
// assertEquals( 3, findMatchesCount(s1,s2));
//}
//
//public void testFindMethodUsageByQName() {
// String s1 = "{ class A { void b(int a) {} { b(1); } } class B extends A { { this.b(2); } } { B i; i.b(3); } }";
// String s2 = "A.b";
// assertEquals( 3, findMatchesCount(s1,s2));
//}
public void _testStaticInstanceInitializers() {
String s1 = "public class DiallingNumber {\n static { int a = 1; } static { int b = 1; } { int c = 2; }}";
String s2 = "class '_Class {\n" + " static { 't*; } }";
String s2_2 = "class '_Class {\n" + " { 't*; } }";
String s2_3 = "class '_Class {\n" + " @Modifier(\"Instance\") { 't*; } }";
assertEquals("Static / instance initializers", 2, findMatchesCount(s1,s2));
assertEquals("Static / instance initializers", 1, findMatchesCount(s1,s2_3));
assertEquals("Static / instance initializers", 3, findMatchesCount(s1,s2_2));
}
@NotNull
@Override
protected String getTestDataPath() {
return PlatformTestUtil.getCommunityPath() + "/platform/structuralsearch/testData/java/";
}
public void testDoNotFindReturn() throws IOException {
String s1 = loadFile(getTestName(false) + ".java");
String s2 = "ApplicationManager.getApplication().runReadAction(new Runnable() {\n" +
" public void run() {\n" +
" 't*:[ !regex( .*return.* ) ];\n" +
" }});";
assertEquals(0, findMatchesCount(s1,s2));
}
public void testDownUpMatch() {
String s1 = "class A {\n" +
" int bbb(int c, int ddd, int eee) {\n" +
" int a = 1;\n" +
" try { int b = 1; } catch(Type t) { a = 2; } catch(Type2 t2) { a = 3; }\n" +
" }\n" +
"}";
String s2 = "try { '_st*; } catch('_Type 't+) { '_st2*; }";
final List<PsiVariable> vars = new ArrayList<PsiVariable>();
final PsiFile file = PsiFileFactory.getInstance(getProject()).createFileFromText("_.java", s1);
file.acceptChildren(new JavaRecursiveElementWalkingVisitor() {
@Override public void visitVariable(final PsiVariable variable) {
super.visitVariable(variable);
vars.add(variable);
}
});
assertEquals(7, vars.size());
List<MatchResult> results = new ArrayList<MatchResult>();
Matcher testMatcher = new Matcher(getProject());
MatchOptions options = new MatchOptions();
options.setSearchPattern(s2);
MatcherImplUtil.transform(options);
options.setFileType(StdFileTypes.JAVA);
for(PsiVariable var:vars) {
final MatchResult matchResult = testMatcher.isMatchedByDownUp(var, options);
if (matchResult != null) results.add(matchResult);
assertTrue(
(var instanceof PsiParameter && var.getParent() instanceof PsiCatchSection && matchResult != null) ||
matchResult == null
);
}
assertEquals(2, results.size());
MatchResult result = results.get(0);
assertEquals("t", result.getMatchImage());
result = results.get(1);
assertEquals("t2", result.getMatchImage());
results.clear();
String s2_2 = "try { '_st*; } catch('Type:Type2 '_t) { '_st2*; }";
options.clearVariableConstraints();
options.setSearchPattern(s2_2);
MatcherImplUtil.transform(options);
for(PsiVariable var:vars) {
final PsiTypeElement typeElement = var.getTypeElement();
final MatchResult matchResult = testMatcher.isMatchedByDownUp(typeElement, options);
if (matchResult != null) results.add(matchResult);
assertTrue(
(var instanceof PsiParameter && var.getParent() instanceof PsiCatchSection && matchResult != null) ||
matchResult == null
);
}
assertEquals(1, results.size());
result = results.get(0);
assertEquals("Type2", result.getMatchImage());
}
@Bombed(day = 28, description = "support it", month = Calendar.JULY, user = "maxim.mossienko")
public void _testContainsPredicate() {
String s1 = "{{\n" +
" int a;\n" +
" a = 1;\n" +
"}\n" +
"{\n" +
" int b = 1;\n" +
" b = 1;\n" +
"}\n" +
"{\n" +
" int c = 2;\n" +
" c = 2;\n" +
"}}";
String s2 = "{\n" +
" '_a*:[contains( \"'type $a$ = $b$;\" )];\n" +
"}";
String s2_2 = "{\n" +
" '_a*:[!contains( \"$type$ $a$ = $b$;\" )];\n" +
"}";
assertEquals(2, findMatchesCount(s1, s2));
assertEquals(1, findMatchesCount(s1, s2_2));
}
public void testWithinPredicate() {
String s1 = "if (true) {\n" +
" int a = 1;\n" +
"}\n" +
"if (true) {\n" +
" int b = 1;\n" +
"}\n" +
"while(true) {\n" +
" int c = 2;\n" +
"}";
String s2 = "'_type 'a:[within( \"if ('_a) { '_st*; }\" )] = '_b;";
String s2_2 = "'_type 'a:[!within( \"if ('_a) { '_st*; }\" )] = '_b;";
assertEquals(2,findMatchesCount(s1, s2));
assertEquals(1,findMatchesCount(s1, s2_2));
// TODO: xxx
//String s3 = "if (true) {\n" +
// " if (true) return;\n" +
// " int a = 1;\n" +
// "}\n else if (true) {\n" +
// " return;\n" +
// "}";
//assertEquals(2,findMatchesCount(s3, s2));
//assertEquals(1,findMatchesCount(s3, s2_2));
}
public void testWithinPredicate2() {
String s3 = "class C {\n" +
" void aaa() {\n" +
" LOG.debug(true);\n" +
" LOG.debug(true);\n" +
" LOG.debug(true);\n" +
" LOG.debug(true);\n" +
" LOG.debug(true);\n" +
" if (true) {\n" +
" LOG.debug(true);\n" +
" }\n" +
" if (true) LOG.debug(true);\n" +
" if (true) { int 1 = 1; } else { LOG.debug(true); }\n" +
" }" +
"}";
String s4 = "LOG.debug('_params*:[!within( \"if('_a) { 'st*; }\" )]);";
assertEquals(6,findMatchesCount(s3, s4));
}
public void testMultiStatementPatternWithTypedVariable() throws Exception {
String s = "Integer i;\ni.valueOf();";
String s_2 = "Integer i;\nint a = 1;\ni.valueOf();";
String s2 = "Integer '_i;\n'_i.valueOf();";
String s2_2 = "Integer '_i;\n'_st; '_i.valueOf();";
String s2_3 = "Integer '_i;\n'_st*; '_i.valueOf();";
assertEquals(1, findMatchesCount(s,s2));
assertEquals(1, findMatchesCount(s_2,s2_2));
assertEquals(1, findMatchesCount(s_2,s2_3));
assertEquals(1, findMatchesCount(s,s2_3));
}
public void testFindAnnotationDeclarations() throws Exception {
String s = "interface Foo {} interface Bar {} @interface X {}";
String s2 = "@interface 'x {}";
assertEquals(1, findMatchesCount(s,s2));
}
public void testFindEnums() throws Exception {
String s = "class Foo {} class Bar {} enum X {}";
String s2 = "enum 'x {}";
assertEquals(1, findMatchesCount(s,s2));
}
public void testFindDeclaration() throws Exception {
String s = "public class F {\n" +
" static Category cat = Category.getInstance(F.class.getName());\n" +
" Category cat2 = Category.getInstance(F.class.getName());\n" +
" Category cat3 = Category.getInstance(F.class.getName());\n" +
"}";
String s2 = "static $Category$ $cat$ = $Category$.getInstance($Arg$);";
assertEquals(1, findMatchesCount(s,s2));
}
public void testFindMethodCallWithTwoOrThreeParameters() {
String source = "{ String.format(\"\"); String.format(\"\", 1); String.format(\"\", 1, 2); String.format(\"\", 1, 2, 3); }";
String pattern = "'_Instance.'_MethodCall('_Parameter{2,3})";
assertEquals(2, findMatchesCount(source, pattern));
}
public void testFindMethodWithCountedExceptionsInThrows() {
String source = "class A {" +
" void a() {}" +
" void b() throws E1 {}" +
" void c() throws E1, E2{}" +
" void d() throws E1, E2, E3 {}" +
"}";
String pattern1 = "class '_A {" +
" '_type+ 'method+ () throws '_E{0,0}" +
"}";
assertEquals(1, findMatchesCount(source, pattern1));
String pattern2 = "class '_A {" +
" '_type+ 'method+ () throws '_E{1,2}" +
"}";
assertEquals(2, findMatchesCount(source, pattern2));
String pattern3 = "class '_A {" +
" '_type+ 'method+ () throws '_E{2,2}" +
"}";
assertEquals(1, findMatchesCount(source, pattern3));
String pattern4 = "class '_A {" +
" '_type+ 'method+ () throws '_E{0,0}:[ regex( E2 )]" +
"}";
assertEquals(2, findMatchesCount(source, pattern4));
}
public void testFindMethodsCalledWithinClass() {
String source = "class A {" +
" void a() {}" +
" static void b() {}" +
" void c() {" +
" a();" +
" b();" +
" }" +
"}" +
"class B extends A {" +
" void d() {" +
" a();" +
" b();" +
" }" +
"}";
String pattern1 = "this.a()";
assertEquals(2, findMatchesCount(source, pattern1));
}
public void testFindReferenceWithParentheses() {
String source = "class A {" +
" String value;" +
" A(String v) {" +
" value = (value);" +
" System.out.println(((2)));" +
" System.out.println(2);" +
" }" +
"}";
String pattern1 = "'_value='_value";
assertEquals(1, findMatchesCount(source, pattern1));
String pattern2 = "System.out.println('_v);" +
"System.out.println('_v);";
assertEquals(1, findMatchesCount(source, pattern2));
}
public void testFindSelfAssignment() {
String source = "class A {" +
" protected String s;" +
" A(String t) {" +
" this.s = s;" +
" t = t;" +
" s = this.s;" +
" }" +
//"}" +
//"class B {" +
//" B(String t) {" +
//" super.s = s;" + // would be nice if found also
//" }" +
"}";
String pattern = "'_var='_var";
assertEquals(3, findMatchesCount(source, pattern));
}
public void testFindLambdas() {
String source = "public interface IntFunction<R> {" +
" R apply(int value);" +
"}" +
"public interface Function<T, R> {" +
" R apply(T t);" +
"}" +
"class A {" +
" void m() {" +
" Runnable q = () -> { /*comment*/ };" +
" Runnable r = () -> { System.out.println(); };" +
" IntFunction<String> f = a -> \"hello\";" +
" Function<String, String> g = a -> \"world\";" +
" }" +
"}";
String pattern1 = "() ->";
assertEquals("should find lamdas", 4, findMatchesCount(source, pattern1));
String pattern2 = "(int '_a) -> {}";
assertEquals("should find lambdas with specific parameter type", 1, findMatchesCount(source, pattern2));
String pattern3 = "('_a{0,0})->{}";
assertEquals("should find lambdas without any parameters", 2, findMatchesCount(source, pattern3));
String pattern4 = "()->System.out.println()";
assertEquals("should find lambdas with matching body", 1, findMatchesCount(source, pattern4));
String pattern5 = "()->{/*comment*/}";
assertEquals("should find lambdas with comment body", 1, findMatchesCount(source, pattern5));
}
public void testFindDefaultMethods() {
String source = "interface XYZ {" +
" default void m() {" +
" System.out.println();" +
" }" +
" void f();" +
" void g();" +
"}" +
"interface ABC {" +
" void m();" +
"}";
String pattern1 = "interface '_Class { default '_ReturnType+ 'MethodName+('_ParameterType* '_Parameter*);}";
assertEquals("should find default method", 1, findMatchesCount(source, pattern1));
String pattern2 = "interface 'Class { default '_ReturnType+ '_MethodName{0,0}('_ParameterType* '_Parameter*);}";
assertEquals("should find interface without default methods", 1, findMatchesCount(source, pattern2));
}
public void testFindMethodReferences() {
String source = "class A {" +
" Runnable r = System.out::println;" +
" Runnable s = this::hashCode;" +
" Runnable t = this::new;" +
" static {" +
" System.out.println();" +
" }" +
"}";
String pattern1 = "System . out :: println";
assertEquals("should find method reference", 1, findMatchesCount(source, pattern1));
String pattern2 = "this::'_a";
assertEquals("should find method reference 2", 2, findMatchesCount(source, pattern2));
String pattern3 = "'_a::'_b";
assertEquals("should find all method references", 3, findMatchesCount(source, pattern3));
}
public void testNoUnexpectedException() {
String source = "{}";
String pattern1 = "/*$A$a*/";
MalformedPatternException ex = null;
try {
findMatchesCount(source, pattern1);
} catch (MalformedPatternException e) {
ex = e;
}
assertNotNull(ex);
String pattern2 = "class $A$Visitor {}";
try {
findMatchesCount(source, pattern2);
} catch (MalformedPatternException e) {
ex = e;
}
assertNotNull(ex);
String pattern3 = "class $Class$ { \n" +
" class $n$$FieldType$ $FieldName$ = $Init$;\n" +
"}";
try {
findMatchesCount(source, pattern3);
} catch (MalformedPatternException e) {
ex = e;
}
assertNotNull(ex);
}
}