/*******************************************************************************
* Copyright (c) 2000, 2017 IBM Corporation and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* IBM Corporation - initial API and implementation
*******************************************************************************/
package org.eclipse.core.tests.internal.localstore;
import java.io.File;
import junit.framework.Test;
import junit.framework.TestSuite;
import org.eclipse.core.filesystem.IFileStore;
import org.eclipse.core.internal.resources.*;
import org.eclipse.core.resources.*;
import org.eclipse.core.runtime.CoreException;
//
public class RefreshLocalTest extends LocalStoreTest implements ICoreConstants {
public static Test suite() {
return new TestSuite(RefreshLocalTest.class);
}
public RefreshLocalTest() {
super();
}
public RefreshLocalTest(String name) {
super(name);
}
/**
* Tests refreshing a folder whose case has changed on disk.
* This is a regression test for bug 79090.
*/
public void testDiscoverCaseChange() {
IProject project = projects[0];
IFolder folder = project.getFolder("A");
IFolder folderVariant = project.getFolder("a");
IFile file = folder.getFile("file");
IFile fileVariant = folderVariant.getFile(file.getName());
//create the project, folder, and file
ensureExistsInWorkspace(file, true);
//change the case of the folder on disk
project.getLocation().append("A").toFile().renameTo((project.getLocation().append("a").toFile()));
try {
//refresh the project
project.refreshLocal(IResource.DEPTH_INFINITE, getMonitor());
} catch (CoreException e) {
fail("1.99", e);
}
//variant should exist but original shouldn't
assertTrue("1.1", folderVariant.exists());
assertTrue("1.2", fileVariant.exists());
assertTrue("1.3", !folder.exists());
assertTrue("1.4", !file.exists());
assertTrue("1.5", project.isSynchronized(IResource.DEPTH_INFINITE));
}
/**
* Test discovery of a linked resource on refresh.
*/
public void testDiscoverLinkedResource() {
//create a linked resource with local contents missing
// IProject project = projects[0];
// ensureExistsInWorkspace(project, true);
// IPath location = getRandomLocation();
// IFile link = project.getFile("Link");
// try {
// link.createLink(location, IResource.ALLOW_MISSING_LOCAL, getMonitor());
// } catch (CoreException e) {
// fail("0.99", e);
// }
//
// //should not be synchronized (exists in ws, but not in fs)
// assertTrue("1.0", !project.isSynchronized(IResource.DEPTH_INFINITE));
// assertTrue("1.1", !link.isSynchronized(IResource.DEPTH_ZERO));
//
// //should exist in workspace
// assertTrue("1.3", link.exists());
//
// //refreshing shouldn't get rid of the link
// try {
// link.refreshLocal(IResource.DEPTH_INFINITE, getMonitor());
// } catch (CoreException e) {
// fail("1.99", e);
// }
// assertTrue("1.4", link.exists());
//
// //create the contents in the file system
// try {
// createFileInFileSystem(location);
// } catch (CoreException e) {
// fail("2.99", e);
// }
//
// //should now be synchronized
// assertTrue("2.1", project.isSynchronized(IResource.DEPTH_INFINITE));
// assertTrue("2.2", link.isSynchronized(IResource.DEPTH_ZERO));
//
// //refresh
// try {
// link.refreshLocal(IResource.DEPTH_INFINITE, getMonitor());
// } catch (CoreException e) {
// fail("3.99", e);
// }
//
// //assert should exist in workspace
// assertTrue("2.3", link.exists());
}
/**
* Tests discovering a file via refresh local when neither the file
* nor its parent exists in the workspace.
*/
public void testFileDiscovery() throws Throwable {
/* initialize common objects */
IProject project = projects[0];
IFolder folder = project.getFolder("Folder");
IFile file = folder.getFile("File");
IResource[] both = new IResource[] {folder, file};
ensureExistsInFileSystem(both);
ensureDoesNotExistInWorkspace(both);
assertTrue("1.0", !file.exists());
assertTrue("1.1", !folder.exists());
assertTrue("1.2", !file.isSynchronized(IResource.DEPTH_ZERO));
assertTrue("1.3", !folder.isSynchronized(IResource.DEPTH_INFINITE));
file.refreshLocal(IResource.DEPTH_ZERO, getMonitor());
assertTrue("1.4", file.exists());
assertTrue("1.5", folder.exists());
//try again with deleted project
project.delete(IResource.FORCE, getMonitor());
ensureExistsInFileSystem(both);
ensureDoesNotExistInWorkspace(both);
assertTrue("2.0", !file.exists());
assertTrue("2.1", !folder.exists());
file.refreshLocal(IResource.DEPTH_ZERO, getMonitor());
assertTrue("2.2", !file.exists());
assertTrue("2.3", !folder.exists());
}
public void testFileToFolder() throws Throwable {
/* initialize common objects */
IProject project = projects[0];
/* */
IFile file = project.getFile("file");
file.create(null, true, null);
ensureDoesNotExistInFileSystem(file);
//
File target = file.getLocation().toFile();
target.mkdirs();
//
assertTrue("1.1", file.exists());
assertTrue("1.2", target.isDirectory());
file.refreshLocal(IResource.DEPTH_ZERO, null);
assertTrue("1.3", !file.exists());
IFolder folder = project.getFolder("file");
assertTrue("1.4", folder.exists());
}
public void testFolderToFile() throws Throwable {
/* initialize common objects */
IProject project = projects[0];
/* test folder to file */
IFolder folder = project.getFolder("folder");
folder.create(true, true, null);
ensureDoesNotExistInFileSystem(folder);
//
IFile file = project.getFile("folder");
ensureExistsInFileSystem(file);
//
assertTrue("1.1", folder.exists());
folder.refreshLocal(IResource.DEPTH_ZERO, null);
assertTrue("1.2", !folder.exists());
assertTrue("1.3", file.exists());
}
public void testRefreshClosedProject() {
IProject project = projects[0];
try {
project.close(getMonitor());
} catch (CoreException e) {
fail("0.99", e);
}
//refreshing a closed project should not fail
try {
project.refreshLocal(IResource.DEPTH_INFINITE, getMonitor());
project.refreshLocal(IResource.DEPTH_ZERO, getMonitor());
project.refreshLocal(IResource.DEPTH_ONE, getMonitor());
} catch (CoreException e) {
fail("1.0", e);
}
}
public void testRefreshFolder() throws Throwable {
/* initialize common objects */
IProject project = projects[0];
/* test deletion of a child */
IFile file = project.getFile("file");
final IFile hackFile = file;
final Workspace workspace = (Workspace) getWorkspace();
IWorkspaceRunnable operation = monitor -> {
workspace.createResource(hackFile, false);
((Resource) hackFile).getResourceInfo(false, true).set(M_LOCAL_EXISTS);
};
workspace.run(operation, null);
assertTrue("1.0", file.exists());
assertTrue("1.1", file.isLocal(IResource.DEPTH_ZERO));
project.refreshLocal(IResource.DEPTH_INFINITE, null);
assertTrue("1.2", !file.exists());
ensureDoesNotExistInWorkspace(file);
ensureDoesNotExistInFileSystem(file);
/* test creation of a child */
file = project.getFile("file");
ensureExistsInFileSystem(file);
assertTrue("2.0", !file.exists());
project.refreshLocal(IResource.DEPTH_INFINITE, null);
assertTrue("2.1", file.exists());
ensureDoesNotExistInWorkspace(file);
ensureDoesNotExistInFileSystem(file);
/* test changes of a child (child is folder) */
IFolder folder = project.getFolder("folder");
folder.create(true, true, null);
file = folder.getFile("file");
ensureExistsInFileSystem(file);
assertTrue("3.1", folder.exists());
assertTrue("3.2", folder.isLocal(IResource.DEPTH_ZERO));
assertTrue("3.3", !file.exists());
folder.refreshLocal(IResource.DEPTH_ZERO, null);
assertTrue("3.4", folder.exists());
assertTrue("3.5", folder.isLocal(IResource.DEPTH_ZERO));
assertTrue("3.6", !file.exists());
folder.refreshLocal(IResource.DEPTH_ONE, null);
assertTrue("3.7", folder.exists());
assertTrue("3.8", folder.isLocal(IResource.DEPTH_ZERO));
assertTrue("3.9", file.exists());
ensureDoesNotExistInWorkspace(folder);
ensureDoesNotExistInFileSystem(folder);
/* test changes of a child (child is file) */
file = project.getFile("file");
IFileStore fileStore = ((Resource) file).getStore();
ensureExistsInWorkspace(file, true);
assertTrue("4.1", file.exists());
assertTrue("4.2", file.isLocal(IResource.DEPTH_ZERO));
assertEquals("4.3", fileStore.fetchInfo().getLastModified(), ((Resource) file).getResourceInfo(false, false).getLocalSyncInfo());
ensureOutOfSync(file);
assertTrue("4.4", ((Resource) file).getResourceInfo(false, false).getLocalSyncInfo() != fileStore.fetchInfo().getLastModified());
project.refreshLocal(IResource.DEPTH_INFINITE, null);
assertEquals("4.5", fileStore.fetchInfo().getLastModified(), ((Resource) file).getResourceInfo(false, false).getLocalSyncInfo());
ensureDoesNotExistInWorkspace(file);
ensureDoesNotExistInFileSystem(file);
}
public void testSimpleRefresh() throws Throwable {
/* initialize common objects */
IProject project = projects[0];
/* test root deletion */
IFile file = project.getFile("file");
ensureExistsInWorkspace(file, true);
ensureDoesNotExistInFileSystem(file);
assertTrue("1.0", file.exists());
file.refreshLocal(IResource.DEPTH_INFINITE, null);
assertTrue("1.1", !file.exists());
/* test root and children creation */
IFolder folder = project.getFolder("folder");
IFileStore target = ((Resource) folder).getStore();
createTree(getTree(target));
assertTrue("2.0", !folder.exists());
folder.refreshLocal(IResource.DEPTH_INFINITE, null);
assertTrue("2.1", folder.exists());
assertTrue("2.2", ((Resource) folder).countResources(IResource.DEPTH_INFINITE, false) == (getTree(target).length + 1));
}
}