1 /******************************************************************************* 2 * Copyright (c) 2000, 2020 IBM Corporation and others. 3 * 4 * This program and the accompanying materials 5 * are made available under the terms of the Eclipse Public License 2.0 6 * which accompanies this distribution, and is available at 7 * https://www.eclipse.org/legal/epl-2.0/ 8 * 9 * SPDX-License-Identifier: EPL-2.0 10 * 11 * Contributors: 12 * IBM Corporation - initial API and implementation 13 *******************************************************************************/ 14 package org.eclipse.jdt.ui.tests.refactoring.ccp; 15 16 import static org.junit.Assert.assertEquals; 17 import static org.junit.Assert.assertTrue; 18 19 import java.io.IOException; 20 import java.util.Arrays; 21 import java.util.HashSet; 22 import java.util.Set; 23 24 import org.junit.Rule; 25 import org.junit.Test; 26 27 import org.eclipse.swt.SWTError; 28 import org.eclipse.swt.dnd.Clipboard; 29 import org.eclipse.swt.dnd.DND; 30 import org.eclipse.swt.dnd.Transfer; 31 import org.eclipse.swt.widgets.Display; 32 33 import org.eclipse.core.runtime.CoreException; 34 import org.eclipse.core.runtime.IAdaptable; 35 36 import org.eclipse.core.resources.IFolder; 37 import org.eclipse.core.resources.IResource; 38 39 import org.eclipse.jface.viewers.IStructuredSelection; 40 41 import org.eclipse.ui.IWorkingSet; 42 import org.eclipse.ui.PlatformUI; 43 44 import org.eclipse.jdt.core.ICompilationUnit; 45 import org.eclipse.jdt.core.IField; 46 import org.eclipse.jdt.core.IImportContainer; 47 import org.eclipse.jdt.core.IJavaElement; 48 import org.eclipse.jdt.core.IMethod; 49 import org.eclipse.jdt.core.IType; 50 import org.eclipse.jdt.core.JavaModelException; 51 52 import org.eclipse.jdt.internal.corext.refactoring.TypedSource; 53 54 import org.eclipse.jdt.ui.tests.refactoring.GenericRefactoringTest; 55 import org.eclipse.jdt.ui.tests.refactoring.infra.MockClipboard; 56 import org.eclipse.jdt.ui.tests.refactoring.infra.MockWorkbenchSite; 57 import org.eclipse.jdt.ui.tests.refactoring.rules.RefactoringTestSetup; 58 59 import org.eclipse.jdt.internal.ui.refactoring.reorg.CopyToClipboardAction; 60 import org.eclipse.jdt.internal.ui.refactoring.reorg.PasteAction; 61 import org.eclipse.jdt.internal.ui.refactoring.reorg.TypedSourceTransfer; 62 63 public class PasteActionTest extends GenericRefactoringTest { 64 private static final boolean BUG_NOT_IMPLEMENTED_YET= true; 65 private Clipboard fClipboard; 66 private static final String REFACTORING_PATH= "Paste/"; 67 68 @Rule 69 public RefactoringTestSetup fts= new RefactoringTestSetup(); 70 71 @Override getRefactoringPath()72 protected String getRefactoringPath() { 73 return REFACTORING_PATH; 74 } 75 76 @Override genericbefore()77 public void genericbefore() throws Exception { 78 super.genericbefore(); 79 fClipboard= new MockClipboard(Display.getDefault()); 80 } 81 82 @Override genericafter()83 public void genericafter() throws Exception { 84 super.genericafter(); 85 fClipboard.dispose(); 86 } 87 merge(Object[] array1, Object[] array2)88 private static Object[] merge(Object[] array1, Object[] array2) { 89 Set<Object> elements= new HashSet<>(array1.length + array2.length); 90 elements.addAll(Arrays.asList(array1)); 91 elements.addAll(Arrays.asList(array2)); 92 return elements.toArray(); 93 } 94 verifyEnabled(IResource[] copySelectedResources, IJavaElement[] copySelectedJavaElements, IResource[] pasteSelectedResources, IJavaElement[] pasteSelectedJavaElements)95 private PasteAction verifyEnabled(IResource[] copySelectedResources, IJavaElement[] copySelectedJavaElements, IResource[] pasteSelectedResources, IJavaElement[] pasteSelectedJavaElements) { 96 PasteAction pasteAction= new PasteAction(new MockWorkbenchSite(merge(pasteSelectedResources, pasteSelectedJavaElements)), fClipboard); 97 CopyToClipboardAction copyToClipboardAction= new CopyToClipboardAction(new MockWorkbenchSite(merge(copySelectedResources, copySelectedJavaElements)), fClipboard); 98 copyToClipboardAction.setAutoRepeatOnFailure(true); 99 copyToClipboardAction.update(copyToClipboardAction.getSelection()); 100 assertTrue("copy not enabled", copyToClipboardAction.isEnabled()); 101 copyToClipboardAction.run(); 102 103 pasteAction.update(pasteAction.getSelection()); 104 assertTrue("paste should be enabled", pasteAction.isEnabled()); 105 return pasteAction; 106 } 107 verifyEnabled(IResource[] copySelectedResources, IJavaElement[] copySelectedJavaElements, IWorkingSet pasteSelectedWorkingSet)108 private PasteAction verifyEnabled(IResource[] copySelectedResources, IJavaElement[] copySelectedJavaElements, IWorkingSet pasteSelectedWorkingSet) { 109 PasteAction pasteAction= new PasteAction(new MockWorkbenchSite(new Object[] {pasteSelectedWorkingSet}), fClipboard); 110 CopyToClipboardAction copyToClipboardAction= new CopyToClipboardAction(new MockWorkbenchSite(merge(copySelectedResources, copySelectedJavaElements)), fClipboard); 111 copyToClipboardAction.setAutoRepeatOnFailure(true); 112 copyToClipboardAction.update(copyToClipboardAction.getSelection()); 113 assertTrue("copy not enabled", copyToClipboardAction.isEnabled()); 114 copyToClipboardAction.run(); 115 116 pasteAction.update(pasteAction.getSelection()); 117 assertTrue("paste should be enabled", pasteAction.isEnabled()); 118 return pasteAction; 119 } 120 121 @Test testEnabled_javaProject()122 public void testEnabled_javaProject() throws Exception { 123 IJavaElement[] javaElements= {RefactoringTestSetup.getProject()}; 124 IResource[] resources= {}; 125 verifyEnabled(resources, javaElements, new IResource[0], new IJavaElement[0]); 126 } 127 128 @Test testEnabled_project()129 public void testEnabled_project() throws Exception { 130 IJavaElement[] javaElements= {}; 131 IResource[] resources= {RefactoringTestSetup.getProject().getProject()}; 132 verifyEnabled(resources, javaElements, new IResource[0], new IJavaElement[0]); 133 } 134 135 @Test testEnabled_workingSet()136 public void testEnabled_workingSet() throws Exception { 137 IWorkingSet ws= PlatformUI.getWorkbench().getWorkingSetManager().createWorkingSet("Test", new IAdaptable[] {}); 138 try { 139 verifyEnabled(new IResource[0], new IJavaElement[] {RefactoringTestSetup.getProject()}, ws); 140 } finally { 141 PlatformUI.getWorkbench().getWorkingSetManager().removeWorkingSet(ws); 142 } 143 } 144 compareContents(String cuName)145 private void compareContents(String cuName) throws JavaModelException, IOException { 146 assertEqualLines(cuName, getFileContents(getOutputTestFileName(cuName)), getPackageP().getCompilationUnit(cuName + ".java").getSource()); 147 } 148 149 @Test test0()150 public void test0() throws Exception { 151 if (BUG_NOT_IMPLEMENTED_YET) { 152 printTestDisabledMessage("not implemented yet"); 153 return; 154 } 155 156 ICompilationUnit cuA= createCUfromTestFile(getPackageP(), "A"); 157 ICompilationUnit cuB= createCUfromTestFile(getPackageP(), "B"); 158 159 IType typeA= cuA.getType("A"); 160 IType typeB= cuB.getType("B"); 161 162 assertTrue("A does not exist", typeA.exists()); 163 assertTrue("B does not exist", typeB.exists()); 164 165 IJavaElement[] copyJavaElements= {typeA}; 166 IResource[] copyResources= {}; 167 IJavaElement[] pasteJavaElements= {typeB}; 168 IResource[] pasteResources= {}; 169 PasteAction paste= verifyEnabled(copyResources, copyJavaElements, pasteResources, pasteJavaElements); 170 paste.run((IStructuredSelection)paste.getSelection()); 171 compareContents("A"); 172 compareContents("B"); 173 } 174 175 @Test test2()176 public void test2() throws Exception { 177 ICompilationUnit cuA= createCUfromTestFile(getPackageP(), "A"); 178 ICompilationUnit cuB= createCUfromTestFile(getPackageP(), "B"); 179 180 IField fieldY= cuA.getType("A").getField("y"); 181 IType typeB= cuB.getType("B"); 182 183 assertTrue("y does not exist", fieldY.exists()); 184 assertTrue("B does not exist", typeB.exists()); 185 186 IJavaElement[] copyJavaElements= {fieldY}; 187 IResource[] copyResources= {}; 188 IJavaElement[] pasteJavaElements= {typeB}; 189 IResource[] pasteResources= {}; 190 PasteAction paste= verifyEnabled(copyResources, copyJavaElements, pasteResources, pasteJavaElements); 191 paste.run((IStructuredSelection)paste.getSelection()); 192 compareContents("A"); 193 compareContents("B"); 194 } 195 196 @Test test3()197 public void test3() throws Exception { 198 // printTestDisabledMessage("test for bug#19007"); 199 ICompilationUnit cuA= createCUfromTestFile(getPackageP(), "A"); 200 ICompilationUnit cuB= createCUfromTestFile(getPackageP(), "B"); 201 202 IJavaElement elem0= cuA.getImport("java.lang.*"); 203 IImportContainer importContainer= cuB.getImportContainer(); 204 205 assertTrue("y does not exist", elem0.exists()); 206 assertTrue("B does not exist", importContainer.exists()); 207 208 IJavaElement[] copyJavaElements= {elem0}; 209 IResource[] copyResources= {}; 210 IJavaElement[] pasteJavaElements= {importContainer}; 211 IResource[] pasteResources= {}; 212 PasteAction paste= verifyEnabled(copyResources, copyJavaElements, pasteResources, pasteJavaElements); 213 paste.run((IStructuredSelection)paste.getSelection()); 214 compareContents("A"); 215 compareContents("B"); 216 } 217 218 @Test test4()219 public void test4() throws Exception { 220 // printTestDisabledMessage("test for bug 20151"); 221 ICompilationUnit cuA= createCUfromTestFile(getPackageP(), "A"); 222 IJavaElement elem0= cuA.getType("A").getMethod("f", new String[0]); 223 IMethod method= cuA.getType("A").getMethod("f1", new String[0]); 224 225 assertTrue("y does not exist", elem0.exists()); 226 assertTrue("B does not exist", method.exists()); 227 228 IJavaElement[] copyJavaElements= {elem0}; 229 IResource[] copyResources= {}; 230 IJavaElement[] pasteJavaElements= {method}; 231 IResource[] pasteResources= {}; 232 PasteAction paste= verifyEnabled(copyResources, copyJavaElements, pasteResources, pasteJavaElements); 233 paste.run((IStructuredSelection)paste.getSelection()); 234 compareContents("A"); 235 } 236 237 @Test testPastingJavaElementIntoWorkingSet()238 public void testPastingJavaElementIntoWorkingSet() throws Exception { 239 IWorkingSet ws= PlatformUI.getWorkbench().getWorkingSetManager().createWorkingSet("Test", new IAdaptable[] {}); 240 try { 241 IResource[] resources= {}; 242 IJavaElement[] jElements= {RefactoringTestSetup.getProject()}; 243 PasteAction paste= verifyEnabled(resources , jElements, ws); 244 paste.run((IStructuredSelection)paste.getSelection()); 245 assertEquals("Only one element", 1, ws.getElements().length); 246 assertEquals(RefactoringTestSetup.getProject(), ws.getElements()[0]); 247 } finally { 248 PlatformUI.getWorkbench().getWorkingSetManager().removeWorkingSet(ws); 249 } 250 } 251 252 @Test testPastingResourceIntoWorkingSet()253 public void testPastingResourceIntoWorkingSet() throws Exception { 254 IWorkingSet ws= PlatformUI.getWorkbench().getWorkingSetManager().createWorkingSet("Test", new IAdaptable[] {}); 255 IFolder folder= RefactoringTestSetup.getProject().getProject().getFolder("folder"); 256 folder.create(true, true, null); 257 try { 258 IResource[] resources= {folder}; 259 IJavaElement[] jElements= {}; 260 PasteAction paste= verifyEnabled(resources , jElements, ws); 261 paste.run((IStructuredSelection)paste.getSelection()); 262 assertEquals("Only one element", 1, ws.getElements().length); 263 assertEquals(folder, ws.getElements()[0]); 264 } finally { 265 PlatformUI.getWorkbench().getWorkingSetManager().removeWorkingSet(ws); 266 } 267 } 268 269 @Test testPastingJavaElementAsResourceIntoWorkingSet()270 public void testPastingJavaElementAsResourceIntoWorkingSet() throws Exception { 271 IWorkingSet ws= PlatformUI.getWorkbench().getWorkingSetManager().createWorkingSet("Test", new IAdaptable[] {}); 272 try { 273 IResource[] resources= {RefactoringTestSetup.getProject().getProject()}; 274 IJavaElement[] jElements= {}; 275 PasteAction paste= verifyEnabled(resources , jElements, ws); 276 paste.run((IStructuredSelection)paste.getSelection()); 277 assertEquals("Only one element", 1, ws.getElements().length); 278 assertEquals(RefactoringTestSetup.getProject(), ws.getElements()[0]); 279 } finally { 280 PlatformUI.getWorkbench().getWorkingSetManager().removeWorkingSet(ws); 281 } 282 } 283 284 @Test testPastingExistingElementIntoWorkingSet()285 public void testPastingExistingElementIntoWorkingSet() throws Exception { 286 IWorkingSet ws= PlatformUI.getWorkbench().getWorkingSetManager().createWorkingSet("Test", 287 new IAdaptable[] {RefactoringTestSetup.getProject()}); 288 try { 289 IResource[] resources= {}; 290 IJavaElement[] jElements= {RefactoringTestSetup.getProject()}; 291 PasteAction paste= verifyEnabled(resources , jElements, ws); 292 paste.run((IStructuredSelection)paste.getSelection()); 293 assertEquals("Only one element", 1, ws.getElements().length); 294 assertEquals(RefactoringTestSetup.getProject(), ws.getElements()[0]); 295 } finally { 296 PlatformUI.getWorkbench().getWorkingSetManager().removeWorkingSet(ws); 297 } 298 } 299 300 @Test testPastingChildJavaElementIntoWorkingSet()301 public void testPastingChildJavaElementIntoWorkingSet() throws Exception { 302 IWorkingSet ws= PlatformUI.getWorkbench().getWorkingSetManager().createWorkingSet("Test", 303 new IAdaptable[] {RefactoringTestSetup.getProject()}); 304 try { 305 IResource[] resources= {}; 306 IJavaElement[] jElements= {getPackageP()}; 307 PasteAction paste= verifyEnabled(resources , jElements, ws); 308 paste.run((IStructuredSelection)paste.getSelection()); 309 assertEquals("Only one element", 1, ws.getElements().length); 310 assertEquals(RefactoringTestSetup.getProject(), ws.getElements()[0]); 311 } finally { 312 PlatformUI.getWorkbench().getWorkingSetManager().removeWorkingSet(ws); 313 } 314 } 315 316 @Test testPastingChildResourceIntoWorkingSet()317 public void testPastingChildResourceIntoWorkingSet() throws Exception { 318 IFolder folder= RefactoringTestSetup.getProject().getProject().getFolder("folder"); 319 folder.create(true, true, null); 320 IWorkingSet ws= PlatformUI.getWorkbench().getWorkingSetManager().createWorkingSet("Test", 321 new IAdaptable[] {folder}); 322 IFolder sub= folder.getFolder("sub"); 323 sub.create(true, true, null); 324 try { 325 IResource[] resources= {sub}; 326 IJavaElement[] jElements= {}; 327 PasteAction paste= verifyEnabled(resources , jElements, ws); 328 paste.run((IStructuredSelection)paste.getSelection()); 329 assertEquals("Only one element", 1, ws.getElements().length); 330 assertEquals(folder, ws.getElements()[0]); 331 } finally { 332 PlatformUI.getWorkbench().getWorkingSetManager().removeWorkingSet(ws); 333 } 334 } 335 336 @Test testPastingChildResourceIntoWorkingSetContainingParent()337 public void testPastingChildResourceIntoWorkingSetContainingParent() throws Exception { 338 IWorkingSet ws= PlatformUI.getWorkbench().getWorkingSetManager().createWorkingSet("Test", 339 new IAdaptable[] {RefactoringTestSetup.getProject()}); 340 IFolder folder= RefactoringTestSetup.getProject().getProject().getFolder("folder"); 341 folder.create(true, true, null); 342 try { 343 IResource[] resources= {folder}; 344 IJavaElement[] jElements= {}; 345 PasteAction paste= verifyEnabled(resources , jElements, ws); 346 paste.run((IStructuredSelection)paste.getSelection()); 347 assertEquals("Only one element", 1, ws.getElements().length); 348 assertEquals(RefactoringTestSetup.getProject(), ws.getElements()[0]); 349 } finally { 350 PlatformUI.getWorkbench().getWorkingSetManager().removeWorkingSet(ws); 351 } 352 } 353 setClipboardContents(TypedSource[] typedSources, int repeat)354 private void setClipboardContents(TypedSource[] typedSources, int repeat) { 355 final int maxRepeat= 10; 356 try { 357 fClipboard.setContents(new Object[] {typedSources}, new Transfer[] {TypedSourceTransfer.getInstance()}); 358 } catch (SWTError e) { 359 if (e.code != DND.ERROR_CANNOT_SET_CLIPBOARD || repeat >= maxRepeat) 360 throw e; 361 setClipboardContents(typedSources, repeat+1); 362 } 363 } 364 copyAndPasteTypedSources(IJavaElement[] elemsForClipboard, IJavaElement[] pasteSelectedJavaElements, boolean pasteEnabled)365 private void copyAndPasteTypedSources(IJavaElement[] elemsForClipboard, IJavaElement[] pasteSelectedJavaElements, boolean pasteEnabled) throws CoreException { 366 setClipboardContents(TypedSource.createTypedSources(elemsForClipboard), 0); 367 PasteAction pasteAction= new PasteAction(new MockWorkbenchSite(pasteSelectedJavaElements), fClipboard); 368 pasteAction.update(pasteAction.getSelection()); 369 assertEquals("action enablement", pasteEnabled, pasteAction.isEnabled()); 370 if (pasteEnabled) 371 pasteAction.run((IStructuredSelection)pasteAction.getSelection()); 372 } 373 374 @Test testPastingTypedResources0()375 public void testPastingTypedResources0() throws Exception { 376 ICompilationUnit cuA= createCUfromTestFile(getPackageP(), "A"); 377 IJavaElement methodM= cuA.getType("A").getMethod("m", new String[0]); 378 IJavaElement[] elemsForClipboard= {methodM}; 379 IJavaElement[] pasteSelectedJavaElements= {methodM}; 380 boolean enabled= true; 381 copyAndPasteTypedSources(elemsForClipboard, pasteSelectedJavaElements, enabled); 382 compareContents("A"); 383 } 384 385 @Test testPastingTypedResources1()386 public void testPastingTypedResources1() throws Exception { 387 ICompilationUnit cuA= createCUfromTestFile(getPackageP(), "A"); 388 IType typeA= cuA.getType("A"); 389 IJavaElement fieldF= typeA.getField("f"); 390 IJavaElement[] elemsForClipboard= {fieldF}; 391 IJavaElement[] pasteSelectedJavaElements= {typeA}; 392 boolean enabled= true; 393 copyAndPasteTypedSources(elemsForClipboard, pasteSelectedJavaElements, enabled); 394 compareContents("A"); 395 } 396 397 @Test testPastingTypedResources2()398 public void testPastingTypedResources2() throws Exception { 399 ICompilationUnit cuA= createCUfromTestFile(getPackageP(), "A"); 400 IType typeA= cuA.getType("A"); 401 IJavaElement fieldF= typeA.getField("f"); 402 IJavaElement[] elemsForClipboard= {fieldF}; 403 IJavaElement[] pasteSelectedJavaElements= {typeA}; 404 boolean enabled= true; 405 copyAndPasteTypedSources(elemsForClipboard, pasteSelectedJavaElements, enabled); 406 compareContents("A"); 407 } 408 409 @Test testPastingTypedResources3()410 public void testPastingTypedResources3() throws Exception { 411 ICompilationUnit cuA= createCUfromTestFile(getPackageP(), "A"); 412 IType typeA= cuA.getType("A"); 413 IJavaElement fieldF= typeA.getField("f"); 414 IJavaElement fieldG= typeA.getField("g"); 415 IJavaElement[] elemsForClipboard= {fieldF, fieldG}; 416 IJavaElement[] pasteSelectedJavaElements= {typeA}; 417 boolean enabled= true; 418 copyAndPasteTypedSources(elemsForClipboard, pasteSelectedJavaElements, enabled); 419 compareContents("A"); 420 } 421 } 422