diff options
Diffstat (limited to 'test/eclipse/src/lombok')
10 files changed, 598 insertions, 0 deletions
diff --git a/test/eclipse/src/lombok/eclipse/EclipseRunner.java b/test/eclipse/src/lombok/eclipse/EclipseRunner.java new file mode 100644 index 00000000..1e1c17fe --- /dev/null +++ b/test/eclipse/src/lombok/eclipse/EclipseRunner.java @@ -0,0 +1,154 @@ +package lombok.eclipse; + +import java.io.File; +import java.util.Arrays; +import java.util.HashMap; +import java.util.HashSet; +import java.util.List; +import java.util.Map; +import java.util.Set; + +import org.eclipse.core.runtime.adaptor.EclipseStarter; +import org.eclipse.osgi.container.Module; +import org.eclipse.osgi.container.Module.StartOptions; +import org.eclipse.osgi.container.Module.State; +import org.eclipse.osgi.internal.location.EquinoxLocations; +import org.junit.runner.Description; +import org.junit.runner.Runner; +import org.junit.runner.notification.RunNotifier; +import org.junit.runners.BlockJUnit4ClassRunner; +import org.junit.runners.model.InitializationError; +import org.osgi.framework.Bundle; +import org.osgi.framework.BundleContext; +import org.osgi.framework.BundleException; +import org.osgi.framework.wiring.BundleRevision; +import org.osgi.framework.wiring.BundleWire; +import org.osgi.framework.wiring.BundleWiring; + +/** + * We have to load the osgi/eclipse classes before we run the test case. This is only possible using a custom runner. + * + */ +public class EclipseRunner extends Runner { + private Runner runner; + private boolean debug = false; + private static boolean setupDone; + + public EclipseRunner(Class<?> klass) throws InitializationError { + try { + if (!setupDone) { + debug = System.getProperty("lombok.debug") != null; + startEclipse(System.getProperty("lombok.testenv")); + setupDone = true; + } + } catch (Throwable e) { + throw new InitializationError(e); + } + + runner = new BlockJUnit4ClassRunner(klass); + + } + + @Override + public Description getDescription() { + return runner.getDescription(); + } + + @Override + public void run(RunNotifier notifier) { + runner.run(notifier); + } + + private void startEclipse(String path) throws Exception { + Map<String, String> initialProperties = new HashMap<String, String>(); + + File rootDir = new File(path); + File pluginDir = new File(rootDir, "plugins/"); + + StringBuilder bundleString = new StringBuilder(); + String osgiPlugin = null; + File[] bundles = pluginDir.listFiles(); + Arrays.sort(bundles); + for (File plugin : bundles) { + String fileName = plugin.getName(); + String bundleName = fileName.substring(0, fileName.indexOf("_")); + + if (bundleName.equals("org.eclipse.osgi")) { + osgiPlugin = plugin.toURI().toString(); + } + + if (bundleString.length() > 0) { + bundleString.append(","); + } + bundleString.append(bundleName); + } + + initialProperties.put(EclipseStarter.PROP_BUNDLES, bundleString.toString()); + initialProperties.put(EclipseStarter.PROP_INSTALL_AREA, "file:" + path); + initialProperties.put(EquinoxLocations.PROP_INSTANCE_AREA, "file:" + path); + initialProperties.put(EclipseStarter.PROP_FRAMEWORK, osgiPlugin); + initialProperties.put("osgi.framework.useSystemProperties", "false"); + initialProperties.put(EclipseStarter.PROP_NOSHUTDOWN, "false"); + + initialProperties.put("osgi.parentClassloader", "fwk"); + initialProperties.put("osgi.frameworkParentClassloader", "fwk"); + initialProperties.put("osgi.contextClassLoaderParent", "ext"); + initialProperties.put("osgi.context.bootdelegation", "*"); + initialProperties.put("org.osgi.framework.bootdelegation", "*"); + + EclipseStarter.setInitialProperties(initialProperties); + String[] args = new String[] {"-clean"}; + if (debug) args = new String[] {"-clean", "-console", "-consoleLog", "-debug"}; + BundleContext context = EclipseStarter.startup(args, null); + + Map<String, Module> moduleMap = new HashMap<String, Module>(); + for (Bundle b : context.getBundles()) { + Module module = b.adapt(Module.class); + moduleMap.put(b.getSymbolicName(), module); + } + + Set<String> startedBundles = new HashSet<String>(); + // Mark the debug bundle as started, it will fail anyway... + startedBundles.add("org.eclipse.debug.ui"); + + startBundle(moduleMap, startedBundles, "org.apache.felix.scr"); + startBundle(moduleMap, startedBundles, "org.eclipse.jdt.core.manipulation"); + startBundle(moduleMap, startedBundles, "org.eclipse.jdt.ui"); + + if (debug) { + for (Bundle b : context.getBundles()) { + System.out.println("BUNDLE: " + b.getSymbolicName() + " " + b.getVersion() + " " + b.getLocation() + " " + b.getState()); + } + } + } + + private void startBundle(Map<String, Module> moduleMap, Set<String> started, String bundle) throws BundleException { + if (started.contains(bundle)) return; + + Module module = moduleMap.get(bundle); + started.add(bundle); + + BundleWiring wiring = module.getBundle().adapt(BundleWiring.class); + List<BundleWire> requiredWires = wiring.getRequiredWires(BundleRevision.PACKAGE_NAMESPACE); + requiredWires.addAll(wiring.getRequiredWires(BundleRevision.BUNDLE_NAMESPACE)); + + for (BundleWire bundleWire : requiredWires) { + startBundle(moduleMap, started, bundleWire.getProvider().getSymbolicName()); + } + + startModule(module); + } + + private void startModule(Module module) throws BundleException { + if (module.getState() == State.LAZY_STARTING || module.getState() == State.RESOLVED) { + if (debug) System.out.print("Starting bundle " + module.getBundle().getSymbolicName() + "..."); + try { + module.start(StartOptions.LAZY_TRIGGER); + if (debug) System.out.println(" [done]"); + } catch (Exception e) { + if (debug) System.out.println(" [error]"); + e.printStackTrace(); + } + } + } +} diff --git a/test/eclipse/src/lombok/eclipse/EclipseTests.java b/test/eclipse/src/lombok/eclipse/EclipseTests.java new file mode 100644 index 00000000..ba017fd2 --- /dev/null +++ b/test/eclipse/src/lombok/eclipse/EclipseTests.java @@ -0,0 +1,16 @@ +package lombok.eclipse; + +import org.junit.runner.RunWith; +import org.junit.runners.Suite; +import org.junit.runners.Suite.SuiteClasses; + +import lombok.eclipse.cleanup.CleanupTest; +import lombok.eclipse.edit.SelectTest; +import lombok.eclipse.refactoring.ExtractInterfaceTest; +import lombok.eclipse.refactoring.RenameTest; + +@RunWith(Suite.class) +@SuiteClasses({ExtractInterfaceTest.class, RenameTest.class, SelectTest.class, CleanupTest.class}) +public class EclipseTests { + +} diff --git a/test/eclipse/src/lombok/eclipse/RefactoringUtils.java b/test/eclipse/src/lombok/eclipse/RefactoringUtils.java new file mode 100644 index 00000000..38349d2d --- /dev/null +++ b/test/eclipse/src/lombok/eclipse/RefactoringUtils.java @@ -0,0 +1,30 @@ +package lombok.eclipse; + +import static org.junit.Assert.assertTrue; + +import org.eclipse.core.resources.ResourcesPlugin; +import org.eclipse.core.runtime.CoreException; +import org.eclipse.ltk.core.refactoring.CheckConditionsOperation; +import org.eclipse.ltk.core.refactoring.CreateChangeOperation; +import org.eclipse.ltk.core.refactoring.PerformChangeOperation; +import org.eclipse.ltk.core.refactoring.Refactoring; +import org.eclipse.ltk.core.refactoring.RefactoringStatus; +import org.eclipse.ltk.core.refactoring.participants.ProcessorBasedRefactoring; +import org.eclipse.ltk.core.refactoring.participants.RefactoringProcessor; + +public class RefactoringUtils { + public static void performRefactoring(RefactoringProcessor proccessor) throws CoreException { + performRefactoring(new ProcessorBasedRefactoring(proccessor)); + } + + public static void performRefactoring(Refactoring refactoring) throws CoreException { + CheckConditionsOperation checkConditionsOperation = new CheckConditionsOperation(refactoring, CheckConditionsOperation.ALL_CONDITIONS); + CreateChangeOperation change = new CreateChangeOperation(checkConditionsOperation, RefactoringStatus.FATAL); + final PerformChangeOperation perform = new PerformChangeOperation(change); + + ResourcesPlugin.getWorkspace().run(perform, null); + + assertTrue("Condition failed", change.getConditionCheckingStatus().isOK()); + assertTrue("Perform failed", perform.changeExecuted()); + } +} diff --git a/test/eclipse/src/lombok/eclipse/SetupBeforeAfterTest.java b/test/eclipse/src/lombok/eclipse/SetupBeforeAfterTest.java new file mode 100644 index 00000000..96e21d4b --- /dev/null +++ b/test/eclipse/src/lombok/eclipse/SetupBeforeAfterTest.java @@ -0,0 +1,52 @@ +package lombok.eclipse; + +import static org.junit.Assert.assertEquals; + +import java.io.File; +import java.io.FileNotFoundException; + +import org.eclipse.jdt.core.ICompilationUnit; +import org.eclipse.jdt.core.JavaModelException; +import org.junit.runner.Description; + +public class SetupBeforeAfterTest extends SetupTest { + + private File before; + private File after; + + @Override + protected void starting(Description description) { + super.starting(description); + + before = new File(root, "/before/"); + after = new File(root, "/after/"); + + try { + copyBeforeFiles(); + } catch (Throwable e) { + throw new RuntimeException(e); + } + } + + @Override + protected void succeeded(Description description) { + try { + compareWithAfter(); + } catch (Throwable e) { + throw new RuntimeException(e); + } + } + + private void compareWithAfter() throws FileNotFoundException, JavaModelException { + for (ICompilationUnit result : packageFragment.getCompilationUnits()) { + assertEquals(getContent(new File(after, result.getElementName())), result.getSource()); + } + } + + void copyBeforeFiles() throws JavaModelException, FileNotFoundException { + for (File file : before.listFiles()) { + createCompilationUnit(file, packageFragment); + } + + } +} diff --git a/test/eclipse/src/lombok/eclipse/SetupSingleFileTest.java b/test/eclipse/src/lombok/eclipse/SetupSingleFileTest.java new file mode 100644 index 00000000..47010f0c --- /dev/null +++ b/test/eclipse/src/lombok/eclipse/SetupSingleFileTest.java @@ -0,0 +1,28 @@ +package lombok.eclipse; + +import java.io.File; +import java.io.FileNotFoundException; + +import org.eclipse.jdt.core.JavaModelException; +import org.junit.runner.Description; + +public class SetupSingleFileTest extends SetupTest { + + @Override + protected void starting(Description description) { + super.starting(description); + + try { + copyRootFiles(); + } catch (Exception e) { + throw new RuntimeException(e); + } + } + + private void copyRootFiles() throws JavaModelException, FileNotFoundException { + for (File file : root.listFiles()) { + createCompilationUnit(file, packageFragment); + } + + } +} diff --git a/test/eclipse/src/lombok/eclipse/SetupTest.java b/test/eclipse/src/lombok/eclipse/SetupTest.java new file mode 100644 index 00000000..fe8d469c --- /dev/null +++ b/test/eclipse/src/lombok/eclipse/SetupTest.java @@ -0,0 +1,107 @@ +package lombok.eclipse; + +import java.io.File; +import java.io.FileNotFoundException; +import java.util.Scanner; + +import org.eclipse.core.resources.IFolder; +import org.eclipse.core.resources.IProject; +import org.eclipse.core.resources.IProjectDescription; +import org.eclipse.core.resources.IWorkspace; +import org.eclipse.core.resources.IWorkspaceRoot; +import org.eclipse.core.resources.ResourcesPlugin; +import org.eclipse.core.runtime.CoreException; +import org.eclipse.core.runtime.Path; +import org.eclipse.jdt.core.IClasspathEntry; +import org.eclipse.jdt.core.ICompilationUnit; +import org.eclipse.jdt.core.IJavaProject; +import org.eclipse.jdt.core.IPackageFragment; +import org.eclipse.jdt.core.JavaCore; +import org.eclipse.jdt.core.JavaModelException; +import org.junit.rules.TestWatcher; +import org.junit.runner.Description; + +public abstract class SetupTest extends TestWatcher { + + private IJavaProject javaProject; + protected IPackageFragment packageFragment; + private IWorkspace workspace; + protected File root; + + public IJavaProject getJavaProject() { + return javaProject; + } + + public IPackageFragment getPackageFragment() { + return packageFragment; + } + + public IWorkspace getWorkspace() { + return workspace; + } + + @Override + protected void starting(Description description) { + String category = description.getTestClass().getSimpleName().toLowerCase().replaceAll("test$", ""); + String testname = description.getMethodName(); + + root = new File("test/eclipse/resource/" + category + "/" + testname); + + try { + createProject(category, description.getMethodName()); + } catch (Exception e) { + throw new RuntimeException(e); + } + } + + private void createProject(String category, String test) throws CoreException { + workspace = ResourcesPlugin.getWorkspace(); + + IWorkspaceRoot root = getWorkspace().getRoot(); + IProject project = root.getProject(category + "_" + test); + + if (project.exists()) { + project.delete(true, true, null); + } + project.create(null); + project.open(null); + + IFolder targetFolder = createFolder(project, "target"); + IFolder srcFolder = createFolder(project, "src"); + + IProjectDescription description = project.getDescription(); + description.setNatureIds(new String[] {JavaCore.NATURE_ID}); + project.setDescription(description, null); + + javaProject = JavaCore.create(project); + javaProject.setOutputLocation(targetFolder.getFullPath(), null); + JavaCore.setComplianceOptions(JavaCore.VERSION_1_8, javaProject.getOptions(false)); + + IClasspathEntry classpathEntry = JavaCore.newSourceEntry(srcFolder.getFullPath()); + IClasspathEntry newLibraryEntry = JavaCore.newLibraryEntry(new Path(new File("dist/lombok.jar").getAbsolutePath()), null, null); + IClasspathEntry javaRtEntry = JavaCore.newLibraryEntry(new Path(new File("lib/rtstubs18.jar").getAbsolutePath()), null, null); + javaProject.setRawClasspath(new IClasspathEntry[] {classpathEntry, newLibraryEntry, javaRtEntry}, null); + + packageFragment = javaProject.getPackageFragmentRoot(srcFolder).createPackageFragment("pkg", false, null); + } + + protected IFolder createFolder(IProject project, String name) throws CoreException { + IFolder folder = project.getFolder(name); + if (folder.exists()) { + folder.delete(true, null); + } + folder.create(false, true, null); + return folder; + } + + protected ICompilationUnit createCompilationUnit(File file, IPackageFragment pkg) throws JavaModelException, FileNotFoundException { + return pkg.createCompilationUnit(file.getName(), getContent(file), true, null); + } + + protected String getContent(File f) throws FileNotFoundException { + Scanner scanner = new Scanner(f); + String text = scanner.useDelimiter("\\A").next(); + scanner.close(); + return text; + } +}
\ No newline at end of file diff --git a/test/eclipse/src/lombok/eclipse/cleanup/CleanupTest.java b/test/eclipse/src/lombok/eclipse/cleanup/CleanupTest.java new file mode 100644 index 00000000..2d018228 --- /dev/null +++ b/test/eclipse/src/lombok/eclipse/cleanup/CleanupTest.java @@ -0,0 +1,45 @@ +package lombok.eclipse.cleanup; + +import static lombok.eclipse.RefactoringUtils.performRefactoring; + +import java.util.Map.Entry; + +import org.eclipse.jdt.core.ICompilationUnit; +import org.eclipse.jdt.internal.corext.fix.CleanUpConstants; +import org.eclipse.jdt.internal.corext.fix.CleanUpRefactoring; +import org.eclipse.jdt.internal.corext.fix.CleanUpRegistry; +import org.eclipse.jdt.internal.ui.JavaPlugin; +import org.eclipse.jdt.internal.ui.fix.CodeStyleCleanUp; +import org.eclipse.jdt.internal.ui.fix.MapCleanUpOptions; +import org.junit.Rule; +import org.junit.Test; +import org.junit.runner.RunWith; + +import lombok.eclipse.EclipseRunner; +import lombok.eclipse.SetupBeforeAfterTest; + +@RunWith(EclipseRunner.class) +public class CleanupTest { + + @Rule + public SetupBeforeAfterTest setup = new SetupBeforeAfterTest(); + + @Test + public void useThis() throws Exception { + ICompilationUnit cu = setup.getPackageFragment().getCompilationUnit("A.java"); + + CleanUpRegistry cleanUpRegistry = JavaPlugin.getDefault().getCleanUpRegistry(); + MapCleanUpOptions options = cleanUpRegistry.getDefaultOptions(CleanUpConstants.DEFAULT_CLEAN_UP_OPTIONS); + for (Entry<String, String> entry : options.getMap().entrySet()) { + entry.setValue(MapCleanUpOptions.FALSE); + } + options.setOption(CleanUpConstants.MEMBER_ACCESSES_NON_STATIC_FIELD_USE_THIS, MapCleanUpOptions.TRUE); + options.setOption(CleanUpConstants.MEMBER_ACCESSES_NON_STATIC_FIELD_USE_THIS_ALWAYS, MapCleanUpOptions.TRUE); + + CleanUpRefactoring ref = new CleanUpRefactoring(); + ref.addCompilationUnit(cu); + ref.addCleanUp(new CodeStyleCleanUp(options.getMap())); + + performRefactoring(ref); + } +} diff --git a/test/eclipse/src/lombok/eclipse/edit/SelectTest.java b/test/eclipse/src/lombok/eclipse/edit/SelectTest.java new file mode 100644 index 00000000..9f348a0c --- /dev/null +++ b/test/eclipse/src/lombok/eclipse/edit/SelectTest.java @@ -0,0 +1,48 @@ +package lombok.eclipse.edit; + +import static org.junit.Assert.assertEquals; + +import org.eclipse.jdt.core.ICompilationUnit; +import org.eclipse.jdt.core.IField; +import org.eclipse.jdt.core.IJavaElement; +import org.eclipse.jdt.core.ISourceRange; +import org.eclipse.jdt.core.IType; +import org.junit.Rule; +import org.junit.Test; +import org.junit.runner.RunWith; + +import lombok.eclipse.EclipseRunner; +import lombok.eclipse.SetupSingleFileTest; + +@RunWith(EclipseRunner.class) +public class SelectTest { + + @Rule + public SetupSingleFileTest setup = new SetupSingleFileTest(); + + @Test + public void builderField() throws Exception { + ICompilationUnit cu = setup.getPackageFragment().getCompilationUnit("A.java"); + IType type = cu.findPrimaryType(); + IField field = type.getField("id"); + + ISourceRange sourceRange = field.getNameRange(); + IJavaElement[] codeSelect = cu.codeSelect(sourceRange.getOffset(), sourceRange.getLength()); + + assertEquals(1, codeSelect.length); + assertEquals(field, codeSelect[0]); + } + + @Test + public void superbuilderField() throws Exception { + ICompilationUnit cu = setup.getPackageFragment().getCompilationUnit("A.java"); + IType type = cu.findPrimaryType(); + IField field = type.getField("id"); + + ISourceRange sourceRange = field.getNameRange(); + IJavaElement[] codeSelect = cu.codeSelect(sourceRange.getOffset(), sourceRange.getLength()); + + assertEquals(1, codeSelect.length); + assertEquals(field, codeSelect[0]); + } +} diff --git a/test/eclipse/src/lombok/eclipse/refactoring/ExtractInterfaceTest.java b/test/eclipse/src/lombok/eclipse/refactoring/ExtractInterfaceTest.java new file mode 100644 index 00000000..d4c892f3 --- /dev/null +++ b/test/eclipse/src/lombok/eclipse/refactoring/ExtractInterfaceTest.java @@ -0,0 +1,47 @@ +package lombok.eclipse.refactoring; + +import static lombok.eclipse.RefactoringUtils.performRefactoring; + +import org.eclipse.jdt.core.ICompilationUnit; +import org.eclipse.jdt.core.IType; +import org.eclipse.jdt.internal.corext.refactoring.structure.ExtractInterfaceProcessor; +import org.eclipse.jdt.internal.ui.preferences.JavaPreferencesSettings; +import org.junit.Rule; +import org.junit.Test; +import org.junit.runner.RunWith; + +import lombok.eclipse.EclipseRunner; +import lombok.eclipse.SetupBeforeAfterTest; + +@RunWith(EclipseRunner.class) +public class ExtractInterfaceTest { + + @Rule + public SetupBeforeAfterTest setup = new SetupBeforeAfterTest(); + + @Test + public void simple() throws Exception { + ICompilationUnit cu = setup.getPackageFragment().getCompilationUnit("A.java"); + IType type = cu.findPrimaryType(); + + ExtractInterfaceProcessor extractInterfaceProcessor = new ExtractInterfaceProcessor(type, JavaPreferencesSettings.getCodeGenerationSettings(setup.getJavaProject())); + extractInterfaceProcessor.setExtractedMembers(type.getMethods()); + extractInterfaceProcessor.setTypeName("Interface"); + + performRefactoring(extractInterfaceProcessor); + } + + @Test + public void usage() throws Exception { + ICompilationUnit cu = setup.getPackageFragment().getCompilationUnit("A.java"); + IType type = cu.findPrimaryType(); + + ExtractInterfaceProcessor extractInterfaceProcessor = new ExtractInterfaceProcessor(type, JavaPreferencesSettings.getCodeGenerationSettings(setup.getJavaProject())); + extractInterfaceProcessor.setExtractedMembers(type.getMethods()); + extractInterfaceProcessor.setTypeName("Interface"); + extractInterfaceProcessor.setReplace(true); + + performRefactoring(extractInterfaceProcessor); + } + +} diff --git a/test/eclipse/src/lombok/eclipse/refactoring/RenameTest.java b/test/eclipse/src/lombok/eclipse/refactoring/RenameTest.java new file mode 100644 index 00000000..c1a86736 --- /dev/null +++ b/test/eclipse/src/lombok/eclipse/refactoring/RenameTest.java @@ -0,0 +1,71 @@ +package lombok.eclipse.refactoring; + +import static lombok.eclipse.RefactoringUtils.performRefactoring; + +import org.eclipse.jdt.core.ICompilationUnit; +import org.eclipse.jdt.core.IField; +import org.eclipse.jdt.core.IType; +import org.eclipse.jdt.internal.corext.refactoring.rename.RenameFieldProcessor; +import org.junit.Rule; +import org.junit.Test; +import org.junit.runner.RunWith; + +import lombok.eclipse.EclipseRunner; +import lombok.eclipse.SetupBeforeAfterTest; + +@RunWith(EclipseRunner.class) +public class RenameTest { + + @Rule + public SetupBeforeAfterTest setup = new SetupBeforeAfterTest(); + + @Test + public void simple() throws Exception { + ICompilationUnit cu = setup.getPackageFragment().getCompilationUnit("A.java"); + IType type = cu.findPrimaryType(); + IField field = type.getField("string"); + + RenameFieldProcessor renameFieldProcessor = new RenameFieldProcessor(field); + renameFieldProcessor.setNewElementName("newString"); + + performRefactoring(renameFieldProcessor); + } + + @Test + public void withGetter() throws Exception { + ICompilationUnit cu = setup.getPackageFragment().getCompilationUnit("A.java"); + IType type = cu.findPrimaryType(); + IField field = type.getField("string"); + + RenameFieldProcessor renameFieldProcessor = new RenameFieldProcessor(field); + renameFieldProcessor.setNewElementName("newString"); + renameFieldProcessor.setRenameGetter(true); + + performRefactoring(renameFieldProcessor); + } + + @Test + public void withGetterDifferentFile() throws Exception { + ICompilationUnit cu = setup.getPackageFragment().getCompilationUnit("A.java"); + IType type = cu.findPrimaryType(); + IField field = type.getField("string"); + + RenameFieldProcessor renameFieldProcessor = new RenameFieldProcessor(field); + renameFieldProcessor.setNewElementName("newString"); + renameFieldProcessor.setRenameGetter(true); + + performRefactoring(renameFieldProcessor); + } + + @Test + public void builderField() throws Exception { + ICompilationUnit cu = setup.getPackageFragment().getCompilationUnit("A.java"); + IType type = cu.findPrimaryType(); + IField field = type.getField("string"); + + RenameFieldProcessor renameFieldProcessor = new RenameFieldProcessor(field); + renameFieldProcessor.setNewElementName("newString"); + + performRefactoring(renameFieldProcessor); + } +} |