org.eclipse.jdt.ui.tests/ui/org/eclipse/jdt/ui/tests/callhierarchy/CallHierarchyTestHelper.java - jdt/eclipse.jdt.ui - Git at Google

 /*******************************************************************************
  * Copyright (c) 2000, 2021 IBM Corporation and others.
  *
  * This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License 2.0
  * which accompanies this distribution, and is available at
  * https://www.eclipse.org/legal/epl-2.0/
  *
  * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *   Jesper Kamstrup Linnet (eclipse@kamstrup-linnet.dk) - initial API and implementation
  *             (report 36180: Callers/Callees view)
  *******************************************************************************/
 package org.eclipse.jdt.ui.tests.callhierarchy;

 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collection;
 import java.util.List;

 import org.junit.Assert;

 import org.eclipse.jdt.testplugin.JavaProjectHelper;

 import org.eclipse.core.runtime.CoreException;

 import org.eclipse.core.resources.IMarker;
 import org.eclipse.core.resources.IResource;
 import org.eclipse.core.resources.IncrementalProjectBuilder;

 import org.eclipse.jdt.core.ICompilationUnit;
 import org.eclipse.jdt.core.IJavaElement;
 import org.eclipse.jdt.core.IJavaProject;
 import org.eclipse.jdt.core.IMember;
 import org.eclipse.jdt.core.IMethod;
 import org.eclipse.jdt.core.IPackageFragment;
 import org.eclipse.jdt.core.IPackageFragmentRoot;
 import org.eclipse.jdt.core.IType;

 import org.eclipse.jdt.internal.corext.callhierarchy.MethodWrapper;

 import org.eclipse.jdt.ui.tests.core.rules.Java17ProjectTestSetup;
 import org.eclipse.jdt.ui.tests.core.rules.ProjectTestSetup;

 @SuppressWarnings("javadoc")
 public class CallHierarchyTestHelper {
     private static final String[] EMPTY= new String[0];

     private IJavaProject fJavaProject1;
     private IJavaProject fJavaProject2;
     private IJavaProject fJavaProject3;
     private IType fType1;
     private IType fType2;
     private IType fTypeP;
 	private IType fFooImplAType;
 	private IType fFooImplBType;
 	private IType fFooType;
 	private IType fAbsType;
 	private IType fAbsI1Type;
 	private IType fAbsI2Type;
     private IPackageFragment fPack1;
     private IPackageFragment fPack2;
     private IPackageFragment fPack3;

     private IMethod fMethod1;
     private IMethod fMethod2;
     private IMethod fMethod3;
     private IMethod fMethod4;
     private IMethod fRecursiveMethod1;
     private IMethod fRecursiveMethod2;
 	private IMethod fCalleeMethod;
 	private IMethod fAbsCalleeMethod;
 	private IMethod fFooMethod;
 	private IMethod fFooImplMethod_A;
 	private IMethod fFooImplMethod_B;
 	private IMethod fAbsFooMethod;
 	private IMethod fAbsI1FooMethod;
 	private IMethod fAbsI2FooMethod;

     public void setUp() throws Exception {
         fJavaProject1= JavaProjectHelper.createJavaProject("TestProject1", "bin");
         fJavaProject2= JavaProjectHelper.createJavaProject("TestProject2", "bin");
         fJavaProject3= JavaProjectHelper.createJavaProject("TestProject3", "bin");
         assertBuildWithoutErrors(fJavaProject1);
         assertBuildWithoutErrors(fJavaProject2);
         assertBuildWithoutErrors(fJavaProject3);
         fType1= null;
         fType2= null;
         fTypeP= null;
         fFooImplAType= null;
         fFooImplBType= null;
         fAbsI1Type= null;
         fAbsI2Type= null;
         fAbsType= null;
         fFooType= null;
         fPack1= null;
         fPack2= null;
         fPack3= null;
     }

     public void tearDown() throws Exception {
         JavaProjectHelper.delete(fJavaProject1);
         JavaProjectHelper.delete(fJavaProject2);
         JavaProjectHelper.delete(fJavaProject3);
     }


     /**
      * Creates two simple classes, A and B. Sets the instance fields fType1 and fType2.
      */
     public void createSimpleClasses() throws Exception {
         createPackages();


         ICompilationUnit cu1= fPack1.getCompilationUnit("A.java");

         fType1=
             cu1.createType(
                 "public class A {\n" +
                 "public A() {\n" +
                 "}\n " +
                 "public void method1() {\n" +
                 "}\n " +
                 "public void method2() {\n" +
                 "  method1();\n" +
                 "}\n " +
                 "public void recursiveMethod1() {\n" +
                 "  recursiveMethod2();\n " +
                 "}\n " +
                 "public void recursiveMethod2() {\n" +
                 "  recursiveMethod1();\n " +
                 "}\n" +
                 "}\n",
                 null,
                 true,
                 null);

         ICompilationUnit cu2= fPack2.getCompilationUnit("B.java");
         fType2=
             cu2.createType(
                 "public class B extends pack1.A {\npublic void method3() { method1(); method2(); }\n public void method4() { method3(); }\n}\n",
                 null,
                 true,
                 null);

         assertBuildWithoutErrors(fJavaProject1);
         assertBuildWithoutErrors(fJavaProject2);
     }

     /**
      * Creates two simple classes, A and its subclass B, where B calls A's implicit constructor explicitly. Sets the instance fields fType1 and fType2.
      */
     public void createImplicitConstructorClasses() throws Exception {
         createPackages();

         ICompilationUnit cu1= fPack1.getCompilationUnit("A.java");
         fType1=
             cu1.createType(
                 "public class A {\n public void method1() { }\n public void method2() { method1(); }\n public void recursiveMethod1() { recursiveMethod2(); }\n public void recursiveMethod2() { recursiveMethod1(); }\n}\n",
                 null,
                 true,
                 null);

         ICompilationUnit cu2= fPack2.getCompilationUnit("B.java");
         fType2=
             cu2.createType(
                 "public class B extends pack1.A {\n public B(String name) { super(); }\n}\n",
                 null,
                 true,
                 null);
         assertBuildWithoutErrors(fPack1);
     }

     /**
      * Creates an inner class and sets the class attribute fType1.
      */
     public void createInnerClass() throws Exception {
         createPackages();

         ICompilationUnit cu1= fPack1.getCompilationUnit("Outer.java");
         fType1=
             cu1.createType(
                 "public class Outer {\n" +
                 "private Inner inner= new Inner();\n" +
                 "class Inner { public void innerMethod1() { outerMethod1(); }\n public void innerMethod2() { innerMethod1(); }\n }\n" +
                 "public void outerMethod1() { }\n public void outerMethod2() { inner.innerMethod2(); }\n" +
                 "}",
                 null,
                 true,
                 null);
         assertBuildWithoutErrors(fPack1);
     }

     /**
      * Creates an anonymous inner class and sets the class attribute fType1.
      */
     public void createAnonymousInnerClass() throws Exception {
         createPackages();

         ICompilationUnit cu1= fPack1.getCompilationUnit("AnonymousInner.java");
         fType1=
             cu1.createType(
                 "public class AnonymousInner {\n" +
                 "  Object anonClass = new Object() {\n" +
                 "    void anotherMethod() {\n" +
                 "      someMethod();\n" +
                 "    }\n" +
                 "  };\n" +
                 "  void someMethod() {\n" +
                 "  }\n" +
                 "}\n",
                 null,
                 true,
                 null);

         ICompilationUnit cu2= fPack2.getCompilationUnit("Outer.java");
         fType2=
             cu2.createType(
                 "public class Outer {\n" +
                 "    interface Intf {\n" +
                 "         public void foo();\n" +
                 "    }\n" +
                 "    class Clazz {\n" +
                 "         public void foo() { };\n" +
                 "    }\n" +
                 "    public void anonymousOnInterface() {\n" +
                 "        new Intf() {\n"+
                 "            public void foo() {\n"+
                 "                someMethod();\n"+
                 "            }\n"+
                 "        };\n"+
                 "    }\n" +
                 "    public void anonymousOnClass() {\n" +
                 "        new Clazz() {\n"+
                 "            public void foo() {\n"+
                 "                someMethod();\n"+
                 "            }\n"+
                 "        };\n"+
                 "    }\n" +
                 "    public void someMethod() { }\n"+
                 "}\n",
                 null,
                 true,
                 null);
         assertBuildWithoutErrors(fPack1);
     }

     /**
      * Creates an anonymous inner class inside another method and sets the class attribute fType1.
      */
     public void createAnonymousInnerClassInsideMethod() throws Exception {
         createPackages();

         ICompilationUnit cu1= fPack1.getCompilationUnit("AnonymousInnerInsideMethod.java");
         fType1=
             cu1.createType(
                 "public class AnonymousInnerInsideMethod {\n" +
                 "  void m() {\n" +
                 "    System.out.println(\"before\");\n"+
                 "    Runnable runnable = new Runnable() {\n"+
                 "      public void run() {\n"+
                 "        System.out.println(\"run\");\n"+
                 "      }\n"+
                 "    };\n"+
                 "    runnable.run();\n"+
                 "  }\n"+
                 "}\n",
                 null,
                 true,
                 null);
         assertBuildWithoutErrors(fPack1);
     }

 	/**
 	 * Creates a class with various lambda function definitions and calls
 	 */
 	public void createClassWithLambdaCalls() throws Exception {
 		createPackages();

 		ICompilationUnit cu= fPack1.getCompilationUnit("Snippet.java");
 		fType1= cu.createType("public class Snippet {\n"
 				+ "	static Function<? super String, ? extends String> mapper1 = y -> transform(y);\n"
 				+ "	Function<? super String, ? extends String> mapper2 = y -> transform(y);\n"
 				+ "\n"
 				+ "	static {\n"
 				+ "		 mapper1 = y -> transform(y);\n"
 				+ "	}\n"
 				+ "\n"
 				+ "	public Snippet() {\n"
 				+ "		mapper2 = y -> transform(y);\n"
 				+ "	}\n"
 				+ "\n"
 				+ "	public static void main(String[] args) {\n"
 				+ "		mapper1 = y -> transform(y);\n"
 				+ "	}\n"
 				+ "\n"
 				+ "	Object[] funcCall() {\n"
 				+ "		return List.of(\"aaa\").stream().map(y -> transform(y)).toArray();\n"
 				+ "	}\n"
 				+ "\n"
 				+ "	static String transform(String s) {\n"
 				+ "     x();\n"
 				+ "		return s.toUpperCase();\n"
 				+ "	}\n"
 				+ " static String x() {"
 				+ "     return null;\n"
 				+ "}\n"
 				+ "}",
 				null,
 				true,
 				null);
 		cu.createImport("java.util.List", fType1, null);
 		cu.createImport("java.util.function.Function", fType1, null);
 		fMethod1= fType1.getMethod("x", EMPTY);
 		fMethod2= fType1.getMethod("transform", new String[] { "QString;" });
 		Assert.assertNotNull(fMethod1);
 		Assert.assertNotNull(fMethod2);
 		assertBuildWithoutErrors(fPack1);
 	}

     /**
      * Creates a class with a static initializer and sets the class attribute fType1.
      */
     public void createStaticInitializerClass() throws Exception {
         createPackages();

         ICompilationUnit cu1= fPack1.getCompilationUnit("Initializer.java");
         fType1=
             cu1.createType(
                 "public class Initializer { static { someMethod(); }\n public static void someMethod() { }\n }\n",
                 null,
                 true,
                 null);
         assertBuildWithoutErrors(fPack1);
     }

     /**
      * Creates a record class, OneRecord and sets the instance field fType1.
      */
     public void createRecordClasses() throws Exception {
     	ProjectTestSetup projectsetup= new Java17ProjectTestSetup(false);
 		fJavaProject3.setRawClasspath(projectsetup.getDefaultClasspath(), null);
 		JavaProjectHelper.set17CompilerOptions(fJavaProject3, false);

 		IPackageFragmentRoot fSourceFolder= JavaProjectHelper.addSourceContainer(fJavaProject3, "src");

 		String MODULE_INFO_FILE_CONTENT = ""
 				+ "module test {\n"
 				+ "}\n";

 		IPackageFragment def= fSourceFolder.createPackageFragment("", false, null);
 		def.createCompilationUnit("module-info.java", MODULE_INFO_FILE_CONTENT, false, null);

 		fPack3= fSourceFolder.createPackageFragment("test", false, null);

     	JavaProjectHelper.set16CompilerOptions(fJavaProject1, true);

         ICompilationUnit cu1= fPack3.getCompilationUnit("Outer.java");

         fType1=
             cu1.createType(
                     "public class Outer {\n" +
                     "record OneRecord(int number1, int number2) {\n" +
                     "  OneRecord() { this(1, 2); }\n" +
                     "}\n " +
                     "    public static void method1() {\n" +
                     "        new OneRecord(3, 5);\n" +
                     "    }\n" +
                     "    public static void method2() {\n" +
                     "        new OneRecord();\n" +
                     "    }\n" +
                     "    public static void method3() {\n" +
                     "        method1();\n" +
                     "        method2();\n" +
                     "    }\n" +
                     "}\n",
                 null,
                 true,
                 null);
         assertBuildWithoutErrors(fJavaProject3);
     }

     public void createCalleeClasses() throws Exception {
         createPackages();

         ICompilationUnit cu3= fPack2.getCompilationUnit("P.java");
         fTypeP=
         		cu3.createType(
                     "public class P {\n"
                     + "  private A handler;\n"
                     + "  private Abs absHandler;\n"
                     + "\n"
                     + "  public void callFoo() {\n"
                     + "     handler.foo();\n"
                     + "  }\n"
                     + "  public void callAbsFoo() {\n"
                     + "     absHandler.absFoo();\n"
                     + "  }\n"
                     + "\n"
                     + "}",
                     null,
                     true,
                     null);

         ICompilationUnit cu4= fPack2.getCompilationUnit("A.java");
         fFooType= cu4.createType(
         		"public interface A {\n"
                 + "   void foo();\n"
                 + "}\n"
                 , null, true, null);


         ICompilationUnit cu5= fPack2.getCompilationUnit("AImpl.java");
         fFooImplAType= cu5.createType(
                 "public class AImpl implements A {\n"
                 + "  public void foo() {\n"
                 + "      System.out.println();\n"
                 + "  }\n"
                 + "}\n"
                 , null, true, null);

         ICompilationUnit cu6= fPack2.getCompilationUnit("BImpl.java");
         fFooImplBType= cu6.createType(
                 "public class BImpl implements A {\n"
                 + "  public void foo() {\n"
                 + "      System.out.printf(\"\");\n"
                 + "  }\n"
                 + "}\n"
                 , null, true, null);


         ICompilationUnit cu7= fPack2.getCompilationUnit("Abs.java");
         fAbsType= cu7.createType(
         		"public abstract class Abs {\n"
                 + "   abstract void absFoo();\n"
                 + "}\n"
                 , null, true, null);

         ICompilationUnit cu8= fPack2.getCompilationUnit("AbsI1.java");
         fAbsI1Type= cu8.createType(
         		"public class AbsI1 extends Abs {\n"
                 + "   void absFoo() {}\n"
                 + "}\n"
                 , null, true, null);

         ICompilationUnit cu9= fPack2.getCompilationUnit("AbsI2.java");
         fAbsI2Type= cu9.createType(
         		"public class AbsI2 extends Abs {\n"
                 + "   void absFoo() {}\n"
                 + "}\n"
                 , null, true, null);

         assertBuildWithoutErrors(fJavaProject1);
         assertBuildWithoutErrors(fJavaProject2);

     }

     /**
      * Creates two packages (pack1 and pack2) in different projects. Sets the
      * instance fields fPack1 and fPack2.
      */
     public void createPackages() throws Exception {
         JavaProjectHelper.addRTJar9(fJavaProject1);

         IPackageFragmentRoot root1= JavaProjectHelper.addSourceContainer(fJavaProject1, "src");
         fPack1= root1.createPackageFragment("pack1", true, null);
         assertBuildWithoutErrors(fPack1);

         JavaProjectHelper.addRTJar9(fJavaProject2);
         JavaProjectHelper.addRequiredProject(fJavaProject2, fJavaProject1);

         IPackageFragmentRoot root2= JavaProjectHelper.addSourceContainer(fJavaProject2, "src");
         fPack2= root2.createPackageFragment("pack2", true, null);
         assertBuildWithoutErrors(fPack2);
     }

     /**
      * Returns all error markers on given resource, recursively
      */
     public List<IMarker> getErrorMarkers(IResource resource) throws CoreException {
         IMarker[] markers = resource.findMarkers(null, true, IResource.DEPTH_INFINITE);
         List<IMarker> errorMarkers = new ArrayList<>();
         for (IMarker marker : markers) {
             if (marker.getAttribute(IMarker.SEVERITY, IMarker.SEVERITY_INFO) == IMarker.SEVERITY_ERROR) {
                 errorMarkers.add(marker);
             }
         }
         return errorMarkers;
     }

     public static List<String> convertMarkers(IMarker [] markers) throws Exception {
         List<String> result = new ArrayList<>();
         for (int i = 0; i < markers.length; i++) {
             IMarker marker = markers[i];
             StringBuilder sb = new StringBuilder("Marker #");
             sb.append(i).append("[");
             sb.append(marker.getAttribute("message", null));
             sb.append(" at line: ").append(marker.getAttribute("lineNumber", 0));
             sb.append("], ");
             result.add(sb.toString());
         }
         return result;
     }

     /**
      * Verifies that no error markers exist in the given resource.
      * <p>
      *
      * @param element
      *            The resource that is searched for error markers
      */
     protected void assertBuildWithoutErrors(IJavaElement element) throws Exception {
     	IResource resource= element.getResource();
     	Assert.assertNotNull("Given element has no resource: " + element, resource);
     	resource.getProject().build(IncrementalProjectBuilder.FULL_BUILD, null);
 		assertNoErrorMarkers(resource);
     }

     /**
      * Verifies that no error markers exist in the given resource.
      * <p>
      *
      * @param resource
      *            The resource that is searched for error markers
      */
     protected void assertNoErrorMarkers(IResource resource) throws Exception {
         List<IMarker> errorMarkers = getErrorMarkers(resource);
         List<String> messages = convertMarkers(errorMarkers.toArray(new IMarker[errorMarkers.size()]));
         Assert.assertEquals("No error marker expected, but found markers with messages: " + messages.toString(), 0,
                 errorMarkers.size());
     }

     /**
      * Asserts that all the expected methods were found in the call results.
      */
     public void assertCalls(Collection<IMember> expectedMembers, Collection<?> calls) {
         Collection<IMember> foundMembers= new ArrayList<>();

 		for (MethodWrapper element : (Collection<MethodWrapper>)calls) {
 			foundMembers.add(element.getMember());
 		}

         Assert.assertEquals("Wrong number of calls", expectedMembers.size(), calls.size());
         Assert.assertTrue("One or more members not found", foundMembers.containsAll(expectedMembers));
     }

     /**
      * Asserts that all the expected methods were found in the call results.
      */
     public void assertCalls(Collection<IMember> expectedMembers, MethodWrapper[] callResults) {
         assertCalls(expectedMembers, Arrays.asList(callResults));
     }

     /**
      * Asserts that all the expected methods were found in the call results.
      */
     public void assertCalls(IMember[] expectedMembers, Object[] callResults) {
         assertCalls(Arrays.asList(expectedMembers), Arrays.asList(callResults));
     }

     public MethodWrapper findMethodWrapper(IMethod method, Object[] methodWrappers) {
         MethodWrapper thirdLevelMethodWrapper= null;
 		for (Object methodWrapper : methodWrappers) {
 			if (method.equals(((MethodWrapper) methodWrapper).getMember())) {
 				thirdLevelMethodWrapper= (MethodWrapper) methodWrapper;
 				break;
 			}
 		}
         return thirdLevelMethodWrapper;
     }

     /**
      * @return
      */
     public IJavaProject getJavaProject2() {
         return fJavaProject2;
     }

     /**
      * @return
      */
     public IPackageFragment getPackage1() {
         return fPack1;
     }

     /**
      * @return
      */
     public IPackageFragment getPackage2() {
         return fPack2;
     }

     /**
      * @return
      */
 	public IType getType1() {
         return fType1;
     }

     /**
      * @return
      */
     public IType getType2() {
         return fType2;
     }

     public IType getTypeP() {
     	return fTypeP;
     }

     public IType getFooImplAType() {
 		return fFooImplAType;
 	}

     public IType getFooImplBType() {
 		return fFooImplBType;
 	}

     public IType getFooType() {
 		return fFooType;
 	}

     public IType getAbsType() {
 		return fAbsType;
 	}

     public IType getAbsI1Type() {
 		return fAbsI1Type;
 	}

     public IType getAbsI2Type() {
 		return fAbsI2Type;
 	}

     public IMethod getMethod1() {
         if (fMethod1 == null) {
             fMethod1= getType1().getMethod("method1", EMPTY);
         }
         return fMethod1;
     }

     public IMethod getMethod2() {
         if (fMethod2 == null) {
             fMethod2= getType1().getMethod("method2", EMPTY);
         }
         return fMethod2;
     }

     public IMethod getMethod3() {
         if (fMethod3 == null) {
             fMethod3= getType2().getMethod("method3", EMPTY);
         }
         return fMethod3;
     }

     public IMethod getMethod4() {
         if (fMethod4 == null) {
             fMethod4= getType2().getMethod("method4", EMPTY);
         }
         return fMethod4;
     }

     public IMethod getRecursiveMethod1() {
         if (fRecursiveMethod1 == null) {
             fRecursiveMethod1= getType1().getMethod("recursiveMethod1", EMPTY);
         }
         return fRecursiveMethod1;
     }

     public IMethod getRecursiveMethod2() {
         if (fRecursiveMethod2 == null) {
             fRecursiveMethod2= getType1().getMethod("recursiveMethod2", EMPTY);
         }
         return fRecursiveMethod2;
     }

     public IMethod getCalleeMethod() {
         if (fCalleeMethod == null) {
             fCalleeMethod= getTypeP().getMethod("callFoo", EMPTY);
         }
         return fCalleeMethod;
     }

     public IMethod getAbsCalleeMethod() {
         if (fAbsCalleeMethod == null) {
         	fAbsCalleeMethod= getTypeP().getMethod("callAbsFoo", EMPTY);
         }
         return fAbsCalleeMethod;
     }

 	public IMethod getFooImplMethod_A() {
         if (fFooImplMethod_A == null) {
         	fFooImplMethod_A= getFooImplAType().getMethod("foo", EMPTY);
         }
         return fFooImplMethod_A;
 	}

 	public IMethod getFooImplMethod_B() {
         if (fFooImplMethod_B == null) {
         	fFooImplMethod_B= getFooImplBType().getMethod("foo", EMPTY);
         }
         return fFooImplMethod_B;
 	}

 	public IMethod getFooMethod() {
         if (fFooMethod == null) {
         	fFooMethod= getFooType().getMethod("foo", EMPTY);
         }
         return fFooMethod;
 	}

 	public IMethod getAbsFooMethod() {
         if (fAbsFooMethod == null) {
         	fAbsFooMethod= getAbsType().getMethod("absFoo", EMPTY);
         }
         return fAbsFooMethod;
 	}

 	public IMethod getAbsI1FooMethod() {
         if (fAbsI1FooMethod == null) {
         	fAbsI1FooMethod= getAbsI1Type().getMethod("absFoo", EMPTY);
         }
         return fAbsI1FooMethod;
 	}

 	public IMethod getAbsI2FooMethod() {
         if (fAbsI2FooMethod == null) {
         	fAbsI2FooMethod= getAbsI2Type().getMethod("absFoo", EMPTY);
         }
         return fAbsI2FooMethod;
 	}
 }
	/*******************************************************************************
	* Copyright (c) 2000, 2021 IBM Corporation and others.
	*
	* This program and the accompanying materials
	* are made available under the terms of the Eclipse Public License 2.0
	* which accompanies this distribution, and is available at
	* https://www.eclipse.org/legal/epl-2.0/
	*
	* SPDX-License-Identifier: EPL-2.0
	*
	* Contributors:
	* Jesper Kamstrup Linnet (eclipse@kamstrup-linnet.dk) - initial API and implementation
	* (report 36180: Callers/Callees view)
	*******************************************************************************/
	package org.eclipse.jdt.ui.tests.callhierarchy;

	import java.util.ArrayList;
	import java.util.Arrays;
	import java.util.Collection;
	import java.util.List;

	import org.junit.Assert;

	import org.eclipse.jdt.testplugin.JavaProjectHelper;

	import org.eclipse.core.runtime.CoreException;

	import org.eclipse.core.resources.IMarker;
	import org.eclipse.core.resources.IResource;
	import org.eclipse.core.resources.IncrementalProjectBuilder;

	import org.eclipse.jdt.core.ICompilationUnit;
	import org.eclipse.jdt.core.IJavaElement;
	import org.eclipse.jdt.core.IJavaProject;
	import org.eclipse.jdt.core.IMember;
	import org.eclipse.jdt.core.IMethod;
	import org.eclipse.jdt.core.IPackageFragment;
	import org.eclipse.jdt.core.IPackageFragmentRoot;
	import org.eclipse.jdt.core.IType;

	import org.eclipse.jdt.internal.corext.callhierarchy.MethodWrapper;

	import org.eclipse.jdt.ui.tests.core.rules.Java17ProjectTestSetup;
	import org.eclipse.jdt.ui.tests.core.rules.ProjectTestSetup;

	@SuppressWarnings("javadoc")
	public class CallHierarchyTestHelper {
	private static final String[] EMPTY= new String[0];

	private IJavaProject fJavaProject1;
	private IJavaProject fJavaProject2;
	private IJavaProject fJavaProject3;
	private IType fType1;
	private IType fType2;
	private IType fTypeP;
	private IType fFooImplAType;
	private IType fFooImplBType;
	private IType fFooType;
	private IType fAbsType;
	private IType fAbsI1Type;
	private IType fAbsI2Type;
	private IPackageFragment fPack1;
	private IPackageFragment fPack2;
	private IPackageFragment fPack3;

	private IMethod fMethod1;
	private IMethod fMethod2;
	private IMethod fMethod3;
	private IMethod fMethod4;
	private IMethod fRecursiveMethod1;
	private IMethod fRecursiveMethod2;
	private IMethod fCalleeMethod;
	private IMethod fAbsCalleeMethod;
	private IMethod fFooMethod;
	private IMethod fFooImplMethod_A;
	private IMethod fFooImplMethod_B;
	private IMethod fAbsFooMethod;
	private IMethod fAbsI1FooMethod;
	private IMethod fAbsI2FooMethod;

	public void setUp() throws Exception {
	fJavaProject1= JavaProjectHelper.createJavaProject("TestProject1", "bin");
	fJavaProject2= JavaProjectHelper.createJavaProject("TestProject2", "bin");
	fJavaProject3= JavaProjectHelper.createJavaProject("TestProject3", "bin");
	assertBuildWithoutErrors(fJavaProject1);
	assertBuildWithoutErrors(fJavaProject2);
	assertBuildWithoutErrors(fJavaProject3);
	fType1= null;
	fType2= null;
	fTypeP= null;
	fFooImplAType= null;
	fFooImplBType= null;
	fAbsI1Type= null;
	fAbsI2Type= null;
	fAbsType= null;
	fFooType= null;
	fPack1= null;
	fPack2= null;
	fPack3= null;
	}

	public void tearDown() throws Exception {
	JavaProjectHelper.delete(fJavaProject1);
	JavaProjectHelper.delete(fJavaProject2);
	JavaProjectHelper.delete(fJavaProject3);
	}


	/**
	* Creates two simple classes, A and B. Sets the instance fields fType1 and fType2.
	*/
	public void createSimpleClasses() throws Exception {
	createPackages();


	ICompilationUnit cu1= fPack1.getCompilationUnit("A.java");

	fType1=
	cu1.createType(
	"public class A {\n" +
	"public A() {\n" +
	"}\n " +
	"public void method1() {\n" +
	"}\n " +
	"public void method2() {\n" +
	" method1();\n" +
	"}\n " +
	"public void recursiveMethod1() {\n" +
	" recursiveMethod2();\n " +
	"}\n " +
	"public void recursiveMethod2() {\n" +
	" recursiveMethod1();\n " +
	"}\n" +
	"}\n",
	null,
	true,
	null);

	ICompilationUnit cu2= fPack2.getCompilationUnit("B.java");
	fType2=
	cu2.createType(
	"public class B extends pack1.A {\npublic void method3() { method1(); method2(); }\n public void method4() { method3(); }\n}\n",
	null,
	true,
	null);

	assertBuildWithoutErrors(fJavaProject1);
	assertBuildWithoutErrors(fJavaProject2);
	}

	/**
	* Creates two simple classes, A and its subclass B, where B calls A's implicit constructor explicitly. Sets the instance fields fType1 and fType2.
	*/
	public void createImplicitConstructorClasses() throws Exception {
	createPackages();

	ICompilationUnit cu1= fPack1.getCompilationUnit("A.java");
	fType1=
	cu1.createType(
	"public class A {\n public void method1() { }\n public void method2() { method1(); }\n public void recursiveMethod1() { recursiveMethod2(); }\n public void recursiveMethod2() { recursiveMethod1(); }\n}\n",
	null,
	true,
	null);

	ICompilationUnit cu2= fPack2.getCompilationUnit("B.java");
	fType2=
	cu2.createType(
	"public class B extends pack1.A {\n public B(String name) { super(); }\n}\n",
	null,
	true,
	null);
	assertBuildWithoutErrors(fPack1);
	}

	/**
	* Creates an inner class and sets the class attribute fType1.
	*/
	public void createInnerClass() throws Exception {
	createPackages();

	ICompilationUnit cu1= fPack1.getCompilationUnit("Outer.java");
	fType1=
	cu1.createType(
	"public class Outer {\n" +
	"private Inner inner= new Inner();\n" +
	"class Inner { public void innerMethod1() { outerMethod1(); }\n public void innerMethod2() { innerMethod1(); }\n }\n" +
	"public void outerMethod1() { }\n public void outerMethod2() { inner.innerMethod2(); }\n" +
	"}",
	null,
	true,
	null);
	assertBuildWithoutErrors(fPack1);
	}

	/**
	* Creates an anonymous inner class and sets the class attribute fType1.
	*/
	public void createAnonymousInnerClass() throws Exception {
	createPackages();

	ICompilationUnit cu1= fPack1.getCompilationUnit("AnonymousInner.java");
	fType1=
	cu1.createType(
	"public class AnonymousInner {\n" +
	" Object anonClass = new Object() {\n" +
	" void anotherMethod() {\n" +
	" someMethod();\n" +
	" }\n" +
	" };\n" +
	" void someMethod() {\n" +
	" }\n" +
	"}\n",
	null,
	true,
	null);

	ICompilationUnit cu2= fPack2.getCompilationUnit("Outer.java");
	fType2=
	cu2.createType(
	"public class Outer {\n" +
	" interface Intf {\n" +
	" public void foo();\n" +
	" }\n" +
	" class Clazz {\n" +
	" public void foo() { };\n" +
	" }\n" +
	" public void anonymousOnInterface() {\n" +
	" new Intf() {\n"+
	" public void foo() {\n"+
	" someMethod();\n"+
	" }\n"+
	" };\n"+
	" }\n" +
	" public void anonymousOnClass() {\n" +
	" new Clazz() {\n"+
	" public void foo() {\n"+
	" someMethod();\n"+
	" }\n"+
	" };\n"+
	" }\n" +
	" public void someMethod() { }\n"+
	"}\n",
	null,
	true,
	null);
	assertBuildWithoutErrors(fPack1);
	}

	/**
	* Creates an anonymous inner class inside another method and sets the class attribute fType1.
	*/
	public void createAnonymousInnerClassInsideMethod() throws Exception {
	createPackages();

	ICompilationUnit cu1= fPack1.getCompilationUnit("AnonymousInnerInsideMethod.java");
	fType1=
	cu1.createType(
	"public class AnonymousInnerInsideMethod {\n" +
	" void m() {\n" +
	" System.out.println(\"before\");\n"+
	" Runnable runnable = new Runnable() {\n"+
	" public void run() {\n"+
	" System.out.println(\"run\");\n"+
	" }\n"+
	" };\n"+
	" runnable.run();\n"+
	" }\n"+
	"}\n",
	null,
	true,
	null);
	assertBuildWithoutErrors(fPack1);
	}

	/**
	* Creates a class with various lambda function definitions and calls
	*/
	public void createClassWithLambdaCalls() throws Exception {
	createPackages();

	ICompilationUnit cu= fPack1.getCompilationUnit("Snippet.java");
	fType1= cu.createType("public class Snippet {\n"
	+ " static Function<? super String, ? extends String> mapper1 = y -> transform(y);\n"
	+ " Function<? super String, ? extends String> mapper2 = y -> transform(y);\n"
	+ "\n"
	+ " static {\n"
	+ " mapper1 = y -> transform(y);\n"
	+ " }\n"
	+ "\n"
	+ " public Snippet() {\n"
	+ " mapper2 = y -> transform(y);\n"
	+ " }\n"
	+ "\n"
	+ " public static void main(String[] args) {\n"
	+ " mapper1 = y -> transform(y);\n"
	+ " }\n"
	+ "\n"
	+ " Object[] funcCall() {\n"
	+ " return List.of(\"aaa\").stream().map(y -> transform(y)).toArray();\n"
	+ " }\n"
	+ "\n"
	+ " static String transform(String s) {\n"
	+ " x();\n"
	+ " return s.toUpperCase();\n"
	+ " }\n"
	+ " static String x() {"
	+ " return null;\n"
	+ "}\n"
	+ "}",
	null,
	true,
	null);
	cu.createImport("java.util.List", fType1, null);
	cu.createImport("java.util.function.Function", fType1, null);
	fMethod1= fType1.getMethod("x", EMPTY);
	fMethod2= fType1.getMethod("transform", new String[] { "QString;" });
	Assert.assertNotNull(fMethod1);
	Assert.assertNotNull(fMethod2);
	assertBuildWithoutErrors(fPack1);
	}

	/**
	* Creates a class with a static initializer and sets the class attribute fType1.
	*/
	public void createStaticInitializerClass() throws Exception {
	createPackages();

	ICompilationUnit cu1= fPack1.getCompilationUnit("Initializer.java");
	fType1=
	cu1.createType(
	"public class Initializer { static { someMethod(); }\n public static void someMethod() { }\n }\n",
	null,
	true,
	null);
	assertBuildWithoutErrors(fPack1);
	}

	/**
	* Creates a record class, OneRecord and sets the instance field fType1.
	*/
	public void createRecordClasses() throws Exception {
	ProjectTestSetup projectsetup= new Java17ProjectTestSetup(false);
	fJavaProject3.setRawClasspath(projectsetup.getDefaultClasspath(), null);
	JavaProjectHelper.set17CompilerOptions(fJavaProject3, false);

	IPackageFragmentRoot fSourceFolder= JavaProjectHelper.addSourceContainer(fJavaProject3, "src");

	String MODULE_INFO_FILE_CONTENT = ""
	+ "module test {\n"
	+ "}\n";

	IPackageFragment def= fSourceFolder.createPackageFragment("", false, null);
	def.createCompilationUnit("module-info.java", MODULE_INFO_FILE_CONTENT, false, null);

	fPack3= fSourceFolder.createPackageFragment("test", false, null);

	JavaProjectHelper.set16CompilerOptions(fJavaProject1, true);

	ICompilationUnit cu1= fPack3.getCompilationUnit("Outer.java");

	fType1=
	cu1.createType(
	"public class Outer {\n" +
	"record OneRecord(int number1, int number2) {\n" +
	" OneRecord() { this(1, 2); }\n" +
	"}\n " +
	" public static void method1() {\n" +
	" new OneRecord(3, 5);\n" +
	" }\n" +
	" public static void method2() {\n" +
	" new OneRecord();\n" +
	" }\n" +
	" public static void method3() {\n" +
	" method1();\n" +
	" method2();\n" +
	" }\n" +
	"}\n",
	null,
	true,
	null);
	assertBuildWithoutErrors(fJavaProject3);
	}

	public void createCalleeClasses() throws Exception {
	createPackages();

	ICompilationUnit cu3= fPack2.getCompilationUnit("P.java");
	fTypeP=
	cu3.createType(
	"public class P {\n"
	+ " private A handler;\n"
	+ " private Abs absHandler;\n"
	+ "\n"
	+ " public void callFoo() {\n"
	+ " handler.foo();\n"
	+ " }\n"
	+ " public void callAbsFoo() {\n"
	+ " absHandler.absFoo();\n"
	+ " }\n"
	+ "\n"
	+ "}",
	null,
	true,
	null);

	ICompilationUnit cu4= fPack2.getCompilationUnit("A.java");
	fFooType= cu4.createType(
	"public interface A {\n"
	+ " void foo();\n"
	+ "}\n"
	, null, true, null);


	ICompilationUnit cu5= fPack2.getCompilationUnit("AImpl.java");
	fFooImplAType= cu5.createType(
	"public class AImpl implements A {\n"
	+ " public void foo() {\n"
	+ " System.out.println();\n"
	+ " }\n"
	+ "}\n"
	, null, true, null);

	ICompilationUnit cu6= fPack2.getCompilationUnit("BImpl.java");
	fFooImplBType= cu6.createType(
	"public class BImpl implements A {\n"
	+ " public void foo() {\n"
	+ " System.out.printf(\"\");\n"
	+ " }\n"
	+ "}\n"
	, null, true, null);


	ICompilationUnit cu7= fPack2.getCompilationUnit("Abs.java");
	fAbsType= cu7.createType(
	"public abstract class Abs {\n"
	+ " abstract void absFoo();\n"
	+ "}\n"
	, null, true, null);

	ICompilationUnit cu8= fPack2.getCompilationUnit("AbsI1.java");
	fAbsI1Type= cu8.createType(
	"public class AbsI1 extends Abs {\n"
	+ " void absFoo() {}\n"
	+ "}\n"
	, null, true, null);

	ICompilationUnit cu9= fPack2.getCompilationUnit("AbsI2.java");
	fAbsI2Type= cu9.createType(
	"public class AbsI2 extends Abs {\n"
	+ " void absFoo() {}\n"
	+ "}\n"
	, null, true, null);

	assertBuildWithoutErrors(fJavaProject1);
	assertBuildWithoutErrors(fJavaProject2);

	}

	/**
	* Creates two packages (pack1 and pack2) in different projects. Sets the
	* instance fields fPack1 and fPack2.
	*/
	public void createPackages() throws Exception {
	JavaProjectHelper.addRTJar9(fJavaProject1);

	IPackageFragmentRoot root1= JavaProjectHelper.addSourceContainer(fJavaProject1, "src");
	fPack1= root1.createPackageFragment("pack1", true, null);
	assertBuildWithoutErrors(fPack1);

	JavaProjectHelper.addRTJar9(fJavaProject2);
	JavaProjectHelper.addRequiredProject(fJavaProject2, fJavaProject1);

	IPackageFragmentRoot root2= JavaProjectHelper.addSourceContainer(fJavaProject2, "src");
	fPack2= root2.createPackageFragment("pack2", true, null);
	assertBuildWithoutErrors(fPack2);
	}

	/**
	* Returns all error markers on given resource, recursively
	*/
	public List<IMarker> getErrorMarkers(IResource resource) throws CoreException {
	IMarker[] markers = resource.findMarkers(null, true, IResource.DEPTH_INFINITE);
	List<IMarker> errorMarkers = new ArrayList<>();
	for (IMarker marker : markers) {
	if (marker.getAttribute(IMarker.SEVERITY, IMarker.SEVERITY_INFO) == IMarker.SEVERITY_ERROR) {
	errorMarkers.add(marker);
	}
	}
	return errorMarkers;
	}

	public static List<String> convertMarkers(IMarker [] markers) throws Exception {
	List<String> result = new ArrayList<>();
	for (int i = 0; i < markers.length; i++) {
	IMarker marker = markers[i];
	StringBuilder sb = new StringBuilder("Marker #");
	sb.append(i).append("[");
	sb.append(marker.getAttribute("message", null));
	sb.append(" at line: ").append(marker.getAttribute("lineNumber", 0));
	sb.append("], ");
	result.add(sb.toString());
	}
	return result;
	}

	/**
	* Verifies that no error markers exist in the given resource.
	* <p>
	*
	* @param element
	* The resource that is searched for error markers
	*/
	protected void assertBuildWithoutErrors(IJavaElement element) throws Exception {
	IResource resource= element.getResource();
	Assert.assertNotNull("Given element has no resource: " + element, resource);
	resource.getProject().build(IncrementalProjectBuilder.FULL_BUILD, null);
	assertNoErrorMarkers(resource);
	}

	/**
	* Verifies that no error markers exist in the given resource.
	* <p>
	*
	* @param resource
	* The resource that is searched for error markers
	*/
	protected void assertNoErrorMarkers(IResource resource) throws Exception {
	List<IMarker> errorMarkers = getErrorMarkers(resource);
	List<String> messages = convertMarkers(errorMarkers.toArray(new IMarker[errorMarkers.size()]));
	Assert.assertEquals("No error marker expected, but found markers with messages: " + messages.toString(), 0,
	errorMarkers.size());
	}

	/**
	* Asserts that all the expected methods were found in the call results.
	*/
	public void assertCalls(Collection<IMember> expectedMembers, Collection<?> calls) {
	Collection<IMember> foundMembers= new ArrayList<>();

	for (MethodWrapper element : (Collection<MethodWrapper>)calls) {
	foundMembers.add(element.getMember());
	}

	Assert.assertEquals("Wrong number of calls", expectedMembers.size(), calls.size());
	Assert.assertTrue("One or more members not found", foundMembers.containsAll(expectedMembers));
	}

	/**
	* Asserts that all the expected methods were found in the call results.
	*/
	public void assertCalls(Collection<IMember> expectedMembers, MethodWrapper[] callResults) {
	assertCalls(expectedMembers, Arrays.asList(callResults));
	}

	/**
	* Asserts that all the expected methods were found in the call results.
	*/
	public void assertCalls(IMember[] expectedMembers, Object[] callResults) {
	assertCalls(Arrays.asList(expectedMembers), Arrays.asList(callResults));
	}

	public MethodWrapper findMethodWrapper(IMethod method, Object[] methodWrappers) {
	MethodWrapper thirdLevelMethodWrapper= null;
	for (Object methodWrapper : methodWrappers) {
	if (method.equals(((MethodWrapper) methodWrapper).getMember())) {
	thirdLevelMethodWrapper= (MethodWrapper) methodWrapper;
	break;
	}
	}
	return thirdLevelMethodWrapper;
	}

	/**
	* @return
	*/
	public IJavaProject getJavaProject2() {
	return fJavaProject2;
	}

	/**
	* @return
	*/
	public IPackageFragment getPackage1() {
	return fPack1;
	}

	/**
	* @return
	*/
	public IPackageFragment getPackage2() {
	return fPack2;
	}

	/**
	* @return
	*/
	public IType getType1() {
	return fType1;
	}

	/**
	* @return
	*/
	public IType getType2() {
	return fType2;
	}

	public IType getTypeP() {
	return fTypeP;
	}

	public IType getFooImplAType() {
	return fFooImplAType;
	}

	public IType getFooImplBType() {
	return fFooImplBType;
	}

	public IType getFooType() {
	return fFooType;
	}

	public IType getAbsType() {
	return fAbsType;
	}

	public IType getAbsI1Type() {
	return fAbsI1Type;
	}

	public IType getAbsI2Type() {
	return fAbsI2Type;
	}

	public IMethod getMethod1() {
	if (fMethod1 == null) {
	fMethod1= getType1().getMethod("method1", EMPTY);
	}
	return fMethod1;
	}

	public IMethod getMethod2() {
	if (fMethod2 == null) {
	fMethod2= getType1().getMethod("method2", EMPTY);
	}
	return fMethod2;
	}

	public IMethod getMethod3() {
	if (fMethod3 == null) {
	fMethod3= getType2().getMethod("method3", EMPTY);
	}
	return fMethod3;
	}

	public IMethod getMethod4() {
	if (fMethod4 == null) {
	fMethod4= getType2().getMethod("method4", EMPTY);
	}
	return fMethod4;
	}

	public IMethod getRecursiveMethod1() {
	if (fRecursiveMethod1 == null) {
	fRecursiveMethod1= getType1().getMethod("recursiveMethod1", EMPTY);
	}
	return fRecursiveMethod1;
	}

	public IMethod getRecursiveMethod2() {
	if (fRecursiveMethod2 == null) {
	fRecursiveMethod2= getType1().getMethod("recursiveMethod2", EMPTY);
	}
	return fRecursiveMethod2;
	}

	public IMethod getCalleeMethod() {
	if (fCalleeMethod == null) {
	fCalleeMethod= getTypeP().getMethod("callFoo", EMPTY);
	}
	return fCalleeMethod;
	}

	public IMethod getAbsCalleeMethod() {
	if (fAbsCalleeMethod == null) {
	fAbsCalleeMethod= getTypeP().getMethod("callAbsFoo", EMPTY);
	}
	return fAbsCalleeMethod;
	}

	public IMethod getFooImplMethod_A() {
	if (fFooImplMethod_A == null) {
	fFooImplMethod_A= getFooImplAType().getMethod("foo", EMPTY);
	}
	return fFooImplMethod_A;
	}

	public IMethod getFooImplMethod_B() {
	if (fFooImplMethod_B == null) {
	fFooImplMethod_B= getFooImplBType().getMethod("foo", EMPTY);
	}
	return fFooImplMethod_B;
	}

	public IMethod getFooMethod() {
	if (fFooMethod == null) {
	fFooMethod= getFooType().getMethod("foo", EMPTY);
	}
	return fFooMethod;
	}

	public IMethod getAbsFooMethod() {
	if (fAbsFooMethod == null) {
	fAbsFooMethod= getAbsType().getMethod("absFoo", EMPTY);
	}
	return fAbsFooMethod;
	}

	public IMethod getAbsI1FooMethod() {
	if (fAbsI1FooMethod == null) {
	fAbsI1FooMethod= getAbsI1Type().getMethod("absFoo", EMPTY);
	}
	return fAbsI1FooMethod;
	}

	public IMethod getAbsI2FooMethod() {
	if (fAbsI2FooMethod == null) {
	fAbsI2FooMethod= getAbsI2Type().getMethod("absFoo", EMPTY);
	}
	return fAbsI2FooMethod;
	}
	}