| /******************************************************************************* |
| * Copyright (c) 2000, 2017 IBM Corporation 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: |
| * IBM Corporation - initial API and implementation |
| * James Blackburn (Broadcom Corp.) - ongoing development |
| *******************************************************************************/ |
| package org.eclipse.core.tests.resources; |
| |
| import java.io.*; |
| import java.nio.file.Files; |
| import java.nio.file.attribute.FileTime; |
| import java.util.HashSet; |
| import java.util.Set; |
| import org.eclipse.core.filesystem.*; |
| import org.eclipse.core.internal.resources.Resource; |
| import org.eclipse.core.internal.utils.FileUtil; |
| import org.eclipse.core.internal.utils.UniversalUniqueIdentifier; |
| import org.eclipse.core.resources.*; |
| import org.eclipse.core.runtime.*; |
| import org.eclipse.core.runtime.jobs.Job; |
| import org.eclipse.core.tests.harness.CoreTest; |
| import org.eclipse.core.tests.harness.FileSystemHelper; |
| |
| /** |
| * Superclass for tests that use the Eclipse Platform workspace. |
| */ |
| public abstract class ResourceTest extends CoreTest { |
| //nature that installs and runs a builder (regression test for bug 29116) |
| protected static final String NATURE_29116 = "org.eclipse.core.tests.resources.nature29116"; |
| |
| //cycle1 requires: cycle2 |
| protected static final String NATURE_CYCLE1 = "org.eclipse.core.tests.resources.cycle1"; |
| //cycle2 requires: cycle3 |
| protected static final String NATURE_CYCLE2 = "org.eclipse.core.tests.resources.cycle2"; |
| |
| //constants for nature ids |
| |
| //cycle3 requires: cycle1 |
| protected static final String NATURE_CYCLE3 = "org.eclipse.core.tests.resources.cycle3"; |
| //earthNature, one-of: stateSet |
| protected static final String NATURE_EARTH = "org.eclipse.core.tests.resources.earthNature"; |
| //invalidNature |
| protected static final String NATURE_INVALID = "org.eclipse.core.tests.resources.invalidNature"; |
| //missing nature |
| protected static final String NATURE_MISSING = "no.such.nature.Missing"; |
| //missing pre-req nature |
| protected static final String NATURE_MISSING_PREREQ = "org.eclipse.core.tests.resources.missingPrerequisiteNature"; |
| //mudNature, requires: waterNature, earthNature, one-of: otherSet |
| protected static final String NATURE_MUD = "org.eclipse.core.tests.resources.mudNature"; |
| //simpleNature |
| protected static final String NATURE_SIMPLE = "org.eclipse.core.tests.resources.simpleNature"; |
| //nature for regression tests of bug 127562 |
| protected static final String NATURE_127562 = "org.eclipse.core.tests.resources.bug127562Nature"; |
| //snowNature, requires: waterNature, one-of: otherSet |
| protected static final String NATURE_SNOW = "org.eclipse.core.tests.resources.snowNature"; |
| //waterNature, one-of: stateSet |
| protected static final String NATURE_WATER = "org.eclipse.core.tests.resources.waterNature"; |
| public static final String PI_RESOURCES_TESTS = "org.eclipse.core.tests.resources"; //$NON-NLS-1$ |
| protected static final String SET_OTHER = "org.eclipse.core.tests.resources.otherSet"; |
| //constants for nature sets |
| protected static final String SET_STATE = "org.eclipse.core.tests.resources.stateSet"; |
| |
| /** |
| * Set of FileStore instances that must be deleted when the |
| * test is complete |
| * @see #getTempStore |
| */ |
| private final Set<IFileStore> storesToDelete = new HashSet<>(); |
| |
| /** |
| * Does some garbage collections to free unused resources |
| */ |
| protected static void gc() { |
| /* make sure old stores get finalized so they free old files */ |
| for (int i = 0; i < 2; i++) { |
| System.runFinalization(); |
| System.gc(); |
| } |
| } |
| |
| public static IWorkspace getWorkspace() { |
| return ResourcesPlugin.getWorkspace(); |
| } |
| |
| /** |
| * Returns whether the file system in which the provided resource |
| * is stored is case sensitive. This succeeds whether or not the resource |
| * exists. |
| */ |
| protected static boolean isCaseSensitive(IResource resource) { |
| return ((Resource) resource).getStore().getFileSystem().isCaseSensitive(); |
| } |
| |
| /** |
| * Returns whether the current platform is windows. |
| * @return <code>true</code> if this platform is windows, and |
| * <code>false</code> otherwise. |
| */ |
| protected static boolean isWindows() { |
| return Platform.getOS().equals(Platform.OS_WIN32); |
| } |
| |
| /** |
| * Convenience method to copy contents from one stream to another. |
| */ |
| public static void transferStreams(InputStream source, OutputStream destination, String path, IProgressMonitor monitor) { |
| SubMonitor subMonitor = SubMonitor.convert(monitor); |
| try { |
| byte[] buffer = new byte[8192]; |
| while (true) { |
| int bytesRead = -1; |
| try { |
| bytesRead = source.read(buffer); |
| } catch (IOException e) { |
| fail("Failed to read during transferStreams", e); |
| } |
| if (bytesRead == -1) { |
| break; |
| } |
| try { |
| destination.write(buffer, 0, bytesRead); |
| } catch (IOException e) { |
| fail("Failed to write during transferStreams", e); |
| } |
| subMonitor.setWorkRemaining(100).split(1); |
| } |
| } finally { |
| try { |
| source.close(); |
| } catch (IOException e) { |
| // ignore |
| } finally { |
| //close destination in finally in case source.close fails |
| try { |
| destination.close(); |
| } catch (IOException e) { |
| // ignore |
| } |
| } |
| } |
| } |
| |
| /** |
| * Need a zero argument constructor to satisfy the test harness. |
| * This constructor should not do any real work nor should it be |
| * called by user code. |
| */ |
| public ResourceTest() { |
| super(null); |
| } |
| |
| /** |
| * Creates a new ResourceTest |
| * @param name java.lang.String |
| */ |
| public ResourceTest(String name) { |
| super(name); |
| } |
| |
| /** |
| * Assert that the given resource does not exist in the local store. |
| */ |
| public void assertDoesNotExistInFileSystem(IResource resource) { |
| assertDoesNotExistInFileSystem("", resource); //$NON-NLS-1$ |
| } |
| |
| /** |
| * Assert that each element of the resource array does not exist in the |
| * local store. |
| */ |
| public void assertDoesNotExistInFileSystem(IResource[] resources) { |
| assertDoesNotExistInFileSystem("", resources); //$NON-NLS-1$ |
| } |
| |
| /** |
| * Assert that the given resource does not exist in the local store. |
| */ |
| public void assertDoesNotExistInFileSystem(String message, IResource resource) { |
| if (existsInFileSystem(resource)) { |
| String formatted = message == null ? "" : message + " "; |
| fail(formatted + resource.getFullPath() + " unexpectedly exists in the file system"); |
| } |
| } |
| |
| /** |
| * Assert that each element of the resource array does not exist in the |
| * local store. |
| */ |
| public void assertDoesNotExistInFileSystem(String message, IResource[] resources) { |
| for (IResource resource : resources) { |
| assertDoesNotExistInFileSystem(message, resource); |
| } |
| } |
| |
| /** |
| * Assert that the given resource does not exist in the workspace |
| * resource info tree. |
| */ |
| public void assertDoesNotExistInWorkspace(IResource resource) { |
| assertDoesNotExistInWorkspace("", resource); //$NON-NLS-1$ |
| } |
| |
| /** |
| * Assert that each element of the resource array does not exist |
| * in the workspace resource info tree. |
| */ |
| public void assertDoesNotExistInWorkspace(IResource[] resources) { |
| assertDoesNotExistInWorkspace("", resources); //$NON-NLS-1$ |
| } |
| |
| /** |
| * Assert that the given resource does not exist in the workspace |
| * resource info tree. |
| */ |
| public void assertDoesNotExistInWorkspace(String message, IResource resource) { |
| if (existsInWorkspace(resource, false)) { |
| String formatted = message == null ? "" : message + " "; |
| fail(formatted + resource.getFullPath().toString() + " unexpectedly exists in the workspace"); |
| } |
| } |
| |
| /** |
| * Assert that each element of the resource array does not exist |
| * in the workspace resource info tree. |
| */ |
| public void assertDoesNotExistInWorkspace(String message, IResource[] resources) { |
| for (IResource resource : resources) { |
| assertDoesNotExistInWorkspace(message, resource); |
| } |
| } |
| |
| /** |
| * Assert whether or not the given resource exists in the local |
| * store. Use the resource manager to ensure that we have a |
| * correct Path -> File mapping. |
| */ |
| public void assertExistsInFileSystem(IResource resource) { |
| assertExistsInFileSystem("", resource); //$NON-NLS-1$ |
| } |
| |
| /** |
| * Assert that each element in the resource array exists in the local store. |
| */ |
| public void assertExistsInFileSystem(IResource[] resources) { |
| assertExistsInFileSystem("", resources); //$NON-NLS-1$ |
| } |
| |
| /** |
| * Assert whether or not the given resource exists in the local |
| * store. Use the resource manager to ensure that we have a |
| * correct Path -> File mapping. |
| */ |
| public void assertExistsInFileSystem(String message, IResource resource) { |
| if (!existsInFileSystem(resource)) { |
| String formatted = message == null ? "" : message + " "; |
| fail(formatted + resource.getFullPath() + " unexpectedly does not exist in the file system"); |
| } |
| } |
| |
| /** |
| * Assert that each element in the resource array exists in the local store. |
| */ |
| public void assertExistsInFileSystem(String message, IResource[] resources) { |
| for (IResource resource : resources) { |
| assertExistsInFileSystem(message, resource); |
| } |
| } |
| |
| /** |
| * Assert whether or not the given resource exists in the workspace |
| * resource info tree. |
| */ |
| public void assertExistsInWorkspace(IResource resource) { |
| assertExistsInWorkspace("", resource, false); //$NON-NLS-1$ |
| } |
| |
| /** |
| * Assert whether or not the given resource exists in the workspace |
| * resource info tree. |
| */ |
| public void assertExistsInWorkspace(IResource resource, boolean phantom) { |
| assertExistsInWorkspace("", resource, phantom); //$NON-NLS-1$ |
| } |
| |
| /** |
| * Assert that each element of the resource array exists in the |
| * workspace resource info tree. |
| */ |
| public void assertExistsInWorkspace(IResource[] resources) { |
| assertExistsInWorkspace("", resources, false); //$NON-NLS-1$ |
| } |
| |
| /** |
| * Assert that each element of the resource array exists in the |
| * workspace resource info tree. |
| */ |
| public void assertExistsInWorkspace(IResource[] resources, boolean phantom) { |
| assertExistsInWorkspace("", resources, phantom); //$NON-NLS-1$ |
| } |
| |
| /** |
| * Assert whether or not the given resource exists in the workspace |
| * resource info tree. |
| */ |
| public void assertExistsInWorkspace(String message, IResource resource) { |
| assertExistsInWorkspace(message, resource, false); |
| } |
| |
| /** |
| * Assert whether or not the given resource exists in the workspace |
| * resource info tree. |
| */ |
| public void assertExistsInWorkspace(String message, IResource resource, boolean phantom) { |
| if (!existsInWorkspace(resource, phantom)) { |
| String formatted = message == null ? "" : message + " "; |
| fail(formatted + resource.getFullPath().toString() + " unexpectedly does not exist in the workspace"); |
| } |
| } |
| |
| /** |
| * Assert that each element of the resource array exists in the |
| * workspace resource info tree. |
| */ |
| public void assertExistsInWorkspace(String message, IResource[] resources) { |
| for (IResource resource : resources) { |
| assertExistsInWorkspace(message, resource, false); |
| } |
| } |
| |
| /** |
| * Assert that each element of the resource array exists in the |
| * workspace resource info tree. |
| */ |
| public void assertExistsInWorkspace(String message, IResource[] resources, boolean phantom) { |
| for (IResource resource : resources) { |
| assertExistsInWorkspace(message, resource, phantom); |
| } |
| } |
| |
| /** |
| * Return a collection of resources the hierarchy defined by defineHeirarchy(). |
| */ |
| public IResource[] buildResources() { |
| return buildResources(getWorkspace().getRoot(), defineHierarchy()); |
| } |
| |
| /** |
| * Return a collection of resources for the given hierarchy at |
| * the given root. |
| */ |
| public IResource[] buildResources(IContainer root, String[] hierarchy) { |
| IResource[] result = new IResource[hierarchy.length]; |
| for (int i = 0; i < hierarchy.length; i++) { |
| IPath path = new Path(hierarchy[i]); |
| IPath fullPath = root.getFullPath().append(path); |
| switch (fullPath.segmentCount()) { |
| case 0 : |
| result[i] = getWorkspace().getRoot(); |
| break; |
| case 1 : |
| result[i] = getWorkspace().getRoot().getProject(fullPath.segment(0)); |
| break; |
| default : |
| if (hierarchy[i].charAt(hierarchy[i].length() - 1) == IPath.SEPARATOR) { |
| result[i] = root.getFolder(path); |
| } else { |
| result[i] = root.getFile(path); |
| } |
| break; |
| } |
| } |
| return result; |
| } |
| |
| protected void cleanup() throws CoreException { |
| final IFileStore[] toDelete = storesToDelete.toArray(new IFileStore[0]); |
| storesToDelete.clear(); |
| getWorkspace().run((IWorkspaceRunnable) monitor -> { |
| getWorkspace().getRoot().delete(IResource.FORCE | IResource.ALWAYS_DELETE_PROJECT_CONTENT, getMonitor()); |
| //clear stores in workspace runnable to avoid interaction with resource jobs |
| for (IFileStore element : toDelete) { |
| clear(element); |
| } |
| }, null); |
| getWorkspace().save(true, null); |
| //don't leak builder jobs, since they may affect subsequent tests |
| waitForBuild(); |
| } |
| |
| protected void clear(IFileStore store) { |
| try { |
| store.delete(EFS.NONE, null); |
| } catch (CoreException e) { |
| fail("IResourceTest#clear.99", e); |
| } |
| } |
| |
| /** |
| * Returns a boolean value indicating whether or not the contents |
| * of the given streams are considered to be equal. Closes both input streams. |
| */ |
| public boolean compareContent(InputStream a, InputStream b) { |
| int c, d; |
| if (a == null && b == null) { |
| return true; |
| } |
| try { |
| if (a == null || b == null) { |
| return false; |
| } |
| while ((c = a.read()) == (d = b.read()) && (c != -1 && d != -1)) { |
| //body not needed |
| } |
| return (c == -1 && d == -1); |
| } catch (IOException e) { |
| return false; |
| } finally { |
| assertClose(a); |
| assertClose(b); |
| } |
| } |
| |
| private IPath computeDefaultLocation(IResource target) { |
| switch (target.getType()) { |
| case IResource.ROOT : |
| return Platform.getLocation(); |
| case IResource.PROJECT : |
| return Platform.getLocation().append(target.getFullPath()); |
| default : |
| IPath location = computeDefaultLocation(target.getProject()); |
| location = location.append(target.getFullPath().removeFirstSegments(1)); |
| return location; |
| } |
| } |
| |
| protected void create(final IResource resource, boolean local) throws CoreException { |
| if (resource == null || resource.exists()) { |
| return; |
| } |
| if (!resource.getParent().exists()) { |
| create(resource.getParent(), local); |
| } |
| switch (resource.getType()) { |
| case IResource.FILE : |
| ((IFile) resource).create(local ? new ByteArrayInputStream(new byte[0]) : null, true, getMonitor()); |
| break; |
| case IResource.FOLDER : |
| ((IFolder) resource).create(true, local, getMonitor()); |
| break; |
| case IResource.PROJECT : |
| ((IProject) resource).create(getMonitor()); |
| ((IProject) resource).open(getMonitor()); |
| break; |
| } |
| } |
| |
| /** |
| * Create the given file in the local store. |
| */ |
| public void createFileInFileSystem(IFileStore file) { |
| createFileInFileSystem(file, getRandomContents()); |
| } |
| |
| /** |
| * Create the given file in the local store. |
| */ |
| public void createFileInFileSystem(IFileStore file, InputStream contents) { |
| OutputStream output = null; |
| try { |
| file.getParent().mkdir(EFS.NONE, null); |
| output = file.openOutputStream(EFS.NONE, null); |
| transferData(contents, output); |
| } catch (CoreException e) { |
| fail("ResourceTest#createFileInFileSystem.2", e); |
| } finally { |
| assertClose(output); |
| } |
| } |
| |
| /** |
| * Create the given file in the file system. |
| */ |
| public void createFileInFileSystem(IPath path) { |
| createFileInFileSystem(path, getRandomContents()); |
| } |
| |
| /** |
| * Create the given file in the file system. |
| */ |
| public void createFileInFileSystem(IPath path, InputStream contents) { |
| try { |
| createFileInFileSystem(path.toFile(), contents); |
| } catch (IOException e) { |
| fail("ResourceTest#createFileInFileSystem", e); |
| } |
| } |
| |
| public IResource[] createHierarchy() { |
| IResource[] result = buildResources(); |
| ensureExistsInWorkspace(result, true); |
| return result; |
| } |
| |
| /** |
| * Returns a collection of string paths describing the standard |
| * resource hierarchy for this test. In the string forms, folders are |
| * represented as having trailing separators ('/'). All other resources |
| * are files. It is generally assumed that this hierarchy will be |
| * inserted under some project structure. |
| * For example, |
| * <pre> |
| * return new String[] {"/", "/1/", "/1/1", "/1/2", "/1/3", "/2/", "/2/1"}; |
| * </pre> |
| */ |
| public String[] defineHierarchy() { |
| return new String[0]; |
| } |
| |
| /** |
| * Delete the given resource from the local store. Use the resource |
| * manager to ensure that we have a correct Path -> File mapping. |
| */ |
| public void ensureDoesNotExistInFileSystem(IResource resource) { |
| IPath path = resource.getLocation(); |
| if (path != null) { |
| ensureDoesNotExistInFileSystem(path.toFile()); |
| } |
| } |
| |
| /** |
| * Delete the resources in the array from the local store. |
| */ |
| public void ensureDoesNotExistInFileSystem(IResource[] resources) { |
| for (IResource resource : resources) { |
| ensureDoesNotExistInFileSystem(resource); |
| } |
| } |
| |
| /** |
| * Delete the given resource from the workspace resource tree. |
| */ |
| public void ensureDoesNotExistInWorkspace(IResource resource) { |
| try { |
| if (resource.exists()) { |
| resource.delete(true, null); |
| } |
| } catch (CoreException e) { |
| fail("#ensureDoesNotExistInWorkspace(IResource): " + resource.getFullPath(), e); |
| } |
| } |
| |
| /** |
| * Delete each element of the resource array from the workspace |
| * resource info tree. |
| */ |
| public void ensureDoesNotExistInWorkspace(final IResource[] resources) { |
| IWorkspaceRunnable body = monitor -> { |
| for (IResource resource : resources) { |
| ensureDoesNotExistInWorkspace(resource); |
| } |
| }; |
| try { |
| getWorkspace().run(body, null); |
| } catch (CoreException e) { |
| fail("#ensureDoesNotExistInWorkspace(IResource[])", e); |
| } |
| } |
| |
| /** |
| * Create the given file in the local store. Use the resource manager |
| * to ensure that we have a correct Path -> File mapping. |
| */ |
| public void ensureExistsInFileSystem(IFile file) { |
| createFileInFileSystem(((Resource) file).getStore()); |
| } |
| |
| /** |
| * Create the given folder in the local store. Use the resource |
| * manager to ensure that we have a correct Path -> File mapping. |
| */ |
| public void ensureExistsInFileSystem(IResource resource) { |
| if (resource instanceof IFile) { |
| ensureExistsInFileSystem((IFile) resource); |
| } else { |
| try { |
| ((Resource) resource).getStore().mkdir(EFS.NONE, null); |
| } catch (CoreException e) { |
| fail("ensureExistsInFileSystem.1", e); |
| } |
| } |
| } |
| |
| /** |
| * Create the each resource of the array in the local store. |
| */ |
| public void ensureExistsInFileSystem(IResource[] resources) { |
| for (IResource resource : resources) { |
| ensureExistsInFileSystem(resource); |
| } |
| } |
| |
| /** |
| * Create the given file in the workspace resource info tree. |
| */ |
| public void ensureExistsInWorkspace(final IFile resource, final InputStream contents) { |
| if (resource == null) { |
| return; |
| } |
| IWorkspaceRunnable body = monitor -> { |
| if (resource.exists()) { |
| resource.setContents(contents, true, false, null); |
| } else { |
| ensureExistsInWorkspace(resource.getParent(), true); |
| resource.create(contents, true, null); |
| } |
| }; |
| try { |
| getWorkspace().run(body, null); |
| } catch (CoreException e) { |
| fail("#ensureExistsInWorkspace(IFile, InputStream): " + resource.getFullPath(), e); |
| } |
| } |
| |
| /** |
| * Create the given file in the workspace resource info tree. |
| */ |
| public void ensureExistsInWorkspace(IFile resource, String contents) { |
| ensureExistsInWorkspace(resource, new ByteArrayInputStream(contents.getBytes())); |
| } |
| |
| /** |
| * Create the given resource in the workspace resource info tree. |
| */ |
| public void ensureExistsInWorkspace(final IResource resource, final boolean local) { |
| IWorkspaceRunnable body = monitor -> create(resource, local); |
| try { |
| getWorkspace().run(body, null); |
| } catch (CoreException e) { |
| fail("#ensureExistsInWorkspace(IResource): " + resource.getFullPath(), e); |
| } |
| } |
| |
| /** |
| * Create each element of the resource array in the workspace resource |
| * info tree. |
| */ |
| public void ensureExistsInWorkspace(final IResource[] resources, final boolean local) { |
| IWorkspaceRunnable body = monitor -> { |
| for (IResource resource : resources) { |
| create(resource, local); |
| } |
| }; |
| try { |
| getWorkspace().run(body, null); |
| } catch (CoreException e) { |
| fail("#ensureExistsInWorkspace(IResource[])", e); |
| } |
| } |
| |
| /** |
| * Modifies the passed in IFile in the file system so that it is out of sync |
| * with the workspace. |
| */ |
| public void ensureOutOfSync(final IFile file) { |
| modifyInFileSystem(file); |
| touchInFilesystem(file); |
| assertTrue("File not out of sync: " + file.getLocation().toOSString(), file.getLocation().toFile().lastModified() != file.getLocalTimeStamp()); |
| } |
| |
| /** |
| * Touch (but don't modify) the resource in the filesystem so that it's modification stamp is newer than |
| * the cached value in the Workspace. |
| */ |
| public void touchInFilesystem(IResource resource) { |
| // Ensure the resource exists in the filesystem |
| IPath location = resource.getLocation(); |
| if (!location.toFile().exists()) { |
| ensureExistsInFileSystem(resource); |
| } |
| // Manually check that the core.resource time-stamp is out-of-sync |
| // with the java.io.File last modified. #isSynchronized() will schedule |
| // out-of-sync resources for refresh, so we don't use that here. |
| for (int count = 0; count < 30 && getLastModifiedTime(location) == resource.getLocalTimeStamp(); count++) { |
| try { |
| Thread.sleep(100); |
| } catch (InterruptedException e) { |
| // ignore |
| } |
| FileTime now = FileTime.fromMillis(System.currentTimeMillis()); |
| try { |
| Files.setLastModifiedTime(location.toFile().toPath(), now); |
| } catch (IOException e) { |
| fail("#touchInFilesystem(IResource)", e); |
| } |
| } |
| assertTrue("File not out of sync: " + location.toOSString(), getLastModifiedTime(location) != resource.getLocalTimeStamp()); |
| } |
| |
| private long getLastModifiedTime(IPath fileLocation) { |
| IFileInfo fileInfo = EFS.getLocalFileSystem().getStore(fileLocation).fetchInfo(); |
| return fileInfo.getLastModified(); |
| } |
| |
| private boolean existsInFileSystem(IResource resource) { |
| IPath path = resource.getLocation(); |
| if (path == null) { |
| path = computeDefaultLocation(resource); |
| } |
| return path.toFile().exists(); |
| } |
| |
| private boolean existsInWorkspace(IResource resource, boolean phantom) { |
| IResource target = getWorkspace().getRoot().findMember(resource.getFullPath(), phantom); |
| return target != null && target.getType() == resource.getType(); |
| } |
| |
| /** |
| * Returns the unqualified class name of the receiver (i.e. without the package prefix). |
| */ |
| protected String getClassName() { |
| String fullClassName = getClass().getName(); |
| return fullClassName.substring(fullClassName.lastIndexOf(".") + 1); |
| } |
| |
| /** |
| * Returns invalid sets of natures |
| */ |
| protected String[][] getInvalidNatureSets() { |
| return new String[][] {{NATURE_SNOW}, //missing water pre-req |
| {NATURE_WATER, NATURE_EARTH}, //duplicates from state-set |
| {NATURE_WATER, NATURE_MUD}, //missing earth pre-req |
| {NATURE_WATER, NATURE_EARTH, NATURE_MUD}, //duplicates from state-set |
| {NATURE_SIMPLE, NATURE_SNOW, NATURE_WATER, NATURE_MUD}, //duplicates from other-set, missing pre-req |
| {NATURE_MISSING}, //doesn't exist |
| {NATURE_SIMPLE, NATURE_MISSING}, //missing doesn't exist |
| {NATURE_MISSING_PREREQ}, //requires nature that doesn't exist |
| {NATURE_SIMPLE, NATURE_MISSING_PREREQ}, //requires nature that doesn't exist |
| {NATURE_CYCLE1}, //missing pre-req |
| {NATURE_CYCLE2, NATURE_CYCLE3}, //missing pre-req |
| {NATURE_CYCLE1, NATURE_SIMPLE, NATURE_CYCLE2, NATURE_CYCLE3}, //cycle |
| }; |
| } |
| |
| protected String getLineSeparatorFromFile(IFile file) { |
| if (file.exists()) { |
| InputStream input = null; |
| try { |
| input = file.getContents(); |
| int c = input.read(); |
| while (c != -1 && c != '\r' && c != '\n') { |
| c = input.read(); |
| } |
| if (c == '\n') |
| { |
| return "\n"; //$NON-NLS-1$ |
| } |
| if (c == '\r') { |
| if (input.read() == '\n') |
| { |
| return "\r\n"; //$NON-NLS-1$ |
| } |
| return "\r"; //$NON-NLS-1$ |
| } |
| } catch (CoreException e) { |
| // ignore |
| } catch (IOException e) { |
| // ignore |
| } finally { |
| try { |
| input.close(); |
| } catch (IOException e) { |
| // ignore |
| } |
| } |
| } |
| return null; |
| } |
| |
| /** |
| * Returns a FileStore instance backed by storage in a temporary location. |
| * The returned store will not exist, but will belong to an existing parent. |
| * The tearDown method in this class will ensure the location is deleted after |
| * the test is completed. |
| */ |
| protected IFileStore getTempStore() { |
| IFileStore store = EFS.getLocalFileSystem().getStore(FileSystemHelper.getRandomLocation(getTempDir())); |
| storesToDelete.add(store); |
| return store; |
| } |
| |
| /** |
| * Ensures that the file system location associated with the corresponding path is deleted during test tear down. |
| */ |
| protected void deleteOnTearDown(IPath path) { |
| storesToDelete.add(EFS.getLocalFileSystem().getStore(path)); |
| |
| } |
| |
| @Override |
| public String getUniqueString() { |
| return new UniversalUniqueIdentifier().toString(); |
| } |
| |
| /** |
| * Returns valid sets of natures |
| */ |
| protected String[][] getValidNatureSets() { |
| return new String[][] {{}, {NATURE_SIMPLE}, {NATURE_SNOW, NATURE_WATER}, {NATURE_EARTH}, {NATURE_WATER, NATURE_SIMPLE, NATURE_SNOW},}; |
| } |
| |
| /** |
| * Checks whether the local file system supports accessing and modifying |
| * the given attribute. |
| */ |
| protected boolean isAttributeSupported(int attribute) { |
| return (EFS.getLocalFileSystem().attributes() & attribute) != 0; |
| } |
| |
| /** |
| * Checks whether the local file system supports accessing and modifying |
| * the read-only flag. |
| */ |
| protected boolean isReadOnlySupported() { |
| return isAttributeSupported(EFS.ATTRIBUTE_READ_ONLY); |
| } |
| |
| /** |
| * Modifies the content of the given file in the file system by |
| * appending an 'f'. |
| * @param file |
| */ |
| protected void modifyInFileSystem(IFile file) { |
| String m = getClassName() + ".modifyInFileSystem(IFile): "; |
| String newContent = readStringInFileSystem(file) + "f"; |
| IPath location = file.getLocation(); |
| if (location == null) { |
| fail("0.1 - null location for file: " + file); |
| return; |
| } |
| java.io.File osFile = location.toFile(); |
| try { |
| FileOutputStream os = null; |
| try { |
| os = new FileOutputStream(osFile); |
| os.write(newContent.getBytes("UTF8")); |
| os.close(); |
| } finally { |
| FileUtil.safeClose(os); |
| } |
| } catch (IOException e) { |
| fail(m + "0.0", e); |
| } |
| } |
| |
| /** |
| * Modifies the content of the given file in the workspace by |
| * appending a 'w'. |
| * @param file |
| */ |
| protected void modifyInWorkspace(IFile file) throws CoreException { |
| String m = getClassName() + ".modifyInWorkspace(IFile): "; |
| try { |
| String newContent = readStringInWorkspace(file) + "w"; |
| ByteArrayInputStream is = new ByteArrayInputStream(newContent.getBytes("UTF8")); |
| file.setContents(is, false, false, null); |
| } catch (UnsupportedEncodingException e) { |
| fail(m + "0.0"); |
| } |
| } |
| |
| /** |
| * Returns the content of the given file in the file system as a |
| * byte array. |
| * @param file |
| */ |
| protected byte[] readBytesInFileSystem(IFile file) { |
| String m = getClassName() + ".readBytesInFileSystem(IFile): "; |
| try { |
| IPath location = file.getLocation(); |
| if (location == null) { |
| fail("0.1 - null location for file: " + file); |
| return null; |
| } |
| java.io.File osFile = location.toFile(); |
| FileInputStream is = new FileInputStream(osFile); |
| ByteArrayOutputStream os = new ByteArrayOutputStream(); |
| transferData(is, os); |
| return os.toByteArray(); |
| } catch (IOException e) { |
| fail(m + "0.0", e); |
| } |
| return null; |
| } |
| |
| /** |
| * Returns the content of the given file in the workspace as a |
| * byte array. |
| */ |
| protected byte[] readBytesInWorkspace(IFile file) { |
| String m = getClassName() + ".readBytesInWorkspace(IFile): "; |
| try { |
| InputStream is = file.getContents(false); |
| ByteArrayOutputStream os = new ByteArrayOutputStream(); |
| transferData(is, os); |
| return os.toByteArray(); |
| } catch (CoreException e) { |
| fail(m + "0.0", e); |
| } |
| return null; |
| } |
| |
| /** |
| * Returns the content of the given file in the file system as a |
| * String (UTF8). |
| * @param file |
| */ |
| protected String readStringInFileSystem(IFile file) { |
| String m = getClassName() + ".readStringInFileSystem(IFile): "; |
| try { |
| return new String(readBytesInFileSystem(file), "UTF8"); |
| } catch (UnsupportedEncodingException e) { |
| fail(m + "0.0", e); |
| } |
| return null; |
| } |
| |
| /** |
| * Returns the content of the given file in the workspace as a |
| * String (UTF8). |
| * @param file |
| */ |
| protected String readStringInWorkspace(IFile file) { |
| String m = getClassName() + ".readStringInWorkspace(IFile): "; |
| try { |
| return new String(readBytesInWorkspace(file), "UTF8"); |
| } catch (UnsupportedEncodingException e) { |
| fail(m + "0.0", e); |
| } |
| return null; |
| } |
| |
| protected void setAttribute(IFileStore target, int attribute, boolean value) { |
| assertTrue("setAttribute.1", isAttributeSupported(attribute)); |
| IFileInfo fileInfo = target.fetchInfo(); |
| fileInfo.setAttribute(attribute, value); |
| try { |
| target.putInfo(fileInfo, EFS.SET_ATTRIBUTES, null); |
| } catch (CoreException e) { |
| fail("ResourceTest#setAttribute", e); |
| } |
| } |
| |
| protected void setReadOnly(IFileStore target, boolean value) { |
| assertTrue("setReadOnly.1", isReadOnlySupported()); |
| IFileInfo fileInfo = target.fetchInfo(); |
| fileInfo.setAttribute(EFS.ATTRIBUTE_READ_ONLY, value); |
| try { |
| target.putInfo(fileInfo, EFS.SET_ATTRIBUTES, null); |
| } catch (CoreException e) { |
| fail("ResourceTest#setReadOnly", e); |
| } |
| } |
| |
| protected void setReadOnly(IResource target, boolean value) { |
| ResourceAttributes attributes = target.getResourceAttributes(); |
| assertNotNull("setReadOnly for null attributes", attributes); |
| attributes.setReadOnly(value); |
| try { |
| target.setResourceAttributes(attributes); |
| } catch (CoreException e) { |
| fail("ResourceTest#setReadOnly", e); |
| } |
| } |
| |
| /** |
| * The environment should be set-up in the main method. |
| */ |
| @Override |
| protected void setUp() throws Exception { |
| assertNotNull("Workspace was not setup", getWorkspace()); |
| } |
| |
| @Override |
| protected void tearDown() throws Exception { |
| super.tearDown(); |
| // Ensure everything is in a clean state for next one. |
| // Session tests should overwrite it. |
| cleanup(); |
| } |
| |
| /** |
| * Blocks the calling thread until autobuild completes. |
| */ |
| protected void waitForBuild() { |
| try { |
| Job.getJobManager().join(ResourcesPlugin.FAMILY_AUTO_BUILD, null); |
| } catch (OperationCanceledException e) { |
| //ignore |
| } catch (InterruptedException e) { |
| //ignore |
| } |
| } |
| |
| /** |
| * Blocks the calling thread until autobuild completes. |
| */ |
| protected void waitForRefresh() { |
| try { |
| Job.getJobManager().join(ResourcesPlugin.FAMILY_AUTO_REFRESH, null); |
| } catch (OperationCanceledException e) { |
| //ignore |
| } catch (InterruptedException e) { |
| //ignore |
| } |
| } |
| |
| public String[] findAvailableDevices() { |
| String[] devices = new String[2]; |
| for (int i = 97/*a*/; i < 123/*z*/; i++) { |
| char c = (char) i; |
| java.io.File rootFile = new java.io.File(c + ":\\"); |
| if (rootFile.exists() && rootFile.canWrite()) { |
| //sometimes canWrite can return true but we are still not allowed to create a file - see bug 379284. |
| File probe = new File(rootFile, getUniqueString()); |
| try { |
| probe.createNewFile(); |
| } catch (IOException e) { |
| //can't create a file here.. try another device |
| continue; |
| } finally { |
| probe.delete(); |
| } |
| if (devices[0] == null) { |
| devices[0] = c + ":/"; |
| } else { |
| devices[1] = c + ":/"; |
| break; |
| } |
| } |
| } |
| return devices; |
| } |
| } |