/*******************************************************************************
* Copyright (c) 2000, 2015 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
* Alexander Kurtakov <akurtako@redhat.com> - Bug 459343
* Sergey Prigogin (Google) - [462440] IFile#getContents methods should specify the status codes for its exceptions
*******************************************************************************/
package org.eclipse.core.tests.resources;
import java.io.*;
import java.util.ArrayList;
import junit.framework.Test;
import junit.framework.TestSuite;
import org.eclipse.core.resources.*;
import org.eclipse.core.runtime.*;
import org.eclipse.core.tests.harness.FussyProgressMonitor;
public class IFileTest extends ResourceTest {
//name of files according to sync category
public static final String DOES_NOT_EXIST = "DoesNotExistFile";
public static final String EXISTING = "ExistingFile";
public static final String LOCAL_ONLY = "LocalOnlyFile";
public static final String OUT_OF_SYNC = "OutOfSyncFile";
// protected static final IProgressMonitor[] PROGRESS_MONITORS = new IProgressMonitor[] {new FussyProgressMonitor(), new CancelingProgressMonitor(), null};
protected static final IProgressMonitor[] PROGRESS_MONITORS = new IProgressMonitor[] {new FussyProgressMonitor(), null};
protected static final Boolean[] TRUE_AND_FALSE = new Boolean[] {Boolean.TRUE, Boolean.FALSE};
public static final String WORKSPACE_ONLY = "WorkspaceOnlyFile";
ArrayList<IFile> allFiles = new ArrayList<>();
ArrayList<IFile> existingFiles = new ArrayList<>();
ArrayList<IFile> localOnlyFiles = new ArrayList<>();
ArrayList<IFile> nonExistingFiles = new ArrayList<>();
ArrayList<IFile> outOfSyncFiles = new ArrayList<>();
IProject[] projects = null;
ArrayList<IFile> workspaceOnlyFiles = new ArrayList<>();
/**
* Sets up the test suite for this class
*/
public static Test suite() {
return new TestSuite(IFileTest.class);
// TestSuite suite = new TestSuite();
// suite.addTest(new IFileTest("testInvalidFileNames"));
// return suite;
}
public IFileTest() {
super();
}
public IFileTest(String name) {
super(name);
}
/**
* Returns true if the given container exists, and is open
* if applicable.
*/
public boolean existsAndOpen(IContainer container) {
if (!container.exists()) {
return false;
}
if (container instanceof IFolder) {
return true;
}
if (container instanceof IProject) {
return ((IProject) container).isOpen();
}
fail("Should not get here in FileTest.existsAndOpen");
return false;
}
/**
* This method creates the necessary resources
* for the FileTests. The interesting files are
* placed in ArrayLists that are members of the class.
*/
protected void generateInterestingFiles() throws CoreException {
IProject[] interestingProjects = interestingProjects();
for (IProject project : interestingProjects) {
//file in project
generateInterestingFiles(project);
//file in non-existent folder
generateInterestingFiles(project.getFolder("NonExistentFolder"));
//file in existent folder
if (project.exists() && project.isOpen()) {
IFolder folder = project.getFolder("ExistingFolder");
folder.create(true, true, getMonitor());
generateInterestingFiles(folder);
}
}
}
/**
* Creates some interesting files in the specified container.
* Adds these files to the appropriate member ArrayLists.
* Conditions on these files (out of sync, workspace only, etc)
* will be ensured by refreshFiles
*/
public void generateInterestingFiles(IContainer container) {
//non-existent file
IFile file = container.getFile(new Path(DOES_NOT_EXIST));
nonExistingFiles.add(file);
allFiles.add(file);
//exists in file system only
file = container.getFile(new Path(LOCAL_ONLY));
localOnlyFiles.add(file);
allFiles.add(file);
if (existsAndOpen(container)) {
//existing file
file = container.getFile(new Path(EXISTING));
existingFiles.add(file);
allFiles.add(file);
//exists in workspace only
file = container.getFile(new Path(WORKSPACE_ONLY));
workspaceOnlyFiles.add(file);
allFiles.add(file);
//exists in both but is out of sync
file = container.getFile(new Path(OUT_OF_SYNC));
outOfSyncFiles.add(file);
allFiles.add(file);
}
}
/**
* Returns some interesting files. These files are created
* during setup.
*/
public IFile[] interestingFiles() {
refreshFiles();
IFile[] result = new IFile[allFiles.size()];
allFiles.toArray(result);
return result;
}
/**
* Creates and returns some interesting projects
*/
public IProject[] interestingProjects() throws CoreException {
if (projects == null) {
projects = new IProject[3];
//open project
IProject openProject = getWorkspace().getRoot().getProject("OpenProject");
openProject.create(getMonitor());
openProject.open(getMonitor());
projects[0] = openProject;
//closed project
IProject closedProject = getWorkspace().getRoot().getProject("ClosedProject");
closedProject.create(getMonitor());
projects[1] = closedProject;
//non-existent project
projects[2] = getWorkspace().getRoot().getProject("NonExistentProject");
}
return projects;
}
/**
* Returns some interesting input streams
*/
public InputStream[] interestingStreams() {
ArrayList<InputStream> streams = new ArrayList<>();
//empty stream
ByteArrayInputStream bis = new ByteArrayInputStream(new byte[0]);
streams.add(bis);
// random content
streams.add(getRandomContents());
//large stream
bis = new ByteArrayInputStream(new byte[10000]);
streams.add(bis);
InputStream[] results = new InputStream[streams.size()];
streams.toArray(results);
return results;
}
/**
* Returns true if the given file is out of sync from the
* local file system. The file must exist in the workspace.
*/
public boolean outOfSync(IFile file) {
return file.getName().equals(OUT_OF_SYNC) || file.getName().equals(WORKSPACE_ONLY);
}
/**
* Makes sure file requirements are met (out of sync, workspace only, etc).
*/
public void refreshFile(IFile file) {
if (file.getName().equals(LOCAL_ONLY)) {
ensureDoesNotExistInWorkspace(file);
//project must exist to access file system store.
if (file.getProject().exists()) {
ensureExistsInFileSystem(file);
}
return;
}
if (file.getName().equals(WORKSPACE_ONLY)) {
ensureExistsInWorkspace(file, true);
ensureDoesNotExistInFileSystem(file);
return;
}
if (file.getName().equals(DOES_NOT_EXIST)) {
ensureDoesNotExistInWorkspace(file);
//project must exist to access file system store.
if (file.getProject().exists()) {
ensureDoesNotExistInFileSystem(file);
}
return;
}
if (file.getName().equals(EXISTING)) {
ensureExistsInWorkspace(file, true);
return;
}
if (file.getName().equals(OUT_OF_SYNC)) {
ensureExistsInWorkspace(file, true);
ensureOutOfSync(file);
return;
}
}
/**
* Makes sure file requirements are met (out of sync, workspace only, etc).
*/
public void refreshFiles() {
for (IFile file : allFiles) {
refreshFile(file);
}
}
@Override
protected void setUp() throws Exception {
super.setUp();
try {
generateInterestingFiles();
} catch (CoreException e) {
fail("Failed in setup for FileTest", e);
}
}
@Override
protected void tearDown() throws Exception {
getWorkspace().getRoot().refreshLocal(IResource.DEPTH_INFINITE, null);
ensureDoesNotExistInWorkspace(getWorkspace().getRoot());
super.tearDown();
}
public void testAppendContents() {
IFile target = projects[0].getFile("file1");
try {
target.create(getContents("abc"), false, null);
} catch (CoreException e) {
fail("1.0", e);
}
try {
target.appendContents(getContents("def"), false, false, null);
} catch (CoreException e) {
fail("2.0", e);
}
InputStream content = null;
try {
content = target.getContents(false);
assertTrue("3.0", compareContent(content, getContents("abcdef")));
} catch (CoreException e) {
fail("3.1", e);
}
}
public void testAppendContents2() {
IFile file = projects[0].getFile("file1");
ensureDoesNotExistInWorkspace(file);
// If force=true, IFile is non-local, file exists in local file system:
// make IFile local, append contents (the thinking being that this file,
// though marked non-local, was in fact local awaiting discovery; so
// force=true says we it is ok to make file local and proceed as per normal)
try {
// setup
file.create(null, false, getMonitor());
assertTrue("1.0", !file.isLocal(IResource.DEPTH_ZERO));
assertTrue("1.1", !file.getLocation().toFile().exists());
ensureExistsInFileSystem(file);
assertTrue("1.2", !file.isLocal(IResource.DEPTH_ZERO));
} catch (CoreException e) {
fail("1.3", e);
}
try {
file.appendContents(getRandomContents(), IResource.FORCE, getMonitor());
} catch (CoreException e) {
fail("1.4", e);
}
assertTrue("1.5", file.isLocal(IResource.DEPTH_ZERO));
assertTrue("1.6", file.getLocation().toFile().exists());
// cleanup
ensureDoesNotExistInWorkspace(file);
// If force=true, IFile is non-local, file does not exist in local file system:
// fail - file not local (this file is not local for real - cannot append
// something to a file that you don't have)
try {
// setup
file.create(null, false, getMonitor());
assertTrue("2.0", !file.isLocal(IResource.DEPTH_ZERO));
assertTrue("2.1", !file.getLocation().toFile().exists());
} catch (CoreException e) {
fail("2.2", e);
}
try {
file.appendContents(getRandomContents(), IResource.FORCE, getMonitor());
fail("2.3");
} catch (CoreException e) {
// should fail
}
assertTrue("2.4", !file.isLocal(IResource.DEPTH_ZERO));
// cleanup
ensureDoesNotExistInWorkspace(file);
// If force=false, IFile is non-local, file exists in local file system:
// fail - file not local
try {
// setup
file.create(null, false, getMonitor());
assertTrue("3.0", !file.isLocal(IResource.DEPTH_ZERO));
assertTrue("3.1", !file.getLocation().toFile().exists());
ensureExistsInFileSystem(file);
assertTrue("3.2", !file.isLocal(IResource.DEPTH_ZERO));
} catch (CoreException e) {
fail("3.3", e);
}
try {
file.appendContents(getRandomContents(), IResource.NONE, getMonitor());
fail("3.4");
} catch (CoreException e) {
// should fail
}
assertTrue("3.5", !file.isLocal(IResource.DEPTH_ZERO));
// cleanup
ensureDoesNotExistInWorkspace(file);
// If force=false, IFile is non-local, file does not exist in local file system:
// fail - file not local
try {
// setup
file.create(null, false, getMonitor());
assertTrue("4.0", !file.isLocal(IResource.DEPTH_ZERO));
assertTrue("4.1", !file.getLocation().toFile().exists());
} catch (CoreException e) {
fail("4.2", e);
}
try {
file.appendContents(getRandomContents(), IResource.NONE, getMonitor());
fail("4.3");
} catch (CoreException e) {
// should fail
}
assertTrue("4.4", !file.isLocal(IResource.DEPTH_ZERO));
// cleanup
ensureDoesNotExistInWorkspace(file);
}
/**
* Performs black box testing of the following method:
* void create(InputStream, boolean, IProgressMonitor)
*/
public void testCreate() {
Object[][] inputs = new Object[][] {interestingFiles(), interestingStreams(), TRUE_AND_FALSE, PROGRESS_MONITORS};
new TestPerformer("IFileTest.testCreate") {
@Override
public void cleanUp(Object[] args, int count) {
IFile file = (IFile) args[0];
refreshFile(file);
}
@Override
public Object[] interestingOldState(Object[] args) throws Exception {
return null;
}
@Override
public Object invokeMethod(Object[] args, int count) throws Exception {
IFile file = (IFile) args[0];
InputStream stream = (InputStream) args[1];
boolean force = ((Boolean) args[2]).booleanValue();
IProgressMonitor monitor = (IProgressMonitor) args[3];
if (monitor instanceof FussyProgressMonitor) {
((FussyProgressMonitor) monitor).prepare();
}
file.create(stream, force, monitor);
if (monitor instanceof FussyProgressMonitor) {
((FussyProgressMonitor) monitor).sanityCheck();
}
return null;
}
@Override
public boolean shouldFail(Object[] args, int count) {
IFile file = (IFile) args[0];
IPath fileLocation = file.getLocation();
boolean force = ((Boolean) args[2]).booleanValue();
boolean fileExistsInWS = file.exists();
boolean fileExistsInFS = fileLocation != null && fileLocation.toFile().exists();
// parent must be accessible
if (!file.getParent().isAccessible()) {
return true;
}
// should never fail if force is true
if (force && !fileExistsInWS) {
return false;
}
// file must not exist in WS or on filesystem.
return fileExistsInWS || fileExistsInFS;
}
@Override
public boolean wasSuccess(Object[] args, Object result, Object[] oldState) throws Exception {
IFile file = (IFile) args[0];
return file.exists();
}
}.performTest(inputs);
}
public void testCreateDerived() {
IFile derived = projects[0].getFile("derived.txt");
ensureExistsInWorkspace(projects[0], true);
ensureDoesNotExistInWorkspace(derived);
try {
derived.create(getRandomContents(), IResource.DERIVED, getMonitor());
} catch (CoreException e) {
fail("0.99", e);
}
assertTrue("1.0", derived.isDerived());
assertTrue("1.1", !derived.isTeamPrivateMember());
try {
derived.delete(false, getMonitor());
derived.create(getRandomContents(), IResource.NONE, getMonitor());
} catch (CoreException e) {
fail("1.99", e);
}
assertTrue("2.0", !derived.isDerived());
assertTrue("2.1", !derived.isTeamPrivateMember());
}
public void testDeltaOnCreateDerived() {
IFile derived = projects[0].getFile("derived.txt");
ensureExistsInWorkspace(projects[0], true);
ResourceDeltaVerifier verifier = new ResourceDeltaVerifier();
getWorkspace().addResourceChangeListener(verifier, IResourceChangeEvent.POST_CHANGE);
verifier.addExpectedChange(derived, IResourceDelta.ADDED, IResource.NONE);
try {
derived.create(getRandomContents(), IResource.FORCE | IResource.DERIVED, getMonitor());
} catch (CoreException e) {
fail("1.0", e);
}
assertTrue("2.0", verifier.isDeltaValid());
}
public void testCreateDerivedTeamPrivate() {
IFile teamPrivate = projects[0].getFile("teamPrivateDerived.txt");
ensureExistsInWorkspace(projects[0], true);
ensureDoesNotExistInWorkspace(teamPrivate);
try {
teamPrivate.create(getRandomContents(), IResource.TEAM_PRIVATE | IResource.DERIVED, getMonitor());
} catch (CoreException e) {
fail("0.99", e);
}
assertTrue("1.0", teamPrivate.isTeamPrivateMember());
assertTrue("1.1", teamPrivate.isDerived());
try {
teamPrivate.delete(false, getMonitor());
teamPrivate.create(getRandomContents(), IResource.NONE, getMonitor());
} catch (CoreException e) {
fail("1.99", e);
}
assertTrue("2.0", !teamPrivate.isTeamPrivateMember());
assertTrue("2.1", !teamPrivate.isDerived());
}
public void testCreateTeamPrivate() {
IFile teamPrivate = projects[0].getFile("teamPrivate.txt");
ensureExistsInWorkspace(projects[0], true);
ensureDoesNotExistInWorkspace(teamPrivate);
try {
teamPrivate.create(getRandomContents(), IResource.TEAM_PRIVATE, getMonitor());
} catch (CoreException e) {
fail("0.99", e);
}
assertTrue("1.0", teamPrivate.isTeamPrivateMember());
assertTrue("1.1", !teamPrivate.isDerived());
try {
teamPrivate.delete(false, getMonitor());
teamPrivate.create(getRandomContents(), IResource.NONE, getMonitor());
} catch (CoreException e) {
fail("1.99", e);
}
assertTrue("2.0", !teamPrivate.isTeamPrivateMember());
assertTrue("2.1", !teamPrivate.isDerived());
}
public void testFileCreation() {
IFile target = projects[0].getFile("file1");
assertTrue("1.0", !target.exists());
try {
target.create(null, true, getMonitor());
} catch (CoreException e) {
fail("1.1", e);
}
assertTrue("1.2", target.exists());
// creation with empty content
target = projects[0].getFile("file2");
assertTrue("2.0", !target.exists());
String contents = "";
try {
target.create(getContents(contents), true, getMonitor());
} catch (CoreException e) {
fail("2.1", e);
}
assertTrue("2.2", target.exists());
InputStream stream = null;
try {
stream = target.getContents(false);
} catch (CoreException e) {
fail("2.3", e);
}
try {
assertTrue("2.4", stream.available() == 0);
} catch (IOException e) {
fail("2.5", e);
}
try {
stream.close();
} catch (IOException e) {
fail("2.55", e);
}
try {
assertTrue("2.6", compareContent(target.getContents(false), getContents(contents)));
} catch (CoreException e) {
fail("2.7", e);
}
// creation with random content
target = projects[0].getFile("file3");
assertTrue("3.0", !target.exists());
contents = getRandomString();
try {
target.create(getContents(contents), true, getMonitor());
} catch (CoreException e) {
fail("3.1", e);
}
assertTrue("3.2", target.exists());
try {
assertTrue("3.2", compareContent(target.getContents(false), getContents(contents)));
} catch (CoreException e) {
fail("3.3", e);
}
// try to create a file over a folder that exists
IFolder folder = projects[0].getFolder("folder1");
try {
folder.create(true, true, getMonitor());
} catch (CoreException e) {
fail("4.0", e);
}
assertTrue("4.1", folder.exists());
target = projects[0].getFile("folder1");
try {
target.create(null, true, getMonitor());
fail("4.2");
} catch (CoreException e) {
// expected
}
assertTrue("4.3", folder.exists());
assertTrue("4.4", !target.exists());
// try to create a file under a non-existent parent
folder = projects[0].getFolder("folder2");
assertTrue("5.0", !folder.exists());
target = folder.getFile("file4");
try {
target.create(null, true, getMonitor());
fail("5.1");
} catch (CoreException e) {
// expected
}
assertTrue("5.2", !folder.exists());
assertTrue("5.3", !target.exists());
//create from stream that throws exceptions
target = projects[0].getFile("file2");
ensureDoesNotExistInWorkspace(target);
ensureDoesNotExistInFileSystem(target);
InputStream content = new InputStream() {
@Override
public int read() throws IOException {
throw new IOException();
}
};
try {
target.create(content, false, getMonitor());
fail("6.1");
} catch (CoreException e) {
// expected
}
assertDoesNotExistInWorkspace("6.2", target);
assertDoesNotExistInFileSystem("6.3", target);
// cleanup
folder = projects[0].getFolder("folder1");
try {
folder.delete(false, getMonitor());
} catch (CoreException e) {
fail("7.0", e);
}
IFile file = projects[0].getFile("file1");
try {
file.delete(false, getMonitor());
} catch (CoreException e) {
fail("7.1", e);
}
file = projects[0].getFile("file2");
try {
file.delete(false, getMonitor());
} catch (CoreException e) {
fail("7.2", e);
}
file = projects[0].getFile("file3");
try {
file.delete(false, getMonitor());
} catch (CoreException e) {
fail("7.3", e);
}
}
public void testFileCreation_Bug107188() {
//create from stream that is canceled
IFile target = projects[0].getFile("file1");
ensureDoesNotExistInWorkspace(target);
ensureDoesNotExistInFileSystem(target);
InputStream content = new InputStream() {
@Override
public int read() {
throw new OperationCanceledException();
}
};
try {
target.create(content, false, getMonitor());
fail("1.0");
} catch (OperationCanceledException e) {
// expected
} catch (CoreException e) {
fail("2.0");
}
assertDoesNotExistInWorkspace("3.0", target);
assertDoesNotExistInFileSystem("4.0", target);
}
public void testFileDeletion() throws Throwable {
IFile target = projects[0].getFile("file1");
target.create(null, true, getMonitor());
assertTrue("1.0", target.exists());
target.delete(true, getMonitor());
assertTrue("1.1", !target.exists());
}
public void testFileEmptyDeletion() throws Throwable {
IFile target = projects[0].getFile("file1");
target.create(getContents(""), true, getMonitor());
assertTrue("1.0", target.exists());
target.delete(true, getMonitor());
assertTrue("1.1", !target.exists());
}
public void testFileInFolderCreation() {
IFolder folder = projects[0].getFolder("folder1");
try {
folder.create(false, true, getMonitor());
} catch (CoreException e) {
fail("1.0", e);
}
IFile target = folder.getFile("file1");
try {
target.create(getRandomContents(), true, getMonitor());
assertTrue("1.1", target.exists());
} catch (CoreException e) {
fail("1.2", e);
}
}
public void testFileInFolderCreation1() throws Throwable {
IFolder folder = projects[0].getFolder("folder1");
folder.create(false, true, null);
IFile target = folder.getFile("file1");
target.create(getRandomContents(), true, getMonitor());
assertTrue("1.0", target.exists());
}
public void testFileInFolderCreation2() {
IFolder folder = projects[0].getFolder("folder1");
try {
folder.create(false, true, getMonitor());
} catch (CoreException e) {
fail("1.0", e);
}
IFile target = folder.getFile("file1");
try {
target.create(getRandomContents(), true, getMonitor());
assertTrue("1.1", target.exists());
} catch (CoreException e) {
fail("1.2", e);
}
}
public void testFileMove() throws Throwable {
IFile target = projects[0].getFile("file1");
target.create(getRandomContents(), true, getMonitor());
IFile destination = projects[0].getFile("file2");
target.move(destination.getFullPath(), true, getMonitor());
assertTrue("1.0", destination.exists());
assertTrue("1.1", !target.exists());
}
public void testFileOverFolder() throws Throwable {
IFolder existing = projects[0].getFolder("ExistingFolder");
IFile target = projects[0].getFile("ExistingFolder");
try {
target.create(null, true, getMonitor());
fail("Should not be able to create file over folder");
} catch (CoreException e) {
assertTrue("1.1", existing.exists());
return;
}
}
/**
* Performs black box testing of the following method:
* InputStream getContents()
*/
public void testGetContents() {
Object[][] inputs = new Object[][] {interestingFiles()};
new TestPerformer("IFileTest.testGetContents") {
@Override
public void cleanUp(Object[] args, int count) {
IFile file = (IFile) args[0];
refreshFile(file);
}
@Override
public Object[] interestingOldState(Object[] args) throws Exception {
return null;
}
@Override
public Object invokeMethod(Object[] args, int count) throws Exception {
IFile file = (IFile) args[0];
return file.getContents(false);
}
@Override
public boolean shouldFail(Object[] args, int count) {
IFile file = (IFile) args[0];
//file must exist
if (!file.exists()) {
return true;
}
//file must be in sync
if (outOfSync(file)) {
return true;
}
return false;
}
@Override
public boolean wasSuccess(Object[] args, Object result, Object[] oldState) throws Exception {
IFile file = (IFile) args[0];
InputStream contents = (InputStream) result;
boolean returnVal = file.exists() && contents != null;
contents.close();
return returnVal;
}
}.performTest(inputs);
}
public void testGetContents2() throws IOException {
IFile target = projects[0].getFile("file1");
String testString = getRandomString();
try {
target.create(null, false, null);
target.setContents(getContents(testString), true, false, getMonitor());
} catch (CoreException e) {
fail("0.0", e);
}
ensureOutOfSync(target);
InputStream content = null;
try {
try {
content = target.getContents(false);
} finally {
if (content != null) {
content.close();
}
}
fail("1.0");
} catch (CoreException e) {
// Ok, the file is out is sync.
assertEquals("1.1", IResourceStatus.OUT_OF_SYNC_LOCAL, e.getStatus().getCode());
}
try {
try {
content = target.getContents(true);
} finally {
if (content != null) {
content.close();
}
}
} catch (CoreException e) {
fail("2.1", e);
}
try {
try {
content = target.getContents(false);
} finally {
if (content != null) {
content.close();
}
}
fail("3.0");
} catch (CoreException e) {
// Ok, the file is out is sync.
assertEquals("3.1", IResourceStatus.OUT_OF_SYNC_LOCAL, e.getStatus().getCode());
}
content = new InputStream() {
@Override
public int read() throws IOException {
throw new IOException();
}
};
try {
target.setContents(content, IResource.NONE, getMonitor());
fail("4.1");
} catch (CoreException e) {
// expected
}
assertExistsInWorkspace("4.2", target);
assertExistsInFileSystem("4.3", target);
}
/**
* Tests creation and manipulation of file names that are reserved on some platforms.
*/
public void testInvalidFileNames() {
IProject project = projects[0];
//should not be able to create a file with invalid path on any platform
String[] names = new String[] {"", "/"};
for (int i = 0; i < names.length; i++) {
try {
project.getFile(names[i]);
fail("0.1." + i);
} catch (RuntimeException e) {
//should fail
}
}
//do some tests with invalid names
names = new String[0];
if (isWindows()) {
//invalid windows names
names = new String[] {"a ", "foo::bar", "prn", "nul", "con", "aux", "clock$", "com1", "com2", "com3", "com4", "com5", "com6", "com7", "com8", "com9", "lpt1", "lpt2", "lpt3", "lpt4", "lpt5", "lpt6", "lpt7", "lpt8", "lpt9", "AUX", "con.foo", "LPT4.txt", "*", "?", "\"", "<", ">", "|"};
} else {
//invalid names on non-windows platforms
names = new String[] {};
}
for (String name : names) {
IFile file = project.getFile(Path.fromPortableString(name));
assertTrue("1.0 " + name, !file.exists());
try {
file.create(getRandomContents(), true, getMonitor());
fail("1.1 " + name);
} catch (CoreException e) {
// expected
}
assertTrue("1.2 " + name, !file.exists());
}
//do some tests with valid names that are *almost* invalid
if (isWindows()) {
//these names are valid on windows
names = new String[] {" a", "hello.prn.txt", "null", "con3", "foo.aux", "lpt0", "com0", "com10", "lpt10", ",", "'", ";", "clock$.class"};
} else {
//these names are valid on non-windows platforms
names = new String[] {" a", "a ", "foo:bar", "prn", "nul", "con", "aux", "clock$", "com1", "com2", "com3", "com4", "com5", "com6", "com7", "com8", "com9", "lpt1", "lpt2", "lpt3", "lpt4", "lpt5", "lpt6", "lpt7", "lpt8", "lpt9", "con.foo", "LPT4.txt", "*", "?", "\"", "<", ">", "|", "hello.prn.txt", "null", "con3", "foo.aux", "lpt0", "com0", "com10", "lpt10", ",", "'", ";"};
}
for (String name : names) {
IFile file = project.getFile(name);
assertTrue("2.0 " + name, !file.exists());
try {
file.create(getRandomContents(), true, getMonitor());
} catch (CoreException e) {
fail("2.1 " + name, e);
}
assertTrue("2.2 " + name, file.exists());
}
}
/**
* Performs black box testing of the following method:
* void setContents(InputStream, boolean, IProgressMonitor)
*/
public void testSetContents1() {
Object[][] inputs = new Object[][] {interestingFiles(), interestingStreams(), TRUE_AND_FALSE, PROGRESS_MONITORS};
new TestPerformer("IFileTest.testSetContents1") {
@Override
public void cleanUp(Object[] args, int count) {
IFile file = (IFile) args[0];
refreshFile(file);
}
@Override
public Object[] interestingOldState(Object[] args) throws Exception {
return null;
}
@Override
public Object invokeMethod(Object[] args, int count) throws Exception {
IFile file = (IFile) args[0];
InputStream stream = (InputStream) args[1];
boolean force = ((Boolean) args[2]).booleanValue();
IProgressMonitor monitor = (IProgressMonitor) args[3];
if (monitor instanceof FussyProgressMonitor) {
((FussyProgressMonitor) monitor).prepare();
}
file.setContents(stream, force, false, monitor);
if (monitor instanceof FussyProgressMonitor) {
((FussyProgressMonitor) monitor).sanityCheck();
}
return null;
}
@Override
public boolean shouldFail(Object[] args, int count) {
IFile file = (IFile) args[0];
boolean force = ((Boolean) args[2]).booleanValue();
//file must exist
if (!file.exists()) {
return true;
}
//file must be in sync if force is false
if (!force && outOfSync(file)) {
return true;
}
return false;
}
@Override
public boolean wasSuccess(Object[] args, Object result, Object[] oldState) throws Exception {
IFile file = (IFile) args[0];
return file.exists();
}
}.performTest(inputs);
}
public void testSetContents2() {
IFile target = projects[0].getFile("file1");
try {
target.create(null, false, null);
} catch (CoreException e) {
fail("0.0", e);
}
String testString = getRandomString();
try {
target.setContents(getContents(testString), true, false, getMonitor());
} catch (CoreException e) {
fail("1.0", e);
}
InputStream content = null;
try {
content = target.getContents(false);
assertTrue("get not equal set", compareContent(content, getContents(testString)));
} catch (CoreException e) {
fail("2.0", e);
} finally {
try {
content.close();
} catch (IOException e) {
// ignore
}
}
}
public void testSetGetFolderPersistentProperty() throws Throwable {
IResource target = getWorkspace().getRoot().getFile(new Path("/Project/File.txt"));
String value = "this is a test property value";
QualifiedName name = new QualifiedName("itp-test", "testProperty");
// getting/setting persistent properties on non-existent resources should throw an exception
ensureDoesNotExistInWorkspace(target);
try {
target.getPersistentProperty(name);
fail("1.0");
} catch (CoreException e) {
//this should happen
}
try {
target.setPersistentProperty(name, value);
fail("1.1");
} catch (CoreException e) {
//this should happen
}
ensureExistsInWorkspace(target, true);
target.setPersistentProperty(name, value);
// see if we can get the property
assertTrue("2.0", target.getPersistentProperty(name).equals(value));
// see what happens if we get a non-existant property
name = new QualifiedName("itp-test", "testNonProperty");
assertNull("2.1", target.getPersistentProperty(name));
//set a persistent property with null qualifier
name = new QualifiedName(null, "foo");
try {
target.setPersistentProperty(name, value);
fail("3.0");
} catch (CoreException e) {
//expect an exception
}
}
}