/*******************************************************************************
* Copyright (c) 2000, 2011 IBM Corporation and others.
*
* This program and the accompanying materials
* are made available under the terms of the Eclipse Public License 2.0
* which accompanies this distribution, and is available at
* https://www.eclipse.org/legal/epl-2.0/
*
* SPDX-License-Identifier: EPL-2.0
*
* Contributors:
* IBM Corporation - initial API and implementation
*******************************************************************************/
package org.eclipse.team.tests.ccvs.core.provider;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;
import org.eclipse.core.resources.IContainer;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IResource;
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.Path;
import org.eclipse.team.core.IFileTypeInfo;
import org.eclipse.team.core.RepositoryProvider;
import org.eclipse.team.core.Team;
import org.eclipse.team.core.TeamException;
import org.eclipse.team.internal.ccvs.core.CVSException;
import org.eclipse.team.internal.ccvs.core.CVSProviderPlugin;
import org.eclipse.team.internal.ccvs.core.CVSStatus;
import org.eclipse.team.internal.ccvs.core.CVSTag;
import org.eclipse.team.internal.ccvs.core.CVSTeamProvider;
import org.eclipse.team.internal.ccvs.core.ICVSFile;
import org.eclipse.team.internal.ccvs.core.ICVSFolder;
import org.eclipse.team.internal.ccvs.core.client.Command;
import org.eclipse.team.internal.ccvs.core.client.Command.KSubstOption;
import org.eclipse.team.internal.ccvs.core.client.Command.LocalOption;
import org.eclipse.team.internal.ccvs.core.client.Session;
import org.eclipse.team.internal.ccvs.core.client.Update;
import org.eclipse.team.internal.ccvs.core.resources.CVSWorkspaceRoot;
import org.eclipse.team.internal.ccvs.core.syncinfo.FolderSyncInfo;
import org.eclipse.team.internal.ccvs.core.syncinfo.ResourceSyncInfo;
import org.eclipse.team.internal.ccvs.core.util.Util;
import org.eclipse.team.internal.ccvs.ui.CVSUIPlugin;
import org.eclipse.team.internal.ccvs.ui.ICVSUIConstants;
import org.eclipse.team.tests.ccvs.core.EclipseTest;
import junit.framework.Test;
/*
* This class tests both the CVSProvider and the CVSTeamProvider
*/
public class CVSProviderTest extends EclipseTest {
/**
* Constructor for CVSProviderTest
*/
public CVSProviderTest() {
super();
}
/**
* Constructor for CVSProviderTest
*/
public CVSProviderTest(String name) {
super(name);
}
public static Test suite() {
return suite(CVSProviderTest.class);
}
public void testAdd() {
// Test add with cvsignores
/*
IProject project = createProject("testAdd", new String[] { "changed.txt", "deleted.txt", "folder1/", "folder1/a.txt" });
IFile file = project.getFile(".cvsignore");
file.create(new ByteArrayInputStream("ignored.txt".getBytes()), false, null);
file = project.getFile("ignored.txt");
file.create(new ByteArrayInputStream("some text".getBytes()), false, null);
file = project.getFile("notignored.txt");
file.create(new ByteArrayInputStream("some more text".getBytes()), false, null);
file = project.getFile("folder1/.cvsignore");
file.create(new ByteArrayInputStream("ignored.txt".getBytes()), false, null);
file = project.getFile("folder1/ignored.txt");
file.create(new ByteArrayInputStream("some text".getBytes()), false, null);
file = project.getFile("folder1/notignored.txt");
file.create(new ByteArrayInputStream("some more text".getBytes()), false, null);
getProvider(project).add(new IResource[] {project}, IResource.DEPTH_INFINITE, DEFAULT_MONITOR);
assertTrue( ! CVSWorkspaceRoot.getCVSResourceFor(project.getFile("ignored.txt")).isManaged());
assertTrue( ! CVSWorkspaceRoot.getCVSResourceFor(project.getFile("folder1/ignored.txt")).isManaged());
assertTrue(CVSWorkspaceRoot.getCVSResourceFor(project.getFile("notignored.txt")).isManaged());
assertTrue(CVSWorkspaceRoot.getCVSResourceFor(project.getFile("folder1/notignored.txt")).isManaged());
assertTrue(CVSWorkspaceRoot.getCVSResourceFor(project.getFile(".cvsignore")).isManaged());
assertTrue(CVSWorkspaceRoot.getCVSResourceFor(project.getFile("folder1/.cvsignore")).isManaged());
*/
}
public void testDeleteHandling() throws TeamException, CoreException {
IProject project = createProject("testDeleteHandling", new String[] { "changed.txt", "deleted.txt", "folder1/", "folder1/a.txt" });
// Delete a file and ensure that it is an outgoing deletion
project.getFile("deleted.txt").delete(false, false, null);
ICVSFile file = CVSWorkspaceRoot.getCVSFileFor(project.getFile("deleted.txt"));
assertTrue("File is not outgoing deletion", file.getSyncInfo().isDeleted());
// Delete a folder and ensure that the file is managed but doesn't exist
// (Special behavior is provider by the CVS move/delete hook but this is not part of CVS core)
project.getFolder("folder1").delete(false, false, null);
ICVSFolder folder = CVSWorkspaceRoot.getCVSFolderFor(project.getFolder("folder1"));
assertTrue("Deleted folder not in proper state", ! folder.exists() && folder.isManaged());
}
public void testCheckin() throws TeamException, CoreException, IOException {
IProject project = createProject("testCheckin", new String[] { "changed.txt", "deleted.txt", "folder1/", "folder1/a.txt" });
// Perform some operations on the project
IResource[] newResources = buildResources(project, new String[] { "added.txt", "folder2/", "folder2/added.txt" }, false);
setContentsAndEnsureModified(project.getFile("changed.txt"));
addResources(newResources);
deleteResources(new IResource[] {project.getFile("deleted.txt")});
assertIsModified("testDeepCheckin: ", newResources);
assertIsModified("testDeepCheckin: ", new IResource[] {project.getFile("deleted.txt"), project.getFile("changed.txt")});
commitResources(new IResource[] {project}, IResource.DEPTH_INFINITE);
assertLocalStateEqualsRemote(project);
}
public void testMoveHandling() throws TeamException, CoreException {
IProject project = createProject("testMoveHandling", new String[] { "changed.txt", "deleted.txt", "folder1/", "folder1/a.txt" });
// Move a file and ensure that it is an outgoing deletion at the source and unmanaged at the destination
project.getFile("deleted.txt").move(new Path("moved.txt"), false, false, null);
ICVSFile file = CVSWorkspaceRoot.getCVSFileFor(project.getFile("deleted.txt"));
assertTrue("Source is not outgoing deletion", file.getSyncInfo().isDeleted());
file = CVSWorkspaceRoot.getCVSFileFor(project.getFile("moved.txt"));
assertTrue("Destination not in proper state", ! file.isManaged());
// Move a folder and ensure the source is deleted
project.getFolder("folder1").move(new Path("moved"), false, false, null);
ICVSFolder folder = CVSWorkspaceRoot.getCVSFolderFor(project.getFolder("folder1"));
assertTrue("Deleted folder not in proper state", ! folder.exists() && folder.isManaged());
folder = CVSWorkspaceRoot.getCVSFolderFor(project.getFolder("moved"));
assertTrue("Moved folder should not be managed", ! folder.isManaged());
assertTrue("Moved folder should not be a CVS folder", ! folder.isCVSFolder());
}
public void testUpdate() throws TeamException, CoreException, IOException {
// Create a test project, import it into cvs and check it out
IProject project = createProject("testUpdate", new String[] { "changed.txt", "deleted.txt", "folder1/", "folder1/a.txt" });
// Check the project out under a different name
IProject copy = checkoutCopy(project, "-copy");
// Perform some operations on the copy
addResources(copy, new String[] { "added.txt", "folder2/", "folder2/added.txt" }, false);
setContentsAndEnsureModified(copy.getFile("changed.txt"));
deleteResources(new IResource[] {copy.getFile("deleted.txt")});
// Commit the copy and update the project
commitResources(new IResource[] {copy}, IResource.DEPTH_INFINITE);
updateProject(project, null, false);
assertEquals(project, copy);
}
public void testUpdate123280() throws CoreException {
IProject project = createProject(new String[] { "changed.txt", "deleted.txt", "folder1/", "folder1/a.txt" });
// Make a remote change
IProject copy = checkoutCopy(project, "-copy");
setContentsAndEnsureModified(copy.getFile("folder1/a.txt"));
commitProject(copy);
// Delete locally and then update
project.getFile("deleted.txt").delete(false, null);
updateProject(project, null, false);
// Ensure that the file is still an outgoing deletion
ICVSFile file = CVSWorkspaceRoot.getCVSFileFor(project.getFile("deleted.txt"));
assertTrue(!file.exists() && file.isManaged());
}
public void testVersionTag() throws TeamException, CoreException, IOException {
// Create a test project, import it into cvs and check it out
IProject project = createProject("testVersionTag", new String[] { "changed.txt", "deleted.txt", "folder1/", "folder1/a.txt" });
// Perform some operations on the copy and commit
IProject copy = checkoutCopy(project, "-copy");
addResources(copy, new String[] { "added.txt", "folder2/", "folder2/added.txt" }, false);
changeResources(copy, new String[] {"changed.txt"}, false);
deleteResources(copy, new String[] {"deleted.txt"}, false);
commitResources(copy, true);
// Tag the original, checkout the tag and compare with original
CVSTag v1Tag = new CVSTag("v1", CVSTag.VERSION);
tagProject(project, v1Tag, false);
IProject v1 = checkoutCopy(project, v1Tag);
assertEquals(project, v1);
// Update original to HEAD and compare with copy including tags
updateProject(project, null, false);
assertEquals(project, copy, false, true);
// Update copy to v1 and compare with the copy (including tag)
updateProject(copy, v1Tag, false);
assertEquals(copy, v1, false, true);
// Update copy back to HEAD and compare with project (including tag)
updateProject(copy, CVSTag.DEFAULT, false);
assertEquals(project, copy, false, true);
}
public void testMakeBranch() throws TeamException, CoreException, IOException {
// Create a test project
IProject project = createProject("testMakeBranch", new String[] { "file1.txt", "file2.txt", "file3.txt", "folder1/", "folder1/a.txt", "folder1/b.txt"});
// Make some local modifications including "cvs adds" and "cvs removes"
addResources(project, new String[] {"folder1/c.txt"}, false);
deleteResources(project, new String[] {"folder1/b.txt"}, false);
changeResources(project, new String[] {"file2.txt"}, false);
// Make the branch including a pre-version
CVSTag version = new CVSTag("v1", CVSTag.BRANCH);
CVSTag branch = new CVSTag("branch1", CVSTag.BRANCH);
makeBranch(new IResource[] {project}, version, branch, true);
// Checkout a copy from the branch and version and compare
IProject branchCopy = checkoutCopy(project, branch);
IProject versionCopy = checkoutCopy(project, version);
assertEquals(branchCopy, versionCopy, true, false);
// Commit the project, update the branch and compare
commitProject(project);
updateProject(branchCopy, null, false);
assertEquals(branchCopy, project, false, true);
}
public void testDuplicatedBranch() throws TeamException, CoreException {
// Create a test project
IProject project = createProject("testDuplicatedBranch", new String[] {
"file1.txt", "file2.txt", "file3.txt", "folder1/",
"folder1/a.txt", "folder1/b.txt" });
// Create a branch
CVSTag version = new CVSTag("v1", CVSTag.BRANCH);
CVSTag branch = new CVSTag("branch1", CVSTag.BRANCH);
makeBranch(new IResource[] { project }, version, branch, false);
// Create the second branch using the same names
try {
makeBranch(new IResource[] { project }, version, branch, false);
fail();
} catch (CVSException e) {
}
}
public void testPruning() throws TeamException, CoreException, IOException {
// Create a project with empty folders
CVSProviderPlugin.getPlugin().setPruneEmptyDirectories(false);
IProject project = createProject("testPruning", new String[] { "file.txt", "folder1/", "folder2/folder3/" });
// Disable pruning, checkout a copy and ensure original and copy are the same
IProject copy = checkoutCopy(project, "-copy");
assertEquals(project, copy);
// Enable pruning, update copy and ensure emtpy folders are gone
CVSProviderPlugin.getPlugin().setPruneEmptyDirectories(true);
updateProject(copy, null, false);
assertDoesNotExistInFileSystem(new IResource[] {copy.getFolder("folder1"), copy.getFolder("folder2"), copy.getFolder("folder2/folder3")});
// Checkout another copy and ensure that the two copies are the same (with pruning enabled)
IProject copy2 = checkoutCopy(project, "-copy2");
assertEquals(copy, copy2);
// Disable pruning, update copy and ensure directories come back
// TODO: disabled until bug 125037 can be resolved
// CVSProviderPlugin.getPlugin().setPruneEmptyDirectories(false);
// updateProject(copy, null, false);
// assertEquals(project, copy);
// Enable pruning again since it's the default
CVSProviderPlugin.getPlugin().setPruneEmptyDirectories(true);
}
public void testGet() throws TeamException, CoreException, IOException {
// Create a project
IProject project = createProject("testGet", new String[] { "changed.txt", "deleted.txt", "folder1/", "folder1/a.txt" });
// Checkout a copy and modify locally
IProject copy = checkoutCopy(project, "-copy");
//addResources(copy, new String[] { "added.txt", "folder2/", "folder2/added.txt" }, false);
deleteResources(copy, new String[] {"deleted.txt"}, false);
setContentsAndEnsureModified(copy.getFile("changed.txt"));
// get the remote conetns
replace(new IResource[] {copy}, null, true);
assertEquals(project, copy);
}
public void testReadOnly() {
// IProject project = createProject("testReadOnly", new String[] { "changed.txt", "deleted.txt", "folder1/", "folder1/a.txt" });
// Need to check the project out as read-only
}
public void testCleanLineDelimiters() throws TeamException, CoreException, IOException {
// Create a project
IProject project = getUniqueTestProject("testCleanLineDelimiters");
IFile file = project.getFile("testfile");
IProgressMonitor monitor = new NullProgressMonitor();
// empty file
setFileContents(file, "");
CVSTeamProvider.cleanLineDelimiters(file, false, monitor);
assertEqualsFileContents(file, "");
CVSTeamProvider.cleanLineDelimiters(file, true, monitor);
assertEqualsFileContents(file, "");
// one byte
setFileContents(file, "a");
CVSTeamProvider.cleanLineDelimiters(file, false, monitor);
assertEqualsFileContents(file, "a");
CVSTeamProvider.cleanLineDelimiters(file, true, monitor);
assertEqualsFileContents(file, "a");
// single orphan carriage return (should be preserved)
setFileContents(file, "\r");
CVSTeamProvider.cleanLineDelimiters(file, false, monitor);
assertEqualsFileContents(file, "\r");
CVSTeamProvider.cleanLineDelimiters(file, true, monitor);
assertEqualsFileContents(file, "\r");
// single line feed
setFileContents(file, "\n");
CVSTeamProvider.cleanLineDelimiters(file, false, monitor);
assertEqualsFileContents(file, "\n");
CVSTeamProvider.cleanLineDelimiters(file, true, monitor);
assertEqualsFileContents(file, "\r\n");
// single carriage return line feed
setFileContents(file, "\r\n");
CVSTeamProvider.cleanLineDelimiters(file, true, monitor);
assertEqualsFileContents(file, "\r\n");
CVSTeamProvider.cleanLineDelimiters(file, false, monitor);
assertEqualsFileContents(file, "\n");
// mixed text with orphaned CR's
setFileContents(file, "The \r\n quick brown \n fox \r\r\r\n jumped \n\n over \r\n the \n lazy dog.\r\n");
CVSTeamProvider.cleanLineDelimiters(file, false, monitor);
assertEqualsFileContents(file, "The \n quick brown \n fox \r\r\n jumped \n\n over \n the \n lazy dog.\n");
setFileContents(file, "The \r\n quick brown \n fox \r\r\r\n jumped \n\n over \r\n the \n lazy dog.\r\n");
CVSTeamProvider.cleanLineDelimiters(file, true, monitor);
assertEqualsFileContents(file, "The \r\n quick brown \r\n fox \r\r\r\n jumped \r\n\r\n over \r\n the \r\n lazy dog.\r\n");
}
public void testKeywordSubstitution() throws TeamException, CoreException {
testKeywordSubstitution(Command.KSUBST_BINARY); // -kb
testKeywordSubstitution(Command.KSUBST_TEXT); // -ko
testKeywordSubstitution(Command.KSUBST_TEXT_EXPAND); // -kkv
}
private void testKeywordSubstitution(KSubstOption ksubst) throws TeamException, CoreException {
// setup some known file types
Team.setAllTypes( new String[] {"xbin", "xtxt"}, new int[] {Team.BINARY, Team.TEXT});
// create a test project
IProject project = createProject("testKeywordSubstitution", new String[] { "dummy" });
addResources(project, new String[] { "binary.xbin", "text.xtxt", "folder1/", "folder1/a.xtxt" }, true);
addResources(project, new String[] { "added.xbin", "added.xtxt" }, false);
assertHasKSubstOption(project, "binary.xbin", Command.KSUBST_BINARY);
assertHasKSubstOption(project, "added.xbin", Command.KSUBST_BINARY);
assertHasKSubstOption(project, "text.xtxt", CVSProviderPlugin.DEFAULT_TEXT_KSUBST_OPTION);
assertHasKSubstOption(project, "folder1/a.xtxt", CVSProviderPlugin.DEFAULT_TEXT_KSUBST_OPTION);
assertHasKSubstOption(project, "added.xtxt", CVSProviderPlugin.DEFAULT_TEXT_KSUBST_OPTION);
// change keyword substitution
Map<IFile, KSubstOption> map = new HashMap<>();
map.put(project.getFile("binary.xbin"), ksubst);
map.put(project.getFile("added.xbin"), ksubst);
map.put(project.getFile("text.xtxt"), ksubst);
map.put(project.getFile("folder1/a.xtxt"), ksubst);
map.put(project.getFile("added.xtxt"), ksubst);
waitMsec(1500);
IStatus status = getProvider(project).setKeywordSubstitution(map, null, null);
assertTrue("Status should be ok, was: " + status.toString(), status.isOK());
assertHasKSubstOption(project, "binary.xbin", ksubst);
assertHasKSubstOption(project, "text.xtxt", ksubst);
assertHasKSubstOption(project, "folder1/a.xtxt", ksubst);
assertHasKSubstOption(project, "added.xtxt", ksubst);
assertHasKSubstOption(project, "added.xbin", ksubst);
// verify that substitution mode changed remotely and "added.xtxt", "added.xbin" don't exist
IProject copy = checkoutCopy(project, "-copy");
assertHasKSubstOption(copy, "binary.xbin", ksubst);
assertHasKSubstOption(copy, "text.xtxt", ksubst);
assertHasKSubstOption(copy, "folder1/a.xtxt", ksubst);
assertDoesNotExistInWorkspace(copy.getFile("added.xtxt"));
assertDoesNotExistInWorkspace(copy.getFile("added.xbin"));
// commit added files then checkout the copy again
commitResources(project, new String[] { "added.xbin", "added.xtxt" });
IProject copy2 = checkoutCopy(project, "-copy2");
assertHasKSubstOption(copy2, "added.xtxt", ksubst);
assertHasKSubstOption(copy2, "added.xbin", ksubst);
IFileTypeInfo[] infos = Team.getDefaultTypes();
String[] extensions = new String[infos.length];
int[] types = new int[infos.length];
for (int i = 0; i < infos.length; i++) {
IFileTypeInfo info = infos[i];
extensions[i] = info.getExtension();
types[i] = info.getType();
}
Team.setAllTypes(extensions, types);
}
public void testKeywordSubsBinToText() throws TeamException, CoreException, IOException {
//create a test project
KSubstOption ksubst = Command.KSUBST_TEXT;
IProject project = createProject("testKeywordSubsBinToText", new String[] { "dummy" });
assertHasKSubstOption(project, "dummy", Command.KSUBST_BINARY);
// change keyword substitution
Map<IFile, KSubstOption> map = new HashMap<>();
map.put(project.getFile("dummy"), ksubst);
// change from binary to text should commit a new file with
waitMsec(1500);
IStatus status = getProvider(project).setKeywordSubstitution(map, null, null);
assertTrue("Status should be ok, was: " + status.toString(), status.isOK());
assertHasKSubstOption(project, "dummy", ksubst);
IProject copy = checkoutCopy(project, "-copy");
assertHasKSubstOption(copy, "dummy", ksubst);
assertEquals(project, copy);
}
public static void setFileContents(IFile file, String string) throws CoreException {
InputStream is = new ByteArrayInputStream(string.getBytes());
if (file.exists()) {
file.setContents(is, false /*force*/, true /*keepHistory*/, null);
} else {
file.create(is, false /*force*/, null);
}
}
public static void assertEqualsFileContents(IFile file, String string) throws CoreException, IOException {
String other = getFileContents(file);
assertEquals(string, other);
}
public static void assertHasKSubstOption(IContainer container, String filename, KSubstOption ksubst)
throws TeamException {
IFile file = container.getFile(new Path(filename));
ICVSFile cvsFile = CVSWorkspaceRoot.getCVSFileFor(file);
ResourceSyncInfo info = cvsFile.getSyncInfo();
assertEquals(ksubst, info.getKeywordMode());
}
public void testUnmap() throws CoreException, TeamException {
// Create a project
IProject project = createProject("testUnmap", new String[] { "changed.txt", "deleted.txt", "folder1/", "folder1/a.txt", "folder1/", "folder1/folder2/deep.txt", "folder2/b.txt" });
// delete a file and folder to create phantoms
project.getFile("deleted.txt").delete(false, false, null);
assertTrue(project.getFile("deleted.txt").isPhantom());
project.getFolder("folder2").delete(false, false, null);
assertTrue(project.getFolder("folder2").isPhantom());
// unmap
RepositoryProvider.unmap(project);
// ensure that phantoms for the resoucrs no longer exist
assertFalse(project.getFile("deleted.txt").isPhantom());
assertFalse(project.getFolder("folder2").isPhantom());
// Create a project
project = createProject("testUnmap2", new String[] { "changed.txt", "deleted.txt", "folder1/", "folder1/a.txt", "folder1/", "folder1/folder2/deep.txt", "folder2/b.txt" });
// delete a deep folder to create phantoms
project.getFolder("folder1/folder2").delete(false, false, null);
assertTrue(project.getFolder("folder1/folder2").isPhantom());
// unmap
RepositoryProvider.unmap(project);
// ensure that phantoms for the resources no longer exist
assertFalse(project.getFolder("folder1/folder2").isPhantom());
}
public void testForBinaryLinefeedCorruption() throws CoreException, TeamException, IOException {
String EOL = "\n";
IProject project = createProject("testForBinaryLinefeedCorruption", new String[] { "binaryFile" });
ICVSFile cvsFile = CVSWorkspaceRoot.getCVSFileFor(project.getFile("binaryFile"));
assertTrue(ResourceSyncInfo.isBinary(cvsFile.getSyncBytes()));
setContentsAndEnsureModified(project.getFile("binaryFile"), "line 1" + EOL + "line 2");
commitProject(project);
// Checkout a copy and ensure the file was not corrupted
IProject copy = checkoutCopy(project, "-copy");
assertEquals(project, copy);
}
public void test33984CannotCommitAfterConflictsMergedLocally() throws CoreException, TeamException, IOException {
String EOL = System.getProperty("line.separator");
IProject project = createProject("test33984", new String[] { "a.txt", "b.txt" });
setContentsAndEnsureModified(project.getFile("a.txt"), "line 1");
setContentsAndEnsureModified(project.getFile("b.txt"), ("line 1" + EOL + "line 2" + EOL + "line3"));
Map<IFile, KSubstOption> kMode = new HashMap<>();
kMode.put(project.getFile("a.txt"), Command.KSUBST_TEXT);
kMode.put(project.getFile("b.txt"), Command.KSUBST_TEXT);
getProvider(project).setKeywordSubstitution(kMode, "", null);
commitProject(project);
// Checkout a copy and ensure the file was not corrupted
IProject copy = checkoutCopy(project, "-copy");
assertEquals(project, copy);
// TEST 1: simulate modifying same file by different users
// b.txt has non-conflicting changes
setContentsAndEnsureModified(copy.getFile("b.txt"), ("line 1a" + EOL + "line 2" + EOL + "line3"));
commitProject(copy);
// user updates which would cause a merge with conflict, a commit should not be allowed
setContentsAndEnsureModified(project.getFile("b.txt"), ("line 1" + EOL + "line 2" + EOL + "line3a"));
updateProject(project, CVSTag.DEFAULT, false /* don't ignore local changes */);
commitProject(project);
// TEST 2: a.txt has conflicting changes
setContentsAndEnsureModified(copy.getFile("a.txt"), "line 1dfgdfne3");
commitProject(copy);
// user updates which would cause a merge with conflict, a commit should not be allowed
setContentsAndEnsureModified(project.getFile("a.txt"), "some other text");
updateProject(project, CVSTag.DEFAULT, false /* don't ignore local changes */);
try {
commitProject(project);
fail("should not be allowed to commit a resource with merged conflicts");
} catch(TeamException e) {
}
}
public void testTagExistsFailure() throws TeamException, CoreException, IOException {
IProject project = createProject(new String[] { "a.txt", "b.txt" });
CVSTag tag = new CVSTag("v1", CVSTag.VERSION);
tagProject(project, tag, false);
setContentsAndEnsureModified(project.getFile("a.txt"));
commitProject(project);
try {
tagProject(project, tag, false/* don't force */);
fail("The tag should have failed since the tag already exists.");
} catch (TeamException e) {
// This is what we expected
assertTrue("This exception should be an error", e.getStatus().getSeverity() == IStatus.ERROR);
}
tagProject(project, tag, true /* force */);
IProject copy = checkoutCopy(project, tag);
assertEquals(project, copy);
}
public void testUpdateWithOverwrite() throws TeamException, CoreException {
// Create a project and ad an unmanaged resource
IProject project = createProject(new String[] { "a.txt", "b.txt" });
buildResources(project, new String[] { "new.txt" }, false);
// Checkout a copy and commit the same resource
IProject copy = checkoutCopy(project, "-copy");
addResources(copy, new String[] { "new.txt" }, true);
// Use the regular update and ensure that it fails
IStatus status = executeCommand(project, Command.UPDATE, Command.NO_LOCAL_OPTIONS);
assertStatusContainsCode(status, CVSStatus.INVALID_LOCAL_RESOURCE_PATH);
// Use the update and overwrite and ensure that it works
status = executeCommand(project, Command.REPLACE, Command.NO_LOCAL_OPTIONS);
assertTrue(status.isOK());
}
private IStatus executeCommand(IProject project, Update update, LocalOption[] options) throws CVSException {
Session session = new Session(getRepository(), CVSWorkspaceRoot.getCVSFolderFor(project));
session.open(DEFAULT_MONITOR);
try {
return update.execute(
session,
Command.NO_GLOBAL_OPTIONS,
options,
new String[] { "." },
null,
DEFAULT_MONITOR);
} finally {
session.close();
}
}
private void setOnlyLookAtTimestamps(boolean b) {
CVSUIPlugin.getPlugin().getPreferenceStore().setValue(ICVSUIConstants.PREF_CONSIDER_CONTENTS, !b);
}
public void testUpdateWithNoChange() throws TeamException, CoreException {
IProject project = createProject(new String[] { "a.txt"});
setContentsAndEnsureModified(project.getFile("a.txt"), "contents");
commitProject(project);
setOnlyLookAtTimestamps(true);
// set the contents to the same value but ensure the local timestamp is different
setContentsAndEnsureModified(project.getFile("a.txt"), "contents");
// Update and ensure file timestamp is what is was before out edit
updateProject(project, null, false);
Date modDate = CVSWorkspaceRoot.getCVSFileFor(project.getFile("a.txt")).getSyncInfo().getTimeStamp();
assertEquals("Timestamp was not properly reset", modDate, CVSWorkspaceRoot.getCVSFileFor(project.getFile("a.txt")).getTimeStamp());
setOnlyLookAtTimestamps(false);
}
public void testBinaryAddition() throws CoreException {
// See bug 132255
KSubstOption option = CVSProviderPlugin.getPlugin().getDefaultTextKSubstOption();
try {
CVSProviderPlugin.getPlugin().setDefaultTextKSubstOption(Command.KSUBST_TEXT_KEYWORDS_ONLY);
IProject project = createProject(new String[] { "a.txt"});
IProject copy = checkoutCopy(project, "-copy");
create(copy.getFile("binaryFile"), true);
setContentsAndEnsureModified(copy.getFile("binaryFile"), "/n/n\n\n");
addResources(new IResource[] { copy.getFile("binaryFile") });
commitProject(copy);
updateProject(project, null, false);
assertContentsEqual(copy.getFile("binaryFile"), project.getFile("binaryFile"));
} finally {
CVSProviderPlugin.getPlugin().setDefaultTextKSubstOption(option);
}
}
public void testDeletedPhantom139250() throws CoreException {
IProject project = createProject(new String[] { "a.txt"});
// Create a phantom folder that is mapped to a remote folder
// but for which no remote exists
ICVSFolder folder = CVSWorkspaceRoot.getCVSFolderFor(project.getFolder("phantom"));
ICVSFolder projectFolder = CVSWorkspaceRoot.getCVSFolderFor(project);
FolderSyncInfo projectInfo = projectFolder.getFolderSyncInfo();
String repo = Util.appendPath(projectInfo.getRepository(), "phantom");
FolderSyncInfo info = new FolderSyncInfo(repo, projectInfo.getRoot(), projectInfo.getTag(), false);
folder.setFolderSyncInfo(info);
updateProject(project, null, false);
}
public void testUpdateOfDeletedFile140007() throws CoreException {
IProject project = createProject(new String[] { "a.txt"});
IProject copy = checkoutCopy(project, "-copy");
deleteResources(copy, new String[] { "a.txt"}, true);
updateResources(project, new String[] { "a.txt"}, false);
}
public void testUpdateOfRemotelyRemovedFile() throws CoreException, IOException {
IProject project = createProject(new String[] { "a.txt"});
IProject copy = checkoutCopy(project, "-copy");
//Create a file and add it to version control (but don't commit)
addResources(copy, new String[] { "b.txt"}, false);
// Change the revision of the file so it appears to exist remotely
ICVSFile file = CVSWorkspaceRoot.getCVSFileFor(copy.getFile("b.txt"));
byte[] syncBytes = file.getSyncBytes();
syncBytes = ResourceSyncInfo.setRevision(syncBytes, "1.1");
file.setSyncBytes(syncBytes, ICVSFile.UNKNOWN);
file.checkedIn(null, true);
// Update the project and verify that the file gets removed
updateProject(copy, null, false);
assertEquals(project, copy);
}
public void testMergeWithTrailingLineFeeds() throws CoreException, IOException {
IProject project = createProject("testFileConflict", new String[] { "file1.txt"});
// Set the contents of file1.txt to ensure proper merging
// Ensure there is a trailing LF
setContentsAndEnsureModified(project.getFile("file1.txt"), "line1" + eol + "line2" + eol + "line3" + eol);
commitProject(project);
// Checkout and modify a copy
IProject copy = checkoutCopy(project, "-copy");
appendText(copy.getFile("file1.txt"), "line0" + eol, true);
commitProject(copy);
// Modify the original in a non-conflicting way
setContentsAndEnsureModified(project.getFile("file1.txt"), "line1" + eol + "line2" + eol + "line2.5" + eol + "line3" + eol);
// Update and ensure the contents are what we expect
updateProject(project, null, false);
assertTrue("File contents are not correct after merge", compareContent(
new ByteArrayInputStream(("line0" + eol + "line1" + eol + "line2" + eol + "line2.5" + eol + "line3" + eol).getBytes()),
project.getFile("file1.txt").getContents()));
}
public void testRevertToBaseHeadTag() throws CoreException, IOException{
IProject project = createProject("testRevertToBase", new String[] {"file1.txt"});
setContentsAndEnsureModified(project.getFile("file1.txt"), "line1" + eol + "line2" + eol + "line3" + eol);
commitProject(project);
IProject copy = checkoutCopy(project, "-copy");
appendText(project.getFile("file1.txt"), "line0" + eol, true);
updateProject(project, CVSTag.BASE, true);
assertTrue("File has changed after revert to base",
compareContent(new ByteArrayInputStream(("line1" + eol + "line2" + eol + "line3" + eol).getBytes()),
project.getFile("file1.txt").getContents()));
assertEquals(getRepositoryProvider(copy), getRepositoryProvider(project), false, true);
}
private CVSTeamProvider getRepositoryProvider(IProject project) {
return (CVSTeamProvider)RepositoryProvider.getProvider(project);
}
public void testRevertToBaseNonHeadTag() throws CoreException, IOException{
IProject project = createProject("testRevertToBaseNonHead", new String[] {"file1.txt"});
setContentsAndEnsureModified(project.getFile("file1.txt"), "line1" + eol + "line2" + eol);
commitProject(project);
tagProject(project, new CVSTag("testtag", CVSTag.BRANCH), true);
appendText(project.getFile("file1.txt"), "line3" + eol, true);
commitProject(project);
IProject copy = checkoutCopy(project, "-copy");
appendText(copy.getFile("file1.txt"), "line0" + eol, true);
updateProject(copy, CVSTag.BASE, true);
assertTrue("File has changed after revert to base",
compareContent(new ByteArrayInputStream(("line3" + eol + "line1" + eol + "line2" + eol).getBytes()),
copy.getFile("file1.txt").getContents()));
assertEquals(getRepositoryProvider(project), getRepositoryProvider(copy), false, true);
}
public void testSwitchTagForModifiedFile()throws CoreException, IOException {
// it's a similar scenario as in https://bugs.eclipse.org/bugs/show_bug.cgi?id=192392
// create a project
IProject project = createProject("testSwitchTagForModifiedFile", new String[] {"file"});
commitProject(project);
// tag it
CVSTag tag = new CVSTag("A", CVSTag.BRANCH);
tagProject(project, tag, true);
// modify a file
appendText(project.getFile("file"), "changed in head" + eol, false);
// switch to the tag
updateProject(project, tag, false);
ICVSFile cvsFile = CVSWorkspaceRoot.getCVSFileFor(project.getFile("file"));
// we expect the file to have the same tag used when switching
assertEquals(tag, cvsFile.getSyncInfo().getTag());
}
}
