/*******************************************************************************
 * Copyright (c) 2009 SAP AG.
 * 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:
 *    Eduard Bartsch (SAP AG) - initial API and implementation
 *    Mathias Kinzler (SAP AG) - initial API and implementation
 *******************************************************************************/
package org.eclipse.core.resources.semantic.test;

import java.io.ByteArrayInputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.UnsupportedEncodingException;
import java.net.URI;
import java.net.URISyntaxException;

import junit.framework.Assert;

import org.eclipse.core.filesystem.EFS;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IFolder;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IProjectDescription;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.IResourceRuleFactory;
import org.eclipse.core.resources.IWorkspace;
import org.eclipse.core.resources.IWorkspaceRunnable;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.resources.semantic.ISemanticFile;
import org.eclipse.core.resources.semantic.ISemanticFileSystem;
import org.eclipse.core.resources.semantic.ISemanticFolder;
import org.eclipse.core.resources.semantic.SemanticResourceException;
import org.eclipse.core.resources.semantic.SyncDirection;
import org.eclipse.core.resources.semantic.examples.remote.RemoteFolder;
import org.eclipse.core.resources.semantic.examples.remote.RemoteStoreTransient;
import org.eclipse.core.resources.semantic.spi.ISemanticFileStore;
import org.eclipse.core.resources.semantic.spi.Util;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.NullProgressMonitor;
import org.eclipse.core.runtime.OperationCanceledException;
import org.eclipse.core.runtime.Path;
import org.eclipse.core.runtime.Status;
import org.eclipse.core.runtime.jobs.ISchedulingRule;
import org.eclipse.team.core.RepositoryProvider;
import org.junit.After;
import org.junit.AfterClass;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Ignore;
import org.junit.Test;

/**
 * Tests the default content provider
 */
public class TestsDefaultContentProvider extends TestsContentProviderUtil {
	IWorkspace workspace = ResourcesPlugin.getWorkspace();

	private static final String UTF_8_CHARSET = "utf-8";
	private static final String TEST = "test";
	private static final String TEST2 = "test2";

	/**
	 * The default constructor
	 */
	public TestsDefaultContentProvider() {
		this(true);
	}

	/**
	 * The constructor with auto-refresh flag
	 * 
	 * @param withAutoRefresh
	 */
	TestsDefaultContentProvider(boolean withAutoRefresh) {
		super(withAutoRefresh, "TestDefaultContentProvider", null);
	}

	/**
	 * Initializes the trace locations
	 * 
	 * @throws Exception
	 */
	@BeforeClass
	public static void beforeClass() throws Exception {
		TestsContentProviderUtil.initTrace();
	}

	/**
	 * Resets the trace locations
	 * 
	 * @throws Exception
	 */
	@AfterClass
	public static void afterClass() throws Exception {

		TestsContentProviderUtil.resetTrace();
	}

	/**
	 * Creates a test project and initializes the remote repository
	 * 
	 * @throws Exception
	 */
	@Override
	@Before
	public void beforeMethod() throws Exception {

		final IProject project = workspace.getRoot().getProject(this.projectName);

		if (project.exists()) {
			throw new IllegalStateException("Project exists");
		}

		IWorkspaceRunnable myRunnable = new IWorkspaceRunnable() {
			public void run(IProgressMonitor monitor) throws CoreException {
				IProjectDescription description = workspace.newProjectDescription(TestsDefaultContentProvider.this.projectName);

				try {
					description.setLocationURI(new URI(ISemanticFileSystem.SCHEME + ":/" + TestsDefaultContentProvider.this.projectName));
				} catch (URISyntaxException e) {
					// really not likely, though
					throw new RuntimeException(e);
				}
				project.create(description, monitor);
				project.open(monitor);

				RemoteStoreTransient store = (RemoteStoreTransient) project.getAdapter(RemoteStoreTransient.class);
				RemoteFolder f1 = store.getRootFolder().addFolder("Folder1");
				f1.addFolder("Folder11");

				// for SFS, we map this to the team provider
				RepositoryProvider.map(project, ISemanticFileSystem.SFS_REPOSITORY_PROVIDER);
				if (!TestsDefaultContentProvider.this.autoRefresh) {
					project.refreshLocal(IResource.DEPTH_INFINITE, monitor);
				}
			}

		};

		workspace.run(myRunnable, project, IWorkspace.AVOID_UPDATE, null);

		this.testProject = project;

	}

	/**
	 * Deletes the test project and resets the remote repository
	 * 
	 * @throws Exception
	 */
	@Override
	@After
	public void afterMethod() throws Exception {

		RemoteStoreTransient store = (RemoteStoreTransient) this.testProject.getAdapter(RemoteStoreTransient.class);
		store.reset();

		this.testProject = null;

		final IProject project = workspace.getRoot().getProject(this.projectName);
		IWorkspaceRunnable runnable = new IWorkspaceRunnable() {

			public void run(IProgressMonitor monitor) throws CoreException {
				project.delete(true, monitor);
				if (!TestsDefaultContentProvider.this.autoRefresh) {
					project.refreshLocal(IResource.DEPTH_INFINITE, monitor);
				}
			}
		};

		workspace.run(runnable, workspace.getRoot(), IWorkspace.AVOID_UPDATE, new NullProgressMonitor());

	}

	/**
	 * 
	 * @throws Exception
	 */
	@Test
	public void testAddFileAndDelete() throws Exception {
		IWorkspaceRunnable runnable = new IWorkspaceRunnable() {

			public void run(IProgressMonitor monitor) throws CoreException {

				IFile file = TestsDefaultContentProvider.this.testProject.getFile("SomeFile");
				Assert.assertEquals("File existence", false, file.exists());
				ByteArrayInputStream is;
				try {
					is = new ByteArrayInputStream("Hello World".getBytes("UTF-8"));
				} catch (UnsupportedEncodingException e) {
					throw new RuntimeException(e);
				}
				file.create(is, false, monitor);
				Util.safeClose(file.getContents());
				Assert.assertEquals("File existence", true, file.exists());

				InputStream stream = null;
				try {
					stream = file.getContents();
					byte[] result = new byte[stream.available()];
					stream.read(result);
					String content = new String(result, "UTF-8");
					Assert.assertEquals("Hello World", content);
				} catch (Exception e) {
					throw new RuntimeException(e);

				} finally {
					Util.safeClose(stream);
				}
				file.delete(false, monitor);

			}
		};
		workspace.run(runnable, this.testProject, IWorkspace.AVOID_UPDATE, new NullProgressMonitor());
	}

	/**
	 * 
	 * @throws Exception
	 */
	@Test
	public void testAddFileAndCopy() throws Exception {
		IWorkspaceRunnable runnable = new IWorkspaceRunnable() {

			public void run(IProgressMonitor monitor) throws CoreException {

				IFile file = TestsDefaultContentProvider.this.testProject.getFile("SomeFile");

				Assert.assertEquals("File existence", false, file.exists());
				ByteArrayInputStream is;
				try {
					is = new ByteArrayInputStream("Hello World".getBytes("UTF-8"));
				} catch (UnsupportedEncodingException e) {
					throw new RuntimeException(e);
				}
				file.create(is, false, monitor);
				Util.safeClose(file.getContents());
				Assert.assertEquals("File existence", true, file.exists());

				file.copy(TestsDefaultContentProvider.this.testProject.getFullPath().append("CopyTarget"), false, monitor);

				InputStream stream = null;
				try {
					stream = file.getContents();
					byte[] result = new byte[stream.available()];
					stream.read(result);
					String content = new String(result, "UTF-8");
					Assert.assertEquals("Hello World", content);
				} catch (Exception e) {
					throw new RuntimeException(e);

				} finally {
					Util.safeClose(stream);
				}
				file.delete(false, monitor);

			}
		};
		workspace.run(runnable, this.testProject.getParent(), IWorkspace.AVOID_UPDATE, new NullProgressMonitor());
	}

	/**
	 * 
	 * @throws Exception
	 */
	@Test
	public void testAddFileAndChangeCharset() throws Exception {
		IWorkspaceRunnable runnable = new IWorkspaceRunnable() {

			public void run(IProgressMonitor monitor) throws CoreException {

				IFile file = TestsDefaultContentProvider.this.testProject.getFile("SomeFile");
				Assert.assertEquals("File existence", false, file.exists());
				ByteArrayInputStream is;
				try {
					is = new ByteArrayInputStream("Hello World".getBytes("UTF-8"));
				} catch (UnsupportedEncodingException e) {
					throw new RuntimeException(e);
				}
				file.create(is, false, monitor);
				Util.safeClose(file.getContents());
				Assert.assertEquals("File existence", true, file.exists());

				file.setCharset("UTF-8", monitor);
				Assert.assertEquals("Wrong charset", file.getCharset(), "UTF-8");

				file.setCharset("UTF-16", monitor);
				Assert.assertEquals("Wrong charset", file.getCharset(), "UTF-16");

				InputStream stream = null;
				try {
					stream = file.getContents();
					byte[] result = new byte[stream.available()];
					stream.read(result);
					String content = new String(result, "UTF-8");
					Assert.assertEquals("Hello World", content);
				} catch (Exception e) {
					throw new RuntimeException(e);

				} finally {
					Util.safeClose(stream);
				}
				file.delete(false, monitor);

			}
		};
		workspace.run(runnable, this.testProject, IWorkspace.AVOID_UPDATE, new NullProgressMonitor());
	}

	/**
	 * 
	 * @throws Exception
	 */
	@Test
	public void testAddFileAndMove() throws Exception {
		IWorkspaceRunnable runnable = new IWorkspaceRunnable() {

			public void run(IProgressMonitor monitor) throws CoreException {

				IFile file = TestsDefaultContentProvider.this.testProject.getFile("SomeFile");
				IFolder targetFolder = TestsDefaultContentProvider.this.testProject.getFolder("target");
				targetFolder.create(false, false, monitor);

				Assert.assertEquals("File existence", false, file.exists());
				ByteArrayInputStream is;
				try {
					is = new ByteArrayInputStream("Hello World".getBytes("UTF-8"));
				} catch (UnsupportedEncodingException e) {
					throw new RuntimeException(e);
				}
				file.create(is, false, monitor);
				Util.safeClose(file.getContents());
				Assert.assertEquals("File existence", true, file.exists());

				InputStream stream = null;
				try {
					stream = file.getContents();
					byte[] result = new byte[stream.available()];
					stream.read(result);
					String content = new String(result, "UTF-8");
					Assert.assertEquals("Hello World", content);
				} catch (Exception e) {
					throw new RuntimeException(e);

				} finally {
					Util.safeClose(stream);
				}
				file.move(targetFolder.getFile(file.getName()).getFullPath(), false, monitor);
				file.delete(false, monitor);

			}
		};
		workspace.run(runnable, TestsDefaultContentProvider.this.testProject, IWorkspace.AVOID_UPDATE, new NullProgressMonitor());
	}

	/**
	 * 
	 * @throws Exception
	 */
	@Test
	public void testAddRemoteFileAndMove() throws Exception {
		final IFolder parent = TestsDefaultContentProvider.this.testProject.getFolder("someFolder");
		final IFolder folder = parent.getFolder("someChild1");
		final IFolder targetFolder = parent.getFolder("someChild2");
		parent.create(true, false, null);
		folder.create(true, false, null);
		targetFolder.create(true, false, null);

		IWorkspaceRunnable runnable = new IWorkspaceRunnable() {

			public void run(IProgressMonitor monitor) throws CoreException {
				try {
					ISemanticFolder sFolder = (ISemanticFolder) folder.getAdapter(ISemanticFolder.class);

					File testfile = createTestFile("test.txt");
					boolean created = testfile.createNewFile();
					if (!created) {
						new FileOutputStream(testfile).close();
					}

					writeContentsToFile(testfile, "Hello World", "UTF-8");

					ISemanticFile sfile = sFolder.addFile("SomeFile", createURI4File(testfile), TestsDefaultContentProvider.this.options,
							monitor);
					if (TestsDefaultContentProvider.this.options == ISemanticFileSystem.SUPPRESS_REFRESH) {
						testProject.refreshLocal(IResource.DEPTH_INFINITE, monitor);
					}

					IFile file = sfile.getAdaptedFile();

					IFile targetFile = targetFolder.getFile(file.getName());

					file.move(targetFolder.getFile(file.getName()).getFullPath(), false, monitor);

					Assert.assertEquals("File existence", false, file.exists());
					Assert.assertEquals("File existence", true, targetFile.exists());

					assertContentsEqual(targetFile, "Hello World");

				} catch (URISyntaxException e) {
					throw new CoreException(new Status(IStatus.ERROR, TestPlugin.PLUGIN_ID, e.getMessage(), e));
				} catch (IOException e) {
					throw new CoreException(new Status(IStatus.ERROR, TestPlugin.PLUGIN_ID, e.getMessage(), e));
				}
			}
		};
		workspace.run(runnable, parent, IWorkspace.AVOID_UPDATE, new NullProgressMonitor());
	}

	@Test(expected = SemanticResourceException.class)
	public void testAddRemoteFileAndMoveWithWrongSchedulingRule() throws Exception {
		final IFolder folder = TestsDefaultContentProvider.this.testProject.getFolder("someFolder/someChild1");

		IWorkspaceRunnable runnable = new IWorkspaceRunnable() {

			public void run(IProgressMonitor monitor) throws CoreException {
				try {
					ISemanticFolder sFolder = (ISemanticFolder) folder.getAdapter(ISemanticFolder.class);

					File testfile = createTestFile("test.txt");
					boolean created = testfile.createNewFile();
					if (!created) {
						new FileOutputStream(testfile).close();
					}

					writeContentsToFile(testfile, "Hello World", "UTF-8");

					ISemanticFile sfile = sFolder.addFile("SomeFile", createURI4File(testfile), TestsDefaultContentProvider.this.options,
							monitor);
					if (TestsDefaultContentProvider.this.options == ISemanticFileSystem.SUPPRESS_REFRESH) {
						testProject.refreshLocal(IResource.DEPTH_INFINITE, monitor);
					}

					IFile file = sfile.getAdaptedFile();

					IFolder targetFolder = TestsDefaultContentProvider.this.testProject.getFolder("someFolder/someChild2");
					targetFolder.create(false, false, monitor);

					IFile targetFile = targetFolder.getFile(file.getName());

					file.move(targetFolder.getFile(file.getName()).getFullPath(), false, monitor);

					Assert.assertEquals("File existence", false, file.exists());
					Assert.assertEquals("File existence", true, targetFile.exists());

					assertContentsEqual(targetFile, "Hello World");

				} catch (URISyntaxException e) {
					throw new CoreException(new Status(IStatus.ERROR, TestPlugin.PLUGIN_ID, e.getMessage(), e));
				} catch (IOException e) {
					throw new CoreException(new Status(IStatus.ERROR, TestPlugin.PLUGIN_ID, e.getMessage(), e));
				}
			}
		};
		workspace.run(runnable, folder, IWorkspace.AVOID_UPDATE, new NullProgressMonitor());
	}

	/**
	 * 
	 * @throws Exception
	 */
	@Test(expected = CoreException.class)
	public void testAddRemoteFileAndMoveToExistingLocation() throws Exception {
		final IFolder folder = TestsDefaultContentProvider.this.testProject.getFolder("someFolder");

		IWorkspaceRunnable runnable = new IWorkspaceRunnable() {

			public void run(IProgressMonitor monitor) throws CoreException {
				try {
					ISemanticFolder sFolder = (ISemanticFolder) folder.getAdapter(ISemanticFolder.class);

					File testfile = createTestFile("test.txt");
					boolean created = testfile.createNewFile();
					if (!created) {
						new FileOutputStream(testfile).close();
					}

					writeContentsToFile(testfile, "Hello World", "UTF-8");

					ISemanticFile sfile = sFolder.addFile("SomeFile", createURI4File(testfile), TestsDefaultContentProvider.this.options,
							monitor);
					if (TestsDefaultContentProvider.this.options == ISemanticFileSystem.SUPPRESS_REFRESH) {
						testProject.refreshLocal(IResource.DEPTH_INFINITE, monitor);
					}

					IFile file = sfile.getAdaptedFile();

					IFolder targetFolder = TestsDefaultContentProvider.this.testProject.getFolder("target");
					targetFolder.create(false, false, monitor);

					IFile targetFile = targetFolder.getFile(file.getName());

					Assert.assertEquals("File existence", false, targetFile.exists());
					ByteArrayInputStream is;
					try {
						is = new ByteArrayInputStream("Hello World".getBytes("UTF-8"));
					} catch (UnsupportedEncodingException e) {
						throw new RuntimeException(e);
					}
					targetFile.create(is, false, monitor);
					Util.safeClose(targetFile.getContents());
					Assert.assertEquals("File existence", true, targetFile.exists());

					file.move(targetFolder.getFile(file.getName()).getFullPath(), false, monitor);

					Assert.assertTrue("file.move() should have failed.", false);
				} catch (URISyntaxException e) {
					throw new CoreException(new Status(IStatus.ERROR, TestPlugin.PLUGIN_ID, e.getMessage(), e));
				} catch (IOException e) {
					throw new CoreException(new Status(IStatus.ERROR, TestPlugin.PLUGIN_ID, e.getMessage(), e));
				}
			}
		};
		workspace.run(runnable, workspace.getRoot(), IWorkspace.AVOID_UPDATE, new NullProgressMonitor());
	}

	/**
	 * 
	 * @throws Exception
	 */
	@Test
	public void testAddFileAndDeleteFolder() throws Exception {
		IWorkspaceRunnable runnable = new IWorkspaceRunnable() {

			public void run(IProgressMonitor monitor) throws CoreException {

				IFile file = TestsDefaultContentProvider.this.testProject.getFile("someFolder/SomeFile");
				Assert.assertEquals("File existence", false, file.exists());
				ByteArrayInputStream is;
				try {
					is = new ByteArrayInputStream("Hello World".getBytes("UTF-8"));
				} catch (UnsupportedEncodingException e) {
					throw new RuntimeException(e);
				}

				IFolder folder = (IFolder) file.getParent();

				folder.create(false, false, monitor);
				file.create(is, false, monitor);
				Util.safeClose(file.getContents());
				Assert.assertEquals("File existence", true, file.exists());

				InputStream stream = null;
				try {
					stream = file.getContents();
					byte[] result = new byte[stream.available()];
					stream.read(result);
					String content = new String(result, "UTF-8");
					Assert.assertEquals("Hello World", content);
				} catch (Exception e) {
					throw new RuntimeException(e);

				} finally {
					Util.safeClose(stream);
				}
				file.getParent().delete(false, monitor);

			}
		};
		ISchedulingRule rule = workspace.getRuleFactory().createRule(testProject.getFolder("someFolder"));
		workspace.run(runnable, rule, IWorkspace.AVOID_UPDATE, new NullProgressMonitor());
	}

	/**
	 * 
	 * @throws Exception
	 */
	@Test
	@Ignore
	// TODO fails due to some problem in
	// RESTContentProvider.openInputStreamInternal (called upon a folder)
	public void testAddFileAndMoveFolder() throws Exception {
		IWorkspaceRunnable runnable = new IWorkspaceRunnable() {

			public void run(IProgressMonitor monitor) throws CoreException {

				IFile file = TestsDefaultContentProvider.this.testProject.getFile("someFolder/SomeFile");
				IFolder targetFolder = TestsDefaultContentProvider.this.testProject.getFolder("newTarget");
				targetFolder.create(false, false, monitor);
				Assert.assertEquals("File existence", false, file.exists());
				ByteArrayInputStream is;
				try {
					is = new ByteArrayInputStream("Hello World".getBytes("UTF-8"));
				} catch (UnsupportedEncodingException e) {
					throw new RuntimeException(e);
				}

				IFolder folder = (IFolder) file.getParent();

				folder.create(false, false, monitor);
				file.create(is, false, monitor);
				Util.safeClose(file.getContents());
				Assert.assertEquals("File existence", true, file.exists());

				InputStream stream = null;
				try {
					stream = file.getContents();
					byte[] result = new byte[stream.available()];
					stream.read(result);
					String content = new String(result, "UTF-8");
					Assert.assertEquals("Hello World", content);
				} catch (Exception e) {
					throw new RuntimeException(e);

				} finally {
					Util.safeClose(stream);
				}

				if (!TestsDefaultContentProvider.this.autoRefresh) {
					TestsDefaultContentProvider.this.testProject.refreshLocal(IResource.DEPTH_INFINITE, monitor);
				}

				IFolder parent = (IFolder) file.getParent();
				parent.move(targetFolder.getFolder(parent.getName()).getFullPath(), false, monitor);
				targetFolder.delete(false, monitor);

			}
		};
		workspace.run(runnable, this.testProject, IWorkspace.AVOID_UPDATE, new NullProgressMonitor());
	}

	/**
	 * 
	 * @throws Exception
	 */
	@Test
	public void testFailRemoteMethods() throws Exception {

		IWorkspaceRunnable runnable = new IWorkspaceRunnable() {

			public void run(IProgressMonitor monitor) throws CoreException {

				IFile file = TestsDefaultContentProvider.this.testProject.getFile("SomeOtherFile");
				Assert.assertEquals("File existence", false, file.exists());
				ByteArrayInputStream is;
				try {
					is = new ByteArrayInputStream("Hello World".getBytes("UTF-8"));
				} catch (UnsupportedEncodingException e) {
					throw new RuntimeException(e);
				}
				file.create(is, false, null);
				Util.safeClose(file.getContents());
				Assert.assertEquals("File existence", true, file.exists());

				ISemanticFolder sf = (ISemanticFolder) TestsDefaultContentProvider.this.testProject.getFolder("testFolder").getAdapter(
						ISemanticFolder.class);

				try {
					sf.addFile("testFile", TestsDefaultContentProvider.this.options, monitor);
					Assert.fail("Should have failed");
				} catch (CoreException e) {
					// $JL-EXC$ expected
				}
				try {
					sf.addFolder("testFolder", TestsDefaultContentProvider.this.options, monitor);
					Assert.fail("Should have failed");
				} catch (CoreException e) {
					// $JL-EXC$ expected
				}

				try {
					sf.addResource("testResource", TestsDefaultContentProvider.this.options, monitor);
					Assert.fail("Should have failed");
				} catch (CoreException e) {
					// $JL-EXC$ expected
				}

				try {
					sf.createFileRemotely("newRemoteFile", new ByteArrayInputStream(new byte[0]), null,
							TestsDefaultContentProvider.this.options, monitor);
					Assert.fail("Should have failed");
				} catch (CoreException e) {
					// $JL-EXC$ expected
				}

				try {
					sf.createResourceRemotely("newRemoteResource", null, TestsDefaultContentProvider.this.options, monitor);
					Assert.fail("Should have failed");
				} catch (CoreException e) {
					// $JL-EXC$ expected
				}

				final ISemanticFile sFile = (ISemanticFile) file.getAdapter(ISemanticFile.class);

				try {
					sFile.deleteRemotely(TestsDefaultContentProvider.this.options, monitor);
					Assert.fail("Should have failed");
				} catch (CoreException e) {
					// $JL-EXC$ expected
				}

				try {
					sFile.revertChanges(TestsDefaultContentProvider.this.options, monitor);
					Assert.fail("Should have failed");
				} catch (CoreException e) {
					// $JL-EXC$ expected
				}
			}
		};

		workspace.run(runnable, this.testProject, 0, new NullProgressMonitor());

	}

	/**
	 * 
	 * @throws CoreException
	 */
	@Test
	public void testMoveProject() throws CoreException {
		IWorkspaceRunnable runnable = new IWorkspaceRunnable() {

			public void run(IProgressMonitor monitor) throws CoreException {

				try {
					TestsDefaultContentProvider.this.testProject.move(new Path("SomeTarget"), false, monitor);
					Assert.fail("Should have failed");
				} catch (OperationCanceledException e) {
					// $JL-EXC$ expected
				}

			}
		};

		workspace.run(runnable, new NullProgressMonitor());
	}

	/**
	 * 
	 * @throws Exception
	 */
	@Test
	public void testTemplateMapping() throws Exception {

		// we have a mapping to PlainTestContentProvider which does not allow to
		// create local files
		final IFolder pcpfolder = this.testProject.getFolder("PlainTestContentProvider");
		pcpfolder.create(false, true, null);

		final IFolder dcpfolder = this.testProject.getFolder("SomeFolder");
		dcpfolder.create(false, true, null);

		IWorkspaceRunnable runnable = new IWorkspaceRunnable() {

			public void run(IProgressMonitor monitor) throws CoreException {
				try {
					pcpfolder.getFile("TestChild").create(new ByteArrayInputStream("".getBytes("UTF-8")), false, monitor);
					Assert.fail("Should have failed");
				} catch (Exception e) {
					// $JL-EXC$ expected
				}

				try {
					// this should succeed, though
					dcpfolder.getFile("TestChild").create(new ByteArrayInputStream("".getBytes("UTF-8")), false, monitor);
				} catch (UnsupportedEncodingException e) {
					throw new RuntimeException(e);
				}

			}
		};

		workspace.run(runnable, workspace.getRuleFactory().refreshRule(dcpfolder), 0, new NullProgressMonitor());

	}

	/**
	 * TODO create some SPI test class
	 * 
	 * @throws Exception
	 */
	@Test
	public void testFileStoreBehaviorAfterRemove() throws Exception {

		IFile file = TestsDefaultContentProvider.this.testProject.getFile("someFolder/SomeFileX");

		((IFolder) file.getParent()).create(false, true, null);

		file.create(new ByteArrayInputStream("".getBytes()), false, null);

		ISemanticFileStore store = (ISemanticFileStore) EFS.getStore(file.getLocationURI());
		ISemanticFileStore store2 = (ISemanticFileStore) EFS.getStore(file.getLocationURI());
		IPath beforePath = store.getPath();
		store.remove(null);
		IPath afterPath = store.getPath();
		IPath afterPath2 = store2.getPath();
		Assert.assertEquals("Path should be the same after removal of semantic file store", beforePath, afterPath);
		Assert.assertEquals("Path should be the same after removal of semantic file store", beforePath, afterPath2);

		try {
			store.getPersistentProperties();
			Assert.assertTrue("GetPersistentProperties should have failed.", false);
		} catch (CoreException e) {
			// ignore
		}
	}

	/**
	 * 
	 * @throws Exception
	 */
	@Test
	public void testFileStoreBehaviorAfterRemove2() throws Exception {

		IFile file = TestsDefaultContentProvider.this.testProject.getFile("someFolder/SomeFileX");

		((IFolder) file.getParent()).create(false, true, null);

		file.create(new ByteArrayInputStream("".getBytes()), false, null);

		ISemanticFileStore store = (ISemanticFileStore) EFS.getStore(file.getLocationURI());
		ISemanticFileStore parentStore = (ISemanticFileStore) EFS.getStore(file.getParent().getLocationURI());
		IPath beforePath = store.getPath();
		IPath beforePath2 = parentStore.getPath();
		parentStore.remove(null);
		IPath afterPath = store.getPath();
		IPath afterPath2 = parentStore.getPath();
		Assert.assertEquals("Path should be the same after removal of semantic file store", beforePath, afterPath);
		Assert.assertEquals("Path should be the same after removal of semantic file store", beforePath2, afterPath2);
		Assert.assertTrue("Folder should not exist", !parentStore.isExists());
		Assert.assertTrue("Child file should not exist as well", !store.isExists());

		try {
			store.getPersistentProperties();
			Assert.assertTrue("GetPersistentProperties should have failed.", false);
		} catch (CoreException e) {
			// ignore
		}
	}

	/**
	 * 
	 * @throws Exception
	 */
	@Test
	public void testAddFileWithURL() throws Exception {
		final IFolder folder = TestsDefaultContentProvider.this.testProject.getFolder("someFolder");

		IWorkspaceRunnable runnable = new IWorkspaceRunnable() {

			public void run(IProgressMonitor monitor) throws CoreException {
				ISemanticFolder sFolder = (ISemanticFolder) folder.getAdapter(ISemanticFolder.class);
				try {
					File testfile = createTestFile("test.txt");
					boolean created = testfile.createNewFile();
					if (!created) {
						new FileOutputStream(testfile).close();
					}

					ISemanticFile sfile = sFolder.addFile("SomeFile", createURI4File(testfile), TestsDefaultContentProvider.this.options,
							monitor);
					if (TestsDefaultContentProvider.this.options == ISemanticFileSystem.SUPPRESS_REFRESH) {
						testProject.refreshLocal(IResource.DEPTH_INFINITE, monitor);
					}

					Util.safeClose(sfile.getAdaptedFile().getContents());

					Assert.assertTrue("Resource should exist " + sfile.getAdaptedResource().getLocationURI(), sfile.getAdaptedResource()
							.exists());

				} catch (URISyntaxException e) {
					throw new CoreException(new Status(IStatus.ERROR, TestPlugin.PLUGIN_ID, e.getMessage(), e));
				} catch (IOException e) {
					throw new CoreException(new Status(IStatus.ERROR, TestPlugin.PLUGIN_ID, e.getMessage(), e));
				}

			}
		};

		workspace.run(runnable, testProject, 0, new NullProgressMonitor());
	}

	/**
	 * 
	 * @throws Exception
	 */
	@Test
	public void testAddFileWithWrongURL() throws Exception {
		final IFolder folder = TestsDefaultContentProvider.this.testProject.getFolder("someFolder");

		IWorkspaceRunnable runnable = new IWorkspaceRunnable() {

			public void run(IProgressMonitor monitor) throws CoreException {
				ISemanticFolder sFolder = (ISemanticFolder) folder.getAdapter(ISemanticFolder.class);

				if (sFolder.getAdaptedContainer().getFile(new Path("SomeFile")).exists()) {
					throw new CoreException(new Status(IStatus.ERROR, TestPlugin.PLUGIN_ID, "resource already exists"));
				}

				try {
					sFolder.addFile("SomeFile", new URI("x:y"), TestsDefaultContentProvider.this.options, monitor);
					Assert.assertTrue("addFile() should have failed", false);

				} catch (CoreException e) {
					// catch and continue
					e.getMessage();
				} catch (URISyntaxException e) {
					throw new CoreException(new Status(IStatus.ERROR, TestPlugin.PLUGIN_ID, e.getMessage(), e));
				}

			}
		};

		workspace.run(runnable, new NullProgressMonitor());
	}

	/**
	 * 
	 * @throws Exception
	 */
	@Test
	public void testAddFileWithNonExistingURL() throws Exception {
		final IFolder folder = TestsDefaultContentProvider.this.testProject.getFolder("someFolder");

		IWorkspaceRunnable runnable = new IWorkspaceRunnable() {

			public void run(IProgressMonitor monitor) throws CoreException {
				ISemanticFolder sFolder = (ISemanticFolder) folder.getAdapter(ISemanticFolder.class);

				if (sFolder.getAdaptedContainer().getFile(new Path("SomeFile")).exists()) {
					throw new CoreException(new Status(IStatus.ERROR, TestPlugin.PLUGIN_ID, "resource already exists"));
				}

				try {
					File testfile = createTestFile("test.txt");
					if (!testfile.delete()) {
						throw new IOException("Cann't delete file " + testfile);
					}

					sFolder.addFile("SomeFile", createURI4File(testfile), TestsDefaultContentProvider.this.options, monitor);
					Assert.assertTrue("addFile() should have failed", false);

				} catch (CoreException e) {
					// catch and continue
					e.getMessage();
				} catch (URISyntaxException e) {
					throw new CoreException(new Status(IStatus.ERROR, TestPlugin.PLUGIN_ID, e.getMessage(), e));
				} catch (IOException e) {
					throw new CoreException(new Status(IStatus.ERROR, TestPlugin.PLUGIN_ID, e.getMessage(), e));
				}

			}
		};

		workspace.run(runnable, new NullProgressMonitor());
	}

	/**
	 * 
	 * @throws Exception
	 */
	@Test
	public void testSynchronize() throws Exception {
		final IFolder folder = TestsDefaultContentProvider.this.testProject.getFolder("someFolder");

		IWorkspaceRunnable runnable = new IWorkspaceRunnable() {

			public void run(IProgressMonitor monitor) throws CoreException {
				ISemanticFolder sFolder = (ISemanticFolder) folder.getAdapter(ISemanticFolder.class);
				try {
					File testfile = createTestFile("test.txt");

					writeContentsToFile(testfile, TEST, UTF_8_CHARSET);

					ISemanticFile sfile = sFolder.addFile("SomeFileZ", createURI4File(testfile), TestsDefaultContentProvider.this.options,
							monitor);
					if (TestsDefaultContentProvider.this.options == ISemanticFileSystem.SUPPRESS_REFRESH) {
						testProject.refreshLocal(IResource.DEPTH_INFINITE, monitor);
					}

					assertContentsEqual(sfile.getAdaptedFile(), TEST);

					Assert.assertTrue("Resource should exist " + sfile.getAdaptedResource().getLocationURI(), sfile.getAdaptedResource()
							.exists());

					writeContentsToFile(testfile, TEST2, UTF_8_CHARSET);

					sfile.synchronizeContentWithRemote(SyncDirection.INCOMING, TestsDefaultContentProvider.this.options, monitor);

					assertContentsEqual(sfile.getAdaptedFile(), TEST2);

					if (!testfile.delete()) {
						throw new IOException("Cann't delete file " + testfile);
					}

					try {
						sfile.synchronizeContentWithRemote(SyncDirection.INCOMING, TestsDefaultContentProvider.this.options, monitor);
					} catch (CoreException e) {
						// ignore and continue
						e.getMessage();
					}

					try {
						Util.safeClose(sfile.getAdaptedFile().getContents());
					} catch (CoreException e) {
						// ignore and continue
						e.getMessage();
					}

					writeContentsToFile(testfile, TEST, UTF_8_CHARSET);

					sfile.synchronizeContentWithRemote(SyncDirection.INCOMING, TestsDefaultContentProvider.this.options, monitor);

					assertContentsEqual(sfile.getAdaptedFile(), TEST);

				} catch (URISyntaxException e) {
					throw new CoreException(new Status(IStatus.ERROR, TestPlugin.PLUGIN_ID, e.getMessage(), e));
				} catch (IOException e) {
					throw new CoreException(new Status(IStatus.ERROR, TestPlugin.PLUGIN_ID, e.getMessage(), e));
				}
			}
		};

		workspace.run(runnable, this.testProject, 0, new NullProgressMonitor());
	}

	/**
	 * 
	 * @throws Exception
	 */
	@Test
	public void testRuleFactory() throws Exception {
		final IFolder folder = TestsDefaultContentProvider.this.testProject.getFolder("someFolder");
		final IFolder subfolder = folder.getFolder("someSubfolder");
		final IFolder file = subfolder.getFolder("someFile");
		IResourceRuleFactory factory = workspace.getRuleFactory();

		Assert.assertEquals(testProject, factory.modifyRule(testProject));
		Assert.assertEquals(folder, factory.modifyRule(folder));
		Assert.assertEquals(subfolder, factory.modifyRule(subfolder));
		Assert.assertEquals(file, factory.modifyRule(file));

		Assert.assertEquals(testProject, factory.refreshRule(testProject));
		Assert.assertEquals(testProject, factory.refreshRule(folder));
		Assert.assertEquals(folder, factory.refreshRule(subfolder));
		Assert.assertEquals(subfolder, factory.refreshRule(file));

		Assert.assertEquals(testProject, factory.deleteRule(testProject));
		Assert.assertEquals(testProject, factory.deleteRule(folder));
		Assert.assertEquals(folder, factory.deleteRule(subfolder));
		Assert.assertEquals(subfolder, factory.deleteRule(file));

		Assert.assertEquals(testProject, factory.createRule(testProject));
		Assert.assertEquals(testProject, factory.createRule(folder));
		Assert.assertEquals(folder, factory.createRule(subfolder));
		Assert.assertEquals(subfolder, factory.createRule(file));
	}

	/**
	 * 
	 * @throws Exception
	 */
	@Test
	public void testImplicitFolderCreation() throws Exception {
		final IFolder folder = TestsDefaultContentProvider.this.testProject.getFolder("someFolder");
		final IFolder subfolder = folder.getFolder("someSubfolder");

		IWorkspaceRunnable runnable = new IWorkspaceRunnable() {
			public void run(IProgressMonitor monitor) throws CoreException {
				ISemanticFolder sFolder = (ISemanticFolder) subfolder.getAdapter(ISemanticFolder.class);

				File testfile = createTestFile("test.txt");

				try {
					writeContentsToFile(testfile, TEST, UTF_8_CHARSET);
				} catch (IOException e) {
					throw new CoreException(new Status(IStatus.ERROR, TestPlugin.PLUGIN_ID, e.getMessage(), e));
				}

				try {
					sFolder.addFile("SomeFile", createURI4File(testfile), TestsDefaultContentProvider.this.options, monitor);
				} catch (URISyntaxException e) {
					throw new CoreException(new Status(IStatus.ERROR, TestPlugin.PLUGIN_ID, e.getMessage(), e));
				}
			}
		};

		workspace.run(runnable, workspace.getRuleFactory().refreshRule(subfolder), 0, new NullProgressMonitor());
	}
}