tests/org.eclipse.ui.resources.semantic.examples.test/src/org/eclipse/core/resources/semantic/test/TestsRestContentProvider.java - e4/org.eclipse.e4.resources - Git at Google

 /*******************************************************************************
  * 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.FileInputStream;
 import java.io.FileOutputStream;
 import java.io.InputStream;
 import java.io.OutputStream;
 import java.io.UnsupportedEncodingException;
 import java.net.URI;
 import java.net.URISyntaxException;

 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.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.ISemanticProject;
 import org.eclipse.core.resources.semantic.ISemanticResourceInfo;
 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.Util;
 import org.eclipse.core.resources.semantic.test.provider.RestTestContentProvider;
 import org.eclipse.core.runtime.CoreException;
 import org.eclipse.core.runtime.IProgressMonitor;
 import org.eclipse.core.runtime.IStatus;
 import org.eclipse.core.runtime.NullProgressMonitor;
 import org.eclipse.core.runtime.Platform;
 import org.eclipse.core.runtime.Status;
 import org.eclipse.team.core.RepositoryProvider;
 import org.junit.After;
 import org.junit.Assert;
 import org.junit.Before;
 import org.junit.Ignore;
 import org.junit.Test;

 /**
  * Test the REST content provider
  *
  */
 public class TestsRestContentProvider extends TestsContentProviderUtil {

 	/**
 	 * Setup
 	 *
 	 * @throws Exception
 	 */
 	@Before
 	public void beforeMethod() throws Exception {

 		final IWorkspace workspace = ResourcesPlugin.getWorkspace();
 		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(TestsRestContentProvider.this.projectName);

 				try {
 					description.setLocationURI(new URI(ISemanticFileSystem.SCHEME + ":/" + TestsRestContentProvider.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);

 				ISemanticProject spr = (ISemanticProject) project.getAdapter(ISemanticProject.class);

 				spr.addFolder("root", TestsRestContentProvider.this.providerName, null, TestsRestContentProvider.this.options, monitor);

 				project.refreshLocal(IResource.DEPTH_INFINITE, monitor);
 			}

 		};

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

 		this.testProject = project;

 	}

 	/**
 	 * Teardown
 	 *
 	 * @throws Exception
 	 */
 	@After
 	public void afterMethod() throws Exception {

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

 		RemoteStoreTransient store = (RemoteStoreTransient) project.getAdapter(RemoteStoreTransient.class);
 		store.reset();

 		IWorkspaceRunnable runnable = new IWorkspaceRunnable() {

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

 		ResourcesPlugin.getWorkspace().run(runnable, new NullProgressMonitor());

 		this.testProject = null;
 	}

 	/**
 	 * Constructor
 	 */
 	public TestsRestContentProvider() {
 		super(true, "TestsRestContentProvider", RestTestContentProvider.class.getName());
 	}

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

 		final String googleuri = "http://www.google.de";
 		final String dummyuri = "file:someUri/which/is/long";

 		IFolder root = this.testProject.getFolder("root");

 		final ISemanticFolder sf = (ISemanticFolder) root.getAdapter(ISemanticFolder.class);

 		IWorkspaceRunnable runnable = new IWorkspaceRunnable() {

 			public void run(IProgressMonitor monitor) throws CoreException {

 				ISemanticFile uriFile;
 				try {
 					uriFile = sf.addFile("file", new URI(dummyuri), TestsRestContentProvider.this.options, monitor);
 					sf.getAdaptedResource().refreshLocal(IResource.DEPTH_INFINITE, monitor);
 					ISemanticResourceInfo info = uriFile.fetchResourceInfo(ISemanticFileSystem.RESOURCE_INFO_EXISTS_REMOTELY, monitor);
 					Assert.assertFalse("Remote existence", info.existsRemotely());
 					try {
 						Util.safeClose(uriFile.getAdaptedFile().getContents());
 						Assert.fail("Should have failed");
 					} catch (CoreException e) {
 						// $JL-EXC$ expected
 					}

 					uriFile = sf.addFile("file2", new URI(googleuri), TestsRestContentProvider.this.options, monitor);
 					sf.getAdaptedResource().refreshLocal(IResource.DEPTH_INFINITE, monitor);

 					info = uriFile.fetchResourceInfo(ISemanticFileSystem.RESOURCE_INFO_EXISTS_REMOTELY, monitor);
 					// TODO this currently fails in the test environment (no
 					// proxy)
 					// Assert.assertTrue("Remote existence",
 					// info.existsRemotely());

 					try {
 						Util.safeClose(uriFile.getAdaptedFile().getContents());
 					} catch (Exception e) {
 						// $JL-EXC$
 						// TODO this currently fails in the test environemnt (no
 						// proxy)
 						// Assert.fail("Should not have failed");
 					}
 				} catch (URISyntaxException e) {
 					// $JL-EXC$
 					throw new CoreException(new Status(IStatus.ERROR, TestPlugin.PLUGIN_ID, e.getMessage(), e));
 				}

 				String uriString = uriFile.fetchResourceInfo(ISemanticFileSystem.RESOURCE_INFO_URI_STRING, monitor).getRemoteURIString();

 				Assert.assertEquals(googleuri, uriString);

 				try {
 					IResource[] resources = sf.findURI(new URI(googleuri), monitor);

 					Assert.assertEquals(1, resources.length);

 					Assert.assertEquals("file2", resources[0].getName());
 				} catch (URISyntaxException e) {
 					// $JL-EXC$
 					throw new CoreException(new Status(IStatus.ERROR, TestPlugin.PLUGIN_ID, e.getMessage(), e));
 				}

 			}
 		};

 		ResourcesPlugin.getWorkspace().run(runnable, new NullProgressMonitor());

 	}

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

 		IFolder root = this.testProject.getFolder("root");

 		final File file = createTestFile("AFile.txt");
 		boolean created = file.createNewFile();
 		if (!created) {
 			new FileOutputStream(file).close();
 		}

 		final ISemanticFolder sf = (ISemanticFolder) root.getAdapter(ISemanticFolder.class);

 		IWorkspaceRunnable runnable = new IWorkspaceRunnable() {

 			public void run(IProgressMonitor monitor) throws CoreException {

 				ISemanticFile uriFile;
 				try {
 					uriFile = sf.addFile("file2", createURI4File(file), TestsRestContentProvider.this.options, monitor);
 					sf.getAdaptedResource().getProject().refreshLocal(IResource.DEPTH_INFINITE, monitor);
 					assertContentsEqual(uriFile.getAdaptedFile(), "");

 					ISemanticResourceInfo info = uriFile.fetchResourceInfo(ISemanticFileSystem.RESOURCE_INFO_EXISTS_REMOTELY, monitor);
 					Assert.assertTrue("Remote existence", info.existsRemotely());

 					FileOutputStream os = null;
 					try {
 						os = new FileOutputStream(file);
 						os.write("Hello World".getBytes("UTF-8"));
 						os.close();
 					} catch (Exception e) {
 						throw new RuntimeException(e);
 					} finally {
 						Util.safeClose(os);
 					}

 					assertContentsEqual(uriFile.getAdaptedFile(), "");

 					uriFile.synchronizeContentWithRemote(SyncDirection.INCOMING, TestsRestContentProvider.this.options, monitor);

 					sf.getAdaptedResource().getProject().refreshLocal(IResource.DEPTH_INFINITE, monitor);
 					assertContentsEqual(uriFile.getAdaptedFile(), "Hello World");

 					long firstTime = uriFile.getAdaptedFile().getLocalTimeStamp();

 					try {
 						// make sure we get another file timestamp
 						Thread.sleep(100);
 					} catch (InterruptedException e1) {
 						// TODO Auto-generated catch block
 						e1.printStackTrace();
 					}

 					try {
 						uriFile.validateEdit(null);
 						uriFile.getAdaptedFile().setContents(new ByteArrayInputStream("Another world".getBytes("UTF-8")), IResource.NONE,
 								monitor);
 					} catch (UnsupportedEncodingException e) {
 						throw new RuntimeException(e);
 					}

 					assertContentsEqual(uriFile.getAdaptedFile(), "Another world");
 					long secondTime = uriFile.getAdaptedFile().getLocalTimeStamp();

 					Assert.assertTrue("Timstamps should differ", secondTime > firstTime);

 					uriFile.revertChanges(TestsRestContentProvider.this.options, monitor);
 					sf.getAdaptedResource().getProject().refreshLocal(IResource.DEPTH_INFINITE, monitor);
 					assertContentsEqual(uriFile.getAdaptedFile(), "Hello World");

 					long thirdTime = uriFile.getAdaptedFile().getLocalTimeStamp();

 					Assert.assertTrue("Timestamp should be the same", thirdTime == firstTime);

 					try {
 						// make sure we get another file timestamp
 						Thread.sleep(100);
 					} catch (InterruptedException e1) {
 						// TODO Auto-generated catch block
 						e1.printStackTrace();
 					}

 					try {
 						uriFile.validateEdit(null);
 						uriFile.getAdaptedFile().setContents(new ByteArrayInputStream("Yet another world".getBytes("UTF-8")),
 								IResource.NONE, monitor);
 					} catch (UnsupportedEncodingException e) {
 						throw new RuntimeException(e);
 					}

 					assertContentsEqual(uriFile.getAdaptedFile(), "Yet another world");
 					long fourthTime = uriFile.getAdaptedFile().getLocalTimeStamp();

 					Assert.assertTrue("Timstamps should differ", fourthTime > secondTime);

 				} catch (URISyntaxException e) {
 					// $JL-EXC$
 					throw new CoreException(new Status(IStatus.ERROR, TestPlugin.PLUGIN_ID, e.getMessage(), e));
 				}

 			}
 		};

 		ResourcesPlugin.getWorkspace().run(runnable, new NullProgressMonitor());

 	}

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

 		IFolder root = this.testProject.getFolder("root");

 		final File file = createTestFile("AFile.txt");
 		boolean created = file.createNewFile();
 		if (!created) {
 			OutputStream os = new FileOutputStream(file);
 			os.write("I'm remote".getBytes("UTF-8"));
 			os.close();
 		}

 		final ISemanticFolder sf = (ISemanticFolder) root.getAdapter(ISemanticFolder.class);

 		IWorkspaceRunnable runnable = new IWorkspaceRunnable() {

 			public void run(IProgressMonitor monitor) throws CoreException {

 				ISemanticFile uriFile;

 				try {
 					uriFile = sf.addFile("file2", createURI4File(file), TestsRestContentProvider.this.options, monitor);
 				} catch (URISyntaxException e2) {
 					throw new RuntimeException(e2);
 				}
 				sf.getAdaptedResource().getProject().refreshLocal(IResource.DEPTH_INFINITE, monitor);

 				assertContentsEqual(uriFile.getAdaptedFile(), "I'm remote");

 				long firstTime = uriFile.getAdaptedFile().getLocalTimeStamp();

 				try {
 					uriFile.validateEdit(null);
 					uriFile.getAdaptedFile()
 							.setContents(new ByteArrayInputStream("New content".getBytes("UTF-8")), IResource.NONE, monitor);
 				} catch (UnsupportedEncodingException e1) {
 					throw new RuntimeException(e1);
 				}

 				assertContentsEqual(file, "I'm remote");
 				assertContentsEqual(uriFile.getAdaptedFile(), "New content");

 				long filestamp = file.lastModified();

 				Assert.assertEquals("Timestamp should be the same", filestamp, firstTime);

 				// folder sync
 				sf.synchronizeContentWithRemote(SyncDirection.OUTGOING, TestsRestContentProvider.this.options, monitor);
 				sf.getAdaptedResource().getProject().refreshLocal(IResource.DEPTH_INFINITE, monitor);

 				assertContentsEqual(file, "New content");

 				long secondTime = uriFile.getAdaptedFile().getLocalTimeStamp();

 				Assert.assertTrue("Timstamps should differ", secondTime > filestamp);

 				if (Platform.OS_WIN32.equals(Platform.getOS())) {
 					Assert.assertEquals("Timestamp should be the same", file.lastModified(), secondTime);
 				} else {
 					// non-millisecond accuracy on UNIXes
 					long millis = secondTime % 1000;
 					Assert.assertEquals("Timestamp should be the same", file.lastModified(), secondTime - millis);
 				}
 			}
 		};

 		ResourcesPlugin.getWorkspace().run(runnable, new NullProgressMonitor());

 	}

 	/**
 	 *
 	 * @throws Exception
 	 */
 	@Test
 	@Ignore
 	// fix this
 	public void testCreateFileRemotely() throws Exception {

 		final IFolder root = this.testProject.getFolder("root");

 		final File file = createTestFile("ANewFile.txt");
 		// boolean created = file.createNewFile();

 		if (file.exists()) {
 			if (!file.delete()) {
 				throw new RuntimeException("Could not prepare test");
 			}

 		}

 		final ISemanticFolder sf = (ISemanticFolder) root.getAdapter(ISemanticFolder.class);

 		IWorkspaceRunnable runnable = new IWorkspaceRunnable() {

 			public void run(IProgressMonitor monitor) throws CoreException {
 				ISemanticFile uriFile;
 				try {
 					uriFile = sf.createFileRemotely("filenew", new ByteArrayInputStream("Hello World".getBytes()), createURI4File(file),
 							TestsRestContentProvider.this.options, monitor);
 					uriFile.getAdaptedFile().getParent().refreshLocal(IResource.DEPTH_INFINITE, monitor);

 				} catch (URISyntaxException e) {
 					throw new RuntimeException(e);
 				}
 				sf.getAdaptedResource().getProject().refreshLocal(IResource.DEPTH_INFINITE, monitor);
 				assertContentsEqual(uriFile.getAdaptedFile(), "Hello World");

 			}
 		};

 		ResourcesPlugin.getWorkspace().run(runnable, new NullProgressMonitor());

 	}

 	// void assertContentsEqual(IFile file, String test) {
 	// InputStream is = null;
 	// try {
 	// is = file.getContents();
 	// int size = is.available();
 	// byte[] buffer = new byte[size];
 	// is.read(buffer);
 	// Util.safeClose(is);
 	// Assert.assertEquals("Wrong content", test, new String(buffer, "UTF-8"));
 	//
 	// } catch (Exception e) {
 	// // $JL-EXC$
 	// Assert.fail("Exception getting file content: " + e.getMessage());
 	// }
 	// }

 	void assertContentsEqual(File file, String test) {
 		InputStream is = null;
 		try {

 			is = new FileInputStream(file);
 			byte[] buffer = new byte[is.available()];
 			is.read(buffer);
 			Util.safeClose(is);
 			Assert.assertEquals("Wrong content", test, new String(buffer, "UTF-8"));

 		} catch (Exception e) {
 			// $JL-EXC$
 			Assert.fail("Exception getting file content: " + e.getMessage());
 		}
 	}

 }
	/*******************************************************************************
	* 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.FileInputStream;
	import java.io.FileOutputStream;
	import java.io.InputStream;
	import java.io.OutputStream;
	import java.io.UnsupportedEncodingException;
	import java.net.URI;
	import java.net.URISyntaxException;

	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.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.ISemanticProject;
	import org.eclipse.core.resources.semantic.ISemanticResourceInfo;
	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.Util;
	import org.eclipse.core.resources.semantic.test.provider.RestTestContentProvider;
	import org.eclipse.core.runtime.CoreException;
	import org.eclipse.core.runtime.IProgressMonitor;
	import org.eclipse.core.runtime.IStatus;
	import org.eclipse.core.runtime.NullProgressMonitor;
	import org.eclipse.core.runtime.Platform;
	import org.eclipse.core.runtime.Status;
	import org.eclipse.team.core.RepositoryProvider;
	import org.junit.After;
	import org.junit.Assert;
	import org.junit.Before;
	import org.junit.Ignore;
	import org.junit.Test;

	/**
	* Test the REST content provider
	*
	*/
	public class TestsRestContentProvider extends TestsContentProviderUtil {

	/**
	* Setup
	*
	* @throws Exception
	*/
	@Before
	public void beforeMethod() throws Exception {

	final IWorkspace workspace = ResourcesPlugin.getWorkspace();
	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(TestsRestContentProvider.this.projectName);

	try {
	description.setLocationURI(new URI(ISemanticFileSystem.SCHEME + ":/" + TestsRestContentProvider.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);

	ISemanticProject spr = (ISemanticProject) project.getAdapter(ISemanticProject.class);

	spr.addFolder("root", TestsRestContentProvider.this.providerName, null, TestsRestContentProvider.this.options, monitor);

	project.refreshLocal(IResource.DEPTH_INFINITE, monitor);
	}

	};

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

	this.testProject = project;

	}

	/**
	* Teardown
	*
	* @throws Exception
	*/
	@After
	public void afterMethod() throws Exception {

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

	RemoteStoreTransient store = (RemoteStoreTransient) project.getAdapter(RemoteStoreTransient.class);
	store.reset();

	IWorkspaceRunnable runnable = new IWorkspaceRunnable() {

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

	ResourcesPlugin.getWorkspace().run(runnable, new NullProgressMonitor());

	this.testProject = null;
	}

	/**
	* Constructor
	*/
	public TestsRestContentProvider() {
	super(true, "TestsRestContentProvider", RestTestContentProvider.class.getName());
	}

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

	final String googleuri = "http://www.google.de";
	final String dummyuri = "file:someUri/which/is/long";

	IFolder root = this.testProject.getFolder("root");

	final ISemanticFolder sf = (ISemanticFolder) root.getAdapter(ISemanticFolder.class);

	IWorkspaceRunnable runnable = new IWorkspaceRunnable() {

	public void run(IProgressMonitor monitor) throws CoreException {

	ISemanticFile uriFile;
	try {
	uriFile = sf.addFile("file", new URI(dummyuri), TestsRestContentProvider.this.options, monitor);
	sf.getAdaptedResource().refreshLocal(IResource.DEPTH_INFINITE, monitor);
	ISemanticResourceInfo info = uriFile.fetchResourceInfo(ISemanticFileSystem.RESOURCE_INFO_EXISTS_REMOTELY, monitor);
	Assert.assertFalse("Remote existence", info.existsRemotely());
	try {
	Util.safeClose(uriFile.getAdaptedFile().getContents());
	Assert.fail("Should have failed");
	} catch (CoreException e) {
	// $JL-EXC$ expected
	}

	uriFile = sf.addFile("file2", new URI(googleuri), TestsRestContentProvider.this.options, monitor);
	sf.getAdaptedResource().refreshLocal(IResource.DEPTH_INFINITE, monitor);

	info = uriFile.fetchResourceInfo(ISemanticFileSystem.RESOURCE_INFO_EXISTS_REMOTELY, monitor);
	// TODO this currently fails in the test environment (no
	// proxy)
	// Assert.assertTrue("Remote existence",
	// info.existsRemotely());

	try {
	Util.safeClose(uriFile.getAdaptedFile().getContents());
	} catch (Exception e) {
	// $JL-EXC$
	// TODO this currently fails in the test environemnt (no
	// proxy)
	// Assert.fail("Should not have failed");
	}
	} catch (URISyntaxException e) {
	// $JL-EXC$
	throw new CoreException(new Status(IStatus.ERROR, TestPlugin.PLUGIN_ID, e.getMessage(), e));
	}

	String uriString = uriFile.fetchResourceInfo(ISemanticFileSystem.RESOURCE_INFO_URI_STRING, monitor).getRemoteURIString();

	Assert.assertEquals(googleuri, uriString);

	try {
	IResource[] resources = sf.findURI(new URI(googleuri), monitor);

	Assert.assertEquals(1, resources.length);

	Assert.assertEquals("file2", resources[0].getName());
	} catch (URISyntaxException e) {
	// $JL-EXC$
	throw new CoreException(new Status(IStatus.ERROR, TestPlugin.PLUGIN_ID, e.getMessage(), e));
	}

	}
	};

	ResourcesPlugin.getWorkspace().run(runnable, new NullProgressMonitor());

	}

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

	IFolder root = this.testProject.getFolder("root");

	final File file = createTestFile("AFile.txt");
	boolean created = file.createNewFile();
	if (!created) {
	new FileOutputStream(file).close();
	}

	final ISemanticFolder sf = (ISemanticFolder) root.getAdapter(ISemanticFolder.class);

	IWorkspaceRunnable runnable = new IWorkspaceRunnable() {

	public void run(IProgressMonitor monitor) throws CoreException {

	ISemanticFile uriFile;
	try {
	uriFile = sf.addFile("file2", createURI4File(file), TestsRestContentProvider.this.options, monitor);
	sf.getAdaptedResource().getProject().refreshLocal(IResource.DEPTH_INFINITE, monitor);
	assertContentsEqual(uriFile.getAdaptedFile(), "");

	ISemanticResourceInfo info = uriFile.fetchResourceInfo(ISemanticFileSystem.RESOURCE_INFO_EXISTS_REMOTELY, monitor);
	Assert.assertTrue("Remote existence", info.existsRemotely());

	FileOutputStream os = null;
	try {
	os = new FileOutputStream(file);
	os.write("Hello World".getBytes("UTF-8"));
	os.close();
	} catch (Exception e) {
	throw new RuntimeException(e);
	} finally {
	Util.safeClose(os);
	}

	assertContentsEqual(uriFile.getAdaptedFile(), "");

	uriFile.synchronizeContentWithRemote(SyncDirection.INCOMING, TestsRestContentProvider.this.options, monitor);

	sf.getAdaptedResource().getProject().refreshLocal(IResource.DEPTH_INFINITE, monitor);
	assertContentsEqual(uriFile.getAdaptedFile(), "Hello World");

	long firstTime = uriFile.getAdaptedFile().getLocalTimeStamp();

	try {
	// make sure we get another file timestamp
	Thread.sleep(100);
	} catch (InterruptedException e1) {
	// TODO Auto-generated catch block
	e1.printStackTrace();
	}

	try {
	uriFile.validateEdit(null);
	uriFile.getAdaptedFile().setContents(new ByteArrayInputStream("Another world".getBytes("UTF-8")), IResource.NONE,
	monitor);
	} catch (UnsupportedEncodingException e) {
	throw new RuntimeException(e);
	}

	assertContentsEqual(uriFile.getAdaptedFile(), "Another world");
	long secondTime = uriFile.getAdaptedFile().getLocalTimeStamp();

	Assert.assertTrue("Timstamps should differ", secondTime > firstTime);

	uriFile.revertChanges(TestsRestContentProvider.this.options, monitor);
	sf.getAdaptedResource().getProject().refreshLocal(IResource.DEPTH_INFINITE, monitor);
	assertContentsEqual(uriFile.getAdaptedFile(), "Hello World");

	long thirdTime = uriFile.getAdaptedFile().getLocalTimeStamp();

	Assert.assertTrue("Timestamp should be the same", thirdTime == firstTime);

	try {
	// make sure we get another file timestamp
	Thread.sleep(100);
	} catch (InterruptedException e1) {
	// TODO Auto-generated catch block
	e1.printStackTrace();
	}

	try {
	uriFile.validateEdit(null);
	uriFile.getAdaptedFile().setContents(new ByteArrayInputStream("Yet another world".getBytes("UTF-8")),
	IResource.NONE, monitor);
	} catch (UnsupportedEncodingException e) {
	throw new RuntimeException(e);
	}

	assertContentsEqual(uriFile.getAdaptedFile(), "Yet another world");
	long fourthTime = uriFile.getAdaptedFile().getLocalTimeStamp();

	Assert.assertTrue("Timstamps should differ", fourthTime > secondTime);

	} catch (URISyntaxException e) {
	// $JL-EXC$
	throw new CoreException(new Status(IStatus.ERROR, TestPlugin.PLUGIN_ID, e.getMessage(), e));
	}

	}
	};

	ResourcesPlugin.getWorkspace().run(runnable, new NullProgressMonitor());

	}

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

	IFolder root = this.testProject.getFolder("root");

	final File file = createTestFile("AFile.txt");
	boolean created = file.createNewFile();
	if (!created) {
	OutputStream os = new FileOutputStream(file);
	os.write("I'm remote".getBytes("UTF-8"));
	os.close();
	}

	final ISemanticFolder sf = (ISemanticFolder) root.getAdapter(ISemanticFolder.class);

	IWorkspaceRunnable runnable = new IWorkspaceRunnable() {

	public void run(IProgressMonitor monitor) throws CoreException {

	ISemanticFile uriFile;

	try {
	uriFile = sf.addFile("file2", createURI4File(file), TestsRestContentProvider.this.options, monitor);
	} catch (URISyntaxException e2) {
	throw new RuntimeException(e2);
	}
	sf.getAdaptedResource().getProject().refreshLocal(IResource.DEPTH_INFINITE, monitor);

	assertContentsEqual(uriFile.getAdaptedFile(), "I'm remote");

	long firstTime = uriFile.getAdaptedFile().getLocalTimeStamp();

	try {
	uriFile.validateEdit(null);
	uriFile.getAdaptedFile()
	.setContents(new ByteArrayInputStream("New content".getBytes("UTF-8")), IResource.NONE, monitor);
	} catch (UnsupportedEncodingException e1) {
	throw new RuntimeException(e1);
	}

	assertContentsEqual(file, "I'm remote");
	assertContentsEqual(uriFile.getAdaptedFile(), "New content");

	long filestamp = file.lastModified();

	Assert.assertEquals("Timestamp should be the same", filestamp, firstTime);

	// folder sync
	sf.synchronizeContentWithRemote(SyncDirection.OUTGOING, TestsRestContentProvider.this.options, monitor);
	sf.getAdaptedResource().getProject().refreshLocal(IResource.DEPTH_INFINITE, monitor);

	assertContentsEqual(file, "New content");

	long secondTime = uriFile.getAdaptedFile().getLocalTimeStamp();

	Assert.assertTrue("Timstamps should differ", secondTime > filestamp);

	if (Platform.OS_WIN32.equals(Platform.getOS())) {
	Assert.assertEquals("Timestamp should be the same", file.lastModified(), secondTime);
	} else {
	// non-millisecond accuracy on UNIXes
	long millis = secondTime % 1000;
	Assert.assertEquals("Timestamp should be the same", file.lastModified(), secondTime - millis);
	}
	}
	};

	ResourcesPlugin.getWorkspace().run(runnable, new NullProgressMonitor());

	}

	/**
	*
	* @throws Exception
	*/
	@Test
	@Ignore
	// fix this
	public void testCreateFileRemotely() throws Exception {

	final IFolder root = this.testProject.getFolder("root");

	final File file = createTestFile("ANewFile.txt");
	// boolean created = file.createNewFile();

	if (file.exists()) {
	if (!file.delete()) {
	throw new RuntimeException("Could not prepare test");
	}

	}

	final ISemanticFolder sf = (ISemanticFolder) root.getAdapter(ISemanticFolder.class);

	IWorkspaceRunnable runnable = new IWorkspaceRunnable() {

	public void run(IProgressMonitor monitor) throws CoreException {
	ISemanticFile uriFile;
	try {
	uriFile = sf.createFileRemotely("filenew", new ByteArrayInputStream("Hello World".getBytes()), createURI4File(file),
	TestsRestContentProvider.this.options, monitor);
	uriFile.getAdaptedFile().getParent().refreshLocal(IResource.DEPTH_INFINITE, monitor);

	} catch (URISyntaxException e) {
	throw new RuntimeException(e);
	}
	sf.getAdaptedResource().getProject().refreshLocal(IResource.DEPTH_INFINITE, monitor);
	assertContentsEqual(uriFile.getAdaptedFile(), "Hello World");

	}
	};

	ResourcesPlugin.getWorkspace().run(runnable, new NullProgressMonitor());

	}

	// void assertContentsEqual(IFile file, String test) {
	// InputStream is = null;
	// try {
	// is = file.getContents();
	// int size = is.available();
	// byte[] buffer = new byte[size];
	// is.read(buffer);
	// Util.safeClose(is);
	// Assert.assertEquals("Wrong content", test, new String(buffer, "UTF-8"));
	//
	// } catch (Exception e) {
	// // $JL-EXC$
	// Assert.fail("Exception getting file content: " + e.getMessage());
	// }
	// }

	void assertContentsEqual(File file, String test) {
	InputStream is = null;
	try {

	is = new FileInputStream(file);
	byte[] buffer = new byte[is.available()];
	is.read(buffer);
	Util.safeClose(is);
	Assert.assertEquals("Wrong content", test, new String(buffer, "UTF-8"));

	} catch (Exception e) {
	// $JL-EXC$
	Assert.fail("Exception getting file content: " + e.getMessage());
	}
	}

	}