Add support for eclipse feature tests

test/eclipse/resource/cleanup/useThis/after/A.java

@@ -0,0 +1,18 @@
+package pkg;
+
+import lombok.Builder;
+import lombok.Data;
+import lombok.With;
+import lombok.experimental.WithBy;
+
+@Data
+@Builder
+@With
+@WithBy
+public class A {
+	private String string;
+	
+	public void a() {
+		this.string = "a";
+	}
+}

test/eclipse/resource/cleanup/useThis/before/A.java

@@ -0,0 +1,18 @@
+package pkg;
+
+import lombok.Builder;
+import lombok.Data;
+import lombok.With;
+import lombok.experimental.WithBy;
+
+@Data
+@Builder
+@With
+@WithBy
+public class A {
+	private String string;
+	
+	public void a() {
+		string = "a";
+	}
+}

test/eclipse/resource/extractinterface/simple/after/A.java

@@ -0,0 +1,15 @@
+package pkg;
+
+import lombok.EqualsAndHashCode;
+import lombok.Getter;
+import lombok.Setter;
+import lombok.ToString;
+
+@EqualsAndHashCode
+@Getter
+@Setter
+@ToString
+public class A implements Interface {
+	private String string;
+	private int integer;
+}

test/eclipse/resource/extractinterface/simple/after/Interface.java

@@ -0,0 +1,21 @@
+package pkg;
+
+public interface Interface {
+
+	boolean equals(java.lang.Object o);
+
+	boolean canEqual(java.lang.Object other);
+
+	int hashCode();
+
+	String getString();
+
+	int getInteger();
+
+	void setString(String string);
+
+	void setInteger(int integer);
+
+	java.lang.String toString();
+
+}

test/eclipse/resource/extractinterface/simple/before/A.java

@@ -0,0 +1,15 @@
+package pkg;
+
+import lombok.EqualsAndHashCode;
+import lombok.Getter;
+import lombok.Setter;
+import lombok.ToString;
+
+@EqualsAndHashCode
+@Getter
+@Setter
+@ToString
+public class A {
+	private String string;
+	private int integer;
+}

test/eclipse/resource/extractinterface/usage/after/A.java

@@ -0,0 +1,15 @@
+package pkg;
+
+import lombok.EqualsAndHashCode;
+import lombok.Getter;
+import lombok.Setter;
+import lombok.ToString;
+
+@EqualsAndHashCode
+@Getter
+@Setter
+@ToString
+public class A implements Interface {
+	private String string;
+	private int integer;
+}

test/eclipse/resource/extractinterface/usage/after/B.java

@@ -0,0 +1,12 @@
+package pkg;
+
+import lombok.Getter;
+import lombok.Setter;
+
+@Getter
+@Setter
+public class B {
+	private Interface a = new A();
+	private String string = a.getString();
+	private int integer = a.getInteger();
+}

test/eclipse/resource/extractinterface/usage/after/Interface.java

@@ -0,0 +1,21 @@
+package pkg;
+
+public interface Interface {
+
+	boolean equals(java.lang.Object o);
+
+	boolean canEqual(java.lang.Object other);
+
+	int hashCode();
+
+	String getString();
+
+	int getInteger();
+
+	void setString(String string);
+
+	void setInteger(int integer);
+
+	java.lang.String toString();
+
+}

test/eclipse/resource/extractinterface/usage/before/A.java

@@ -0,0 +1,15 @@
+package pkg;
+
+import lombok.EqualsAndHashCode;
+import lombok.Getter;
+import lombok.Setter;
+import lombok.ToString;
+
+@EqualsAndHashCode
+@Getter
+@Setter
+@ToString
+public class A {
+	private String string;
+	private int integer;
+}

test/eclipse/resource/extractinterface/usage/before/B.java

@@ -0,0 +1,12 @@
+package pkg;
+
+import lombok.Getter;
+import lombok.Setter;
+
+@Getter
+@Setter
+public class B {
+	private A a = new A();
+	private String string = a.getString();
+	private int integer = a.getInteger();
+}

test/eclipse/resource/rename/builderField/after/A.java

@@ -0,0 +1,8 @@
+package pkg;
+
+import lombok.Builder;
+
+@Builder
+public class A {
+	private String newString;
+}

test/eclipse/resource/rename/builderField/before/A.java

@@ -0,0 +1,8 @@
+package pkg;
+
+import lombok.Builder;
+
+@Builder
+public class A {
+	private String string;
+}

test/eclipse/resource/rename/simple/after/A.java

@@ -0,0 +1,14 @@
+package pkg;
+
+import lombok.EqualsAndHashCode;
+import lombok.Getter;
+import lombok.Setter;
+import lombok.ToString;
+
+@EqualsAndHashCode
+@Getter
+@Setter
+@ToString
+public class A {
+	private String newString;
+}

test/eclipse/resource/rename/simple/before/A.java

@@ -0,0 +1,14 @@
+package pkg;
+
+import lombok.EqualsAndHashCode;
+import lombok.Getter;
+import lombok.Setter;
+import lombok.ToString;
+
+@EqualsAndHashCode
+@Getter
+@Setter
+@ToString
+public class A {
+	private String string;
+}

test/eclipse/resource/rename/withGetter/after/A.java

@@ -0,0 +1,18 @@
+package pkg;
+
+import lombok.EqualsAndHashCode;
+import lombok.Getter;
+import lombok.Setter;
+import lombok.ToString;
+
+@EqualsAndHashCode
+@Getter
+@Setter
+@ToString
+public class A {
+	private String newString;
+	
+	public String test() {
+		return getNewString();
+	}
+}

test/eclipse/resource/rename/withGetter/before/A.java

@@ -0,0 +1,18 @@
+package pkg;
+
+import lombok.EqualsAndHashCode;
+import lombok.Getter;
+import lombok.Setter;
+import lombok.ToString;
+
+@EqualsAndHashCode
+@Getter
+@Setter
+@ToString
+public class A {
+	private String string;
+	
+	public String test() {
+		return getString();
+	}
+}

test/eclipse/resource/rename/withGetterDifferentFile/after/A.java

@@ -0,0 +1,14 @@
+package pkg;
+
+import lombok.EqualsAndHashCode;
+import lombok.Getter;
+import lombok.Setter;
+import lombok.ToString;
+
+@EqualsAndHashCode
+@Getter
+@Setter
+@ToString
+public class A {
+	private String newString;
+}

test/eclipse/resource/rename/withGetterDifferentFile/after/B.java

@@ -0,0 +1,7 @@
+package pkg;
+
+public class B {
+	public String test() {
+		return new A().getNewString();
+	}
+}

test/eclipse/resource/rename/withGetterDifferentFile/before/A.java

@@ -0,0 +1,14 @@
+package pkg;
+
+import lombok.EqualsAndHashCode;
+import lombok.Getter;
+import lombok.Setter;
+import lombok.ToString;
+
+@EqualsAndHashCode
+@Getter
+@Setter
+@ToString
+public class A {
+	private String string;
+}

test/eclipse/resource/rename/withGetterDifferentFile/before/B.java

@@ -0,0 +1,7 @@
+package pkg;
+
+public class B {
+	public String test() {
+		return new A().getString();
+	}
+}

test/eclipse/resource/select/builderField/A.java

@@ -0,0 +1,8 @@
+package pkg;
+
+import lombok.Builder;
+
+@Builder
+public class A {
+	private String id;
+}

test/eclipse/resource/select/superbuilderField/A.java

@@ -0,0 +1,8 @@
+package pkg;
+
+import lombok.experimental.SuperBuilder;
+
+@SuperBuilder
+public class A {
+	private String id;
+}

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

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 {
+	
+}

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

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

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

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

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

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

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

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