/*******************************************************************************
* 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
*******************************************************************************/
package org.eclipse.core.tests.internal.localstore;
import java.io.*;
import java.util.*;
import junit.framework.Test;
import junit.framework.TestSuite;
import org.eclipse.core.filesystem.IFileStore;
import org.eclipse.core.filesystem.provider.FileInfo;
import org.eclipse.core.internal.localstore.IHistoryStore;
import org.eclipse.core.internal.resources.*;
import org.eclipse.core.internal.utils.UniversalUniqueIdentifier;
import org.eclipse.core.resources.*;
import org.eclipse.core.runtime.*;
import org.eclipse.core.tests.resources.ResourceTest;
/**
* This class defines all tests for the HistoryStore Class.
*/
public class HistoryStoreTest extends ResourceTest {
class LogListenerVerifier implements ILogListener {
List<Integer> actual = new ArrayList<>();
List<Integer> expected = new ArrayList<>();
void addExpected(int statusCode) {
expected.add(Integer.valueOf(statusCode));
}
String dump() {
StringBuffer buffer = new StringBuffer();
buffer.append("Expected:\n");
for (Integer integer : expected) {
buffer.append("\t" + integer + "\n");
}
buffer.append("Actual:\n");
for (Integer integer : actual) {
buffer.append("\t" + integer + "\n");
}
return buffer.toString();
}
@Override
public void logging(IStatus status, String plugin) {
actual.add(Integer.valueOf(status.getCode()));
}
void reset() {
expected = new ArrayList<>();
actual = new ArrayList<>();
}
void verify() throws VerificationFailedException {
String message;
if (expected.size() != actual.size()) {
message = "Expected size: " + expected.size() + " does not equal actual size: " + actual.size() + "\n";
message += dump();
throw new VerificationFailedException(message);
}
for (Integer status : expected) {
if (!actual.contains(status)) {
message = "Expected and actual results differ.\n";
message += dump();
throw new VerificationFailedException(message);
}
}
}
}
class VerificationFailedException extends Exception {
/**
* All serializable objects should have a stable serialVersionUID
*/
private static final long serialVersionUID = 1L;
VerificationFailedException(String message) {
super(message);
}
}
private IWorkspaceDescription original;
public static void assertEquals(String tag, IFileState expected, IFileState actual) {
assertEquals(tag + " path differs", expected.getFullPath(), actual.getFullPath());
assertEquals(tag + " timestamp differs", expected.getModificationTime(), actual.getModificationTime());
assertEquals(tag + " uuid differs", ((FileState) expected).getUUID(), ((FileState) actual).getUUID());
}
public static Test suite() {
// TestSuite suite = new TestSuite(HistoryStoreTest.class.getName());
// suite.addTest(new HistoryStoreTest("testMoveProject"));
// suite.addTest(new HistoryStoreTest("testFindDeleted"));
// return suite;
return new TestSuite(HistoryStoreTest.class);
}
/*
* This little helper method makes sure that the history store is
* completely clean after it is invoked. If a history store entry or
* a file is left, it may become part of the history for another file in
* another test (if this file has the same name).
*/
public static void wipeHistoryStore(IProgressMonitor monitor) {
IHistoryStore store = ((Workspace) getWorkspace()).getFileSystemManager().getHistoryStore();
// Remove all the entries from the history store index. Note that
// this does not cause the history store states to be removed.
store.remove(Path.ROOT, monitor);
// Now make sure all the states are really removed.
store.removeGarbage();
}
public HistoryStoreTest() {
super();
}
public HistoryStoreTest(String name) {
super(name);
}
private int numBytes(InputStream input) {
int i = 0;
int c = -1;
try {
c = input.read();
while (c != -1) {
i++;
c = input.read();
}
} catch (IOException e) {
i = 0;
}
if (c != -1) {
i = 0;
}
return i;
}
public IWorkspaceDescription setMaxFileStates(int maxFileStates) throws CoreException {
IWorkspaceDescription currentDescription = getWorkspace().getDescription();
IWorkspaceDescription newDescription = getWorkspace().getDescription();
newDescription.setMaxFileStates(maxFileStates);
getWorkspace().setDescription(newDescription);
return currentDescription;
}
@Override
protected void setUp() throws Exception {
super.setUp();
original = getWorkspace().getDescription();
}
@Override
protected void tearDown() throws Exception {
getWorkspace().setDescription(original);
super.tearDown();
wipeHistoryStore(getMonitor());
}
/**
* Test the various policies in place to ensure that the history store
* does not grow to unmanageable size. The policies currently in place
* include:
* - store only a maximum number of states for each file
* - do not store files greater than some stated size
* - consider history store information stale after some specified period
* of time and discard stale data
*
* History store states are always stored in order from the newest state to
* the oldest state. This will be tested as well
*
* Scenario:
* 1. Create project AddStateAndPoliciesProject
* 2. Create file (file.txt) random contents
* 3. Set policy information in the workspace description as follows:
* - don't store states older than 1 day
* - keep a maximum of 5 states per file
* - file states must be less than 1 Mb
* 4. Make 8 modifications to file.txt (causing 8 states to be created)
* 5. Ensure only 5 states were kept.
* 6. Ensure states are in order from newest to oldest.
* 7. Set policy such that file states must be no greater than 7 bytes.
* 8. Create a new file file1.txt
* 9. Add 10 bytes of data to this file.
* 10. Check each of the states for this file and ensure they are not
* greater than 7 bytes.
* 11. Revert to policy in #3
* 12. Make sure we still have 5 states for file.txt (the first file we
* worked with)
* 13. Change the policy so that data older than 10 seconds is stale.
* 14. Wait 12 seconds (make it longer than 10 seconds to ensure we don't
* encounter granularity issues).
* 15. Check file states. There should be none left.
*/
public void testAddStateAndPolicies() {
/* Create common objects. */
IProject project = getWorkspace().getRoot().getProject("Project");
IFile file = project.getFile("file.txt");
try {
project.create(getMonitor());
project.open(getMonitor());
file.create(getRandomContents(), true, getMonitor());
} catch (CoreException e) {
fail("0.0", e);
}
/* set local history policies */
IWorkspaceDescription description = getWorkspace().getDescription();
// longevity set to 1 day
description.setFileStateLongevity(1000 * 3600 * 24);
// keep a max of 5 file states
description.setMaxFileStates(5);
// max size of file = 1 Mb
description.setMaxFileStateSize(1024 * 1024);
try {
getWorkspace().setDescription(description);
} catch (CoreException e) {
fail("0.1", e);
}
/* test max file states */
for (int i = 0; i < 8; i++) {
try {
ensureOutOfSync(file);
file.refreshLocal(IResource.DEPTH_ZERO, getMonitor());
file.setContents(getRandomContents(), true, true, getMonitor());
} catch (CoreException e) {
fail("1.0", e);
}
}
IFileState[] states = null;
try {
states = file.getHistory(getMonitor());
} catch (CoreException e) {
fail("1.01", e);
}
// Make sure we have 8 states as we haven't trimmed yet.
assertEquals("1.02", 8, states.length);
IFileState[] oldStates = states;
try {
getWorkspace().save(true, null);
states = file.getHistory(getMonitor());
} catch (CoreException e) {
fail("1.1", e);
}
// We added 8 states. Make sure we only have 5 (the max).
assertEquals("1.2", description.getMaxFileStates(), states.length);
// assert that states are in the correct order (newer ones first)
long lastModified = states[0].getModificationTime();
for (int i = 1; i < states.length; i++) {
assertTrue("1.3." + i, lastModified >= states[i].getModificationTime());
lastModified = states[i].getModificationTime();
}
// assert that the most recent states were preserved
for (int i = 0; i < states.length; i++) {
assertEquals("1.4." + i, oldStates[i], states[i]);
}
/* test max file state size */
description.setMaxFileStates(15);
// max size of file = 7 bytes
description.setMaxFileStateSize(7);
try {
getWorkspace().setDescription(description);
} catch (CoreException e) {
fail("2.0.0", e);
}
file = project.getFile("file1.txt");
try {
file.create(new ByteArrayInputStream(new byte[0]), true, getMonitor());
} catch (CoreException e) {
fail("2.0", e);
}
// Add 10 bytes to exceed the max file state size.
for (int i = 0; i < 10; i++) {
try {
file.appendContents(getContents("a"), true, true, getMonitor());
} catch (CoreException e) {
fail("2.1", e);
}
}
try {
getWorkspace().save(true, null);
states = file.getHistory(getMonitor());
// #states = size + 1 for the 0 byte length file to begin with.
for (int i = 0; i < states.length; i++) {
int bytesRead = numBytes(states[i].getContents());
assertTrue("2.2." + i, bytesRead <= description.getMaxFileStateSize());
}
} catch (CoreException e) {
fail("2.3", e);
}
/* test max file longevity */
// use the file of the first test
file = project.getFile("file.txt");
// 1 day
description.setFileStateLongevity(1000 * 3600 * 24);
description.setMaxFileStates(5);
// 1 Mb
description.setMaxFileStateSize(1024 * 1024);
// the description should be the same as the first test
try {
getWorkspace().setDescription(description);
} catch (CoreException e) {
fail("3.0", e);
}
try {
states = file.getHistory(getMonitor());
// Make sure we have 5 states for file file.txt
assertEquals("3.1", description.getMaxFileStates(), states.length);
} catch (CoreException e) {
fail("3.2", e);
}
// change policies
// 10 seconds
description.setFileStateLongevity(1000 * 10);
// 1 Mb
description.setMaxFileStateSize(1024 * 1024);
try {
getWorkspace().setDescription(description);
} catch (CoreException e) {
fail("3.3", e);
}
try {
// sleep for more than 10 seconds (the granularity varies on
// some machines so we will sleep for 12 seconds)
Thread.sleep(1000 * 12);
} catch (InterruptedException e) {
fail("3.4", e);
}
try {
getWorkspace().save(true, null);
states = file.getHistory(getMonitor());
// The 5 states for file.txt should have exceeded their longevity
// and been removed. Make sure we have 0 states left.
assertEquals("3.5", 0, states.length);
} catch (CoreException e) {
fail("3.6", e);
}
}
public void testBug28238() {
// paths to mimic files in the workspace
IProject project = getWorkspace().getRoot().getProject("myproject");
IFolder folder = project.getFolder("myfolder");
IFolder destinationFolder = project.getFolder("myfolder2");
IFile file = folder.getFile("myfile.txt");
IFile destinationFile = destinationFolder.getFile(file.getName());
IHistoryStore store = ((Resource) getWorkspace().getRoot()).getLocalManager().getHistoryStore();
// location of the data on disk
IFileStore fileStore = getTempStore();
createFileInFileSystem(fileStore);
// add the data to the history store
FileInfo fileInfo = new FileInfo(file.getName());
fileInfo.setLastModified(System.currentTimeMillis());
store.addState(file.getFullPath(), fileStore, fileInfo, true);
IFileState[] states = store.getStates(file.getFullPath(), getMonitor());
assertEquals("2.0", 1, states.length);
// copy the data
store.copyHistory(folder, destinationFolder, true);
states = store.getStates(destinationFile.getFullPath(), getMonitor());
assertEquals("3.0", 1, states.length);
}
public void testBug28603() {
// paths to mimic files in the workspace
IProject project = getWorkspace().getRoot().getProject("myproject");
IFolder folder1 = project.getFolder("myfolder1");
IFolder folder2 = project.getFolder("myfolder2");
IFile file1 = folder1.getFile("myfile.txt");
IFile file2 = folder2.getFile(file1.getName());
ensureExistsInWorkspace(new IResource[] {project, folder1, folder2}, true);
try {
file1.create(getRandomContents(), IResource.FORCE, getMonitor());
file1.setContents(getRandomContents(), IResource.FORCE | IResource.KEEP_HISTORY, getMonitor());
file1.setContents(getRandomContents(), IResource.FORCE | IResource.KEEP_HISTORY, getMonitor());
file1.setContents(getRandomContents(), IResource.FORCE | IResource.KEEP_HISTORY, getMonitor());
setMaxFileStates(50);
} catch (CoreException e) {
fail("0.0", e);
}
int maxStates = ResourcesPlugin.getWorkspace().getDescription().getMaxFileStates();
IFileState[] states = null;
try {
states = file1.getHistory(getMonitor());
} catch (CoreException e) {
fail("1.0", e);
}
assertEquals("1.1", 3, states.length);
int currentStates = 3;
for (int i = 0; i < maxStates + 10; i++) {
try {
states = file1.getHistory(getMonitor());
} catch (CoreException e) {
fail("2.0." + i, e);
}
assertEquals("2.1." + i + " file1 states", currentStates, states.length);
try {
file1.move(file2.getFullPath(), true, true, getMonitor());
} catch (CoreException e) {
fail("2.2." + i, e);
}
try {
states = file2.getHistory(getMonitor());
} catch (CoreException e) {
fail("2.3." + i, e);
}
currentStates = currentStates < maxStates ? currentStates + 1 : maxStates;
assertEquals("2.4." + i + " file2 states", currentStates, states.length);
try {
file2.move(file1.getFullPath(), true, true, getMonitor());
} catch (CoreException e) {
fail("2.5." + i, e);
}
try {
states = file1.getHistory(getMonitor());
} catch (CoreException e) {
fail("2.6." + i, e);
}
currentStates = currentStates < maxStates ? currentStates + 1 : maxStates;
assertEquals("2.7." + i + " file1 states", currentStates, states.length);
}
}
/*
* Test the functionality in store.clean() which is called to ensure
* the history store to ensure that the history store does not grow to
* unmanageable size. The policies currently in place include:
* - store only a maximum number of states for each file
* - do not store files greater than some stated size
* - consider history store information stale after some specified period
* of time and discard stale data
*
*/
public void testClean() {
/* Create common objects. */
IProject project = getWorkspace().getRoot().getProject("Project");
IFile file = project.getFile("file.txt");
try {
project.create(getMonitor());
project.open(getMonitor());
file.create(getRandomContents(), true, getMonitor());
} catch (CoreException e) {
fail("0.0", e);
}
IHistoryStore store = ((Workspace) getWorkspace()).getFileSystemManager().getHistoryStore();
// get another copy for changes
IWorkspaceDescription description = getWorkspace().getDescription();
/* test max file states */
// 1 day
description.setFileStateLongevity(1000 * 3600 * 24);
// 500 states per file max.
description.setMaxFileStates(500);
// 1Mb max size
description.setMaxFileStateSize(1024 * 1024);
try {
getWorkspace().setDescription(description);
} catch (CoreException e) {
fail("0.1", e);
}
// Set up 8 file states for this file when 500 are allowed
for (int i = 0; i < 8; i++) {
try {
ensureOutOfSync(file);
file.refreshLocal(IResource.DEPTH_ZERO, getMonitor());
// try {
// Thread.sleep(5000); // necessary because of lastmodified granularity in some file systems
// } catch (InterruptedException e) {
// }
file.setContents(getRandomContents(), true, true, getMonitor());
} catch (CoreException e) {
fail("1.0", e);
}
}
// All 8 states should exist.
long oldLastModTimes[] = new long[8];
try {
IFileState[] states = file.getHistory(getMonitor());
assertEquals("1.1", 8, states.length);
for (int i = 0; i < 8; i++) {
oldLastModTimes[i] = states[i].getModificationTime();
}
} catch (CoreException e) {
fail("1.2", e);
}
// Set max. number of file states to be 3
description.setMaxFileStates(3);
try {
getWorkspace().setDescription(description);
} catch (CoreException e) {
fail("2.0", e);
}
// Run 'clean' - should cause 5 of 8 states to be removed
store.clean(getMonitor());
// Restore max. number of states/file to 500
description.setMaxFileStates(500);
try {
getWorkspace().setDescription(description);
} catch (CoreException e) {
fail("2.2", e);
}
// Check to ensure only 3 states remain. Make sure these are the 3
// newer states.
try {
IFileState[] states = file.getHistory(getMonitor());
assertEquals("2.3", 3, states.length);
// assert that states are in the correct order (newer ones first)
long lastModified = states[0].getModificationTime();
for (int i = 1; i < states.length; i++) {
assertTrue("2.4." + i, lastModified >= states[i].getModificationTime());
lastModified = states[i].getModificationTime();
}
// Make sure we kept the 3 newer states.
for (int i = 0; i < states.length; i++) {
assertTrue("2.5." + i, oldLastModTimes[i] == states[i].getModificationTime());
}
} catch (CoreException e) {
fail("2.6", e);
}
/* test max file longevity */
file = project.getFile("file.txt"); // use the file of the first test
description.setFileStateLongevity(1000 * 3600 * 24); // 1 day
description.setMaxFileStates(500);
description.setMaxFileStateSize(1024 * 1024); // 1 Mb
// the description should be the same as the first test
try {
getWorkspace().setDescription(description);
} catch (CoreException e) {
fail("3.0", e);
}
try {
IFileState[] states = file.getHistory(getMonitor());
assertEquals("3.1", 3, states.length);
} catch (CoreException e) {
fail("3.2", e);
}
// change policies
// 10 seconds
description.setFileStateLongevity(1000 * 10);
// 1 Mb
description.setMaxFileStateSize(1024 * 1024);
try {
getWorkspace().setDescription(description);
} catch (CoreException e) {
fail("4.0", e);
}
try {
// sleep for 12 seconds (must exceed 10 seconds). This should
// cause all 3 states for file.txt to be considered stale.
Thread.sleep(1000 * 12);
} catch (InterruptedException e) {
fail("4.1", e);
}
store.clean(getMonitor());
// change policies - restore to original values
// 1 day
description.setFileStateLongevity(1000 * 3600 * 24);
// 1 Mb
description.setMaxFileStateSize(1024 * 1024);
try {
getWorkspace().setDescription(description);
} catch (CoreException e) {
fail("5.0", e);
}
// Ensure we have no state information left. It should have been
// considered stale.
try {
IFileState[] states = file.getHistory(getMonitor());
assertEquals("5.1", 0, states.length);
} catch (CoreException e) {
fail("5.2", e);
}
}
/**
* Copy case for History Store of folder when the local history is being
* copied.
*
* Scenario:
* 1. Create folder (folder1)
* 2. Create file "content 1"
* 3. Set new content "content 2"
* 4. Set new content "content 3"
* 5. Copy folder
* 6. Set new content to moved file "content 4"
* 7. Set new content to moved file "content 5"
*
* The original file should have two states available.
* But the copied file should have 4 states as it retains the states from
* before the copy took place as well.
*/
public void testCopyFolder() {
String[] contents = {"content1", "content2", "content3", "content4", "content5"};
// create common objects
IProject project = getWorkspace().getRoot().getProject("CopyFolderProject");
try {
project.create(getMonitor());
project.open(getMonitor());
} catch (CoreException e) {
fail("0.0", e);
}
IFile file = project.getFile("file1.txt");
IFolder folder = project.getFolder("folder1");
IFolder folder2 = project.getFolder("folder2");
file = folder.getFile("file1.txt");
try {
// Setup folder1 and file1.txt with some local history
folder.create(true, true, getMonitor());
file.create(getContents(contents[0]), true, getMonitor());
file.setContents(getContents(contents[1]), true, true, getMonitor());
file.setContents(getContents(contents[2]), true, true, getMonitor());
IFileState[] states = file.getHistory(getMonitor());
assertEquals("1.0", 2, states.length);
assertTrue("1.1", compareContent(getContents(contents[1]), states[0].getContents()));
assertTrue("1.2", compareContent(getContents(contents[0]), states[1].getContents()));
// Now do the move
folder.copy(folder2.getFullPath(), true, getMonitor());
// Check to make sure the file has been copied
IFile file2 = folder2.getFile("file1.txt");
assertTrue("1.3", file2.getFullPath().toString().endsWith("folder2/file1.txt"));
// Give the new (copied file) some new contents
file2.setContents(getContents(contents[3]), true, true, getMonitor());
file2.setContents(getContents(contents[4]), true, true, getMonitor());
// Check the local history of both files
states = file.getHistory(getMonitor());
assertEquals("2.0", 2, states.length);
assertTrue("2.1", compareContent(getContents(contents[1]), states[0].getContents()));
assertTrue("2.2", compareContent(getContents(contents[0]), states[1].getContents()));
states = file2.getHistory(getMonitor());
assertEquals("2.3", 4, states.length);
assertTrue("2.4", compareContent(getContents(contents[3]), states[0].getContents()));
assertTrue("2.5", compareContent(getContents(contents[2]), states[1].getContents()));
assertTrue("2.6", compareContent(getContents(contents[1]), states[2].getContents()));
assertTrue("2.7", compareContent(getContents(contents[0]), states[3].getContents()));
} catch (CoreException e) {
fail("2.8", e);
}
try {
project.delete(true, getMonitor());
} catch (CoreException e) {
fail("3.0", e);
}
}
/*
* This test is designed to exercise the public API method
* HistoryStore.copyHistory(). The following tests will be performed:
* - give a null source path
* - give a null destination path
* - give the same path for source and destination
* - give an invalid source path but a valid destination path
* - give an invalid destination path but a valid source path
*/
public void testCopyHistoryFile() {
// Create a project, folder and file so we have some history store
// Should have a project that appears as follows:
// - project name TestCopyHistoryProject
// - has one folder called folder1
// - folder1 has one file called file1.txt
// - file1.txt was created with initial data "content1"
// - change data in file1.txt to be "content2"
// - change data in file1.txt to be "content3"
// As a result of the above, there should be 2 history store states for
// file1.txt (one with "contents1" and the other with "contents2".
String[] contents = {"content0", "content1", "content2", "content3", "content4"};
// create common objects
IProject project = getWorkspace().getRoot().getProject("TestCopyHistoryProject");
ensureExistsInWorkspace(project, true);
IFolder folder = project.getFolder("folder1");
IFile file = folder.getFile("file1.txt");
IFile file2 = folder.getFile("file2.txt");
try {
// Setup folder1 and file1.txt with some local history
folder.create(true, true, getMonitor());
file.create(getContents(contents[0]), true, getMonitor());
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
fail("0.0", e);
}
file.setContents(getContents(contents[1]), true, true, getMonitor());
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
fail("0.1", e);
}
file.setContents(getContents(contents[2]), true, true, getMonitor());
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
fail("0.2", e);
}
IFileState[] states = file.getHistory(getMonitor());
assertEquals("1.0", 2, states.length);
assertTrue("1.1", compareContent(getContents(contents[1]), states[0].getContents()));
assertTrue("1.2", compareContent(getContents(contents[0]), states[1].getContents()));
file2.create(getContents(contents[3]), true, getMonitor());
file2.setContents(getContents(contents[4]), true, true, getMonitor());
} catch (CoreException e) {
fail("1.3", e);
}
// Run some tests with illegal arguments
LogListenerVerifier verifier = new LogListenerVerifier();
ILog log = ResourcesPlugin.getPlugin().getLog();
log.addLogListener(verifier);
// Test with null source and/or destination
IHistoryStore store = ((Resource) file).getLocalManager().getHistoryStore();
verifier.addExpected(IResourceStatus.INTERNAL_ERROR);
store.copyHistory(null, null, false);
try {
verifier.verify();
} catch (VerificationFailedException e) {
fail("1.4 ", e);
}
verifier.reset();
verifier.addExpected(IResourceStatus.INTERNAL_ERROR);
store.copyHistory(null, file2, false);
try {
verifier.verify();
} catch (VerificationFailedException e) {
fail("1.5 ", e);
}
verifier.reset();
verifier.addExpected(IResourceStatus.INTERNAL_ERROR);
store.copyHistory(file, null, false);
try {
verifier.verify();
} catch (VerificationFailedException e) {
fail("1.6 ", e);
}
verifier.reset();
// Try to copy the history store stuff to the same location
verifier.addExpected(IResourceStatus.INTERNAL_ERROR);
store.copyHistory(file, file, false);
try {
verifier.verify();
} catch (VerificationFailedException e) {
fail("1.7 ", e);
}
verifier.reset();
// Remember to remove the log listener now that we are done
// testing illegal arguments.
log.removeLogListener(verifier);
// Test a valid copy of a file
store.copyHistory(file, file2, false);
IFileState[] states = null;
try {
states = file2.getHistory(getMonitor());
} catch (CoreException e) {
fail("2.3");
}
assertEquals("2.4", 3, states.length);
try {
assertTrue("2.5", compareContent(getContents(contents[3]), states[0].getContents()));
assertTrue("2.6", compareContent(getContents(contents[1]), states[1].getContents()));
assertTrue("2.7", compareContent(getContents(contents[0]), states[2].getContents()));
} catch (CoreException e) {
fail("2.8");
}
}
public void testCopyHistoryFolder() {
String[] contents = {"content0", "content1", "content2", "content3", "content4"};
// create common objects
IProject project = getWorkspace().getRoot().getProject("TestCopyHistoryProject");
ensureExistsInWorkspace(project, true);
IFolder folder = project.getFolder("folder1");
IFolder folder2 = project.getFolder("folder2");
IFile file = folder.getFile("file1.txt");
IFile file2 = folder2.getFile("file1.txt");
try {
// Setup folder1 and file1.txt with some local history
folder.create(true, true, getMonitor());
file.create(getContents(contents[0]), true, getMonitor());
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
fail("0.0", e);
}
file.setContents(getContents(contents[1]), true, true, getMonitor());
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
fail("0.1", e);
}
file.setContents(getContents(contents[2]), true, true, getMonitor());
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
fail("0.2", e);
}
IFileState[] states = file.getHistory(getMonitor());
assertEquals("1.0", 2, states.length);
assertTrue("1.1", compareContent(getContents(contents[1]), states[0].getContents()));
assertTrue("1.2", compareContent(getContents(contents[0]), states[1].getContents()));
folder2.create(true, true, getMonitor());
file2.create(getContents(contents[3]), true, getMonitor());
file2.setContents(getContents(contents[4]), true, true, getMonitor());
} catch (CoreException e) {
fail("1.9", e);
}
// Test a valid copy of a folder
IHistoryStore store = ((Resource) file).getLocalManager().getHistoryStore();
store.copyHistory(folder, folder2, false);
IFileState[] states = null;
try {
states = file2.getHistory(getMonitor());
} catch (CoreException e) {
fail("2.3");
}
assertEquals("2.4", 3, states.length);
try {
assertTrue("2.5", compareContent(getContents(contents[3]), states[0].getContents()));
assertTrue("2.6", compareContent(getContents(contents[1]), states[1].getContents()));
assertTrue("2.7", compareContent(getContents(contents[0]), states[2].getContents()));
} catch (CoreException e) {
fail("2.8");
}
}
public void testCopyHistoryProject() {
String[] contents = {"content0", "content1", "content2", "content3", "content4"};
// create common objects
IProject project = getWorkspace().getRoot().getProject("TestCopyHistoryProject");
IProject project2 = getWorkspace().getRoot().getProject("TestCopyHistoryProject2");
ensureExistsInWorkspace(new IResource[] {project, project2}, true);
IFolder folder = project.getFolder("folder1");
IFolder folder2 = project2.getFolder("folder1");
IFile file = folder.getFile("file1.txt");
IFile file2 = folder2.getFile("file1.txt");
try {
// Setup folder1 and file1.txt with some local history
folder.create(true, true, getMonitor());
file.create(getContents(contents[0]), true, getMonitor());
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
fail("0.0", e);
}
file.setContents(getContents(contents[1]), true, true, getMonitor());
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
fail("0.1", e);
}
file.setContents(getContents(contents[2]), true, true, getMonitor());
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
fail("0.2", e);
}
IFileState[] states = file.getHistory(getMonitor());
assertEquals("1.0", 2, states.length);
assertTrue("1.1", compareContent(getContents(contents[1]), states[0].getContents()));
assertTrue("1.2", compareContent(getContents(contents[0]), states[1].getContents()));
folder2.create(true, true, getMonitor());
file2.create(getContents(contents[3]), true, getMonitor());
file2.setContents(getContents(contents[4]), true, true, getMonitor());
} catch (CoreException e) {
fail("1.9", e);
}
// Test a valid copy of a folder
IHistoryStore store = ((Resource) file).getLocalManager().getHistoryStore();
store.copyHistory(project, project2, false);
IFileState[] states = null;
try {
states = file2.getHistory(getMonitor());
} catch (CoreException e) {
fail("2.3");
}
assertEquals("2.4", 3, states.length);
try {
assertTrue("2.5", compareContent(getContents(contents[3]), states[0].getContents()));
assertTrue("2.6", compareContent(getContents(contents[1]), states[1].getContents()));
assertTrue("2.7", compareContent(getContents(contents[0]), states[2].getContents()));
} catch (CoreException e) {
fail("2.8");
}
}
public void testDelete() {
// create common objects
IProject project = getWorkspace().getRoot().getProject("MyProject");
try {
project.create(getMonitor());
project.open(getMonitor());
} catch (CoreException e) {
fail("0.0", e);
}
// test file
IFile file = project.getFile("file.txt");
try {
file.create(getRandomContents(), true, getMonitor());
file.setContents(getRandomContents(), true, true, getMonitor());
file.setContents(getRandomContents(), true, true, getMonitor());
// Check to see that there are only 2 states before the deletion
IFileState[] states = file.getHistory(getMonitor());
assertEquals("1.0", 2, states.length);
// Delete the file. This should add a state to the history store.
file.delete(true, true, getMonitor());
states = file.getHistory(getMonitor());
assertEquals("1.1", 3, states.length);
// Re-create the file. This should not affect the history store.
file.create(getRandomContents(), true, getMonitor());
states = file.getHistory(getMonitor());
assertEquals("1.2", 3, states.length);
} catch (CoreException e) {
fail("1.20", e);
}
// test folder
IFolder folder = project.getFolder("folder");
// Make sure this has a different name as the history store information
// for the first 'file.txt' is likely still around.
file = folder.getFile("file2.txt");
try {
folder.create(true, true, getMonitor());
file.create(getRandomContents(), true, getMonitor());
file.setContents(getRandomContents(), true, true, getMonitor());
file.setContents(getRandomContents(), true, true, getMonitor());
// There should only be 2 history store entries.
IFileState[] states = file.getHistory(getMonitor());
assertEquals("2.0", 2, states.length);
// Delete the folder. This should cause one more history store entry.
folder.delete(true, true, getMonitor());
states = file.getHistory(getMonitor());
assertEquals("2.1", 3, states.length);
// Re-create the folder. There should be no new history store entries.
folder.create(true, true, getMonitor());
file.create(getRandomContents(), true, getMonitor());
states = file.getHistory(getMonitor());
assertEquals("2.2", 3, states.length);
} catch (CoreException e) {
fail("2.99", e);
}
try {
project.delete(true, getMonitor());
} catch (CoreException e) {
fail("20.0", e);
}
}
/**
* Test for existence of file states in the HistoryStore.
*/
public void testExists() throws Throwable {
/* Create common objects. */
IProject project = getWorkspace().getRoot().getProject("Project");
IFile file = project.getFile("removeAllStatesFile.txt");
try {
project.create(getMonitor());
project.open(getMonitor());
file.create(getRandomContents(), true, getMonitor());
} catch (CoreException e) {
fail("0.0", e);
}
// Constant for the number of states we will create
final int ITERATIONS = 20;
/* Add multiple states for one file location. */
for (int i = 0; i < ITERATIONS; i++) {
try {
file.setContents(getRandomContents(), true, true, getMonitor());
} catch (CoreException e) {
fail("3.0." + i, e);
}
}
/* Valid Case: Test retrieved values. */
IFileState[] states = null;
try {
states = file.getHistory(getMonitor());
} catch (CoreException e) {
fail("5.0", e);
}
// Make sure we have ITERATIONS number of states
assertEquals("5.1", ITERATIONS, states.length);
// Make sure that each of these states really exists in the filesystem.
for (int i = 0; i < states.length; i++) {
assertTrue("5.2." + i, states[i].exists());
}
}
public void testFindDeleted() {
// create common objects
IWorkspaceRoot root = getWorkspace().getRoot();
IProject project = root.getProject("MyProject");
try {
project.create(getMonitor());
project.open(getMonitor());
IFile[] df = project.findDeletedMembersWithHistory(IResource.DEPTH_ONE, getMonitor());
assertEquals("0.1", 0, df.length);
} catch (CoreException e) {
fail("0.0", e);
}
// test that a deleted file can be found
IFile pfile = project.getFile("findDeletedFile.txt");
try {
// create and delete a file
pfile.create(getRandomContents(), true, getMonitor());
pfile.delete(true, true, getMonitor());
// the deleted file should show up as a deleted member of project
IFile[] df = project.findDeletedMembersWithHistory(IResource.DEPTH_ONE, getMonitor());
assertEquals("0.1", 1, df.length);
assertEquals("0.2", pfile, df[0]);
df = project.findDeletedMembersWithHistory(IResource.DEPTH_INFINITE, getMonitor());
assertEquals("0.3", 1, df.length);
assertEquals("0.4", pfile, df[0]);
df = project.findDeletedMembersWithHistory(IResource.DEPTH_ZERO, getMonitor());
assertEquals("0.5", 0, df.length);
// the deleted file should show up as a deleted member of workspace root
df = root.findDeletedMembersWithHistory(IResource.DEPTH_ONE, getMonitor());
assertEquals("0.5.1", 0, df.length);
df = root.findDeletedMembersWithHistory(IResource.DEPTH_INFINITE, getMonitor());
assertEquals("0.5.2", 1, df.length);
assertEquals("0.5.3", pfile, df[0]);
df = root.findDeletedMembersWithHistory(IResource.DEPTH_ZERO, getMonitor());
assertEquals("0.5.4", 0, df.length);
// recreate the file
pfile.create(getRandomContents(), true, getMonitor());
// the deleted file should no longer show up as a deleted member of project
df = project.findDeletedMembersWithHistory(IResource.DEPTH_ONE, getMonitor());
assertEquals("0.6", 0, df.length);
df = project.findDeletedMembersWithHistory(IResource.DEPTH_INFINITE, getMonitor());
assertEquals("0.7", 0, df.length);
df = project.findDeletedMembersWithHistory(IResource.DEPTH_ZERO, getMonitor());
assertEquals("0.8", 0, df.length);
// the deleted file should no longer show up as a deleted member of ws root
df = root.findDeletedMembersWithHistory(IResource.DEPTH_ONE, getMonitor());
assertEquals("0.8.1", 0, df.length);
df = root.findDeletedMembersWithHistory(IResource.DEPTH_INFINITE, getMonitor());
assertEquals("0.8.2", 0, df.length);
df = root.findDeletedMembersWithHistory(IResource.DEPTH_ZERO, getMonitor());
assertEquals("0.8.3", 0, df.length);
} catch (CoreException e) {
fail("0.00", e);
}
// scrub the project
try {
project.delete(true, getMonitor());
project.create(getMonitor());
project.open(getMonitor());
IFile[] df = project.findDeletedMembersWithHistory(IResource.DEPTH_ONE, getMonitor());
assertEquals("0.9", 0, df.length);
} catch (CoreException e) {
fail("0.10", e);
}
// test folder
IFolder folder = project.getFolder("folder");
IFile file = folder.getFile("filex.txt");
IFile folderAsFile = project.getFile(folder.getProjectRelativePath());
try {
// create and delete a file in a folder
folder.create(true, true, getMonitor());
file.create(getRandomContents(), true, getMonitor());
file.delete(true, true, getMonitor());
// the deleted file should show up as a deleted member
IFile[] df = project.findDeletedMembersWithHistory(IResource.DEPTH_ONE, getMonitor());
assertEquals("1.1", 0, df.length);
df = project.findDeletedMembersWithHistory(IResource.DEPTH_INFINITE, getMonitor());
assertEquals("1.2", 1, df.length);
assertEquals("1.3", file, df[0]);
df = project.findDeletedMembersWithHistory(IResource.DEPTH_ZERO, getMonitor());
assertEquals("1.4", 0, df.length);
// recreate the file
file.create(getRandomContents(), true, getMonitor());
// the deleted file should no longer show up as a deleted member
df = project.findDeletedMembersWithHistory(IResource.DEPTH_ONE, getMonitor());
assertEquals("1.5", 0, df.length);
df = project.findDeletedMembersWithHistory(IResource.DEPTH_INFINITE, getMonitor());
assertEquals("1.6", 0, df.length);
df = project.findDeletedMembersWithHistory(IResource.DEPTH_ZERO, getMonitor());
assertEquals("1.7", 0, df.length);
// deleting the folder should bring it back
folder.delete(true, true, getMonitor());
// the deleted file should show up as a deleted member of project
df = project.findDeletedMembersWithHistory(IResource.DEPTH_ONE, getMonitor());
assertEquals("1.8", 0, df.length);
df = project.findDeletedMembersWithHistory(IResource.DEPTH_INFINITE, getMonitor());
assertEquals("1.9", 1, df.length);
assertEquals("1.10", file, df[0]);
df = project.findDeletedMembersWithHistory(IResource.DEPTH_ZERO, getMonitor());
assertEquals("1.11", 0, df.length);
// create and delete a file where the folder was
folderAsFile.create(getRandomContents(), true, getMonitor());
folderAsFile.delete(true, true, getMonitor());
folder.create(true, true, getMonitor());
// the deleted file should show up as a deleted member of folder
df = folder.findDeletedMembersWithHistory(IResource.DEPTH_ZERO, getMonitor());
assertEquals("1.12", 1, df.length);
assertEquals("1.13", folderAsFile, df[0]);
df = folder.findDeletedMembersWithHistory(IResource.DEPTH_ONE, getMonitor());
assertEquals("1.14", 2, df.length);
List<IFile> dfList = Arrays.asList(df);
assertTrue("1.15", dfList.contains(file));
assertTrue("1.16", dfList.contains(folderAsFile));
df = folder.findDeletedMembersWithHistory(IResource.DEPTH_INFINITE, getMonitor());
assertEquals("1.17", 2, df.length);
dfList = Arrays.asList(df);
assertTrue("1.18", dfList.contains(file));
assertTrue("1.19", dfList.contains(folderAsFile));
} catch (CoreException e) {
fail("1.00", e);
}
// scrub the project
try {
project.delete(true, getMonitor());
project.create(getMonitor());
project.open(getMonitor());
IFile[] df = project.findDeletedMembersWithHistory(IResource.DEPTH_ONE, getMonitor());
assertEquals("1.50", 0, df.length);
} catch (CoreException e) {
fail("1.51", e);
}
// test a bunch of deletes
folder = project.getFolder("folder");
IFile file1 = folder.getFile("file1.txt");
IFile file2 = folder.getFile("file2.txt");
IFolder folder2 = folder.getFolder("folder2");
IFile file3 = folder2.getFile("file3.txt");
try {
// create and delete a file in a folder
folder.create(true, true, getMonitor());
folder2.create(true, true, getMonitor());
file1.create(getRandomContents(), true, getMonitor());
file2.create(getRandomContents(), true, getMonitor());
file3.create(getRandomContents(), true, getMonitor());
folder.delete(true, true, getMonitor());
// under root
IFile[] df = root.findDeletedMembersWithHistory(IResource.DEPTH_ZERO, getMonitor());
assertEquals("3.1", 0, df.length);
df = root.findDeletedMembersWithHistory(IResource.DEPTH_ONE, getMonitor());
assertEquals("3.2", 0, df.length);
df = root.findDeletedMembersWithHistory(IResource.DEPTH_INFINITE, getMonitor());
assertEquals("3.3", 3, df.length);
List<IFile> dfList = Arrays.asList(df);
assertTrue("3.3.1", dfList.contains(file1));
assertTrue("3.3.2", dfList.contains(file2));
assertTrue("3.3.3", dfList.contains(file3));
// under project
df = project.findDeletedMembersWithHistory(IResource.DEPTH_ZERO, getMonitor());
assertEquals("3.4", 0, df.length);
df = project.findDeletedMembersWithHistory(IResource.DEPTH_ONE, getMonitor());
assertEquals("3.5", 0, df.length);
df = project.findDeletedMembersWithHistory(IResource.DEPTH_INFINITE, getMonitor());
assertEquals("3.6", 3, df.length);
dfList = Arrays.asList(df);
assertTrue("3.6.1", dfList.contains(file1));
assertTrue("3.6.2", dfList.contains(file2));
assertTrue("3.6.3", dfList.contains(file3));
// under folder
df = folder.findDeletedMembersWithHistory(IResource.DEPTH_ZERO, getMonitor());
assertEquals("3.7", 0, df.length);
df = folder.findDeletedMembersWithHistory(IResource.DEPTH_ONE, getMonitor());
assertEquals("3.8", 2, df.length);
df = folder.findDeletedMembersWithHistory(IResource.DEPTH_INFINITE, getMonitor());
assertEquals("3.9", 3, df.length);
// under folder2
df = folder2.findDeletedMembersWithHistory(IResource.DEPTH_ZERO, getMonitor());
assertEquals("3.10", 0, df.length);
df = folder2.findDeletedMembersWithHistory(IResource.DEPTH_ONE, getMonitor());
assertEquals("3.11", 1, df.length);
df = folder2.findDeletedMembersWithHistory(IResource.DEPTH_INFINITE, getMonitor());
assertEquals("3.12", 1, df.length);
} catch (CoreException e) {
fail("3.00", e);
}
try {
project.delete(true, getMonitor());
} catch (CoreException e) {
fail("3.5", e);
}
// once the project is gone, so is all the history for that project
try {
// under root
IFile[] df = root.findDeletedMembersWithHistory(IResource.DEPTH_ZERO, getMonitor());
assertEquals("4.1", 0, df.length);
df = root.findDeletedMembersWithHistory(IResource.DEPTH_ONE, getMonitor());
assertEquals("4.2", 0, df.length);
df = root.findDeletedMembersWithHistory(IResource.DEPTH_INFINITE, getMonitor());
assertEquals("4.3", 0, df.length);
// under project
df = project.findDeletedMembersWithHistory(IResource.DEPTH_ZERO, getMonitor());
assertEquals("4.4", 0, df.length);
df = project.findDeletedMembersWithHistory(IResource.DEPTH_ONE, getMonitor());
assertEquals("4.5", 0, df.length);
df = project.findDeletedMembersWithHistory(IResource.DEPTH_INFINITE, getMonitor());
assertEquals("4.6", 0, df.length);
// under folder
df = folder.findDeletedMembersWithHistory(IResource.DEPTH_ZERO, getMonitor());
assertEquals("4.7", 0, df.length);
df = folder.findDeletedMembersWithHistory(IResource.DEPTH_ONE, getMonitor());
assertEquals("4.8", 0, df.length);
df = folder.findDeletedMembersWithHistory(IResource.DEPTH_INFINITE, getMonitor());
assertEquals("4.9", 0, df.length);
// under folder2
df = folder2.findDeletedMembersWithHistory(IResource.DEPTH_ZERO, getMonitor());
assertEquals("4.10", 0, df.length);
df = folder2.findDeletedMembersWithHistory(IResource.DEPTH_ONE, getMonitor());
assertEquals("4.11", 0, df.length);
df = folder2.findDeletedMembersWithHistory(IResource.DEPTH_INFINITE, getMonitor());
assertEquals("4.12", 0, df.length);
} catch (CoreException e) {
fail("4.00", e);
}
}
/**
* Test for retrieving contents of files with states logged in the HistoryStore.
*/
public void testGetContents() throws Throwable {
final int ITERATIONS = 20;
/* Create common objects. */
IProject project = getWorkspace().getRoot().getProject("Project");
try {
project.create(getMonitor());
project.open(getMonitor());
} catch (CoreException e) {
fail("0.0", e);
}
/* Create files. */
IFile file = project.getFile("getContentsFile.txt");
String contents = "This file has some contents in testGetContents.";
ensureExistsInWorkspace(file, contents);
IFile secondValidFile = project.getFile("secondGetContentsFile.txt");
contents = "A file with some other contents in testGetContents.";
ensureExistsInWorkspace(secondValidFile, contents);
IHistoryStore historyStore = ((Workspace) getWorkspace()).getFileSystemManager().getHistoryStore();
/* Simulated date -- Increment once for each edition added. */
long myLong = 0L;
/* Add multiple editions for one file location. */
for (int i = 0; i < ITERATIONS; i++, myLong++) {
FileInfo fileInfo = new FileInfo(file.getName());
fileInfo.setLastModified(myLong);
historyStore.addState(file.getFullPath(), ((Resource) file).getStore(), fileInfo, true);
try {
contents = "This file has some contents in testGetContents.";
InputStream is = new ByteArrayInputStream(contents.getBytes());
createFileInFileSystem(file.getLocation(), is);
file.refreshLocal(IResource.DEPTH_INFINITE, null);
} catch (CoreException e) {
fail("1.1." + i, e);
}
}
/* Add multiple editions for second file location. */
for (int i = 0; i < ITERATIONS; i++, myLong++) {
FileInfo fileInfo = new FileInfo(file.getName());
fileInfo.setLastModified(myLong);
historyStore.addState(secondValidFile.getFullPath(), ((Resource) secondValidFile).getStore(), fileInfo, true);
try {
contents = "A file with some other contents in testGetContents.";
InputStream is = new ByteArrayInputStream(contents.getBytes());
createFileInFileSystem(secondValidFile.getLocation(), is);
secondValidFile.refreshLocal(IResource.DEPTH_INFINITE, null);
} catch (CoreException e) {
fail("2.1." + i, e);
}
}
/* Ensure contents of file and retrieved resource are identical.
Does not check timestamps. Timestamp checks are performed in a separate test. */
DataInputStream inFile = null;
DataInputStream inContents = null;
IFileState[] stateArray = null;
stateArray = historyStore.getStates(file.getFullPath(), getMonitor());
for (int i = 0; i < stateArray.length; i++, myLong++) {
inFile = new DataInputStream(file.getContents(false));
try {
inContents = new DataInputStream(historyStore.getContents(stateArray[i]));
} catch (CoreException e) {
fail("3.1." + i, e);
}
if (!compareContent(inFile, inContents)) {
fail("3.2." + i + " No match, files are not identical.");
}
}
stateArray = historyStore.getStates(secondValidFile.getFullPath(), getMonitor());
for (int i = 0; i < stateArray.length; i++, myLong++) {
inFile = new DataInputStream(secondValidFile.getContents(false));
try {
inContents = new DataInputStream(historyStore.getContents(stateArray[i]));
} catch (CoreException e) {
fail("4.1." + i, e);
}
if (!compareContent(inFile, inContents)) {
fail("4.2." + i + " No match, files are not identical.");
}
}
/* Test getting an invalid file state. */
for (int i = 0; i < ITERATIONS; i++) {
// Create bogus FileState using invalid uuid.
try {
InputStream in = historyStore.getContents(new FileState(historyStore, Path.ROOT, myLong, new UniversalUniqueIdentifier()));
in.close();
fail("6." + i + " Edition should be invalid.");
} catch (CoreException e) {
// expected
}
}
/* Test verification using null file state. */
for (int i = 0; i < ITERATIONS; i++) {
try {
historyStore.getContents(null);
fail("7." + i + " Null edition should be invalid.");
} catch (RuntimeException e) {
// expected
}
}
}
public void testModifiedStamp() {
/* Initialize common objects. */
IProject project = getWorkspace().getRoot().getProject("Project");
try {
project.create(getMonitor());
project.open(getMonitor());
} catch (CoreException e) {
fail("0.0", e);
}
IFile file = project.getFile("file");
try {
file.create(getRandomContents(), true, getMonitor());
} catch (CoreException e) {
fail("1.0", e);
}
IFileState[] history = null;
try {
history = file.getHistory(getMonitor());
} catch (CoreException e) {
fail("1.1", e);
}
// no history yet
assertEquals("1.2", 0, history.length);
// save the file's current time stamp - it will be remembered in the file state
long fileTimeStamp = file.getLocalTimeStamp();
try {
file.setContents(getRandomContents(), true, true, getMonitor());
} catch (CoreException e) {
fail("2.0", e);
}
try {
history = file.getHistory(getMonitor());
} catch (CoreException e) {
fail("2.1", e);
}
// one state in the history
assertEquals("2.2", 1, history.length);
// the timestamp in the state should match the previous file's timestamp
assertEquals("3.0", fileTimeStamp, history[0].getModificationTime());
}
/**
* Move case for History Store of folder when the local history is being
* copied.
*
* Scenario:
* 1. Create folder (folder1)
* 2. Create file "content 1"
* 3. Set new content "content 2"
* 4. Set new content "content 3"
* 5. Move folder
* 6. Set new content to moved file "content 4"
* 7. Set new content to moved file "content 5"
*
* The original file should have two states available.
* But the moved file should have 4 states as it retains the states from
* before the move took place as well.
*/
public void testMoveFolder() {
String[] contents = {"content1", "content2", "content3", "content4", "content5"};
// create common objects
IProject project = getWorkspace().getRoot().getProject("MyProject");
try {
project.create(getMonitor());
project.open(getMonitor());
} catch (CoreException e) {
fail("0.0", e);
}
IFile file = project.getFile("file1.txt");
IFolder folder = project.getFolder("folder1");
IFolder folder2 = project.getFolder("folder2");
file = folder.getFile("file1.txt");
try {
// Setup folder1 and file1.txt with some local history
folder.create(true, true, getMonitor());
file.create(getContents(contents[0]), true, getMonitor());
file.setContents(getContents(contents[1]), true, true, getMonitor());
file.setContents(getContents(contents[2]), true, true, getMonitor());
IFileState[] states = file.getHistory(getMonitor());
assertEquals("1.0", 2, states.length);
assertTrue("1.1", compareContent(getContents(contents[1]), states[0].getContents()));
assertTrue("1.2", compareContent(getContents(contents[0]), states[1].getContents()));
// Now do the move
folder.move(folder2.getFullPath(), true, getMonitor());
// Check to make sure the file has been moved
IFile file2 = folder2.getFile("file1.txt");
assertTrue("1.3", file2.getFullPath().toString().endsWith("folder2/file1.txt"));
// Give the new (moved file) some new contents
file2.setContents(getContents(contents[3]), true, true, getMonitor());
file2.setContents(getContents(contents[4]), true, true, getMonitor());
// Check the local history of both files
states = file.getHistory(getMonitor());
assertEquals("2.0", 2, states.length);
assertTrue("2.1", compareContent(getContents(contents[1]), states[0].getContents()));
assertTrue("2.2", compareContent(getContents(contents[0]), states[1].getContents()));
states = file2.getHistory(getMonitor());
assertEquals("2.3", 4, states.length);
assertTrue("2.4", compareContent(getContents(contents[3]), states[0].getContents()));
assertTrue("2.5", compareContent(getContents(contents[2]), states[1].getContents()));
assertTrue("2.6", compareContent(getContents(contents[1]), states[2].getContents()));
assertTrue("2.7", compareContent(getContents(contents[0]), states[3].getContents()));
} catch (CoreException e) {
fail("2.8", e);
}
try {
project.delete(true, getMonitor());
} catch (CoreException e) {
fail("3.0", e);
}
}
/**
* Move case for History Store of project. Note that local history is
* NOT copied for a project move.
*
* Scenario:
* 1. Create folder (folder1)
* 2. Create file "content 1"
* 2. Set new content "content 2"
* 3. Set new content "content 3"
* 4. Copy folder
* 5. Set new content to moved file "content 4"
* 6. Set new content to moved file "content 5"
*
* The original file should have two states available.
* But the copied file should have 4 states as it retains the states from
* before the copy took place as well.
*/
public void testMoveProject() {
String[] contents = {"content1", "content2", "content3", "content4", "content5"};
// create common objects
IProject project = getWorkspace().getRoot().getProject("MoveProjectProject");
IProject project2 = getWorkspace().getRoot().getProject("SecondMoveProjectProject");
try {
project.create(getMonitor());
project.open(getMonitor());
} catch (CoreException e) {
fail("0.0", e);
}
IFile file = project.getFile("file1.txt");
IFolder folder = project.getFolder("folder1");
file = folder.getFile("file1.txt");
try {
// Setup folder1 and file1.txt with some local history
folder.create(true, true, getMonitor());
file.create(getContents(contents[0]), true, getMonitor());
file.setContents(getContents(contents[1]), true, true, getMonitor());
file.setContents(getContents(contents[2]), true, true, getMonitor());
IFileState[] states = file.getHistory(getMonitor());
assertEquals("1.0", 2, states.length);
assertTrue("1.1", compareContent(getContents(contents[1]), states[0].getContents()));
assertTrue("1.2", compareContent(getContents(contents[0]), states[1].getContents()));
// Now do the move
project.move(new Path("SecondMoveProjectProject"), true, getMonitor());
// Check to make sure the file has been moved
IFile file2 = project2.getFile("folder1/file1.txt");
assertTrue("1.3", file2.getFullPath().toString().endsWith("SecondMoveProjectProject/folder1/file1.txt"));
// Give the new (copied file) some new contents
file2.setContents(getContents(contents[3]), true, true, getMonitor());
file2.setContents(getContents(contents[4]), true, true, getMonitor());
// Check the local history of both files
states = file.getHistory(getMonitor());
// original file should not remember history when project is moved
assertEquals("2.0", 0, states.length);
states = file2.getHistory(getMonitor());
assertEquals("2.3", 4, states.length);
assertTrue("2.4", compareContent(getContents(contents[3]), states[0].getContents()));
assertTrue("2.5", compareContent(getContents(contents[2]), states[1].getContents()));
assertTrue("2.6", compareContent(getContents(contents[1]), states[2].getContents()));
assertTrue("2.7", compareContent(getContents(contents[0]), states[3].getContents()));
} catch (CoreException e) {
fail("2.9", e);
}
try {
project.delete(true, getMonitor());
} catch (CoreException e) {
fail("3.0", e);
}
}
public void testRemoveAll() {
/* Create common objects. */
IProject project = getWorkspace().getRoot().getProject("Project");
IFile file = project.getFile("removeAllStatesFile.txt");
try {
project.create(getMonitor());
project.open(getMonitor());
file.create(getRandomContents(), true, getMonitor());
} catch (CoreException e) {
fail("0.0", e);
}
final int ITERATIONS = 20;
/* test remove in a file */
for (int i = 0; i < ITERATIONS; i++) {
try {
file.setContents(getRandomContents(), true, true, getMonitor());
} catch (CoreException e) {
fail("3.0." + i, e);
}
}
/* Valid Case: Ensure correct number of states available. */
IFileState[] states = null;
try {
states = file.getHistory(getMonitor());
} catch (CoreException e) {
fail("4.0", e);
}
assertEquals("4.1", ITERATIONS, states.length);
/* Remove all states, and verify that no states remain. */
try {
file.clearHistory(getMonitor());
states = file.getHistory(getMonitor());
assertEquals("5.0", 0, states.length);
} catch (CoreException e) {
fail("5.1", e);
}
/* test remove in a folder -- make sure it does not affect other resources' states*/
IFolder folder = project.getFolder("folder");
IFile anotherOne = folder.getFile("anotherOne");
try {
folder.create(true, true, getMonitor());
anotherOne.create(getRandomContents(), true, getMonitor());
} catch (CoreException e) {
fail("6.0", e);
}
for (int i = 0; i < ITERATIONS; i++) {
try {
file.setContents(getRandomContents(), true, true, getMonitor());
anotherOne.setContents(getRandomContents(), true, true, getMonitor());
} catch (CoreException e) {
fail("6.1." + i, e);
}
}
try {
states = file.getHistory(getMonitor());
assertEquals("6.2", ITERATIONS, states.length);
states = anotherOne.getHistory(getMonitor());
assertEquals("6.3", ITERATIONS, states.length);
} catch (CoreException e) {
fail("6.4", e);
}
/* Remove all states, and verify that no states remain. */
try {
project.clearHistory(getMonitor());
states = file.getHistory(getMonitor());
assertEquals("7.0", 0, states.length);
states = anotherOne.getHistory(getMonitor());
assertEquals("7.1", 0, states.length);
} catch (CoreException e) {
fail("7.2", e);
}
/* test remove in a folder -- make sure it does not affect other resources' states*/
IFile aaa = project.getFile("aaa");
IFolder bbb = project.getFolder("bbb");
anotherOne = bbb.getFile("anotherOne");
IFile ccc = project.getFile("ccc");
try {
bbb.create(true, true, getMonitor());
anotherOne.create(getRandomContents(), true, getMonitor());
aaa.create(getRandomContents(), true, getMonitor());
ccc.create(getRandomContents(), true, getMonitor());
} catch (CoreException e) {
fail("8.0", e);
}
for (int i = 0; i < ITERATIONS; i++) {
try {
anotherOne.setContents(getRandomContents(), true, true, getMonitor());
aaa.setContents(getRandomContents(), true, true, getMonitor());
ccc.setContents(getRandomContents(), true, true, getMonitor());
} catch (CoreException e) {
fail("8.1." + i, e);
}
}
try {
states = anotherOne.getHistory(getMonitor());
assertEquals("8.3", ITERATIONS, states.length);
states = aaa.getHistory(getMonitor());
assertEquals("8.4", ITERATIONS, states.length);
states = ccc.getHistory(getMonitor());
assertEquals("8.5", ITERATIONS, states.length);
} catch (CoreException e) {
fail("8.6", e);
}
/* Remove all states, and verify that no states remain. aaa and ccc should not be affected. */
try {
bbb.clearHistory(getMonitor());
states = anotherOne.getHistory(getMonitor());
assertEquals("9.1", 0, states.length);
states = aaa.getHistory(getMonitor());
assertEquals("9.2", ITERATIONS, states.length);
states = ccc.getHistory(getMonitor());
assertEquals("9.3", ITERATIONS, states.length);
} catch (CoreException e) {
fail("9.4", e);
}
}
/**
* Simple copy case for History Store when the local history is being
* copied.
*
* Scenario:
* 1. Create file "content 1"
* 2. Set new content "content 2"
* 3. Set new content "content 3"
* 4. Move file
* 5. Set new content to copied file "content 4"
* 6. Set new content to copied file "content 5"
*
* The original file should have two states available.
* But the copied file should have 4 states as it retains the states from
* before the copy took place as well.
*/
public void testSimpleCopy() {
/* Initialize common objects. */
IProject project = getWorkspace().getRoot().getProject("SimpleCopyProject");
try {
project.create(getMonitor());
project.open(getMonitor());
} catch (CoreException e) {
fail("0.0", e);
}
String[] contents = {"content1", "content2", "content3", "content4", "content5"};
IFile file = project.getFile("simpleCopyFileWithHistoryCopy");
IFile copyFile = project.getFile("copyOfSimpleCopyFileWithHistoryCopy");
/* Create first file. */
try {
file.create(getContents(contents[0]), true, null);
} catch (CoreException e) {
fail("1.2", e);
}
/* Set new contents on first file. Should add two entries to the history store. */
try {
file.setContents(getContents(contents[1]), true, true, null);
file.setContents(getContents(contents[2]), true, true, null);
} catch (CoreException e) {
fail("2.0", e);
}
/* Copy first file to the second. Second file should have no history. */
try {
file.copy(copyFile.getFullPath(), true, null);
} catch (CoreException e) {
fail("3.0", e);
}
/* Check history for both files. */
try {
IFileState[] states = file.getHistory(null);
assertEquals("4.0", 2, states.length);
states = copyFile.getHistory(null);
assertEquals("4.1", 2, states.length);
} catch (CoreException e) {
fail("4.2", e);
}
/* Set new contents on second file. Should add two entries to the history store. */
try {
copyFile.setContents(getContents(contents[3]), true, true, null);
copyFile.setContents(getContents(contents[4]), true, true, null);
} catch (CoreException e) {
fail("5.0", e);
}
/* Check history for both files. */
try {
// Check log for original file.
IFileState[] states = file.getHistory(null);
assertEquals("6.0", 2, states.length);
assertTrue("6.1", compareContent(getContents(contents[1]), states[0].getContents()));
assertTrue("6.2", compareContent(getContents(contents[0]), states[1].getContents()));
// Check log for copy.
states = copyFile.getHistory(null);
assertEquals("6.3", 4, states.length);
assertTrue("6.4", compareContent(getContents(contents[3]), states[0].getContents()));
assertTrue("6.5", compareContent(getContents(contents[2]), states[1].getContents()));
assertTrue("6.6", compareContent(getContents(contents[1]), states[2].getContents()));
assertTrue("6.7", compareContent(getContents(contents[0]), states[3].getContents()));
} catch (CoreException e) {
fail("6.8", e);
}
}
/**
* Simple move case for History Store when the local history is being
* copied.
*
* Scenario:
* 1. Create file "content 1"
* 2. Set new content "content 2"
* 3. Set new content "content 3"
* 4. Move file
* 5. Set new content to moved file "content 4"
* 6. Set new content to moved file "content 5"
*
* The original file should have two states available.
* But the moved file should have 4 states as it retains the states from
* before the move took place as well.
*/
public void testSimpleMove() {
/* Initialize common objects. */
IProject project = getWorkspace().getRoot().getProject("SimpleMoveProject");
try {
project.create(getMonitor());
project.open(getMonitor());
} catch (CoreException e) {
fail("0.0", e);
}
String[] contents = {"content1", "content2", "content3", "content4", "content5"};
IFile file = project.getFile("simpleMoveFileWithCopy");
IFile moveFile = project.getFile("copyOfSimpleMoveFileWithCopy");
/* Create first file. */
try {
file.create(getContents(contents[0]), true, null);
} catch (CoreException e) {
fail("1.2", e);
}
/* Set new contents on source file. Should add two entries to the history store. */
try {
file.setContents(getContents(contents[1]), true, true, null);
file.setContents(getContents(contents[2]), true, true, null);
} catch (CoreException e) {
fail("2.0", e);
}
/* Move source file to second location.
* Moved files should have the history of the original file.
*/
try {
file.move(moveFile.getFullPath(), true, null);
} catch (CoreException e) {
fail("3.0", e);
}
/* Check history for both files. */
try {
IFileState[] states = file.getHistory(null);
assertEquals("4.0", 2, states.length);
states = moveFile.getHistory(null);
assertEquals("4.1", 2, states.length);
} catch (CoreException e) {
fail("4.2", e);
}
/* Set new contents on moved file. Should add two entries to the history store. */
try {
moveFile.setContents(getContents(contents[3]), true, true, null);
moveFile.setContents(getContents(contents[4]), true, true, null);
} catch (CoreException e) {
fail("5.0", e);
}
/* Check history for both files. */
try {
// Check log for original file.
IFileState[] states = file.getHistory(null);
assertEquals("6.0", 2, states.length);
assertTrue("6.1", compareContent(getContents(contents[1]), states[0].getContents()));
assertTrue("6.2", compareContent(getContents(contents[0]), states[1].getContents()));
// Check log for moved file.
states = moveFile.getHistory(null);
assertEquals("6.3", 4, states.length);
assertTrue("6.4", compareContent(getContents(contents[3]), states[0].getContents()));
assertTrue("6.5", compareContent(getContents(contents[2]), states[1].getContents()));
assertTrue("6.6", compareContent(getContents(contents[1]), states[2].getContents()));
assertTrue("6.7", compareContent(getContents(contents[0]), states[3].getContents()));
} catch (CoreException e) {
fail("6.8", e);
}
}
/**
* Simple use case for History Store.
*
* Scenario: # Editions
* 1. Create file "content 1" 0
* 2. Set new content "content 2" 1
* 3. Set new content "content 3" 2
* 4. Delete file 3
* 5. Roll back to first version "content 1" 3
* 6. Set new content "content 2" 4
* 7. Roll back to third version "content 3" 5
*/
public void testSimpleUse() {
/* Initialize common objects. */
IProject project = getWorkspace().getRoot().getProject("Project");
try {
project.create(getMonitor());
project.open(getMonitor());
} catch (CoreException e) {
fail("0.0", e);
}
String[] contents = {"content1", "content2", "content3"};
IFile file = project.getFile("file");
/* Create the file. */
try {
file.create(getContents(contents[0]), true, getMonitor());
} catch (CoreException e) {
fail("1.0", e);
}
/* Set new contents on the file. Should add two entries to the store. */
try {
for (int i = 0; i < 2; i++) {
file.setContents(getContents(contents[i + 1]), true, true, getMonitor());
}
} catch (CoreException e) {
fail("2.0", e);
}
/* Ensure two entries are available for the file, and that content matches. */
try {
IFileState[] states = file.getHistory(getMonitor());
assertEquals("3.0", 2, states.length);
assertTrue("3.1.1", compareContent(getContents(contents[1]), states[0].getContents()));
assertTrue("3.1.2", compareContent(getContents(contents[0]), states[1].getContents()));
} catch (CoreException e) {
fail("3.2", e);
}
/* Delete the file. Should add an entry to the store. */
try {
file.delete(true, true, getMonitor());
} catch (CoreException e) {
fail("4.0", e);
}
/* Ensure three entries are available for the file, and that content matches. */
try {
IFileState[] states = file.getHistory(getMonitor());
assertEquals("5.0", 3, states.length);
assertTrue("5.1.1", compareContent(getContents(contents[2]), states[0].getContents()));
assertTrue("5.1.2", compareContent(getContents(contents[1]), states[1].getContents()));
assertTrue("5.1.3", compareContent(getContents(contents[0]), states[2].getContents()));
} catch (CoreException e) {
fail("5.2", e);
}
/* Roll file back to first version, and ensure that content matches. */
try {
IFileState[] states = file.getHistory(getMonitor());
// Create the file with the contents from one of the states.
// Won't add another entry to the store.
file.create(states[0].getContents(), false, getMonitor());
// Check history store.
states = file.getHistory(getMonitor());
assertEquals("6.0", 3, states.length);
assertTrue("6.1.1", compareContent(getContents(contents[2]), states[0].getContents()));
assertTrue("6.1.2", compareContent(getContents(contents[1]), states[1].getContents()));
assertTrue("6.1.3", compareContent(getContents(contents[0]), states[2].getContents()));
// Check file contents.
assertTrue("6.2", compareContent(getContents(contents[2]), file.getContents(false)));
} catch (CoreException e) {
fail("6.3", e);
}
/* Set new contents on the file. Should add an entry to the history store. */
try {
file.setContents(getContents(contents[1]), true, true, null);
} catch (CoreException e) {
fail("7.0", e);
}
/* Ensure four entries are available for the file, and that entries match. */
try {
IFileState[] states = file.getHistory(getMonitor());
assertEquals("8.0", 4, states.length);
assertTrue("8.1.1", compareContent(getContents(contents[2]), states[0].getContents()));
assertTrue("8.1.2", compareContent(getContents(contents[2]), states[1].getContents()));
assertTrue("8.1.3", compareContent(getContents(contents[1]), states[2].getContents()));
assertTrue("8.1.4", compareContent(getContents(contents[0]), states[3].getContents()));
} catch (CoreException e) {
fail("8.2", e);
}
/* Roll file back to third version, and ensure that content matches. */
try {
IFileState[] states = file.getHistory(getMonitor());
// Will add another entry to log.
file.setContents(states[2], true, true, getMonitor());
// Check history log.
states = file.getHistory(getMonitor());
assertEquals("9.0", 5, states.length);
assertTrue("9.1.1", compareContent(getContents(contents[1]), states[0].getContents()));
assertTrue("9.1.2", compareContent(getContents(contents[2]), states[1].getContents()));
assertTrue("9.1.3", compareContent(getContents(contents[2]), states[2].getContents()));
assertTrue("9.1.4", compareContent(getContents(contents[1]), states[3].getContents()));
assertTrue("9.1.5", compareContent(getContents(contents[0]), states[4].getContents()));
// Check file contents.
assertTrue("9.2", compareContent(getContents(contents[1]), file.getContents(false)));
} catch (CoreException e) {
fail("9.3", e);
}
}
}