| /******************************************************************************* |
| * Copyright (c) 2012, 2014 Google, Inc and others. |
| * All rights reserved. This program and the accompanying materials |
| * are made available under the terms of the Eclipse Public License v1.0 |
| * which accompanies this distribution, and is available at |
| * http://www.eclipse.org/legal/epl-v10.html |
| * |
| * Contributors: |
| * Sergey Prigogin (Google) - initial API and implementation |
| *******************************************************************************/ |
| package org.eclipse.cdt.ui.tests.refactoring; |
| |
| import java.io.BufferedReader; |
| import java.io.ByteArrayInputStream; |
| import java.io.InputStreamReader; |
| import java.io.StringReader; |
| import java.net.URI; |
| import java.util.LinkedHashSet; |
| import java.util.Set; |
| import java.util.regex.Pattern; |
| |
| import org.eclipse.core.filesystem.URIUtil; |
| import org.eclipse.core.resources.IFile; |
| import org.eclipse.core.resources.IProject; |
| import org.eclipse.core.resources.IResource; |
| import org.eclipse.core.runtime.CoreException; |
| import org.eclipse.core.runtime.Path; |
| import org.eclipse.jface.preference.IPreferenceStore; |
| import org.eclipse.jface.text.TextSelection; |
| import org.eclipse.ltk.core.refactoring.Change; |
| import org.eclipse.ltk.core.refactoring.Refactoring; |
| import org.eclipse.ltk.core.refactoring.RefactoringContext; |
| import org.eclipse.ltk.core.refactoring.RefactoringDescriptor; |
| import org.eclipse.ltk.core.refactoring.RefactoringDescriptorProxy; |
| import org.eclipse.ltk.core.refactoring.RefactoringStatus; |
| import org.eclipse.ltk.core.refactoring.RefactoringStatusEntry; |
| import org.eclipse.ltk.core.refactoring.history.RefactoringHistory; |
| import org.eclipse.ltk.internal.core.refactoring.history.RefactoringHistoryService; |
| import org.osgi.framework.Bundle; |
| |
| import org.eclipse.cdt.core.CCorePlugin; |
| import org.eclipse.cdt.core.dom.IPDOMManager; |
| import org.eclipse.cdt.core.model.CoreModel; |
| import org.eclipse.cdt.core.model.ICProject; |
| import org.eclipse.cdt.core.model.ITranslationUnit; |
| import org.eclipse.cdt.core.testplugin.CProjectHelper; |
| import org.eclipse.cdt.core.testplugin.TestScannerProvider; |
| import org.eclipse.cdt.core.testplugin.util.BaseTestCase; |
| import org.eclipse.cdt.core.testplugin.util.TestSourceReader; |
| import org.eclipse.cdt.ui.CUIPlugin; |
| import org.eclipse.cdt.ui.PreferenceConstants; |
| import org.eclipse.cdt.ui.testplugin.CTestPlugin; |
| |
| import org.eclipse.cdt.internal.ui.refactoring.CRefactoring; |
| import org.eclipse.cdt.internal.ui.refactoring.CRefactoringContext; |
| |
| /** |
| * Common base for refactoring tests. |
| */ |
| public abstract class RefactoringTestBase extends BaseTestCase { |
| private static final Pattern FILENAME_PATTERN = Pattern.compile("((\\w|_|-)+/)*(\\w|_|-)+\\.\\w+"); |
| /** Allows empty files to be created during test setup. */ |
| protected boolean createEmptyFiles = true; |
| /** See {@link PreferenceConstants.CLASS_MEMBER_ASCENDING_VISIBILITY_ORDER} */ |
| protected boolean ascendingVisibilityOrder; |
| /** Expected counts of errors, warnings and info messages */ |
| protected int expectedInitialErrors; |
| protected int expectedInitialWarnings; |
| protected int expectedFinalWarnings; |
| protected int expectedFinalInfos; |
| |
| private boolean cpp = true; |
| private ICProject cproject; |
| private final Set<TestSourceFile> testFiles = new LinkedHashSet<>(); |
| private TestSourceFile selectedFile; |
| private TextSelection selection; |
| private TestSourceFile historyScript; |
| |
| protected RefactoringTestBase() { |
| super(); |
| } |
| |
| protected RefactoringTestBase(String name) { |
| super(name); |
| } |
| |
| @Override |
| public void setUp() throws Exception { |
| super.setUp(); |
| resetPreferences(); |
| cproject = cpp ? |
| CProjectHelper.createCCProject(getName() + System.currentTimeMillis(), "bin", IPDOMManager.ID_NO_INDEXER) : |
| CProjectHelper.createCProject(getName() + System.currentTimeMillis(), "bin", IPDOMManager.ID_NO_INDEXER); |
| TestScannerProvider.sLocalIncludes = new String[] { cproject.getProject().getLocation().toOSString() }; |
| |
| Bundle bundle = CTestPlugin.getDefault().getBundle(); |
| CharSequence[] testData = TestSourceReader.getContentsForTest(bundle, "ui", getClass(), getName(), 0); |
| |
| for (CharSequence contents : testData) { |
| TestSourceFile testFile = null; |
| boolean firstAfterDelimiter = false; |
| boolean expectedResult = false; |
| BufferedReader reader = new BufferedReader(new StringReader(contents.toString())); |
| String line; |
| while ((line = reader.readLine()) != null) { |
| String trimmedLine = line.trim(); |
| if (testFile == null) { |
| if (isResultDelimiter(trimmedLine)) { |
| expectedResult = true; |
| firstAfterDelimiter = true; |
| testFile = new TestSourceFile(null); |
| } else { |
| assertTrue("Invalid file name \"" + trimmedLine + "\"", |
| FILENAME_PATTERN.matcher(trimmedLine).matches()); |
| testFile = new TestSourceFile(trimmedLine); |
| } |
| } else if (isResultDelimiter(trimmedLine)) { |
| expectedResult = true; |
| firstAfterDelimiter = true; |
| } else if (expectedResult) { |
| if (firstAfterDelimiter) { |
| firstAfterDelimiter = false; |
| if (FILENAME_PATTERN.matcher(trimmedLine).matches()) { |
| testFile.setExpectedName(trimmedLine); |
| continue; |
| } |
| } |
| assertTrue(testFile.getExpectedName() != null); |
| testFile.addLineToExpectedSource(line); |
| } else { |
| testFile.addLineToSource(line); |
| } |
| } |
| reader.close(); |
| |
| if (testFile.getName() != null && (createEmptyFiles || !testFile.getSource().isEmpty())) { |
| TestSourceReader.createFile(cproject.getProject(), new Path(testFile.getName()), |
| testFile.getSource()); |
| } |
| testFiles.add(testFile); |
| if (testFile.getName().endsWith(".xml")) { |
| historyScript = testFile; |
| } else if (selection == null) { |
| selection = testFile.getSelection(); |
| if (selection != null) |
| selectedFile = testFile; |
| } |
| } |
| if (selectedFile == null && !testFiles.isEmpty()) { |
| selectedFile = testFiles.iterator().next(); |
| } |
| CCorePlugin.getIndexManager().setIndexerId(cproject, IPDOMManager.ID_FAST_INDEXER); |
| waitForIndexer(cproject); |
| } |
| |
| @Override |
| public void tearDown() throws Exception { |
| if (cproject != null) { |
| cproject.getProject().delete(IResource.FORCE | IResource.ALWAYS_DELETE_PROJECT_CONTENT, |
| npm()); |
| } |
| resetPreferences(); |
| super.tearDown(); |
| } |
| |
| protected void assertRefactoringSuccess() throws Exception { |
| executeRefactoring(true); |
| compareFiles(); |
| } |
| |
| protected void assertRefactoringFailure() throws Exception { |
| executeRefactoring(false); |
| } |
| |
| protected void executeRefactoring(boolean expectedSuccess) throws Exception { |
| if (ascendingVisibilityOrder) { |
| getPreferenceStore().setValue(PreferenceConstants.CLASS_MEMBER_ASCENDING_VISIBILITY_ORDER, |
| ascendingVisibilityOrder); |
| } |
| if (historyScript != null) { |
| executeHistoryRefactoring(expectedSuccess); |
| return; |
| } |
| |
| Refactoring refactoring = createRefactoring(); |
| RefactoringContext context; |
| if (refactoring instanceof CRefactoring) { |
| context = new CRefactoringContext((CRefactoring) refactoring); |
| } else { |
| context = new RefactoringContext(refactoring); |
| } |
| executeRefactoring(refactoring, context, true, expectedSuccess); |
| } |
| |
| protected void executeRefactoring(Refactoring refactoring, boolean expectedSuccess) |
| throws CoreException, Exception { |
| executeRefactoring(refactoring, null, false, expectedSuccess); |
| } |
| |
| protected void executeRefactoring(Refactoring refactoring, RefactoringContext context, |
| boolean withUserInput, boolean expectedSuccess) throws CoreException, Exception { |
| try { |
| RefactoringStatus initialStatus = refactoring.checkInitialConditions(npm()); |
| if (!expectedSuccess) { |
| assertStatusFatalError(initialStatus); |
| return; |
| } |
| if (expectedInitialErrors != 0) { |
| assertStatusError(initialStatus, expectedInitialErrors); |
| } else if (expectedInitialWarnings != 0) { |
| assertStatusWarning(initialStatus, expectedInitialWarnings); |
| } else { |
| assertStatusOk(initialStatus); |
| } |
| |
| if (withUserInput) |
| simulateUserInput(); |
| RefactoringStatus finalStatus = refactoring.checkFinalConditions(npm()); |
| if (expectedFinalWarnings != 0) { |
| assertStatusWarning(finalStatus, expectedFinalWarnings); |
| } else if (expectedFinalInfos != 0) { |
| assertStatusInfo(finalStatus, expectedFinalInfos); |
| } else { |
| assertStatusOk(finalStatus); |
| } |
| Change change = refactoring.createChange(npm()); |
| change.perform(npm()); |
| } finally { |
| if (context != null) |
| context.dispose(); |
| } |
| } |
| |
| private void executeHistoryRefactoring(boolean expectedSuccess) throws Exception { |
| URI uri= URIUtil.toURI(cproject.getProject().getLocation()); |
| String scriptSource = historyScript.getSource().replaceAll("\\$\\{projectPath\\}", uri.getPath()); |
| RefactoringHistory history = RefactoringHistoryService.getInstance().readRefactoringHistory( |
| new ByteArrayInputStream(scriptSource.getBytes()), 0); |
| for (RefactoringDescriptorProxy proxy : history.getDescriptors()) { |
| RefactoringDescriptor descriptor = proxy.requestDescriptor(npm()); |
| RefactoringStatus status = new RefactoringStatus(); |
| RefactoringContext context = descriptor.createRefactoringContext(status); |
| assertTrue(status.isOK()); |
| executeRefactoring(context.getRefactoring(), context, false, expectedSuccess); |
| } |
| } |
| |
| /** |
| * Creates a refactoring object. |
| */ |
| protected abstract Refactoring createRefactoring(); |
| |
| /** |
| * Subclasses can override to simulate user input. |
| */ |
| protected void simulateUserInput() { |
| } |
| |
| protected ICProject getCProject() { |
| return cproject; |
| } |
| |
| protected IProject getProject() { |
| return cproject.getProject(); |
| } |
| |
| protected TestSourceFile getSelectedTestFile() { |
| return selectedFile; |
| } |
| |
| protected IFile getSelectedFile() { |
| if (selectedFile == null) |
| return null; |
| return cproject.getProject().getFile(new Path(selectedFile.getName())); |
| } |
| |
| protected ITranslationUnit getSelectedTranslationUnit() { |
| IFile file = getSelectedFile(); |
| if (file == null) |
| return null; |
| return (ITranslationUnit) CoreModel.getDefault().create(file); |
| } |
| |
| protected TestSourceFile getHistoryScriptFile() { |
| return historyScript; |
| } |
| |
| protected TextSelection getSelection() { |
| return selection; |
| } |
| |
| protected boolean isCpp() { |
| return cpp; |
| } |
| |
| protected void setCpp(boolean cpp) { |
| this.cpp = cpp; |
| } |
| |
| private boolean isResultDelimiter(String str) { |
| if (str.isEmpty()) |
| return false; |
| for (int i = 0; i < str.length(); i++) { |
| if (str.charAt(i) != '=') |
| return false; |
| } |
| return true; |
| } |
| |
| protected void assertStatusOk(RefactoringStatus status) { |
| if (!status.isOK()) |
| fail("Error or warning status: " + status.getEntries()[0].getMessage()); |
| } |
| |
| protected void assertStatusWarning(RefactoringStatus status, int number) { |
| if (number > 0) { |
| assertTrue("Warning status expected", status.hasWarning()); |
| } |
| RefactoringStatusEntry[] entries = status.getEntries(); |
| int count = 0; |
| for (RefactoringStatusEntry entry : entries) { |
| if (entry.isWarning()) { |
| ++count; |
| } |
| } |
| assertEquals("Found " + count + " warnings instead of expected " + number, number, count); |
| } |
| |
| protected void assertStatusInfo(RefactoringStatus status, int number) { |
| if (number > 0) { |
| assertTrue("Info status expected", status.hasInfo()); |
| } |
| RefactoringStatusEntry[] entries = status.getEntries(); |
| int count = 0; |
| for (RefactoringStatusEntry entry : entries) { |
| if (entry.isInfo()) { |
| ++count; |
| } |
| } |
| assertEquals("Found " + count + " informational messages instead of expected " + number, number, count); |
| } |
| |
| protected void assertStatusError(RefactoringStatus status, int number) { |
| if (number > 0) { |
| assertTrue("Error status expected", status.hasError()); |
| } |
| RefactoringStatusEntry[] entries = status.getEntries(); |
| int count = 0; |
| for (RefactoringStatusEntry entry : entries) { |
| if (entry.isError()) { |
| ++count; |
| } |
| } |
| assertEquals("Found " + count + " errors instead of expected " + number, number, count); |
| } |
| |
| protected void assertStatusFatalError(RefactoringStatus status, int number) { |
| if (number > 0) { |
| assertTrue("Fatal error status expected", status.hasFatalError()); |
| } |
| RefactoringStatusEntry[] entries = status.getEntries(); |
| int count = 0; |
| for (RefactoringStatusEntry entry : entries) { |
| if (entry.isFatalError()) { |
| ++count; |
| } |
| } |
| assertEquals("Found " + count + " fatal errors instead of expected " + number, number, count); |
| } |
| |
| protected void assertStatusFatalError(RefactoringStatus status) { |
| assertTrue("Fatal error status expected", status.hasFatalError()); |
| } |
| |
| protected void assertEquals(TestSourceFile testFile, IFile file) throws Exception { |
| String actualSource = getFileContents(file); |
| assertEquals(testFile.getExpectedSource(), actualSource); |
| } |
| |
| protected void compareFiles() throws Exception { |
| for (TestSourceFile testFile : testFiles) { |
| String expectedSource = testFile.getExpectedSource(); |
| IFile file = cproject.getProject().getFile(new Path(testFile.getExpectedName())); |
| String actualSource = getFileContents(file); |
| expectedSource= expectedSource.replace("\r\n", "\n"); |
| actualSource= actualSource.replace("\r\n", "\n"); |
| assertEquals(expectedSource, actualSource); |
| } |
| } |
| |
| protected String getFileContents(IFile file) throws Exception { |
| BufferedReader reader = new BufferedReader(new InputStreamReader(file.getContents(), "UTF-8")); |
| StringBuilder buffer = new StringBuilder(); |
| char[] part= new char[2048]; |
| int read= 0; |
| while ((read= reader.read(part)) != -1) |
| buffer.append(part, 0, read); |
| reader.close(); |
| return buffer.toString().replace("\r", ""); |
| } |
| |
| protected void resetPreferences() { |
| getPreferenceStore().setToDefault(PreferenceConstants.CLASS_MEMBER_ASCENDING_VISIBILITY_ORDER); |
| } |
| |
| protected IPreferenceStore getPreferenceStore() { |
| return CUIPlugin.getDefault().getPreferenceStore(); |
| } |
| } |
