/*******************************************************************************
* 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
*******************************************************************************/
package org.eclipse.core.tests.internal.localstore;
import java.io.InputStream;
import java.net.URI;
import java.net.URISyntaxException;
import junit.framework.Test;
import junit.framework.TestSuite;
import org.eclipse.core.filesystem.IFileInfo;
import org.eclipse.core.filesystem.IFileStore;
import org.eclipse.core.internal.resources.*;
import org.eclipse.core.resources.*;
import org.eclipse.core.runtime.*;
import org.eclipse.core.tests.internal.filesystem.bug440110.Bug440110FileSystem;
//
public class FileSystemResourceManagerTest extends LocalStoreTest implements ICoreConstants {
public FileSystemResourceManagerTest() {
super();
}
public FileSystemResourceManagerTest(String name) {
super(name);
}
@Override
public String[] defineHierarchy() {
return new String[] {"/Folder1/", "/Folder1/File1", "/Folder1/Folder2/", "/Folder1/Folder2/File2", "/Folder1/Folder2/Folder3/"};
}
public static Test suite() {
return new TestSuite(FileSystemResourceManagerTest.class);
}
public void testBug440110() throws URISyntaxException, CoreException {
String projectName = getUniqueString();
IWorkspace workspace = getWorkspace();
IProject project = workspace.getRoot().getProject(projectName);
IProjectDescription projectDescription = workspace.newProjectDescription(projectName);
projectDescription.setLocationURI(new URI(Bug440110FileSystem.SCHEME + "://" + projectName));
project.create(projectDescription, null);
project.open(null);
assertEquals("0.1", Bug440110FileSystem.SCHEME, project.getLocationURI().getScheme());
IFolder folder = project.getFolder("folder");
folder.create(true, true, null);
assertEquals("0.2", Bug440110FileSystem.SCHEME, folder.getLocationURI().getScheme());
Bug440110FileSystem.clearFetchedFileTree();
folder.refreshLocal(IResource.DEPTH_ZERO, null);
assertFalse("1.0", Bug440110FileSystem.hasFetchedFileTree());
Bug440110FileSystem.clearFetchedFileTree();
folder.refreshLocal(IResource.DEPTH_ONE, null);
assertTrue("2.0", Bug440110FileSystem.hasFetchedFileTree());
Bug440110FileSystem.clearFetchedFileTree();
folder.refreshLocal(IResource.DEPTH_INFINITE, null);
assertTrue("3.0", Bug440110FileSystem.hasFetchedFileTree());
}
/**
*/
public void testContainerFor() throws Throwable {
/* test null parameter */
try {
getLocalManager().containerForLocation(null);
fail("1.1");
} catch (RuntimeException e) {
// expected
}
/* test normal conditions under default mapping */
// project/target
Path path = new Path("target");
IFolder folder = projects[0].getFolder(path);
IPath location = projects[0].getLocation().append(path);
IFolder testFolder = (IFolder) getLocalManager().containerForLocation(location);
assertTrue("2.1", folder.equals(testFolder));
// project/folder/target
path = new Path("folder/target");
folder = projects[0].getFolder(path);
location = projects[0].getLocation().append(path);
testFolder = (IFolder) getLocalManager().containerForLocation(location);
assertTrue("2.2", folder.equals(testFolder));
// project/folder/folder/target
path = new Path("folder/folder/target");
folder = projects[0].getFolder(path);
location = projects[0].getLocation().append(path);
testFolder = (IFolder) getLocalManager().containerForLocation(location);
assertTrue("2.3", folder.equals(testFolder));
/* non-existent location */
testFolder = (IFolder) getLocalManager().containerForLocation(new Path("../this/path/must/not/exist"));
assertTrue("3.1", testFolder == null);
}
/**
* this test should move to FileTest
*/
public void testCreateFile() throws Throwable {
/* initialize common objects */
IProject project = projects[0];
File file = (File) project.getFile("foo");
/* common contents */
String originalContent = "this string should not be equal the other";
/* create file with flag false */
try {
file.create(getContents(originalContent), false, null);
} catch (CoreException e) {
fail("1.1", e);
}
assertTrue("1.2", file.exists());
assertTrue("1.3", file.isLocal(IResource.DEPTH_ZERO));
assertEquals("1.4", file.getStore().fetchInfo().getLastModified(), file.getResourceInfo(false, false).getLocalSyncInfo());
try {
assertTrue("1.5", compareContent(getContents(originalContent), getLocalManager().read(file, true, null)));
} catch (CoreException e) {
fail("1.6", e);
}
}
/**
*/
public void testFileFor() throws Throwable {
/* test null parameter */
try {
getLocalManager().fileForLocation(null);
fail("1.1");
} catch (RuntimeException e) {
// expected
}
/* test normal conditions under default mapping */
// project/file
Path path = new Path("file");
IFile file = projects[0].getFile(path);
IPath location = projects[0].getLocation().append(path);
IFile testFile = getLocalManager().fileForLocation(location);
assertTrue("2.1", file.equals(testFile));
// project/folder/file
path = new Path("folder/file");
file = projects[0].getFile(path);
location = projects[0].getLocation().append(path);
testFile = getLocalManager().fileForLocation(location);
assertTrue("2.2", file.equals(testFile));
// project/folder/folder/file
path = new Path("folder/folder/file");
file = projects[0].getFile(path);
location = projects[0].getLocation().append(path);
testFile = getLocalManager().fileForLocation(location);
assertTrue("2.3", file.equals(testFile));
/* non-existent location */
testFile = getLocalManager().fileForLocation(new Path("../this/path/must/not/exist"));
assertTrue("7.1", testFile == null);
}
public void testIsLocal() throws Throwable {
/* initialize common objects */
final IProject project = projects[0];
// create resources
IResource[] resources = buildResources(project, defineHierarchy());
ensureExistsInWorkspace(resources, true);
ensureDoesNotExistInFileSystem(resources);
// exists
assertTrue("1.0", project.isLocal(IResource.DEPTH_INFINITE)); // test
// test the depth parameter
final IFolder folder = project.getFolder("Folder1");
IWorkspaceRunnable operation = monitor -> {
IResource[] members = folder.members();
for (IResource member : members) {
((Resource) member).getResourceInfo(false, true).clear(M_LOCAL_EXISTS);
}
};
getWorkspace().run(operation, null);
assertTrue("2.0", project.isLocal(IResource.DEPTH_ONE));
assertTrue("3.0", folder.isLocal(IResource.DEPTH_ZERO));
assertTrue("4.0", !folder.isLocal(IResource.DEPTH_INFINITE));
// remove the trash
ensureDoesNotExistInWorkspace(project);
}
/**
* Scenario:
* 1 solution
* 3 projects
*/
public void testLocationFor() throws Throwable {
/* test project */
IPath location = projects[0].getLocation();
assertTrue("2.1", location.equals(getLocalManager().locationFor(projects[0])));
assertTrue("2.2", location.equals(getWorkspace().getRoot().getLocation().append(projects[0].getName())));
}
/**
* Scenario:
* 1 solution
* 3 projects
*/
public void testResourcePathFor() throws Throwable {
///* test null parameter */
//try {
//getLocalManager().resourcePathFor(null);
//fail("1.1");
//} catch (RuntimeException e) {
//} catch (CoreException e) {
//fail("1.2", e);
//}
///* test normal conditions under default mapping */
//// project/file
//Path path = new Path("file");
//IFile file = projects[0].getFile(path);
//IPath location = projects[0].getLocation().append(path);
//IPath testPath = getLocalManager().resourcePathFor(location);
//assert("2.1", file.getFullPath().equals(testPath));
//// project/folder/file
//path = new Path("folder/file");
//file = projects[0].getFile(path);
//location = projects[0].getLocation().append(path);
//testPath = getLocalManager().resourcePathFor(location);
//assert("2.2", file.getFullPath().equals(testPath));
//// project/folder/folder/file
//path = new Path("folder/folder/file");
//file = projects[0].getFile(path);
//location = projects[0].getLocation().append(path);
//testPath = getLocalManager().resourcePathFor(location);
//assert("2.3", file.getFullPath().equals(testPath));
}
public void testSynchronizeProject() throws Throwable {
/* test DEPTH parameter */
/* DEPTH_ZERO */
IFile file = projects[0].getFile("file");
ensureExistsInFileSystem(file);
projects[0].refreshLocal(IResource.DEPTH_ZERO, null);
assertTrue("1.1", !file.exists());
/* DEPTH_ONE */
IFolder folder = projects[0].getFolder("folder");
IFolder subfolder = folder.getFolder("subfolder");
IFile subfile = folder.getFile("subfile");
ensureExistsInFileSystem(folder);
ensureExistsInFileSystem(subfolder);
ensureExistsInFileSystem(subfile);
projects[0].refreshLocal(IResource.DEPTH_ONE, null);
assertTrue("2.1", file.exists());
assertTrue("2.2", folder.exists());
assertTrue("2.3", !subfolder.exists());
assertTrue("2.4", !subfile.exists());
/* DEPTH_INFINITE */
projects[0].refreshLocal(IResource.DEPTH_INFINITE, null);
assertTrue("3.1", file.exists());
assertTrue("3.2", folder.exists());
assertTrue("3.3", subfolder.exists());
assertTrue("3.4", subfile.exists());
/* closed project */
file = projects[0].getFile("closed");
projects[0].close(null);
ensureExistsInFileSystem(file);
projects[0].open(null);
assertTrue("4.1", !file.exists());
projects[0].refreshLocal(IResource.DEPTH_INFINITE, null);
assertTrue("4.2", file.exists());
/* refreshing an inexisting project should do nothing */
getWorkspace().getRoot().getProject("inexistingProject").refreshLocal(IResource.DEPTH_INFINITE, null);
}
public void testWriteFile() {
/* initialize common objects */
IProject project = projects[0];
IFile file = project.getFile("foo");
ensureExistsInWorkspace(file, true);
/* common contents */
String originalContent = "this string should not be equal the other";
String anotherContent = "and this string should not... well, you know...";
InputStream original;
InputStream another;
/* write file for the first time */
original = getContents(originalContent);
try {
write(file, original, true, null);
} catch (CoreException e) {
fail("1.0", e);
}
original = getContents(originalContent);
try {
assertTrue("1.1", compareContent(original, getLocalManager().read(file, true, null)));
} catch (CoreException e) {
fail("1.2", e);
}
/* test the overwrite parameter (false) */
another = getContents(anotherContent);
try {
write(file, another, false, null);
} catch (CoreException e) {
fail("2.0", e);
}
another = getContents(anotherContent);
try {
assertTrue("2.1", compareContent(another, getLocalManager().read(file, true, null)));
} catch (CoreException e) {
fail("2.2", e);
}
/* test the overwrite parameter (true) */
original = getContents(originalContent);
try {
write(file, original, true, null);
} catch (CoreException e) {
fail("3.0", e);
}
original = getContents(originalContent);
try {
assertTrue("3.1", compareContent(original, getLocalManager().read(file, true, null)));
} catch (CoreException e) {
fail("3.2", e);
}
/* test the overwrite parameter (false) */
ensureOutOfSync(file);
another = getContents(anotherContent);
try {
write(file, another, false, null);
fail("4.0");
} catch (CoreException e) {
// expected
}
try {
file.setContents(another, false, false, null);
fail("4.3");
} catch (CoreException e) {
// expected
}
try {
file.setContents(another, true, false, null);
} catch (CoreException e) {
fail("4.4", e);
}
/* test the overwrite parameter (false) */
ensureDoesNotExistInFileSystem(file);
another = getContents(anotherContent);
try {
write(file, another, false, null);
fail("5.0");
} catch (CoreException e) {
// expected
}
/* remove trash */
ensureDoesNotExistInWorkspace(project);
}
public void testWriteFolder() throws Throwable {
/* initialize common objects */
IProject project = projects[0];
IFolder folder = project.getFolder("foo");
ensureExistsInWorkspace(folder, true);
boolean ok;
/* existing file on destination */
ensureDoesNotExistInFileSystem(folder);
IFile file = project.getFile("foo");
ensureExistsInFileSystem(file);
/* force = true */
ok = false;
try {
write(folder, true, null);
} catch (CoreException e) {
ok = true;
}
assertTrue("1.1", ok);
/* force = false */
ok = false;
try {
write(folder, false, null);
} catch (CoreException e) {
ok = true;
}
assertTrue("1.2", ok);
ensureDoesNotExistInFileSystem(file);
/* existing folder on destination */
ensureExistsInFileSystem(folder);
/* force = true */
write(folder, true, null);
assertTrue("2.1", folder.getLocation().toFile().isDirectory());
/* force = false */
ok = false;
try {
write(folder, false, null);
} catch (CoreException e) {
ok = true;
}
assertTrue("2.2", ok);
ensureDoesNotExistInFileSystem(folder);
/* inexisting resource on destination */
/* force = true */
write(folder, true, null);
assertTrue("3.1", folder.getLocation().toFile().isDirectory());
ensureDoesNotExistInFileSystem(folder);
/* force = false */
write(folder, false, null);
assertTrue("3.1", folder.getLocation().toFile().isDirectory());
}
/**
* 1.2 - write a project with default local location
* 2.1 - delete project's local location
*/
public void testWriteProject() throws Throwable {
/* initialize common objects */
final IProject project = projects[0];
IFile dotProject = project.getFile(IProjectDescription.DESCRIPTION_FILE_NAME);
final IFileStore fileStore = ((Resource) project).getStore();
// create project and then delete from file system
// wrap in runnable to prevent snapshot from occurring in the middle.
getWorkspace().run((IWorkspaceRunnable) monitor -> {
ensureDoesNotExistInFileSystem(project);
assertTrue("2.1", !fileStore.fetchInfo().isDirectory());
//write project in a runnable, otherwise tree will be locked
((Project) project).writeDescription(IResource.FORCE);
}, null);
assertTrue("2.2", fileStore.fetchInfo().isDirectory());
long lastModified = ((Resource) dotProject).getStore().fetchInfo().getLastModified();
assertEquals("2.3", lastModified, ((Resource) project).getResourceInfo(false, false).getLocalSyncInfo());
}
protected void write(final IFile file, final InputStream contents, final boolean force, IProgressMonitor monitor) throws CoreException {
IWorkspaceRunnable operation = pm -> {
int flags = force ? IResource.FORCE : IResource.NONE;
IFileInfo info = ((Resource) file).getStore().fetchInfo();
getLocalManager().write(file, contents, info, flags, false, null);
};
getWorkspace().run(operation, null);
}
protected void write(final IFolder folder, final boolean force, IProgressMonitor monitor) throws CoreException {
IWorkspaceRunnable operation = pm -> getLocalManager().write(folder, force, null);
getWorkspace().run(operation, null);
}
}