/*******************************************************************************
* Copyright (c) 2000, 2012 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.filesystem;
import java.io.File;
import java.io.OutputStream;
import java.net.URI;
import java.net.URISyntaxException;
import java.util.Date;
import junit.framework.Test;
import junit.framework.TestSuite;
import org.eclipse.core.filesystem.*;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.runtime.*;
import org.eclipse.core.tests.internal.localstore.LocalStoreTest;
/**
* Basic tests for the IFileStore API
*/
public class FileStoreTest extends LocalStoreTest {
public static Test suite() {
return new TestSuite(FileStoreTest.class);
}
public FileStoreTest() {
super();
}
public FileStoreTest(String name) {
super(name);
}
private IFileStore createDir(IFileStore store, boolean clear) throws CoreException {
if (clear && store.fetchInfo().exists()) {
store.delete(EFS.NONE, null);
}
store.mkdir(EFS.NONE, null);
IFileInfo info = store.fetchInfo();
assertTrue("createDir.1", info.exists());
assertTrue("createDir.1", info.isDirectory());
return store;
}
private IFileStore createDir(String string, boolean clear) throws CoreException {
return createDir(EFS.getFileSystem(EFS.SCHEME_FILE).getStore(new Path(string)), clear);
}
/**
* Tests behavior of IFileStore#fetchInfo when underlying file system
* throws exceptions.
*/
public void testBrokenFetchInfo() {
IFileStore broken = null;
try {
broken = EFS.getStore(new URI("broken://a/b/c"));
} catch (CoreException e) {
fail("0.98", e);
} catch (URISyntaxException e) {
fail("0.99", e);
}
//no-arg fetch info should return non-existent file
IFileInfo info = broken.fetchInfo();
assertTrue("1.0", !info.exists());
//two-arg fetchInfo should throw exception
try {
info = broken.fetchInfo(EFS.NONE, getMonitor());
fail("2.0");
} catch (CoreException e) {
//expected
}
}
private IFileStore getDirFileStore(String path) throws CoreException {
IFileStore store = EFS.getFileSystem(EFS.SCHEME_FILE).getStore(new Path(path));
store.mkdir(EFS.NONE, null);
return store;
}
private IFileStore[] getFileStoresOnTwoVolumes() {
IFileStore[] tempDirs = new IFileStore[2];
for (int i = 99/*c*/; i < 123/*z*/; i++) {
char c = (char) i;
try {
IFileStore store = getDirFileStore(c + ":/temp");
IFileInfo info = store.fetchInfo();
if (info.exists() && info.isDirectory() && !info.getAttribute(EFS.ATTRIBUTE_READ_ONLY)) {
if (tempDirs[0] == null) {
tempDirs[0] = store;
} else {
tempDirs[1] = store;
break; //both temp dirs have been created
}
}
} catch (CoreException e) {//ignore and go to next volume
continue;
}
}
return tempDirs;
}
/**
* Basically this is a test for the Windows Platform.
*/
public void testCopyAcrossVolumes() throws Throwable {
IFileStore[] tempDirectories = getFileStoresOnTwoVolumes();
/* test if we are in the adequate environment */
if (tempDirectories == null || tempDirectories.length < 2 || tempDirectories[0] == null || tempDirectories[1] == null) {
return;
}
/* build scenario */
// create source root folder
IFileStore tempSrc = tempDirectories[0];
/* get the destination folder */
IFileStore tempDest = tempDirectories[1];
// create tree
IFileStore target = tempSrc.getChild("target");
createDir(target, true);
createTree(getTree(target));
/* c:\temp\target -> d:\temp\target */
IFileStore destination = tempDest.getChild("target");
target.copy(destination, EFS.NONE, null);
assertTrue("3.1", verifyTree(getTree(destination)));
destination.delete(EFS.NONE, null);
/* c:\temp\target -> d:\temp\copy of target */
destination = tempDest.getChild("copy of target");
target.copy(destination, EFS.NONE, null);
assertTrue("4.1", verifyTree(getTree(destination)));
destination.delete(EFS.NONE, null);
/* c:\temp\target -> d:\temp\target (but the destination is already a file) */
destination = tempDest.getChild("target");
String anotherContent = "nothing..................gnihton";
createFile(destination, anotherContent);
assertTrue("5.1", !destination.fetchInfo().isDirectory());
try {
target.copy(destination, EFS.NONE, null);
fail("5.2");
} catch (CoreException e) {
//should fail
}
assertTrue("5.3", !verifyTree(getTree(destination)));
destination.delete(EFS.NONE, null);
/* c:\temp\target -> d:\temp\target (but the destination is already a folder */
destination = tempDest.getChild("target");
createDir(destination, true);
target.copy(destination, EFS.NONE, null);
assertTrue("6.2", verifyTree(getTree(destination)));
destination.delete(EFS.NONE, null);
/* remove trash */
target.delete(EFS.NONE, null);
}
public void testCopyDirectory() throws Throwable {
/* build scenario */
IFileStore temp = EFS.getFileSystem(EFS.SCHEME_FILE).getStore(getWorkspace().getRoot().getLocation().append("temp"));
temp.mkdir(EFS.NONE, null);
assertTrue("1.1", temp.fetchInfo().isDirectory());
// create tree
IFileStore target = temp.getChild("target");
target.delete(EFS.NONE, null);
createTree(getTree(target));
/* temp\target -> temp\copy of target */
IFileStore copyOfTarget = temp.getChild("copy of target");
target.copy(copyOfTarget, EFS.NONE, null);
assertTrue("2.1", verifyTree(getTree(copyOfTarget)));
/* remove trash */
target.delete(EFS.NONE, null);
copyOfTarget.delete(EFS.NONE, null);
}
public void testCopyDirectoryParentMissing() throws Throwable {
IFileStore parent = getTempStore();
IFileStore child = parent.getChild("child");
IFileStore existing = getTempStore();
createFile(existing, getRandomString());
//try to copy when parent of destination does not exist
try {
existing.copy(child, EFS.NONE, getMonitor());
fail("1.0");
} catch (CoreException e) {
//should fail
}
//destination should not exist
assertTrue("1.1", !child.fetchInfo().exists());
}
public void testCopyFile() throws Throwable {
/* build scenario */
IFileStore temp = createDir(getWorkspace().getRoot().getLocation().append("temp").toString(), true);
// create target
String content = "this is just a simple content \n to a simple file \n to test a 'simple' copy";
IFileStore target = temp.getChild("target");
target.delete(EFS.NONE, null);
createFile(target, content);
assertTrue("1.3", target.fetchInfo().exists());
assertTrue("1.4", compareContent(getContents(content), target.openInputStream(EFS.NONE, null)));
/* temp\target -> temp\copy of target */
IFileStore copyOfTarget = temp.getChild("copy of target");
target.copy(copyOfTarget, IResource.DEPTH_INFINITE, null);
assertTrue("2.1", compareContent(getContents(content), copyOfTarget.openInputStream(EFS.NONE, null)));
copyOfTarget.delete(EFS.NONE, null);
// We need to know whether or not we can unset the read-only flag
// in order to perform this part of the test.
if (isReadOnlySupported()) {
/* make source read-only and try the copy temp\target -> temp\copy of target */
copyOfTarget = temp.getChild("copy of target");
setReadOnly(target, true);
target.copy(copyOfTarget, IResource.DEPTH_INFINITE, null);
assertTrue("3.1", compareContent(getContents(content), copyOfTarget.openInputStream(EFS.NONE, null)));
// reset read only flag for cleanup
setReadOnly(copyOfTarget, false);
copyOfTarget.delete(EFS.NONE, null);
// reset the read only flag for cleanup
setReadOnly(target, false);
target.delete(EFS.NONE, null);
}
/* copy a big file to test progress monitor */
StringBuffer sb = new StringBuffer();
for (int i = 0; i < 1000; i++) {
sb.append("asdjhasldhaslkfjhasldkfjhasdlkfjhasdlfkjhasdflkjhsdaf");
}
IFileStore bigFile = temp.getChild("bigFile");
createFile(bigFile, sb.toString());
assertTrue("7.1", bigFile.fetchInfo().exists());
assertTrue("7.2", compareContent(getContents(sb.toString()), bigFile.openInputStream(EFS.NONE, null)));
IFileStore destination = temp.getChild("copy of bigFile");
//IProgressMonitor monitor = new LoggingProgressMonitor(System.out);
IProgressMonitor monitor = getMonitor();
bigFile.copy(destination, EFS.NONE, monitor);
assertTrue("7.3", compareContent(getContents(sb.toString()), destination.openInputStream(EFS.NONE, null)));
destination.delete(EFS.NONE, null);
/* take out the trash */
temp.delete(EFS.NONE, null);
}
/**
* Basically this is a test for the Windows Platform.
*/
public void testCopyFileAcrossVolumes() throws Throwable {
IFileStore[] tempDirectories = getFileStoresOnTwoVolumes();
/* test if we are in the adequate environment */
if (tempDirectories == null || tempDirectories.length < 2 || tempDirectories[0] == null || tempDirectories[1] == null) {
return;
}
/* build scenario */
/* get the source folder */
IFileStore tempSrc = tempDirectories[0];
/* get the destination folder */
IFileStore tempDest = tempDirectories[1];
// create target
String content = "this is just a simple content \n to a simple file \n to test a 'simple' copy";
IFileStore target = tempSrc.getChild("target");
target.delete(EFS.NONE, null);
createFile(target, content);
assertTrue("1.3", target.fetchInfo().exists());
assertTrue("1.4", compareContent(getContents(content), target.openInputStream(EFS.NONE, null)));
/* c:\temp\target -> d:\temp\target */
IFileStore destination = tempDest.getChild("target");
target.copy(destination, IResource.DEPTH_INFINITE, null);
assertTrue("3.1", compareContent(getContents(content), destination.openInputStream(EFS.NONE, null)));
destination.delete(EFS.NONE, null);
/* c:\temp\target -> d:\temp\copy of target */
destination = tempDest.getChild("copy of target");
target.copy(destination, IResource.DEPTH_INFINITE, null);
assertTrue("4.1", compareContent(getContents(content), destination.openInputStream(EFS.NONE, null)));
destination.delete(EFS.NONE, null);
/* c:\temp\target -> d:\temp\target (but the destination is already a file */
destination = tempDest.getChild("target");
String anotherContent = "nothing..................gnihton";
createFile(destination, anotherContent);
assertTrue("5.1", !destination.fetchInfo().isDirectory());
target.copy(destination, IResource.DEPTH_INFINITE, null);
assertTrue("5.2", compareContent(getContents(content), destination.openInputStream(EFS.NONE, null)));
destination.delete(EFS.NONE, null);
/* c:\temp\target -> d:\temp\target (but the destination is already a folder */
destination = tempDest.getChild("target");
createDir(destination, true);
assertTrue("6.1", destination.fetchInfo().isDirectory());
boolean ok = false;
try {
target.copy(destination, EFS.NONE, null);
} catch (CoreException e) {
/* test if the input stream inside the copy method was closed */
target.delete(EFS.NONE, null);
createFile(target, content);
ok = true;
}
assertTrue("6.2", ok);
assertTrue("6.3", destination.fetchInfo().isDirectory());
destination.delete(EFS.NONE, null);
/* remove trash */
target.delete(EFS.NONE, null);
}
public void testGetLength() throws Exception {
// evaluate test environment
IPath root = getWorkspace().getRoot().getLocation().append("" + new Date().getTime());
IFileStore temp = createDir(root.toString(), true);
try {
// create common objects
IFileStore target = temp.getChild("target");
// test non-existent file
assertEquals("1.0", EFS.NONE, target.fetchInfo().getLength());
// create empty file
target.openOutputStream(EFS.NONE, null).close();
assertEquals("1.0", 0, target.fetchInfo().getLength());
// add a byte
OutputStream out = target.openOutputStream(EFS.NONE, null);
out.write(5);
out.close();
assertEquals("1.0", 1, target.fetchInfo().getLength());
} finally {
/* remove trash */
temp.delete(EFS.NONE, null);
}
}
public void testGetStat() throws CoreException {
/* evaluate test environment */
IPath root = getWorkspace().getRoot().getLocation().append("" + new Date().getTime());
IFileStore temp = createDir(root.toString(), true);
/* create common objects */
IFileStore target = temp.getChild("target");
long stat;
/* test stat with an non-existing file */
stat = target.fetchInfo().getLastModified();
assertEquals("1.0", EFS.NONE, stat);
/* test stat with an existing folder */
createDir(target, true);
stat = target.fetchInfo().getLastModified();
assertTrue("2.0", EFS.NONE != stat);
/* remove trash */
temp.delete(EFS.NONE, null);
}
public void testMove() throws Throwable {
/* build scenario */
IFileStore tempC = createDir(getWorkspace().getRoot().getLocation().append("temp").toString(), true);
// create target file
IFileStore target = tempC.getChild("target");
String content = "just a content.....tnetnoc a tsuj";
createFile(target, content);
assertTrue("1.3", target.fetchInfo().exists());
// create target tree
IFileStore tree = tempC.getChild("tree");
createDir(tree, true);
createTree(getTree(tree));
/* rename file */
IFileStore destination = tempC.getChild("destination");
target.move(destination, EFS.NONE, null);
assertTrue("2.1", !destination.fetchInfo().isDirectory());
assertTrue("2.2", !target.fetchInfo().exists());
destination.move(target, EFS.NONE, null);
assertTrue("2.3", !target.fetchInfo().isDirectory());
assertTrue("2.4", !destination.fetchInfo().exists());
/* rename file (but destination is already a file) */
String anotherContent = "another content";
createFile(destination, anotherContent);
boolean ok = false;
try {
target.move(destination, EFS.NONE, null);
} catch (CoreException e) {
ok = true;
}
assertTrue("3.1", ok);
assertTrue("3.2", !target.fetchInfo().isDirectory());
destination.delete(EFS.NONE, null);
assertTrue("3.3", !destination.fetchInfo().exists());
/* rename file (but destination is already a folder) */
createDir(destination, true);
try {
target.move(destination, EFS.NONE, null);
} catch (CoreException e) {
ok = true;
}
assertTrue("4.1", ok);
assertTrue("4.2", !target.fetchInfo().isDirectory());
destination.delete(EFS.NONE, null);
assertTrue("4.3", !destination.fetchInfo().exists());
/* rename folder */
destination = tempC.getChild("destination");
tree.move(destination, EFS.NONE, null);
assertTrue("6.1", verifyTree(getTree(destination)));
assertTrue("6.2", !tree.fetchInfo().exists());
destination.move(tree, EFS.NONE, null);
assertTrue("6.3", verifyTree(getTree(tree)));
assertTrue("6.4", !destination.fetchInfo().exists());
/* remove trash */
target.delete(EFS.NONE, null);
tree.delete(EFS.NONE, null);
}
public void testMoveAcrossVolumes() throws Throwable {
IFileStore[] tempDirectories = getFileStoresOnTwoVolumes();
/* test if we are in the adequate environment */
if (tempDirectories == null || tempDirectories.length < 2 || tempDirectories[0] == null || tempDirectories[1] == null) {
return;
}
/* build scenario */
/* get the source folder */
IFileStore tempSrc = tempDirectories[0];
/* get the destination folder */
IFileStore tempDest = tempDirectories[1];
// create target file
IFileStore target = tempSrc.getChild("target");
String content = "just a content.....tnetnoc a tsuj";
createFile(target, content);
assertTrue("1.3", target.fetchInfo().exists());
// create target tree
IFileStore tree = tempSrc.getChild("tree");
createDir(tree, true);
createTree(getTree(tree));
/* move file across volumes */
IFileStore destination = tempDest.getChild("target");
target.move(destination, EFS.NONE, null);
assertTrue("5.1", !destination.fetchInfo().isDirectory());
assertTrue("5.2", !target.fetchInfo().exists());
destination.move(target, EFS.NONE, null);
assertTrue("5.3", !target.fetchInfo().isDirectory());
assertTrue("5.4", !destination.fetchInfo().exists());
/* move folder across volumes */
destination = tempDest.getChild("target");
tree.move(destination, EFS.NONE, null);
assertTrue("9.1", verifyTree(getTree(destination)));
assertTrue("9.2", !tree.fetchInfo().exists());
destination.move(tree, EFS.NONE, null);
assertTrue("9.3", verifyTree(getTree(tree)));
assertTrue("9.4", !destination.fetchInfo().exists());
/* remove trash */
target.delete(EFS.NONE, null);
tree.delete(EFS.NONE, null);
}
public void testMoveDirectoryParentMissing() throws Throwable {
IFileStore parent = getTempStore();
IFileStore child = parent.getChild("child");
IFileStore existing = getTempStore();
createFile(existing, getRandomString());
//try to move when parent of destination does not exist
try {
existing.move(child, EFS.NONE, getMonitor());
fail("1.0");
} catch (CoreException e) {
//should fail
}
//destination should not exist
assertTrue("1.1", !child.fetchInfo().exists());
}
/**
* Tests public API method {@link IFileStore#putInfo(IFileInfo, int, IProgressMonitor)}.
*/
public void testPutInfo() {
IFileStore nonExisting = getTempStore();
//assert that modifying a non-existing store fails
IFileInfo info = nonExisting.fetchInfo();
info.setLastModified(System.currentTimeMillis());
try {
nonExisting.putInfo(info, EFS.SET_LAST_MODIFIED, getMonitor());
fail("1.0");
} catch (CoreException e) {
//expected
}
info = nonExisting.fetchInfo();
info.setAttribute(EFS.ATTRIBUTE_READ_ONLY, false);
try {
nonExisting.putInfo(info, EFS.SET_ATTRIBUTES, getMonitor());
fail("1.1");
} catch (CoreException e) {
//expected
}
}
public void testReadOnly() throws CoreException {
testAttribute(EFS.ATTRIBUTE_READ_ONLY);
}
public void testPermissionsEnabled() {
String os = Platform.getOS();
String arch = Platform.getOSArch();
if (Platform.OS_LINUX.equals(os) || (Platform.OS_SOLARIS.equals(os) && Platform.ARCH_SPARC.equals(arch)) || Platform.OS_MACOSX.equals(os) || Platform.OS_AIX.equals(os)) {
assertTrue(isAttributeSupported(EFS.ATTRIBUTE_OWNER_READ));
assertTrue(isAttributeSupported(EFS.ATTRIBUTE_OWNER_WRITE));
assertTrue(isAttributeSupported(EFS.ATTRIBUTE_OWNER_EXECUTE));
assertTrue(isAttributeSupported(EFS.ATTRIBUTE_GROUP_READ));
assertTrue(isAttributeSupported(EFS.ATTRIBUTE_GROUP_WRITE));
assertTrue(isAttributeSupported(EFS.ATTRIBUTE_GROUP_EXECUTE));
assertTrue(isAttributeSupported(EFS.ATTRIBUTE_OTHER_READ));
assertTrue(isAttributeSupported(EFS.ATTRIBUTE_OTHER_WRITE));
assertTrue(isAttributeSupported(EFS.ATTRIBUTE_OTHER_EXECUTE));
} else {
assertFalse(isAttributeSupported(EFS.ATTRIBUTE_OWNER_READ));
assertFalse(isAttributeSupported(EFS.ATTRIBUTE_OWNER_WRITE));
assertFalse(isAttributeSupported(EFS.ATTRIBUTE_OWNER_EXECUTE));
assertFalse(isAttributeSupported(EFS.ATTRIBUTE_GROUP_READ));
assertFalse(isAttributeSupported(EFS.ATTRIBUTE_GROUP_WRITE));
assertFalse(isAttributeSupported(EFS.ATTRIBUTE_GROUP_EXECUTE));
assertFalse(isAttributeSupported(EFS.ATTRIBUTE_OTHER_READ));
assertFalse(isAttributeSupported(EFS.ATTRIBUTE_OTHER_WRITE));
assertFalse(isAttributeSupported(EFS.ATTRIBUTE_OTHER_EXECUTE));
}
}
public void testPermissions() throws CoreException {
testAttribute(EFS.ATTRIBUTE_OWNER_READ);
testAttribute(EFS.ATTRIBUTE_OWNER_WRITE);
testAttribute(EFS.ATTRIBUTE_OWNER_EXECUTE);
testAttribute(EFS.ATTRIBUTE_GROUP_READ);
testAttribute(EFS.ATTRIBUTE_GROUP_WRITE);
testAttribute(EFS.ATTRIBUTE_GROUP_EXECUTE);
testAttribute(EFS.ATTRIBUTE_OTHER_READ);
testAttribute(EFS.ATTRIBUTE_OTHER_WRITE);
testAttribute(EFS.ATTRIBUTE_OTHER_EXECUTE);
}
private void testAttribute(int attribute) throws CoreException {
if (!isAttributeSupported(attribute)) {
return;
}
IPath root = getWorkspace().getRoot().getLocation().append("" + new Date().getTime());
IFileStore targetFolder = createDir(root.toString(), true);
try {
IFileStore targetFile = targetFolder.getChild("targetFile");
createFileInFileSystem(targetFile);
// file
boolean init = targetFile.fetchInfo().getAttribute(attribute);
setAttribute(targetFile, attribute, !init);
assertTrue("1.2", targetFile.fetchInfo().getAttribute(attribute) != init);
setAttribute(targetFile, attribute, init);
assertTrue("1.4", targetFile.fetchInfo().getAttribute(attribute) == init);
// folder
init = targetFolder.fetchInfo().getAttribute(attribute);
setAttribute(targetFolder, attribute, !init);
assertTrue("2.2", targetFolder.fetchInfo().getAttribute(attribute) != init);
setAttribute(targetFolder, attribute, init);
assertTrue("2.4", targetFolder.fetchInfo().getAttribute(attribute) == init);
} finally {
/* remove trash */
targetFolder.delete(EFS.NONE, null);
}
}
public void testGetFileStore() throws Exception {
// create files
File file = getTempDir().append("test.txt").toFile();
file.createNewFile();
assertTrue("1.0", file.exists());
IFileStore tempStore = createDir(getTempDir().append("temp").toString(), true);
createDir(getTempDir().append("temp/temp2").toString(), true);
file = getTempDir().append("temp/temp2/test.txt").toFile();
file.createNewFile();
assertTrue("2.0", file.exists());
// check the parent reference
IPath relativePath = new Path("../test.txt");
IFileStore relativeStore = tempStore.getFileStore(relativePath);
assertNotNull("3.0", relativeStore);
IFileInfo info = relativeStore.fetchInfo();
assertNotNull("4.0", info);
assertTrue("5.0", info.exists());
// check the parent and self reference
relativePath = new Path(".././test.txt");
relativeStore = tempStore.getFileStore(relativePath);
assertNotNull("6.0", relativeStore);
info = relativeStore.fetchInfo();
assertNotNull("7.0", info);
assertTrue("8.0", info.exists());
// check the a path with no parent and self references
relativePath = new Path("temp2/test.txt");
relativeStore = tempStore.getFileStore(relativePath);
assertNotNull("9.0", relativeStore);
info = relativeStore.fetchInfo();
assertNotNull("10.0", info);
assertTrue("11.0", info.exists());
}
}