Merge branch 'stable-4.2'
* stable-4.2: FileTreeIteratorTest: Open Git and RevWalk in try-with-resource RebaseCommandTest: Open RevWalk in try-with-resource PullCommandTest: Open RevWalk in try-with-resource BlameGeneratorTest: Create Git instances in try-with-resource Remove unnecessary suppression of deprecation warnings in tests DiffEntryTest: Open Git and TreeWalk in try-with-resource DiffCommandTest: Open Git and RevWalk in try-with-resource CommitCommandTest: Open Git and TreeWalk in try-with-resource Change-Id: Ic886ec9b1a4b3b46f9fa14188b4df832ce36cfa6 Signed-off-by: David Pursehouse <david.pursehouse@sonymobile.com>
This commit is contained in:
commit
27a6a52654
|
@ -186,297 +186,302 @@ public boolean isCaseSensitive() {
|
||||||
|
|
||||||
@Test
|
@Test
|
||||||
public void commitNewSubmodule() throws Exception {
|
public void commitNewSubmodule() throws Exception {
|
||||||
Git git = new Git(db);
|
try (Git git = new Git(db)) {
|
||||||
writeTrashFile("file.txt", "content");
|
writeTrashFile("file.txt", "content");
|
||||||
git.add().addFilepattern("file.txt").call();
|
git.add().addFilepattern("file.txt").call();
|
||||||
RevCommit commit = git.commit().setMessage("create file").call();
|
RevCommit commit = git.commit().setMessage("create file").call();
|
||||||
|
|
||||||
SubmoduleAddCommand command = new SubmoduleAddCommand(db);
|
SubmoduleAddCommand command = new SubmoduleAddCommand(db);
|
||||||
String path = "sub";
|
String path = "sub";
|
||||||
command.setPath(path);
|
command.setPath(path);
|
||||||
String uri = db.getDirectory().toURI().toString();
|
String uri = db.getDirectory().toURI().toString();
|
||||||
command.setURI(uri);
|
command.setURI(uri);
|
||||||
Repository repo = command.call();
|
Repository repo = command.call();
|
||||||
assertNotNull(repo);
|
assertNotNull(repo);
|
||||||
addRepoToClose(repo);
|
addRepoToClose(repo);
|
||||||
|
|
||||||
SubmoduleWalk generator = SubmoduleWalk.forIndex(db);
|
SubmoduleWalk generator = SubmoduleWalk.forIndex(db);
|
||||||
assertTrue(generator.next());
|
assertTrue(generator.next());
|
||||||
assertEquals(path, generator.getPath());
|
assertEquals(path, generator.getPath());
|
||||||
assertEquals(commit, generator.getObjectId());
|
assertEquals(commit, generator.getObjectId());
|
||||||
assertEquals(uri, generator.getModulesUrl());
|
assertEquals(uri, generator.getModulesUrl());
|
||||||
assertEquals(path, generator.getModulesPath());
|
assertEquals(path, generator.getModulesPath());
|
||||||
assertEquals(uri, generator.getConfigUrl());
|
assertEquals(uri, generator.getConfigUrl());
|
||||||
Repository subModRepo = generator.getRepository();
|
Repository subModRepo = generator.getRepository();
|
||||||
assertNotNull(subModRepo);
|
assertNotNull(subModRepo);
|
||||||
subModRepo.close();
|
subModRepo.close();
|
||||||
assertEquals(commit, repo.resolve(Constants.HEAD));
|
assertEquals(commit, repo.resolve(Constants.HEAD));
|
||||||
|
|
||||||
RevCommit submoduleCommit = git.commit().setMessage("submodule add")
|
RevCommit submoduleCommit = git.commit().setMessage("submodule add")
|
||||||
.setOnly(path).call();
|
.setOnly(path).call();
|
||||||
assertNotNull(submoduleCommit);
|
assertNotNull(submoduleCommit);
|
||||||
TreeWalk walk = new TreeWalk(db);
|
try (TreeWalk walk = new TreeWalk(db)) {
|
||||||
walk.addTree(commit.getTree());
|
walk.addTree(commit.getTree());
|
||||||
walk.addTree(submoduleCommit.getTree());
|
walk.addTree(submoduleCommit.getTree());
|
||||||
walk.setFilter(TreeFilter.ANY_DIFF);
|
walk.setFilter(TreeFilter.ANY_DIFF);
|
||||||
List<DiffEntry> diffs = DiffEntry.scan(walk);
|
List<DiffEntry> diffs = DiffEntry.scan(walk);
|
||||||
assertEquals(1, diffs.size());
|
assertEquals(1, diffs.size());
|
||||||
DiffEntry subDiff = diffs.get(0);
|
DiffEntry subDiff = diffs.get(0);
|
||||||
assertEquals(FileMode.MISSING, subDiff.getOldMode());
|
assertEquals(FileMode.MISSING, subDiff.getOldMode());
|
||||||
assertEquals(FileMode.GITLINK, subDiff.getNewMode());
|
assertEquals(FileMode.GITLINK, subDiff.getNewMode());
|
||||||
assertEquals(ObjectId.zeroId(), subDiff.getOldId().toObjectId());
|
assertEquals(ObjectId.zeroId(), subDiff.getOldId().toObjectId());
|
||||||
assertEquals(commit, subDiff.getNewId().toObjectId());
|
assertEquals(commit, subDiff.getNewId().toObjectId());
|
||||||
assertEquals(path, subDiff.getNewPath());
|
assertEquals(path, subDiff.getNewPath());
|
||||||
|
}
|
||||||
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
@Test
|
@Test
|
||||||
public void commitSubmoduleUpdate() throws Exception {
|
public void commitSubmoduleUpdate() throws Exception {
|
||||||
Git git = new Git(db);
|
try (Git git = new Git(db)) {
|
||||||
writeTrashFile("file.txt", "content");
|
writeTrashFile("file.txt", "content");
|
||||||
git.add().addFilepattern("file.txt").call();
|
git.add().addFilepattern("file.txt").call();
|
||||||
RevCommit commit = git.commit().setMessage("create file").call();
|
RevCommit commit = git.commit().setMessage("create file").call();
|
||||||
writeTrashFile("file.txt", "content2");
|
writeTrashFile("file.txt", "content2");
|
||||||
git.add().addFilepattern("file.txt").call();
|
git.add().addFilepattern("file.txt").call();
|
||||||
RevCommit commit2 = git.commit().setMessage("edit file").call();
|
RevCommit commit2 = git.commit().setMessage("edit file").call();
|
||||||
|
|
||||||
SubmoduleAddCommand command = new SubmoduleAddCommand(db);
|
SubmoduleAddCommand command = new SubmoduleAddCommand(db);
|
||||||
String path = "sub";
|
String path = "sub";
|
||||||
command.setPath(path);
|
command.setPath(path);
|
||||||
String uri = db.getDirectory().toURI().toString();
|
String uri = db.getDirectory().toURI().toString();
|
||||||
command.setURI(uri);
|
command.setURI(uri);
|
||||||
Repository repo = command.call();
|
Repository repo = command.call();
|
||||||
assertNotNull(repo);
|
assertNotNull(repo);
|
||||||
addRepoToClose(repo);
|
addRepoToClose(repo);
|
||||||
|
|
||||||
SubmoduleWalk generator = SubmoduleWalk.forIndex(db);
|
SubmoduleWalk generator = SubmoduleWalk.forIndex(db);
|
||||||
assertTrue(generator.next());
|
assertTrue(generator.next());
|
||||||
assertEquals(path, generator.getPath());
|
assertEquals(path, generator.getPath());
|
||||||
assertEquals(commit2, generator.getObjectId());
|
assertEquals(commit2, generator.getObjectId());
|
||||||
assertEquals(uri, generator.getModulesUrl());
|
assertEquals(uri, generator.getModulesUrl());
|
||||||
assertEquals(path, generator.getModulesPath());
|
assertEquals(path, generator.getModulesPath());
|
||||||
assertEquals(uri, generator.getConfigUrl());
|
assertEquals(uri, generator.getConfigUrl());
|
||||||
Repository subModRepo = generator.getRepository();
|
Repository subModRepo = generator.getRepository();
|
||||||
assertNotNull(subModRepo);
|
assertNotNull(subModRepo);
|
||||||
subModRepo.close();
|
subModRepo.close();
|
||||||
assertEquals(commit2, repo.resolve(Constants.HEAD));
|
assertEquals(commit2, repo.resolve(Constants.HEAD));
|
||||||
|
|
||||||
RevCommit submoduleAddCommit = git.commit().setMessage("submodule add")
|
RevCommit submoduleAddCommit = git.commit().setMessage("submodule add")
|
||||||
.setOnly(path).call();
|
.setOnly(path).call();
|
||||||
assertNotNull(submoduleAddCommit);
|
assertNotNull(submoduleAddCommit);
|
||||||
|
|
||||||
RefUpdate update = repo.updateRef(Constants.HEAD);
|
RefUpdate update = repo.updateRef(Constants.HEAD);
|
||||||
update.setNewObjectId(commit);
|
update.setNewObjectId(commit);
|
||||||
assertEquals(Result.FORCED, update.forceUpdate());
|
assertEquals(Result.FORCED, update.forceUpdate());
|
||||||
|
|
||||||
RevCommit submoduleEditCommit = git.commit()
|
RevCommit submoduleEditCommit = git.commit()
|
||||||
.setMessage("submodule add").setOnly(path).call();
|
.setMessage("submodule add").setOnly(path).call();
|
||||||
assertNotNull(submoduleEditCommit);
|
assertNotNull(submoduleEditCommit);
|
||||||
TreeWalk walk = new TreeWalk(db);
|
try (TreeWalk walk = new TreeWalk(db)) {
|
||||||
walk.addTree(submoduleAddCommit.getTree());
|
walk.addTree(submoduleAddCommit.getTree());
|
||||||
walk.addTree(submoduleEditCommit.getTree());
|
walk.addTree(submoduleEditCommit.getTree());
|
||||||
walk.setFilter(TreeFilter.ANY_DIFF);
|
walk.setFilter(TreeFilter.ANY_DIFF);
|
||||||
List<DiffEntry> diffs = DiffEntry.scan(walk);
|
List<DiffEntry> diffs = DiffEntry.scan(walk);
|
||||||
assertEquals(1, diffs.size());
|
assertEquals(1, diffs.size());
|
||||||
DiffEntry subDiff = diffs.get(0);
|
DiffEntry subDiff = diffs.get(0);
|
||||||
assertEquals(FileMode.GITLINK, subDiff.getOldMode());
|
assertEquals(FileMode.GITLINK, subDiff.getOldMode());
|
||||||
assertEquals(FileMode.GITLINK, subDiff.getNewMode());
|
assertEquals(FileMode.GITLINK, subDiff.getNewMode());
|
||||||
assertEquals(commit2, subDiff.getOldId().toObjectId());
|
assertEquals(commit2, subDiff.getOldId().toObjectId());
|
||||||
assertEquals(commit, subDiff.getNewId().toObjectId());
|
assertEquals(commit, subDiff.getNewId().toObjectId());
|
||||||
assertEquals(path, subDiff.getNewPath());
|
assertEquals(path, subDiff.getNewPath());
|
||||||
assertEquals(path, subDiff.getOldPath());
|
assertEquals(path, subDiff.getOldPath());
|
||||||
|
}
|
||||||
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
@Test
|
@Test
|
||||||
public void commitUpdatesSmudgedEntries() throws Exception {
|
public void commitUpdatesSmudgedEntries() throws Exception {
|
||||||
Git git = new Git(db);
|
try (Git git = new Git(db)) {
|
||||||
|
File file1 = writeTrashFile("file1.txt", "content1");
|
||||||
|
assertTrue(file1.setLastModified(file1.lastModified() - 5000));
|
||||||
|
File file2 = writeTrashFile("file2.txt", "content2");
|
||||||
|
assertTrue(file2.setLastModified(file2.lastModified() - 5000));
|
||||||
|
File file3 = writeTrashFile("file3.txt", "content3");
|
||||||
|
assertTrue(file3.setLastModified(file3.lastModified() - 5000));
|
||||||
|
|
||||||
File file1 = writeTrashFile("file1.txt", "content1");
|
assertNotNull(git.add().addFilepattern("file1.txt")
|
||||||
assertTrue(file1.setLastModified(file1.lastModified() - 5000));
|
.addFilepattern("file2.txt").addFilepattern("file3.txt").call());
|
||||||
File file2 = writeTrashFile("file2.txt", "content2");
|
RevCommit commit = git.commit().setMessage("add files").call();
|
||||||
assertTrue(file2.setLastModified(file2.lastModified() - 5000));
|
assertNotNull(commit);
|
||||||
File file3 = writeTrashFile("file3.txt", "content3");
|
|
||||||
assertTrue(file3.setLastModified(file3.lastModified() - 5000));
|
|
||||||
|
|
||||||
assertNotNull(git.add().addFilepattern("file1.txt")
|
DirCache cache = DirCache.read(db.getIndexFile(), db.getFS());
|
||||||
.addFilepattern("file2.txt").addFilepattern("file3.txt").call());
|
int file1Size = cache.getEntry("file1.txt").getLength();
|
||||||
RevCommit commit = git.commit().setMessage("add files").call();
|
int file2Size = cache.getEntry("file2.txt").getLength();
|
||||||
assertNotNull(commit);
|
int file3Size = cache.getEntry("file3.txt").getLength();
|
||||||
|
ObjectId file2Id = cache.getEntry("file2.txt").getObjectId();
|
||||||
|
ObjectId file3Id = cache.getEntry("file3.txt").getObjectId();
|
||||||
|
assertTrue(file1Size > 0);
|
||||||
|
assertTrue(file2Size > 0);
|
||||||
|
assertTrue(file3Size > 0);
|
||||||
|
|
||||||
DirCache cache = DirCache.read(db.getIndexFile(), db.getFS());
|
// Smudge entries
|
||||||
int file1Size = cache.getEntry("file1.txt").getLength();
|
cache = DirCache.lock(db.getIndexFile(), db.getFS());
|
||||||
int file2Size = cache.getEntry("file2.txt").getLength();
|
cache.getEntry("file1.txt").setLength(0);
|
||||||
int file3Size = cache.getEntry("file3.txt").getLength();
|
cache.getEntry("file2.txt").setLength(0);
|
||||||
ObjectId file2Id = cache.getEntry("file2.txt").getObjectId();
|
cache.getEntry("file3.txt").setLength(0);
|
||||||
ObjectId file3Id = cache.getEntry("file3.txt").getObjectId();
|
cache.write();
|
||||||
assertTrue(file1Size > 0);
|
assertTrue(cache.commit());
|
||||||
assertTrue(file2Size > 0);
|
|
||||||
assertTrue(file3Size > 0);
|
|
||||||
|
|
||||||
// Smudge entries
|
// Verify entries smudged
|
||||||
cache = DirCache.lock(db.getIndexFile(), db.getFS());
|
cache = DirCache.read(db.getIndexFile(), db.getFS());
|
||||||
cache.getEntry("file1.txt").setLength(0);
|
assertEquals(0, cache.getEntry("file1.txt").getLength());
|
||||||
cache.getEntry("file2.txt").setLength(0);
|
assertEquals(0, cache.getEntry("file2.txt").getLength());
|
||||||
cache.getEntry("file3.txt").setLength(0);
|
assertEquals(0, cache.getEntry("file3.txt").getLength());
|
||||||
cache.write();
|
|
||||||
assertTrue(cache.commit());
|
|
||||||
|
|
||||||
// Verify entries smudged
|
long indexTime = db.getIndexFile().lastModified();
|
||||||
cache = DirCache.read(db.getIndexFile(), db.getFS());
|
db.getIndexFile().setLastModified(indexTime - 5000);
|
||||||
assertEquals(0, cache.getEntry("file1.txt").getLength());
|
|
||||||
assertEquals(0, cache.getEntry("file2.txt").getLength());
|
|
||||||
assertEquals(0, cache.getEntry("file3.txt").getLength());
|
|
||||||
|
|
||||||
long indexTime = db.getIndexFile().lastModified();
|
write(file1, "content4");
|
||||||
db.getIndexFile().setLastModified(indexTime - 5000);
|
assertTrue(file1.setLastModified(file1.lastModified() + 2500));
|
||||||
|
assertNotNull(git.commit().setMessage("edit file").setOnly("file1.txt")
|
||||||
|
.call());
|
||||||
|
|
||||||
write(file1, "content4");
|
cache = db.readDirCache();
|
||||||
assertTrue(file1.setLastModified(file1.lastModified() + 2500));
|
assertEquals(file1Size, cache.getEntry("file1.txt").getLength());
|
||||||
assertNotNull(git.commit().setMessage("edit file").setOnly("file1.txt")
|
assertEquals(file2Size, cache.getEntry("file2.txt").getLength());
|
||||||
.call());
|
assertEquals(file3Size, cache.getEntry("file3.txt").getLength());
|
||||||
|
assertEquals(file2Id, cache.getEntry("file2.txt").getObjectId());
|
||||||
cache = db.readDirCache();
|
assertEquals(file3Id, cache.getEntry("file3.txt").getObjectId());
|
||||||
assertEquals(file1Size, cache.getEntry("file1.txt").getLength());
|
}
|
||||||
assertEquals(file2Size, cache.getEntry("file2.txt").getLength());
|
|
||||||
assertEquals(file3Size, cache.getEntry("file3.txt").getLength());
|
|
||||||
assertEquals(file2Id, cache.getEntry("file2.txt").getObjectId());
|
|
||||||
assertEquals(file3Id, cache.getEntry("file3.txt").getObjectId());
|
|
||||||
}
|
}
|
||||||
|
|
||||||
@Test
|
@Test
|
||||||
public void commitIgnoresSmudgedEntryWithDifferentId() throws Exception {
|
public void commitIgnoresSmudgedEntryWithDifferentId() throws Exception {
|
||||||
Git git = new Git(db);
|
try (Git git = new Git(db)) {
|
||||||
|
File file1 = writeTrashFile("file1.txt", "content1");
|
||||||
|
assertTrue(file1.setLastModified(file1.lastModified() - 5000));
|
||||||
|
File file2 = writeTrashFile("file2.txt", "content2");
|
||||||
|
assertTrue(file2.setLastModified(file2.lastModified() - 5000));
|
||||||
|
|
||||||
File file1 = writeTrashFile("file1.txt", "content1");
|
assertNotNull(git.add().addFilepattern("file1.txt")
|
||||||
assertTrue(file1.setLastModified(file1.lastModified() - 5000));
|
.addFilepattern("file2.txt").call());
|
||||||
File file2 = writeTrashFile("file2.txt", "content2");
|
RevCommit commit = git.commit().setMessage("add files").call();
|
||||||
assertTrue(file2.setLastModified(file2.lastModified() - 5000));
|
assertNotNull(commit);
|
||||||
|
|
||||||
assertNotNull(git.add().addFilepattern("file1.txt")
|
DirCache cache = DirCache.read(db.getIndexFile(), db.getFS());
|
||||||
.addFilepattern("file2.txt").call());
|
int file1Size = cache.getEntry("file1.txt").getLength();
|
||||||
RevCommit commit = git.commit().setMessage("add files").call();
|
int file2Size = cache.getEntry("file2.txt").getLength();
|
||||||
assertNotNull(commit);
|
assertTrue(file1Size > 0);
|
||||||
|
assertTrue(file2Size > 0);
|
||||||
|
|
||||||
DirCache cache = DirCache.read(db.getIndexFile(), db.getFS());
|
writeTrashFile("file2.txt", "content3");
|
||||||
int file1Size = cache.getEntry("file1.txt").getLength();
|
assertNotNull(git.add().addFilepattern("file2.txt").call());
|
||||||
int file2Size = cache.getEntry("file2.txt").getLength();
|
writeTrashFile("file2.txt", "content4");
|
||||||
assertTrue(file1Size > 0);
|
|
||||||
assertTrue(file2Size > 0);
|
|
||||||
|
|
||||||
writeTrashFile("file2.txt", "content3");
|
// Smudge entries
|
||||||
assertNotNull(git.add().addFilepattern("file2.txt").call());
|
cache = DirCache.lock(db.getIndexFile(), db.getFS());
|
||||||
writeTrashFile("file2.txt", "content4");
|
cache.getEntry("file1.txt").setLength(0);
|
||||||
|
cache.getEntry("file2.txt").setLength(0);
|
||||||
|
cache.write();
|
||||||
|
assertTrue(cache.commit());
|
||||||
|
|
||||||
// Smudge entries
|
// Verify entries smudged
|
||||||
cache = DirCache.lock(db.getIndexFile(), db.getFS());
|
cache = db.readDirCache();
|
||||||
cache.getEntry("file1.txt").setLength(0);
|
assertEquals(0, cache.getEntry("file1.txt").getLength());
|
||||||
cache.getEntry("file2.txt").setLength(0);
|
assertEquals(0, cache.getEntry("file2.txt").getLength());
|
||||||
cache.write();
|
|
||||||
assertTrue(cache.commit());
|
|
||||||
|
|
||||||
// Verify entries smudged
|
long indexTime = db.getIndexFile().lastModified();
|
||||||
cache = db.readDirCache();
|
db.getIndexFile().setLastModified(indexTime - 5000);
|
||||||
assertEquals(0, cache.getEntry("file1.txt").getLength());
|
|
||||||
assertEquals(0, cache.getEntry("file2.txt").getLength());
|
|
||||||
|
|
||||||
long indexTime = db.getIndexFile().lastModified();
|
write(file1, "content5");
|
||||||
db.getIndexFile().setLastModified(indexTime - 5000);
|
assertTrue(file1.setLastModified(file1.lastModified() + 1000));
|
||||||
|
|
||||||
write(file1, "content5");
|
assertNotNull(git.commit().setMessage("edit file").setOnly("file1.txt")
|
||||||
assertTrue(file1.setLastModified(file1.lastModified() + 1000));
|
.call());
|
||||||
|
|
||||||
assertNotNull(git.commit().setMessage("edit file").setOnly("file1.txt")
|
cache = db.readDirCache();
|
||||||
.call());
|
assertEquals(file1Size, cache.getEntry("file1.txt").getLength());
|
||||||
|
assertEquals(0, cache.getEntry("file2.txt").getLength());
|
||||||
cache = db.readDirCache();
|
}
|
||||||
assertEquals(file1Size, cache.getEntry("file1.txt").getLength());
|
|
||||||
assertEquals(0, cache.getEntry("file2.txt").getLength());
|
|
||||||
}
|
}
|
||||||
|
|
||||||
@Test
|
@Test
|
||||||
public void commitAfterSquashMerge() throws Exception {
|
public void commitAfterSquashMerge() throws Exception {
|
||||||
Git git = new Git(db);
|
try (Git git = new Git(db)) {
|
||||||
|
writeTrashFile("file1", "file1");
|
||||||
|
git.add().addFilepattern("file1").call();
|
||||||
|
RevCommit first = git.commit().setMessage("initial commit").call();
|
||||||
|
|
||||||
writeTrashFile("file1", "file1");
|
assertTrue(new File(db.getWorkTree(), "file1").exists());
|
||||||
git.add().addFilepattern("file1").call();
|
createBranch(first, "refs/heads/branch1");
|
||||||
RevCommit first = git.commit().setMessage("initial commit").call();
|
checkoutBranch("refs/heads/branch1");
|
||||||
|
|
||||||
assertTrue(new File(db.getWorkTree(), "file1").exists());
|
writeTrashFile("file2", "file2");
|
||||||
createBranch(first, "refs/heads/branch1");
|
git.add().addFilepattern("file2").call();
|
||||||
checkoutBranch("refs/heads/branch1");
|
git.commit().setMessage("second commit").call();
|
||||||
|
assertTrue(new File(db.getWorkTree(), "file2").exists());
|
||||||
|
|
||||||
writeTrashFile("file2", "file2");
|
checkoutBranch("refs/heads/master");
|
||||||
git.add().addFilepattern("file2").call();
|
|
||||||
git.commit().setMessage("second commit").call();
|
|
||||||
assertTrue(new File(db.getWorkTree(), "file2").exists());
|
|
||||||
|
|
||||||
checkoutBranch("refs/heads/master");
|
MergeResult result = git.merge()
|
||||||
|
.include(db.exactRef("refs/heads/branch1"))
|
||||||
|
.setSquash(true)
|
||||||
|
.call();
|
||||||
|
|
||||||
MergeResult result = git.merge()
|
assertTrue(new File(db.getWorkTree(), "file1").exists());
|
||||||
.include(db.exactRef("refs/heads/branch1"))
|
assertTrue(new File(db.getWorkTree(), "file2").exists());
|
||||||
.setSquash(true)
|
assertEquals(MergeResult.MergeStatus.FAST_FORWARD_SQUASHED,
|
||||||
.call();
|
result.getMergeStatus());
|
||||||
|
|
||||||
assertTrue(new File(db.getWorkTree(), "file1").exists());
|
// comment not set, should be inferred from SQUASH_MSG
|
||||||
assertTrue(new File(db.getWorkTree(), "file2").exists());
|
RevCommit squashedCommit = git.commit().call();
|
||||||
assertEquals(MergeResult.MergeStatus.FAST_FORWARD_SQUASHED,
|
|
||||||
result.getMergeStatus());
|
|
||||||
|
|
||||||
// comment not set, should be inferred from SQUASH_MSG
|
assertEquals(1, squashedCommit.getParentCount());
|
||||||
RevCommit squashedCommit = git.commit().call();
|
assertNull(db.readSquashCommitMsg());
|
||||||
|
assertEquals("commit: Squashed commit of the following:", db
|
||||||
assertEquals(1, squashedCommit.getParentCount());
|
.getReflogReader(Constants.HEAD).getLastEntry().getComment());
|
||||||
assertNull(db.readSquashCommitMsg());
|
assertEquals("commit: Squashed commit of the following:", db
|
||||||
assertEquals("commit: Squashed commit of the following:", db
|
.getReflogReader(db.getBranch()).getLastEntry().getComment());
|
||||||
.getReflogReader(Constants.HEAD).getLastEntry().getComment());
|
}
|
||||||
assertEquals("commit: Squashed commit of the following:", db
|
|
||||||
.getReflogReader(db.getBranch()).getLastEntry().getComment());
|
|
||||||
}
|
}
|
||||||
|
|
||||||
@Test(expected = WrongRepositoryStateException.class)
|
@Test(expected = WrongRepositoryStateException.class)
|
||||||
public void commitAmendOnInitialShouldFail() throws Exception {
|
public void commitAmendOnInitialShouldFail() throws Exception {
|
||||||
Git git = new Git(db);
|
try (Git git = new Git(db)) {
|
||||||
git.commit().setAmend(true).setMessage("initial commit").call();
|
git.commit().setAmend(true).setMessage("initial commit").call();
|
||||||
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
@Test
|
@Test
|
||||||
public void commitAmendWithoutAuthorShouldSetOriginalAuthorAndAuthorTime()
|
public void commitAmendWithoutAuthorShouldSetOriginalAuthorAndAuthorTime()
|
||||||
throws Exception {
|
throws Exception {
|
||||||
Git git = new Git(db);
|
try (Git git = new Git(db)) {
|
||||||
|
writeTrashFile("file1", "file1");
|
||||||
|
git.add().addFilepattern("file1").call();
|
||||||
|
|
||||||
writeTrashFile("file1", "file1");
|
final String authorName = "First Author";
|
||||||
git.add().addFilepattern("file1").call();
|
final String authorEmail = "author@example.org";
|
||||||
|
final Date authorDate = new Date(1349621117000L);
|
||||||
|
PersonIdent firstAuthor = new PersonIdent(authorName, authorEmail,
|
||||||
|
authorDate, TimeZone.getTimeZone("UTC"));
|
||||||
|
git.commit().setMessage("initial commit").setAuthor(firstAuthor).call();
|
||||||
|
|
||||||
final String authorName = "First Author";
|
RevCommit amended = git.commit().setAmend(true)
|
||||||
final String authorEmail = "author@example.org";
|
.setMessage("amend commit").call();
|
||||||
final Date authorDate = new Date(1349621117000L);
|
|
||||||
PersonIdent firstAuthor = new PersonIdent(authorName, authorEmail,
|
|
||||||
authorDate, TimeZone.getTimeZone("UTC"));
|
|
||||||
git.commit().setMessage("initial commit").setAuthor(firstAuthor).call();
|
|
||||||
|
|
||||||
RevCommit amended = git.commit().setAmend(true)
|
PersonIdent amendedAuthor = amended.getAuthorIdent();
|
||||||
.setMessage("amend commit").call();
|
assertEquals(authorName, amendedAuthor.getName());
|
||||||
|
assertEquals(authorEmail, amendedAuthor.getEmailAddress());
|
||||||
PersonIdent amendedAuthor = amended.getAuthorIdent();
|
assertEquals(authorDate.getTime(), amendedAuthor.getWhen().getTime());
|
||||||
assertEquals(authorName, amendedAuthor.getName());
|
}
|
||||||
assertEquals(authorEmail, amendedAuthor.getEmailAddress());
|
|
||||||
assertEquals(authorDate.getTime(), amendedAuthor.getWhen().getTime());
|
|
||||||
}
|
}
|
||||||
|
|
||||||
@Test
|
@Test
|
||||||
public void commitAmendWithAuthorShouldUseIt() throws Exception {
|
public void commitAmendWithAuthorShouldUseIt() throws Exception {
|
||||||
Git git = new Git(db);
|
try (Git git = new Git(db)) {
|
||||||
|
writeTrashFile("file1", "file1");
|
||||||
|
git.add().addFilepattern("file1").call();
|
||||||
|
git.commit().setMessage("initial commit").call();
|
||||||
|
|
||||||
writeTrashFile("file1", "file1");
|
RevCommit amended = git.commit().setAmend(true)
|
||||||
git.add().addFilepattern("file1").call();
|
.setAuthor("New Author", "newauthor@example.org")
|
||||||
git.commit().setMessage("initial commit").call();
|
.setMessage("amend commit").call();
|
||||||
|
|
||||||
RevCommit amended = git.commit().setAmend(true)
|
PersonIdent amendedAuthor = amended.getAuthorIdent();
|
||||||
.setAuthor("New Author", "newauthor@example.org")
|
assertEquals("New Author", amendedAuthor.getName());
|
||||||
.setMessage("amend commit").call();
|
assertEquals("newauthor@example.org", amendedAuthor.getEmailAddress());
|
||||||
|
}
|
||||||
PersonIdent amendedAuthor = amended.getAuthorIdent();
|
|
||||||
assertEquals("New Author", amendedAuthor.getName());
|
|
||||||
assertEquals("newauthor@example.org", amendedAuthor.getEmailAddress());
|
|
||||||
}
|
}
|
||||||
|
|
||||||
@Test
|
@Test
|
||||||
|
@ -532,18 +537,19 @@ public void commitOnlyShouldCommitUnmergedPathAndNotAffectOthers()
|
||||||
+ "[unmerged2, mode:100644, stage:3]",
|
+ "[unmerged2, mode:100644, stage:3]",
|
||||||
indexState(0));
|
indexState(0));
|
||||||
|
|
||||||
Git git = new Git(db);
|
try (Git git = new Git(db)) {
|
||||||
RevCommit commit = git.commit().setOnly("unmerged1")
|
RevCommit commit = git.commit().setOnly("unmerged1")
|
||||||
.setMessage("Only one file").call();
|
.setMessage("Only one file").call();
|
||||||
|
|
||||||
assertEquals("[other, mode:100644]" + "[unmerged1, mode:100644]"
|
assertEquals("[other, mode:100644]" + "[unmerged1, mode:100644]"
|
||||||
+ "[unmerged2, mode:100644, stage:1]"
|
+ "[unmerged2, mode:100644, stage:1]"
|
||||||
+ "[unmerged2, mode:100644, stage:2]"
|
+ "[unmerged2, mode:100644, stage:2]"
|
||||||
+ "[unmerged2, mode:100644, stage:3]",
|
+ "[unmerged2, mode:100644, stage:3]",
|
||||||
indexState(0));
|
indexState(0));
|
||||||
|
|
||||||
try (TreeWalk walk = TreeWalk.forPath(db, "unmerged1", commit.getTree())) {
|
try (TreeWalk walk = TreeWalk.forPath(db, "unmerged1", commit.getTree())) {
|
||||||
assertEquals(FileMode.REGULAR_FILE, walk.getFileMode(0));
|
assertEquals(FileMode.REGULAR_FILE, walk.getFileMode(0));
|
||||||
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
|
@ -70,32 +70,33 @@ public void testDiffModified() throws Exception {
|
||||||
File folder = new File(db.getWorkTree(), "folder");
|
File folder = new File(db.getWorkTree(), "folder");
|
||||||
folder.mkdir();
|
folder.mkdir();
|
||||||
write(new File(folder, "folder.txt"), "folder");
|
write(new File(folder, "folder.txt"), "folder");
|
||||||
Git git = new Git(db);
|
try (Git git = new Git(db)) {
|
||||||
git.add().addFilepattern(".").call();
|
git.add().addFilepattern(".").call();
|
||||||
git.commit().setMessage("Initial commit").call();
|
git.commit().setMessage("Initial commit").call();
|
||||||
write(new File(folder, "folder.txt"), "folder change");
|
write(new File(folder, "folder.txt"), "folder change");
|
||||||
|
|
||||||
OutputStream out = new ByteArrayOutputStream();
|
OutputStream out = new ByteArrayOutputStream();
|
||||||
List<DiffEntry> entries = git.diff().setOutputStream(out).call();
|
List<DiffEntry> entries = git.diff().setOutputStream(out).call();
|
||||||
assertEquals(1, entries.size());
|
assertEquals(1, entries.size());
|
||||||
assertEquals(ChangeType.MODIFY, entries.get(0)
|
assertEquals(ChangeType.MODIFY, entries.get(0)
|
||||||
.getChangeType());
|
.getChangeType());
|
||||||
assertEquals("folder/folder.txt", entries.get(0)
|
assertEquals("folder/folder.txt", entries.get(0)
|
||||||
.getOldPath());
|
.getOldPath());
|
||||||
assertEquals("folder/folder.txt", entries.get(0)
|
assertEquals("folder/folder.txt", entries.get(0)
|
||||||
.getNewPath());
|
.getNewPath());
|
||||||
|
|
||||||
String actual = out.toString();
|
String actual = out.toString();
|
||||||
String expected = "diff --git a/folder/folder.txt b/folder/folder.txt\n"
|
String expected = "diff --git a/folder/folder.txt b/folder/folder.txt\n"
|
||||||
+ "index 0119635..95c4c65 100644\n"
|
+ "index 0119635..95c4c65 100644\n"
|
||||||
+ "--- a/folder/folder.txt\n"
|
+ "--- a/folder/folder.txt\n"
|
||||||
+ "+++ b/folder/folder.txt\n"
|
+ "+++ b/folder/folder.txt\n"
|
||||||
+ "@@ -1 +1 @@\n"
|
+ "@@ -1 +1 @@\n"
|
||||||
+ "-folder\n"
|
+ "-folder\n"
|
||||||
+ "\\ No newline at end of file\n"
|
+ "\\ No newline at end of file\n"
|
||||||
+ "+folder change\n"
|
+ "+folder change\n"
|
||||||
+ "\\ No newline at end of file\n";
|
+ "\\ No newline at end of file\n";
|
||||||
assertEquals(expected.toString(), actual);
|
assertEquals(expected.toString(), actual);
|
||||||
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
@Test
|
@Test
|
||||||
|
@ -103,33 +104,34 @@ public void testDiffCached() throws Exception {
|
||||||
write(new File(db.getWorkTree(), "test.txt"), "test");
|
write(new File(db.getWorkTree(), "test.txt"), "test");
|
||||||
File folder = new File(db.getWorkTree(), "folder");
|
File folder = new File(db.getWorkTree(), "folder");
|
||||||
folder.mkdir();
|
folder.mkdir();
|
||||||
Git git = new Git(db);
|
try (Git git = new Git(db)) {
|
||||||
git.add().addFilepattern(".").call();
|
git.add().addFilepattern(".").call();
|
||||||
git.commit().setMessage("Initial commit").call();
|
git.commit().setMessage("Initial commit").call();
|
||||||
write(new File(folder, "folder.txt"), "folder");
|
write(new File(folder, "folder.txt"), "folder");
|
||||||
git.add().addFilepattern(".").call();
|
git.add().addFilepattern(".").call();
|
||||||
|
|
||||||
OutputStream out = new ByteArrayOutputStream();
|
OutputStream out = new ByteArrayOutputStream();
|
||||||
List<DiffEntry> entries = git.diff().setOutputStream(out)
|
List<DiffEntry> entries = git.diff().setOutputStream(out)
|
||||||
.setCached(true).call();
|
.setCached(true).call();
|
||||||
assertEquals(1, entries.size());
|
assertEquals(1, entries.size());
|
||||||
assertEquals(ChangeType.ADD, entries.get(0)
|
assertEquals(ChangeType.ADD, entries.get(0)
|
||||||
.getChangeType());
|
.getChangeType());
|
||||||
assertEquals("/dev/null", entries.get(0)
|
assertEquals("/dev/null", entries.get(0)
|
||||||
.getOldPath());
|
.getOldPath());
|
||||||
assertEquals("folder/folder.txt", entries.get(0)
|
assertEquals("folder/folder.txt", entries.get(0)
|
||||||
.getNewPath());
|
.getNewPath());
|
||||||
|
|
||||||
String actual = out.toString();
|
String actual = out.toString();
|
||||||
String expected = "diff --git a/folder/folder.txt b/folder/folder.txt\n"
|
String expected = "diff --git a/folder/folder.txt b/folder/folder.txt\n"
|
||||||
+ "new file mode 100644\n"
|
+ "new file mode 100644\n"
|
||||||
+ "index 0000000..0119635\n"
|
+ "index 0000000..0119635\n"
|
||||||
+ "--- /dev/null\n"
|
+ "--- /dev/null\n"
|
||||||
+ "+++ b/folder/folder.txt\n"
|
+ "+++ b/folder/folder.txt\n"
|
||||||
+ "@@ -0,0 +1 @@\n"
|
+ "@@ -0,0 +1 @@\n"
|
||||||
+ "+folder\n"
|
+ "+folder\n"
|
||||||
+ "\\ No newline at end of file\n";
|
+ "\\ No newline at end of file\n";
|
||||||
assertEquals(expected.toString(), actual);
|
assertEquals(expected.toString(), actual);
|
||||||
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
@Test
|
@Test
|
||||||
|
@ -138,107 +140,109 @@ public void testDiffTwoCommits() throws Exception {
|
||||||
File folder = new File(db.getWorkTree(), "folder");
|
File folder = new File(db.getWorkTree(), "folder");
|
||||||
folder.mkdir();
|
folder.mkdir();
|
||||||
write(new File(folder, "folder.txt"), "folder");
|
write(new File(folder, "folder.txt"), "folder");
|
||||||
Git git = new Git(db);
|
try (Git git = new Git(db)) {
|
||||||
git.add().addFilepattern(".").call();
|
git.add().addFilepattern(".").call();
|
||||||
git.commit().setMessage("Initial commit").call();
|
git.commit().setMessage("Initial commit").call();
|
||||||
write(new File(folder, "folder.txt"), "folder change");
|
write(new File(folder, "folder.txt"), "folder change");
|
||||||
git.add().addFilepattern(".").call();
|
git.add().addFilepattern(".").call();
|
||||||
git.commit().setMessage("second commit").call();
|
git.commit().setMessage("second commit").call();
|
||||||
write(new File(folder, "folder.txt"), "second folder change");
|
write(new File(folder, "folder.txt"), "second folder change");
|
||||||
git.add().addFilepattern(".").call();
|
git.add().addFilepattern(".").call();
|
||||||
git.commit().setMessage("third commit").call();
|
git.commit().setMessage("third commit").call();
|
||||||
|
|
||||||
// bad filter
|
// bad filter
|
||||||
DiffCommand diff = git.diff().setShowNameAndStatusOnly(true)
|
DiffCommand diff = git.diff().setShowNameAndStatusOnly(true)
|
||||||
.setPathFilter(PathFilter.create("test.txt"))
|
.setPathFilter(PathFilter.create("test.txt"))
|
||||||
.setOldTree(getTreeIterator("HEAD^^"))
|
.setOldTree(getTreeIterator("HEAD^^"))
|
||||||
.setNewTree(getTreeIterator("HEAD^"));
|
.setNewTree(getTreeIterator("HEAD^"));
|
||||||
List<DiffEntry> entries = diff.call();
|
List<DiffEntry> entries = diff.call();
|
||||||
assertEquals(0, entries.size());
|
assertEquals(0, entries.size());
|
||||||
|
|
||||||
// no filter, two commits
|
// no filter, two commits
|
||||||
OutputStream out = new ByteArrayOutputStream();
|
OutputStream out = new ByteArrayOutputStream();
|
||||||
diff = git.diff().setOutputStream(out)
|
diff = git.diff().setOutputStream(out)
|
||||||
.setOldTree(getTreeIterator("HEAD^^"))
|
.setOldTree(getTreeIterator("HEAD^^"))
|
||||||
.setNewTree(getTreeIterator("HEAD^"));
|
.setNewTree(getTreeIterator("HEAD^"));
|
||||||
entries = diff.call();
|
entries = diff.call();
|
||||||
assertEquals(1, entries.size());
|
assertEquals(1, entries.size());
|
||||||
assertEquals(ChangeType.MODIFY, entries.get(0).getChangeType());
|
assertEquals(ChangeType.MODIFY, entries.get(0).getChangeType());
|
||||||
assertEquals("folder/folder.txt", entries.get(0).getOldPath());
|
assertEquals("folder/folder.txt", entries.get(0).getOldPath());
|
||||||
assertEquals("folder/folder.txt", entries.get(0).getNewPath());
|
assertEquals("folder/folder.txt", entries.get(0).getNewPath());
|
||||||
|
|
||||||
String actual = out.toString();
|
String actual = out.toString();
|
||||||
String expected = "diff --git a/folder/folder.txt b/folder/folder.txt\n"
|
String expected = "diff --git a/folder/folder.txt b/folder/folder.txt\n"
|
||||||
+ "index 0119635..95c4c65 100644\n"
|
+ "index 0119635..95c4c65 100644\n"
|
||||||
+ "--- a/folder/folder.txt\n"
|
+ "--- a/folder/folder.txt\n"
|
||||||
+ "+++ b/folder/folder.txt\n"
|
+ "+++ b/folder/folder.txt\n"
|
||||||
+ "@@ -1 +1 @@\n"
|
+ "@@ -1 +1 @@\n"
|
||||||
+ "-folder\n"
|
+ "-folder\n"
|
||||||
+ "\\ No newline at end of file\n"
|
+ "\\ No newline at end of file\n"
|
||||||
+ "+folder change\n"
|
+ "+folder change\n"
|
||||||
+ "\\ No newline at end of file\n";
|
+ "\\ No newline at end of file\n";
|
||||||
assertEquals(expected.toString(), actual);
|
assertEquals(expected.toString(), actual);
|
||||||
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
@Test
|
@Test
|
||||||
public void testDiffWithPrefixes() throws Exception {
|
public void testDiffWithPrefixes() throws Exception {
|
||||||
write(new File(db.getWorkTree(), "test.txt"), "test");
|
write(new File(db.getWorkTree(), "test.txt"), "test");
|
||||||
Git git = new Git(db);
|
try (Git git = new Git(db)) {
|
||||||
git.add().addFilepattern(".").call();
|
git.add().addFilepattern(".").call();
|
||||||
git.commit().setMessage("Initial commit").call();
|
git.commit().setMessage("Initial commit").call();
|
||||||
write(new File(db.getWorkTree(), "test.txt"), "test change");
|
write(new File(db.getWorkTree(), "test.txt"), "test change");
|
||||||
|
|
||||||
OutputStream out = new ByteArrayOutputStream();
|
OutputStream out = new ByteArrayOutputStream();
|
||||||
git.diff().setOutputStream(out).setSourcePrefix("old/")
|
git.diff().setOutputStream(out).setSourcePrefix("old/")
|
||||||
.setDestinationPrefix("new/")
|
.setDestinationPrefix("new/").call();
|
||||||
.call();
|
|
||||||
|
|
||||||
String actual = out.toString();
|
String actual = out.toString();
|
||||||
String expected = "diff --git old/test.txt new/test.txt\n"
|
String expected = "diff --git old/test.txt new/test.txt\n"
|
||||||
+ "index 30d74d2..4dba797 100644\n" + "--- old/test.txt\n"
|
+ "index 30d74d2..4dba797 100644\n" + "--- old/test.txt\n"
|
||||||
+ "+++ new/test.txt\n" + "@@ -1 +1 @@\n" + "-test\n"
|
+ "+++ new/test.txt\n" + "@@ -1 +1 @@\n" + "-test\n"
|
||||||
+ "\\ No newline at end of file\n" + "+test change\n"
|
+ "\\ No newline at end of file\n" + "+test change\n"
|
||||||
+ "\\ No newline at end of file\n";
|
+ "\\ No newline at end of file\n";
|
||||||
assertEquals(expected.toString(), actual);
|
assertEquals(expected.toString(), actual);
|
||||||
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
@Test
|
@Test
|
||||||
public void testDiffWithNegativeLineCount() throws Exception {
|
public void testDiffWithNegativeLineCount() throws Exception {
|
||||||
write(new File(db.getWorkTree(), "test.txt"),
|
write(new File(db.getWorkTree(), "test.txt"),
|
||||||
"0\n1\n2\n3\n4\n5\n6\n7\n8\n9");
|
"0\n1\n2\n3\n4\n5\n6\n7\n8\n9");
|
||||||
Git git = new Git(db);
|
try (Git git = new Git(db)) {
|
||||||
git.add().addFilepattern(".").call();
|
git.add().addFilepattern(".").call();
|
||||||
git.commit().setMessage("Initial commit").call();
|
git.commit().setMessage("Initial commit").call();
|
||||||
write(new File(db.getWorkTree(), "test.txt"),
|
write(new File(db.getWorkTree(), "test.txt"),
|
||||||
"0\n1\n2\n3\n4a\n5\n6\n7\n8\n9");
|
"0\n1\n2\n3\n4a\n5\n6\n7\n8\n9");
|
||||||
|
|
||||||
OutputStream out = new ByteArrayOutputStream();
|
OutputStream out = new ByteArrayOutputStream();
|
||||||
git.diff().setOutputStream(out).setContextLines(1)
|
git.diff().setOutputStream(out).setContextLines(1).call();
|
||||||
.call();
|
|
||||||
|
|
||||||
String actual = out.toString();
|
String actual = out.toString();
|
||||||
String expected = "diff --git a/test.txt b/test.txt\n"
|
String expected = "diff --git a/test.txt b/test.txt\n"
|
||||||
+ "index f55b5c9..c5ec8fd 100644\n" + "--- a/test.txt\n"
|
+ "index f55b5c9..c5ec8fd 100644\n" + "--- a/test.txt\n"
|
||||||
+ "+++ b/test.txt\n" + "@@ -4,3 +4,3 @@\n" + " 3\n" + "-4\n"
|
+ "+++ b/test.txt\n" + "@@ -4,3 +4,3 @@\n" + " 3\n" + "-4\n"
|
||||||
+ "+4a\n" + " 5\n";
|
+ "+4a\n" + " 5\n";
|
||||||
assertEquals(expected.toString(), actual);
|
assertEquals(expected.toString(), actual);
|
||||||
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
@Test
|
@Test
|
||||||
public void testNoOutputStreamSet() throws Exception {
|
public void testNoOutputStreamSet() throws Exception {
|
||||||
File file = writeTrashFile("test.txt", "a");
|
File file = writeTrashFile("test.txt", "a");
|
||||||
assertTrue(file.setLastModified(file.lastModified() - 5000));
|
assertTrue(file.setLastModified(file.lastModified() - 5000));
|
||||||
Git git = new Git(db);
|
try (Git git = new Git(db)) {
|
||||||
git.add().addFilepattern(".").call();
|
git.add().addFilepattern(".").call();
|
||||||
write(file, "b");
|
write(file, "b");
|
||||||
|
|
||||||
List<DiffEntry> diffs = git.diff().call();
|
List<DiffEntry> diffs = git.diff().call();
|
||||||
assertNotNull(diffs);
|
assertNotNull(diffs);
|
||||||
assertEquals(1, diffs.size());
|
assertEquals(1, diffs.size());
|
||||||
DiffEntry diff = diffs.get(0);
|
DiffEntry diff = diffs.get(0);
|
||||||
assertEquals(ChangeType.MODIFY, diff.getChangeType());
|
assertEquals(ChangeType.MODIFY, diff.getChangeType());
|
||||||
assertEquals("test.txt", diff.getOldPath());
|
assertEquals("test.txt", diff.getOldPath());
|
||||||
assertEquals("test.txt", diff.getNewPath());
|
assertEquals("test.txt", diff.getNewPath());
|
||||||
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
private AbstractTreeIterator getTreeIterator(String name)
|
private AbstractTreeIterator getTreeIterator(String name)
|
||||||
|
@ -247,8 +251,9 @@ private AbstractTreeIterator getTreeIterator(String name)
|
||||||
if (id == null)
|
if (id == null)
|
||||||
throw new IllegalArgumentException(name);
|
throw new IllegalArgumentException(name);
|
||||||
final CanonicalTreeParser p = new CanonicalTreeParser();
|
final CanonicalTreeParser p = new CanonicalTreeParser();
|
||||||
try (ObjectReader or = db.newObjectReader()) {
|
try (ObjectReader or = db.newObjectReader();
|
||||||
p.reset(or, new RevWalk(db).parseTree(id));
|
RevWalk rw = new RevWalk(db)) {
|
||||||
|
p.reset(or, rw.parseTree(id));
|
||||||
return p;
|
return p;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
|
@ -140,11 +140,12 @@ public void testPullMerge() throws Exception {
|
||||||
ObjectId[] mergedCommits = mergeResult.getMergedCommits();
|
ObjectId[] mergedCommits = mergeResult.getMergedCommits();
|
||||||
assertEquals(targetCommit.getId(), mergedCommits[0]);
|
assertEquals(targetCommit.getId(), mergedCommits[0]);
|
||||||
assertEquals(sourceCommit.getId(), mergedCommits[1]);
|
assertEquals(sourceCommit.getId(), mergedCommits[1]);
|
||||||
RevCommit mergeCommit = new RevWalk(dbTarget).parseCommit(mergeResult
|
try (RevWalk rw = new RevWalk(dbTarget)) {
|
||||||
.getNewHead());
|
RevCommit mergeCommit = rw.parseCommit(mergeResult.getNewHead());
|
||||||
String message = "Merge branch 'master' of "
|
String message = "Merge branch 'master' of "
|
||||||
+ db.getWorkTree().getAbsolutePath();
|
+ db.getWorkTree().getAbsolutePath();
|
||||||
assertEquals(message, mergeCommit.getShortMessage());
|
assertEquals(message, mergeCommit.getShortMessage());
|
||||||
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
@Test
|
@Test
|
||||||
|
@ -259,11 +260,12 @@ public void testPullMergeProgrammaticConfiguration() throws Exception {
|
||||||
ObjectId[] mergedCommits = mergeResult.getMergedCommits();
|
ObjectId[] mergedCommits = mergeResult.getMergedCommits();
|
||||||
assertEquals(targetCommit.getId(), mergedCommits[0]);
|
assertEquals(targetCommit.getId(), mergedCommits[0]);
|
||||||
assertEquals(sourceCommit.getId(), mergedCommits[1]);
|
assertEquals(sourceCommit.getId(), mergedCommits[1]);
|
||||||
RevCommit mergeCommit = new RevWalk(dbTarget).parseCommit(mergeResult
|
try (RevWalk rw = new RevWalk(dbTarget)) {
|
||||||
.getNewHead());
|
RevCommit mergeCommit = rw.parseCommit(mergeResult.getNewHead());
|
||||||
String message = "Merge branch 'other' of "
|
String message = "Merge branch 'other' of "
|
||||||
+ db.getWorkTree().getAbsolutePath();
|
+ db.getWorkTree().getAbsolutePath();
|
||||||
assertEquals(message, mergeCommit.getShortMessage());
|
assertEquals(message, mergeCommit.getShortMessage());
|
||||||
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
@Test
|
@Test
|
||||||
|
@ -293,11 +295,12 @@ public void testPullMergeProgrammaticConfigurationImpliedTargetBranch()
|
||||||
ObjectId[] mergedCommits = mergeResult.getMergedCommits();
|
ObjectId[] mergedCommits = mergeResult.getMergedCommits();
|
||||||
assertEquals(targetCommit.getId(), mergedCommits[0]);
|
assertEquals(targetCommit.getId(), mergedCommits[0]);
|
||||||
assertEquals(sourceCommit.getId(), mergedCommits[1]);
|
assertEquals(sourceCommit.getId(), mergedCommits[1]);
|
||||||
RevCommit mergeCommit = new RevWalk(dbTarget).parseCommit(mergeResult
|
try (RevWalk rw = new RevWalk(dbTarget)) {
|
||||||
.getNewHead());
|
RevCommit mergeCommit = rw.parseCommit(mergeResult.getNewHead());
|
||||||
String message = "Merge branch 'other' of "
|
String message = "Merge branch 'other' of "
|
||||||
+ db.getWorkTree().getAbsolutePath() + " into other";
|
+ db.getWorkTree().getAbsolutePath() + " into other";
|
||||||
assertEquals(message, mergeCommit.getShortMessage());
|
assertEquals(message, mergeCommit.getShortMessage());
|
||||||
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
private enum TestPullMode {
|
private enum TestPullMode {
|
||||||
|
|
|
@ -288,13 +288,14 @@ public void testRebaseShouldIgnoreMergeCommits()
|
||||||
RebaseResult res = git.rebase().setUpstream("refs/heads/master").call();
|
RebaseResult res = git.rebase().setUpstream("refs/heads/master").call();
|
||||||
assertEquals(Status.OK, res.getStatus());
|
assertEquals(Status.OK, res.getStatus());
|
||||||
|
|
||||||
RevWalk rw = new RevWalk(db);
|
try (RevWalk rw = new RevWalk(db)) {
|
||||||
rw.markStart(rw.parseCommit(db.resolve("refs/heads/topic")));
|
rw.markStart(rw.parseCommit(db.resolve("refs/heads/topic")));
|
||||||
assertDerivedFrom(rw.next(), e);
|
assertDerivedFrom(rw.next(), e);
|
||||||
assertDerivedFrom(rw.next(), d);
|
assertDerivedFrom(rw.next(), d);
|
||||||
assertDerivedFrom(rw.next(), c);
|
assertDerivedFrom(rw.next(), c);
|
||||||
assertEquals(b, rw.next());
|
assertEquals(b, rw.next());
|
||||||
assertEquals(a, rw.next());
|
assertEquals(a, rw.next());
|
||||||
|
}
|
||||||
|
|
||||||
List<ReflogEntry> headLog = db.getReflogReader(Constants.HEAD)
|
List<ReflogEntry> headLog = db.getReflogReader(Constants.HEAD)
|
||||||
.getReverseEntries();
|
.getReverseEntries();
|
||||||
|
@ -354,8 +355,6 @@ public void testRebasePreservingMerges2() throws Exception {
|
||||||
*/
|
*/
|
||||||
private void doTestRebasePreservingMerges(boolean testConflict)
|
private void doTestRebasePreservingMerges(boolean testConflict)
|
||||||
throws Exception {
|
throws Exception {
|
||||||
RevWalk rw = new RevWalk(db);
|
|
||||||
|
|
||||||
// create file1 on master
|
// create file1 on master
|
||||||
writeTrashFile(FILE1, FILE1);
|
writeTrashFile(FILE1, FILE1);
|
||||||
git.add().addFilepattern(FILE1).call();
|
git.add().addFilepattern(FILE1).call();
|
||||||
|
@ -409,7 +408,9 @@ private void doTestRebasePreservingMerges(boolean testConflict)
|
||||||
f = git.commit().setMessage("commit f").call();
|
f = git.commit().setMessage("commit f").call();
|
||||||
} else {
|
} else {
|
||||||
assertEquals(MergeStatus.MERGED, result.getMergeStatus());
|
assertEquals(MergeStatus.MERGED, result.getMergeStatus());
|
||||||
f = rw.parseCommit(result.getNewHead());
|
try (RevWalk rw = new RevWalk(db)) {
|
||||||
|
f = rw.parseCommit(result.getNewHead());
|
||||||
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
RebaseResult res = git.rebase().setUpstream("refs/heads/master")
|
RebaseResult res = git.rebase().setUpstream("refs/heads/master")
|
||||||
|
@ -453,23 +454,25 @@ private void doTestRebasePreservingMerges(boolean testConflict)
|
||||||
assertEquals("file2", read("file2"));
|
assertEquals("file2", read("file2"));
|
||||||
assertEquals("more change", read("file3"));
|
assertEquals("more change", read("file3"));
|
||||||
|
|
||||||
rw.markStart(rw.parseCommit(db.resolve("refs/heads/topic")));
|
try (RevWalk rw = new RevWalk(db)) {
|
||||||
RevCommit newF = rw.next();
|
rw.markStart(rw.parseCommit(db.resolve("refs/heads/topic")));
|
||||||
assertDerivedFrom(newF, f);
|
RevCommit newF = rw.next();
|
||||||
assertEquals(2, newF.getParentCount());
|
assertDerivedFrom(newF, f);
|
||||||
RevCommit newD = rw.next();
|
assertEquals(2, newF.getParentCount());
|
||||||
assertDerivedFrom(newD, d);
|
RevCommit newD = rw.next();
|
||||||
if (testConflict)
|
assertDerivedFrom(newD, d);
|
||||||
assertEquals("d new", readFile("conflict", newD));
|
if (testConflict)
|
||||||
RevCommit newE = rw.next();
|
assertEquals("d new", readFile("conflict", newD));
|
||||||
assertDerivedFrom(newE, e);
|
RevCommit newE = rw.next();
|
||||||
if (testConflict)
|
assertDerivedFrom(newE, e);
|
||||||
assertEquals("e new", readFile("conflict", newE));
|
if (testConflict)
|
||||||
assertEquals(newD, newF.getParent(0));
|
assertEquals("e new", readFile("conflict", newE));
|
||||||
assertEquals(newE, newF.getParent(1));
|
assertEquals(newD, newF.getParent(0));
|
||||||
assertDerivedFrom(rw.next(), c);
|
assertEquals(newE, newF.getParent(1));
|
||||||
assertEquals(b, rw.next());
|
assertDerivedFrom(rw.next(), c);
|
||||||
assertEquals(a, rw.next());
|
assertEquals(b, rw.next());
|
||||||
|
assertEquals(a, rw.next());
|
||||||
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
private String readFile(String path, RevCommit commit) throws IOException {
|
private String readFile(String path, RevCommit commit) throws IOException {
|
||||||
|
@ -517,88 +520,89 @@ public void testRebasePreservingMergesWithUnrelatedSide2() throws Exception {
|
||||||
*/
|
*/
|
||||||
private void doTestRebasePreservingMergesWithUnrelatedSide(
|
private void doTestRebasePreservingMergesWithUnrelatedSide(
|
||||||
boolean testConflict) throws Exception {
|
boolean testConflict) throws Exception {
|
||||||
RevWalk rw = new RevWalk(db);
|
try (RevWalk rw = new RevWalk(db)) {
|
||||||
rw.sort(RevSort.TOPO);
|
rw.sort(RevSort.TOPO);
|
||||||
|
|
||||||
writeTrashFile(FILE1, FILE1);
|
writeTrashFile(FILE1, FILE1);
|
||||||
git.add().addFilepattern(FILE1).call();
|
git.add().addFilepattern(FILE1).call();
|
||||||
RevCommit a = git.commit().setMessage("commit a").call();
|
RevCommit a = git.commit().setMessage("commit a").call();
|
||||||
|
|
||||||
writeTrashFile("file2", "blah");
|
writeTrashFile("file2", "blah");
|
||||||
git.add().addFilepattern("file2").call();
|
git.add().addFilepattern("file2").call();
|
||||||
RevCommit b = git.commit().setMessage("commit b").call();
|
RevCommit b = git.commit().setMessage("commit b").call();
|
||||||
|
|
||||||
// create a topic branch
|
// create a topic branch
|
||||||
createBranch(b, "refs/heads/topic");
|
createBranch(b, "refs/heads/topic");
|
||||||
checkoutBranch("refs/heads/topic");
|
checkoutBranch("refs/heads/topic");
|
||||||
|
|
||||||
writeTrashFile("file3", "more changess");
|
writeTrashFile("file3", "more changess");
|
||||||
writeTrashFile(FILE1, "preparing conflict");
|
writeTrashFile(FILE1, "preparing conflict");
|
||||||
git.add().addFilepattern("file3").addFilepattern(FILE1).call();
|
git.add().addFilepattern("file3").addFilepattern(FILE1).call();
|
||||||
RevCommit c = git.commit().setMessage("commit c").call();
|
RevCommit c = git.commit().setMessage("commit c").call();
|
||||||
|
|
||||||
createBranch(a, "refs/heads/side");
|
createBranch(a, "refs/heads/side");
|
||||||
checkoutBranch("refs/heads/side");
|
checkoutBranch("refs/heads/side");
|
||||||
writeTrashFile("conflict", "e");
|
|
||||||
writeTrashFile(FILE1, FILE1 + "\n" + "line 2");
|
|
||||||
git.add().addFilepattern(".").call();
|
|
||||||
RevCommit e = git.commit().setMessage("commit e").call();
|
|
||||||
|
|
||||||
// switch back to topic and merge in side, creating d
|
|
||||||
checkoutBranch("refs/heads/topic");
|
|
||||||
MergeResult result = git.merge().include(e)
|
|
||||||
.setStrategy(MergeStrategy.RESOLVE).call();
|
|
||||||
|
|
||||||
assertEquals(MergeStatus.CONFLICTING, result.getMergeStatus());
|
|
||||||
assertEquals(result.getConflicts().keySet(),
|
|
||||||
Collections.singleton(FILE1));
|
|
||||||
writeTrashFile(FILE1, "merge resolution");
|
|
||||||
git.add().addFilepattern(FILE1).call();
|
|
||||||
RevCommit d = git.commit().setMessage("commit d").call();
|
|
||||||
|
|
||||||
RevCommit f = commitFile("file2", "new content two", "topic");
|
|
||||||
|
|
||||||
checkoutBranch("refs/heads/master");
|
|
||||||
writeTrashFile("fileg", "fileg");
|
|
||||||
if (testConflict)
|
|
||||||
writeTrashFile("conflict", "g");
|
|
||||||
git.add().addFilepattern(".").call();
|
|
||||||
RevCommit g = git.commit().setMessage("commit g").call();
|
|
||||||
|
|
||||||
checkoutBranch("refs/heads/topic");
|
|
||||||
RebaseResult res = git.rebase().setUpstream("refs/heads/master")
|
|
||||||
.setPreserveMerges(true).call();
|
|
||||||
if (testConflict) {
|
|
||||||
assertEquals(Status.STOPPED, res.getStatus());
|
|
||||||
assertEquals(Collections.singleton("conflict"), git.status().call()
|
|
||||||
.getConflicting());
|
|
||||||
// resolve
|
|
||||||
writeTrashFile("conflict", "e");
|
writeTrashFile("conflict", "e");
|
||||||
git.add().addFilepattern("conflict").call();
|
writeTrashFile(FILE1, FILE1 + "\n" + "line 2");
|
||||||
res = git.rebase().setOperation(Operation.CONTINUE).call();
|
git.add().addFilepattern(".").call();
|
||||||
|
RevCommit e = git.commit().setMessage("commit e").call();
|
||||||
|
|
||||||
|
// switch back to topic and merge in side, creating d
|
||||||
|
checkoutBranch("refs/heads/topic");
|
||||||
|
MergeResult result = git.merge().include(e)
|
||||||
|
.setStrategy(MergeStrategy.RESOLVE).call();
|
||||||
|
|
||||||
|
assertEquals(MergeStatus.CONFLICTING, result.getMergeStatus());
|
||||||
|
assertEquals(result.getConflicts().keySet(),
|
||||||
|
Collections.singleton(FILE1));
|
||||||
|
writeTrashFile(FILE1, "merge resolution");
|
||||||
|
git.add().addFilepattern(FILE1).call();
|
||||||
|
RevCommit d = git.commit().setMessage("commit d").call();
|
||||||
|
|
||||||
|
RevCommit f = commitFile("file2", "new content two", "topic");
|
||||||
|
|
||||||
|
checkoutBranch("refs/heads/master");
|
||||||
|
writeTrashFile("fileg", "fileg");
|
||||||
|
if (testConflict)
|
||||||
|
writeTrashFile("conflict", "g");
|
||||||
|
git.add().addFilepattern(".").call();
|
||||||
|
RevCommit g = git.commit().setMessage("commit g").call();
|
||||||
|
|
||||||
|
checkoutBranch("refs/heads/topic");
|
||||||
|
RebaseResult res = git.rebase().setUpstream("refs/heads/master")
|
||||||
|
.setPreserveMerges(true).call();
|
||||||
|
if (testConflict) {
|
||||||
|
assertEquals(Status.STOPPED, res.getStatus());
|
||||||
|
assertEquals(Collections.singleton("conflict"), git.status().call()
|
||||||
|
.getConflicting());
|
||||||
|
// resolve
|
||||||
|
writeTrashFile("conflict", "e");
|
||||||
|
git.add().addFilepattern("conflict").call();
|
||||||
|
res = git.rebase().setOperation(Operation.CONTINUE).call();
|
||||||
|
}
|
||||||
|
assertEquals(Status.OK, res.getStatus());
|
||||||
|
|
||||||
|
assertEquals("merge resolution", read(FILE1));
|
||||||
|
assertEquals("new content two", read("file2"));
|
||||||
|
assertEquals("more changess", read("file3"));
|
||||||
|
assertEquals("fileg", read("fileg"));
|
||||||
|
|
||||||
|
rw.markStart(rw.parseCommit(db.resolve("refs/heads/topic")));
|
||||||
|
RevCommit newF = rw.next();
|
||||||
|
assertDerivedFrom(newF, f);
|
||||||
|
RevCommit newD = rw.next();
|
||||||
|
assertDerivedFrom(newD, d);
|
||||||
|
assertEquals(2, newD.getParentCount());
|
||||||
|
RevCommit newC = rw.next();
|
||||||
|
assertDerivedFrom(newC, c);
|
||||||
|
RevCommit newE = rw.next();
|
||||||
|
assertEquals(e, newE);
|
||||||
|
assertEquals(newC, newD.getParent(0));
|
||||||
|
assertEquals(e, newD.getParent(1));
|
||||||
|
assertEquals(g, rw.next());
|
||||||
|
assertEquals(b, rw.next());
|
||||||
|
assertEquals(a, rw.next());
|
||||||
}
|
}
|
||||||
assertEquals(Status.OK, res.getStatus());
|
|
||||||
|
|
||||||
assertEquals("merge resolution", read(FILE1));
|
|
||||||
assertEquals("new content two", read("file2"));
|
|
||||||
assertEquals("more changess", read("file3"));
|
|
||||||
assertEquals("fileg", read("fileg"));
|
|
||||||
|
|
||||||
rw.markStart(rw.parseCommit(db.resolve("refs/heads/topic")));
|
|
||||||
RevCommit newF = rw.next();
|
|
||||||
assertDerivedFrom(newF, f);
|
|
||||||
RevCommit newD = rw.next();
|
|
||||||
assertDerivedFrom(newD, d);
|
|
||||||
assertEquals(2, newD.getParentCount());
|
|
||||||
RevCommit newC = rw.next();
|
|
||||||
assertDerivedFrom(newC, c);
|
|
||||||
RevCommit newE = rw.next();
|
|
||||||
assertEquals(e, newE);
|
|
||||||
assertEquals(newC, newD.getParent(0));
|
|
||||||
assertEquals(e, newD.getParent(1));
|
|
||||||
assertEquals(g, rw.next());
|
|
||||||
assertEquals(b, rw.next());
|
|
||||||
assertEquals(a, rw.next());
|
|
||||||
}
|
}
|
||||||
|
|
||||||
@Test
|
@Test
|
||||||
|
@ -687,8 +691,10 @@ public void testConflictFreeWithSingleFile() throws Exception {
|
||||||
checkFile(theFile, "1master\n2\n3\ntopic\n");
|
checkFile(theFile, "1master\n2\n3\ntopic\n");
|
||||||
// our old branch should be checked out again
|
// our old branch should be checked out again
|
||||||
assertEquals("refs/heads/topic", db.getFullBranch());
|
assertEquals("refs/heads/topic", db.getFullBranch());
|
||||||
assertEquals(lastMasterChange, new RevWalk(db).parseCommit(
|
try (RevWalk rw = new RevWalk(db)) {
|
||||||
db.resolve(Constants.HEAD)).getParent(0));
|
assertEquals(lastMasterChange, rw.parseCommit(
|
||||||
|
db.resolve(Constants.HEAD)).getParent(0));
|
||||||
|
}
|
||||||
assertEquals(origHead, db.readOrigHead());
|
assertEquals(origHead, db.readOrigHead());
|
||||||
List<ReflogEntry> headLog = db.getReflogReader(Constants.HEAD)
|
List<ReflogEntry> headLog = db.getReflogReader(Constants.HEAD)
|
||||||
.getReverseEntries();
|
.getReverseEntries();
|
||||||
|
@ -737,8 +743,10 @@ public void testDetachedHead() throws Exception {
|
||||||
RebaseResult res = git.rebase().setUpstream("refs/heads/master").call();
|
RebaseResult res = git.rebase().setUpstream("refs/heads/master").call();
|
||||||
assertEquals(Status.OK, res.getStatus());
|
assertEquals(Status.OK, res.getStatus());
|
||||||
checkFile(theFile, "1master\n2\n3\ntopic\n");
|
checkFile(theFile, "1master\n2\n3\ntopic\n");
|
||||||
assertEquals(lastMasterChange, new RevWalk(db).parseCommit(
|
try (RevWalk rw = new RevWalk(db)) {
|
||||||
db.resolve(Constants.HEAD)).getParent(0));
|
assertEquals(lastMasterChange, rw.parseCommit(
|
||||||
|
db.resolve(Constants.HEAD)).getParent(0));
|
||||||
|
}
|
||||||
|
|
||||||
List<ReflogEntry> headLog = db.getReflogReader(Constants.HEAD)
|
List<ReflogEntry> headLog = db.getReflogReader(Constants.HEAD)
|
||||||
.getReverseEntries();
|
.getReverseEntries();
|
||||||
|
@ -785,8 +793,10 @@ public void testFilesAddedFromTwoBranches() throws Exception {
|
||||||
|
|
||||||
// our old branch should be checked out again
|
// our old branch should be checked out again
|
||||||
assertEquals("refs/heads/file3", db.getFullBranch());
|
assertEquals("refs/heads/file3", db.getFullBranch());
|
||||||
assertEquals(addFile2, new RevWalk(db).parseCommit(
|
try (RevWalk rw = new RevWalk(db)) {
|
||||||
db.resolve(Constants.HEAD)).getParent(0));
|
assertEquals(addFile2, rw.parseCommit(
|
||||||
|
db.resolve(Constants.HEAD)).getParent(0));
|
||||||
|
}
|
||||||
|
|
||||||
checkoutBranch("refs/heads/file2");
|
checkoutBranch("refs/heads/file2");
|
||||||
assertTrue(new File(db.getWorkTree(), FILE1).exists());
|
assertTrue(new File(db.getWorkTree(), FILE1).exists());
|
||||||
|
@ -846,9 +856,10 @@ public void testStopOnConflict() throws Exception {
|
||||||
assertEquals(res.getStatus(), Status.ABORTED);
|
assertEquals(res.getStatus(), Status.ABORTED);
|
||||||
assertEquals("refs/heads/topic", db.getFullBranch());
|
assertEquals("refs/heads/topic", db.getFullBranch());
|
||||||
checkFile(FILE1, "1topic", "2", "3", "topic4");
|
checkFile(FILE1, "1topic", "2", "3", "topic4");
|
||||||
RevWalk rw = new RevWalk(db);
|
try (RevWalk rw = new RevWalk(db)) {
|
||||||
assertEquals(lastTopicCommit, rw
|
assertEquals(lastTopicCommit,
|
||||||
.parseCommit(db.resolve(Constants.HEAD)));
|
rw.parseCommit(db.resolve(Constants.HEAD)));
|
||||||
|
}
|
||||||
assertEquals(RepositoryState.SAFE, db.getRepositoryState());
|
assertEquals(RepositoryState.SAFE, db.getRepositoryState());
|
||||||
|
|
||||||
// rebase- dir in .git must be deleted
|
// rebase- dir in .git must be deleted
|
||||||
|
@ -909,9 +920,10 @@ public void testStopOnConflictAndAbortWithDetachedHEAD() throws Exception {
|
||||||
assertEquals(res.getStatus(), Status.ABORTED);
|
assertEquals(res.getStatus(), Status.ABORTED);
|
||||||
assertEquals(lastTopicCommit.getName(), db.getFullBranch());
|
assertEquals(lastTopicCommit.getName(), db.getFullBranch());
|
||||||
checkFile(FILE1, "1topic", "2", "3", "topic4");
|
checkFile(FILE1, "1topic", "2", "3", "topic4");
|
||||||
RevWalk rw = new RevWalk(db);
|
try (RevWalk rw = new RevWalk(db)) {
|
||||||
assertEquals(lastTopicCommit,
|
assertEquals(lastTopicCommit,
|
||||||
rw.parseCommit(db.resolve(Constants.HEAD)));
|
rw.parseCommit(db.resolve(Constants.HEAD)));
|
||||||
|
}
|
||||||
assertEquals(RepositoryState.SAFE, db.getRepositoryState());
|
assertEquals(RepositoryState.SAFE, db.getRepositoryState());
|
||||||
|
|
||||||
// rebase- dir in .git must be deleted
|
// rebase- dir in .git must be deleted
|
||||||
|
@ -966,11 +978,12 @@ public void testStopOnConflictAndContinue() throws Exception {
|
||||||
assertEquals(RepositoryState.SAFE, db.getRepositoryState());
|
assertEquals(RepositoryState.SAFE, db.getRepositoryState());
|
||||||
|
|
||||||
ObjectId headId = db.resolve(Constants.HEAD);
|
ObjectId headId = db.resolve(Constants.HEAD);
|
||||||
RevWalk rw = new RevWalk(db);
|
try (RevWalk rw = new RevWalk(db)) {
|
||||||
RevCommit rc = rw.parseCommit(headId);
|
RevCommit rc = rw.parseCommit(headId);
|
||||||
RevCommit parent = rw.parseCommit(rc.getParent(0));
|
RevCommit parent = rw.parseCommit(rc.getParent(0));
|
||||||
assertEquals("change file1 in topic\n\nThis is conflicting", parent
|
assertEquals("change file1 in topic\n\nThis is conflicting", parent
|
||||||
.getFullMessage());
|
.getFullMessage());
|
||||||
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
@Test
|
@Test
|
||||||
|
@ -1017,9 +1030,10 @@ public void testStopOnConflictAndContinueWithNoDeltaToMaster()
|
||||||
git.rebase().setOperation(Operation.SKIP).call();
|
git.rebase().setOperation(Operation.SKIP).call();
|
||||||
|
|
||||||
ObjectId headId = db.resolve(Constants.HEAD);
|
ObjectId headId = db.resolve(Constants.HEAD);
|
||||||
RevWalk rw = new RevWalk(db);
|
try (RevWalk rw = new RevWalk(db)) {
|
||||||
RevCommit rc = rw.parseCommit(headId);
|
RevCommit rc = rw.parseCommit(headId);
|
||||||
assertEquals("change file1 in master", rc.getFullMessage());
|
assertEquals("change file1 in master", rc.getFullMessage());
|
||||||
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
@Test
|
@Test
|
||||||
|
@ -1308,10 +1322,11 @@ public void testStopOnConflictCommitAndContinue() throws Exception {
|
||||||
git.rebase().setOperation(Operation.SKIP).call();
|
git.rebase().setOperation(Operation.SKIP).call();
|
||||||
|
|
||||||
ObjectId headId = db.resolve(Constants.HEAD);
|
ObjectId headId = db.resolve(Constants.HEAD);
|
||||||
RevWalk rw = new RevWalk(db);
|
try (RevWalk rw = new RevWalk(db)) {
|
||||||
RevCommit rc = rw.parseCommit(headId);
|
RevCommit rc = rw.parseCommit(headId);
|
||||||
RevCommit parent = rw.parseCommit(rc.getParent(0));
|
RevCommit parent = rw.parseCommit(rc.getParent(0));
|
||||||
assertEquals("A different commit message", parent.getFullMessage());
|
assertEquals("A different commit message", parent.getFullMessage());
|
||||||
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
private RevCommit writeFileAndCommit(String fileName, String commitMessage,
|
private RevCommit writeFileAndCommit(String fileName, String commitMessage,
|
||||||
|
@ -1420,9 +1435,10 @@ public void testStopOnConflictFileCreationAndDeletion() throws Exception {
|
||||||
res = git.rebase().setOperation(Operation.ABORT).call();
|
res = git.rebase().setOperation(Operation.ABORT).call();
|
||||||
assertEquals(res.getStatus(), Status.ABORTED);
|
assertEquals(res.getStatus(), Status.ABORTED);
|
||||||
assertEquals("refs/heads/topic", db.getFullBranch());
|
assertEquals("refs/heads/topic", db.getFullBranch());
|
||||||
RevWalk rw = new RevWalk(db);
|
try (RevWalk rw = new RevWalk(db)) {
|
||||||
assertEquals(conflicting, rw.parseCommit(db.resolve(Constants.HEAD)));
|
assertEquals(conflicting, rw.parseCommit(db.resolve(Constants.HEAD)));
|
||||||
assertEquals(RepositoryState.SAFE, db.getRepositoryState());
|
assertEquals(RepositoryState.SAFE, db.getRepositoryState());
|
||||||
|
}
|
||||||
|
|
||||||
// rebase- dir in .git must be deleted
|
// rebase- dir in .git must be deleted
|
||||||
assertFalse(new File(db.getDirectory(), "rebase-merge").exists());
|
assertFalse(new File(db.getDirectory(), "rebase-merge").exists());
|
||||||
|
@ -2286,14 +2302,15 @@ public String modifyCommitMessage(String commit) {
|
||||||
assertEquals(RebaseResult.Status.OK, res2.getStatus());
|
assertEquals(RebaseResult.Status.OK, res2.getStatus());
|
||||||
|
|
||||||
ObjectId headId = db.resolve(Constants.HEAD);
|
ObjectId headId = db.resolve(Constants.HEAD);
|
||||||
RevWalk rw = new RevWalk(db);
|
try (RevWalk rw = new RevWalk(db)) {
|
||||||
RevCommit rc = rw.parseCommit(headId);
|
RevCommit rc = rw.parseCommit(headId);
|
||||||
|
|
||||||
ObjectId head1Id = db.resolve(Constants.HEAD + "~1");
|
ObjectId head1Id = db.resolve(Constants.HEAD + "~1");
|
||||||
RevCommit rc1 = rw.parseCommit(head1Id);
|
RevCommit rc1 = rw.parseCommit(head1Id);
|
||||||
|
|
||||||
assertEquals(rc.getFullMessage(), c4.getFullMessage());
|
assertEquals(rc.getFullMessage(), c4.getFullMessage());
|
||||||
assertEquals(rc1.getFullMessage(), c2.getFullMessage());
|
assertEquals(rc1.getFullMessage(), c2.getFullMessage());
|
||||||
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
@Test
|
@Test
|
||||||
|
@ -2643,15 +2660,16 @@ public String modifyCommitMessage(String commit) {
|
||||||
}
|
}
|
||||||
}).call();
|
}).call();
|
||||||
|
|
||||||
RevWalk walk = new RevWalk(db);
|
try (RevWalk walk = new RevWalk(db)) {
|
||||||
ObjectId headId = db.resolve(Constants.HEAD);
|
ObjectId headId = db.resolve(Constants.HEAD);
|
||||||
RevCommit headCommit = walk.parseCommit(headId);
|
RevCommit headCommit = walk.parseCommit(headId);
|
||||||
assertEquals(headCommit.getFullMessage(),
|
assertEquals(headCommit.getFullMessage(),
|
||||||
"update file2 on master\nnew line");
|
"update file2 on master\nnew line");
|
||||||
|
|
||||||
ObjectId head2Id = db.resolve(Constants.HEAD + "^1");
|
ObjectId head2Id = db.resolve(Constants.HEAD + "^1");
|
||||||
RevCommit head1Commit = walk.parseCommit(head2Id);
|
RevCommit head1Commit = walk.parseCommit(head2Id);
|
||||||
assertEquals("changed", head1Commit.getFullMessage());
|
assertEquals("changed", head1Commit.getFullMessage());
|
||||||
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
@Test
|
@Test
|
||||||
|
@ -2722,17 +2740,18 @@ public String modifyCommitMessage(String commit) {
|
||||||
}
|
}
|
||||||
}).call();
|
}).call();
|
||||||
|
|
||||||
RevWalk walk = new RevWalk(db);
|
try (RevWalk walk = new RevWalk(db)) {
|
||||||
ObjectId headId = db.resolve(Constants.HEAD);
|
ObjectId headId = db.resolve(Constants.HEAD);
|
||||||
RevCommit headCommit = walk.parseCommit(headId);
|
RevCommit headCommit = walk.parseCommit(headId);
|
||||||
assertEquals(headCommit.getFullMessage(),
|
assertEquals(headCommit.getFullMessage(),
|
||||||
"update file2 on master\nnew line");
|
"update file2 on master\nnew line");
|
||||||
|
|
||||||
ObjectId head2Id = db.resolve(Constants.HEAD + "^1");
|
ObjectId head2Id = db.resolve(Constants.HEAD + "^1");
|
||||||
RevCommit head1Commit = walk.parseCommit(head2Id);
|
RevCommit head1Commit = walk.parseCommit(head2Id);
|
||||||
assertEquals(
|
assertEquals(
|
||||||
"Add file1\nnew line\nAdd file2\nnew line\nupdated file1 on master\nnew line",
|
"Add file1\nnew line\nAdd file2\nnew line\nupdated file1 on master\nnew line",
|
||||||
head1Commit.getFullMessage());
|
head1Commit.getFullMessage());
|
||||||
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
@Test
|
@Test
|
||||||
|
@ -2804,15 +2823,16 @@ public String modifyCommitMessage(String commit) {
|
||||||
}
|
}
|
||||||
}).call();
|
}).call();
|
||||||
|
|
||||||
RevWalk walk = new RevWalk(db);
|
try (RevWalk walk = new RevWalk(db)) {
|
||||||
ObjectId headId = db.resolve(Constants.HEAD);
|
ObjectId headId = db.resolve(Constants.HEAD);
|
||||||
RevCommit headCommit = walk.parseCommit(headId);
|
RevCommit headCommit = walk.parseCommit(headId);
|
||||||
assertEquals(headCommit.getFullMessage(),
|
assertEquals(headCommit.getFullMessage(),
|
||||||
"update file2 on master\nnew line");
|
"update file2 on master\nnew line");
|
||||||
|
|
||||||
ObjectId head2Id = db.resolve(Constants.HEAD + "^1");
|
ObjectId head2Id = db.resolve(Constants.HEAD + "^1");
|
||||||
RevCommit head1Commit = walk.parseCommit(head2Id);
|
RevCommit head1Commit = walk.parseCommit(head2Id);
|
||||||
assertEquals("changed", head1Commit.getFullMessage());
|
assertEquals("changed", head1Commit.getFullMessage());
|
||||||
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
@Test
|
@Test
|
||||||
|
@ -2855,16 +2875,17 @@ public String modifyCommitMessage(String commit) {
|
||||||
}
|
}
|
||||||
}).call();
|
}).call();
|
||||||
|
|
||||||
RevWalk walk = new RevWalk(db);
|
try (RevWalk walk = new RevWalk(db)) {
|
||||||
ObjectId headId = db.resolve(Constants.HEAD);
|
ObjectId headId = db.resolve(Constants.HEAD);
|
||||||
RevCommit headCommit = walk.parseCommit(headId);
|
RevCommit headCommit = walk.parseCommit(headId);
|
||||||
assertEquals("update file2 on master\nnew line",
|
assertEquals("update file2 on master\nnew line",
|
||||||
headCommit.getFullMessage());
|
headCommit.getFullMessage());
|
||||||
|
|
||||||
ObjectId head1Id = db.resolve(Constants.HEAD + "^1");
|
ObjectId head1Id = db.resolve(Constants.HEAD + "^1");
|
||||||
RevCommit head1Commit = walk.parseCommit(head1Id);
|
RevCommit head1Commit = walk.parseCommit(head1Id);
|
||||||
assertEquals("Add file2\nnew line",
|
assertEquals("Add file2\nnew line",
|
||||||
head1Commit.getFullMessage());
|
head1Commit.getFullMessage());
|
||||||
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
@Test
|
@Test
|
||||||
|
@ -2903,11 +2924,12 @@ public String modifyCommitMessage(String commit) {
|
||||||
}
|
}
|
||||||
}).call();
|
}).call();
|
||||||
|
|
||||||
RevWalk walk = new RevWalk(db);
|
try (RevWalk walk = new RevWalk(db)) {
|
||||||
ObjectId headId = db.resolve(Constants.HEAD);
|
ObjectId headId = db.resolve(Constants.HEAD);
|
||||||
RevCommit headCommit = walk.parseCommit(headId);
|
RevCommit headCommit = walk.parseCommit(headId);
|
||||||
assertEquals("Add file2",
|
assertEquals("Add file2",
|
||||||
headCommit.getFullMessage());
|
headCommit.getFullMessage());
|
||||||
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
@Test(expected = InvalidRebaseStepException.class)
|
@Test(expected = InvalidRebaseStepException.class)
|
||||||
|
|
|
@ -58,141 +58,142 @@
|
||||||
public class BlameGeneratorTest extends RepositoryTestCase {
|
public class BlameGeneratorTest extends RepositoryTestCase {
|
||||||
@Test
|
@Test
|
||||||
public void testBoundLineDelete() throws Exception {
|
public void testBoundLineDelete() throws Exception {
|
||||||
Git git = new Git(db);
|
try (Git git = new Git(db)) {
|
||||||
|
String[] content1 = new String[] { "first", "second" };
|
||||||
|
writeTrashFile("file.txt", join(content1));
|
||||||
|
git.add().addFilepattern("file.txt").call();
|
||||||
|
RevCommit c1 = git.commit().setMessage("create file").call();
|
||||||
|
|
||||||
String[] content1 = new String[] { "first", "second" };
|
String[] content2 = new String[] { "third", "first", "second" };
|
||||||
writeTrashFile("file.txt", join(content1));
|
writeTrashFile("file.txt", join(content2));
|
||||||
git.add().addFilepattern("file.txt").call();
|
git.add().addFilepattern("file.txt").call();
|
||||||
RevCommit c1 = git.commit().setMessage("create file").call();
|
RevCommit c2 = git.commit().setMessage("create file").call();
|
||||||
|
|
||||||
String[] content2 = new String[] { "third", "first", "second" };
|
try (BlameGenerator generator = new BlameGenerator(db, "file.txt")) {
|
||||||
writeTrashFile("file.txt", join(content2));
|
generator.push(null, db.resolve(Constants.HEAD));
|
||||||
git.add().addFilepattern("file.txt").call();
|
assertEquals(3, generator.getResultContents().size());
|
||||||
RevCommit c2 = git.commit().setMessage("create file").call();
|
|
||||||
|
|
||||||
try (BlameGenerator generator = new BlameGenerator(db, "file.txt")) {
|
assertTrue(generator.next());
|
||||||
generator.push(null, db.resolve(Constants.HEAD));
|
assertEquals(c2, generator.getSourceCommit());
|
||||||
assertEquals(3, generator.getResultContents().size());
|
assertEquals(1, generator.getRegionLength());
|
||||||
|
assertEquals(0, generator.getResultStart());
|
||||||
|
assertEquals(1, generator.getResultEnd());
|
||||||
|
assertEquals(0, generator.getSourceStart());
|
||||||
|
assertEquals(1, generator.getSourceEnd());
|
||||||
|
assertEquals("file.txt", generator.getSourcePath());
|
||||||
|
|
||||||
assertTrue(generator.next());
|
assertTrue(generator.next());
|
||||||
assertEquals(c2, generator.getSourceCommit());
|
assertEquals(c1, generator.getSourceCommit());
|
||||||
assertEquals(1, generator.getRegionLength());
|
assertEquals(2, generator.getRegionLength());
|
||||||
assertEquals(0, generator.getResultStart());
|
assertEquals(1, generator.getResultStart());
|
||||||
assertEquals(1, generator.getResultEnd());
|
assertEquals(3, generator.getResultEnd());
|
||||||
assertEquals(0, generator.getSourceStart());
|
assertEquals(0, generator.getSourceStart());
|
||||||
assertEquals(1, generator.getSourceEnd());
|
assertEquals(2, generator.getSourceEnd());
|
||||||
assertEquals("file.txt", generator.getSourcePath());
|
assertEquals("file.txt", generator.getSourcePath());
|
||||||
|
|
||||||
assertTrue(generator.next());
|
assertFalse(generator.next());
|
||||||
assertEquals(c1, generator.getSourceCommit());
|
}
|
||||||
assertEquals(2, generator.getRegionLength());
|
|
||||||
assertEquals(1, generator.getResultStart());
|
|
||||||
assertEquals(3, generator.getResultEnd());
|
|
||||||
assertEquals(0, generator.getSourceStart());
|
|
||||||
assertEquals(2, generator.getSourceEnd());
|
|
||||||
assertEquals("file.txt", generator.getSourcePath());
|
|
||||||
|
|
||||||
assertFalse(generator.next());
|
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
@Test
|
@Test
|
||||||
public void testRenamedBoundLineDelete() throws Exception {
|
public void testRenamedBoundLineDelete() throws Exception {
|
||||||
Git git = new Git(db);
|
try (Git git = new Git(db)) {
|
||||||
final String FILENAME_1 = "subdir/file1.txt";
|
final String FILENAME_1 = "subdir/file1.txt";
|
||||||
final String FILENAME_2 = "subdir/file2.txt";
|
final String FILENAME_2 = "subdir/file2.txt";
|
||||||
|
|
||||||
String[] content1 = new String[] { "first", "second" };
|
String[] content1 = new String[] { "first", "second" };
|
||||||
writeTrashFile(FILENAME_1, join(content1));
|
writeTrashFile(FILENAME_1, join(content1));
|
||||||
git.add().addFilepattern(FILENAME_1).call();
|
git.add().addFilepattern(FILENAME_1).call();
|
||||||
RevCommit c1 = git.commit().setMessage("create file1").call();
|
RevCommit c1 = git.commit().setMessage("create file1").call();
|
||||||
|
|
||||||
// rename it
|
// rename it
|
||||||
writeTrashFile(FILENAME_2, join(content1));
|
writeTrashFile(FILENAME_2, join(content1));
|
||||||
git.add().addFilepattern(FILENAME_2).call();
|
git.add().addFilepattern(FILENAME_2).call();
|
||||||
deleteTrashFile(FILENAME_1);
|
deleteTrashFile(FILENAME_1);
|
||||||
git.rm().addFilepattern(FILENAME_1).call();
|
git.rm().addFilepattern(FILENAME_1).call();
|
||||||
git.commit().setMessage("rename file1.txt to file2.txt").call();
|
git.commit().setMessage("rename file1.txt to file2.txt").call();
|
||||||
|
|
||||||
// and change the new file
|
// and change the new file
|
||||||
String[] content2 = new String[] { "third", "first", "second" };
|
String[] content2 = new String[] { "third", "first", "second" };
|
||||||
writeTrashFile(FILENAME_2, join(content2));
|
writeTrashFile(FILENAME_2, join(content2));
|
||||||
git.add().addFilepattern(FILENAME_2).call();
|
git.add().addFilepattern(FILENAME_2).call();
|
||||||
RevCommit c2 = git.commit().setMessage("change file2").call();
|
RevCommit c2 = git.commit().setMessage("change file2").call();
|
||||||
|
|
||||||
try (BlameGenerator generator = new BlameGenerator(db, FILENAME_2)) {
|
try (BlameGenerator generator = new BlameGenerator(db, FILENAME_2)) {
|
||||||
generator.push(null, db.resolve(Constants.HEAD));
|
generator.push(null, db.resolve(Constants.HEAD));
|
||||||
assertEquals(3, generator.getResultContents().size());
|
assertEquals(3, generator.getResultContents().size());
|
||||||
|
|
||||||
assertTrue(generator.next());
|
assertTrue(generator.next());
|
||||||
assertEquals(c2, generator.getSourceCommit());
|
assertEquals(c2, generator.getSourceCommit());
|
||||||
assertEquals(1, generator.getRegionLength());
|
assertEquals(1, generator.getRegionLength());
|
||||||
assertEquals(0, generator.getResultStart());
|
assertEquals(0, generator.getResultStart());
|
||||||
assertEquals(1, generator.getResultEnd());
|
assertEquals(1, generator.getResultEnd());
|
||||||
assertEquals(0, generator.getSourceStart());
|
assertEquals(0, generator.getSourceStart());
|
||||||
assertEquals(1, generator.getSourceEnd());
|
assertEquals(1, generator.getSourceEnd());
|
||||||
assertEquals(FILENAME_2, generator.getSourcePath());
|
assertEquals(FILENAME_2, generator.getSourcePath());
|
||||||
|
|
||||||
assertTrue(generator.next());
|
assertTrue(generator.next());
|
||||||
assertEquals(c1, generator.getSourceCommit());
|
assertEquals(c1, generator.getSourceCommit());
|
||||||
assertEquals(2, generator.getRegionLength());
|
assertEquals(2, generator.getRegionLength());
|
||||||
assertEquals(1, generator.getResultStart());
|
assertEquals(1, generator.getResultStart());
|
||||||
assertEquals(3, generator.getResultEnd());
|
assertEquals(3, generator.getResultEnd());
|
||||||
assertEquals(0, generator.getSourceStart());
|
assertEquals(0, generator.getSourceStart());
|
||||||
assertEquals(2, generator.getSourceEnd());
|
assertEquals(2, generator.getSourceEnd());
|
||||||
assertEquals(FILENAME_1, generator.getSourcePath());
|
assertEquals(FILENAME_1, generator.getSourcePath());
|
||||||
|
|
||||||
assertFalse(generator.next());
|
assertFalse(generator.next());
|
||||||
}
|
}
|
||||||
|
|
||||||
// and test again with other BlameGenerator API:
|
// and test again with other BlameGenerator API:
|
||||||
try (BlameGenerator generator = new BlameGenerator(db, FILENAME_2)) {
|
try (BlameGenerator generator = new BlameGenerator(db, FILENAME_2)) {
|
||||||
generator.push(null, db.resolve(Constants.HEAD));
|
generator.push(null, db.resolve(Constants.HEAD));
|
||||||
BlameResult result = generator.computeBlameResult();
|
BlameResult result = generator.computeBlameResult();
|
||||||
|
|
||||||
assertEquals(3, result.getResultContents().size());
|
assertEquals(3, result.getResultContents().size());
|
||||||
|
|
||||||
assertEquals(c2, result.getSourceCommit(0));
|
assertEquals(c2, result.getSourceCommit(0));
|
||||||
assertEquals(FILENAME_2, result.getSourcePath(0));
|
assertEquals(FILENAME_2, result.getSourcePath(0));
|
||||||
|
|
||||||
assertEquals(c1, result.getSourceCommit(1));
|
assertEquals(c1, result.getSourceCommit(1));
|
||||||
assertEquals(FILENAME_1, result.getSourcePath(1));
|
assertEquals(FILENAME_1, result.getSourcePath(1));
|
||||||
|
|
||||||
assertEquals(c1, result.getSourceCommit(2));
|
assertEquals(c1, result.getSourceCommit(2));
|
||||||
assertEquals(FILENAME_1, result.getSourcePath(2));
|
assertEquals(FILENAME_1, result.getSourcePath(2));
|
||||||
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
@Test
|
@Test
|
||||||
public void testLinesAllDeletedShortenedWalk() throws Exception {
|
public void testLinesAllDeletedShortenedWalk() throws Exception {
|
||||||
Git git = new Git(db);
|
try (Git git = new Git(db)) {
|
||||||
|
String[] content1 = new String[] { "first", "second", "third" };
|
||||||
|
|
||||||
String[] content1 = new String[] { "first", "second", "third" };
|
writeTrashFile("file.txt", join(content1));
|
||||||
|
git.add().addFilepattern("file.txt").call();
|
||||||
|
git.commit().setMessage("create file").call();
|
||||||
|
|
||||||
writeTrashFile("file.txt", join(content1));
|
String[] content2 = new String[] { "" };
|
||||||
git.add().addFilepattern("file.txt").call();
|
|
||||||
git.commit().setMessage("create file").call();
|
|
||||||
|
|
||||||
String[] content2 = new String[] { "" };
|
writeTrashFile("file.txt", join(content2));
|
||||||
|
git.add().addFilepattern("file.txt").call();
|
||||||
|
git.commit().setMessage("create file").call();
|
||||||
|
|
||||||
writeTrashFile("file.txt", join(content2));
|
writeTrashFile("file.txt", join(content1));
|
||||||
git.add().addFilepattern("file.txt").call();
|
git.add().addFilepattern("file.txt").call();
|
||||||
git.commit().setMessage("create file").call();
|
RevCommit c3 = git.commit().setMessage("create file").call();
|
||||||
|
|
||||||
writeTrashFile("file.txt", join(content1));
|
try (BlameGenerator generator = new BlameGenerator(db, "file.txt")) {
|
||||||
git.add().addFilepattern("file.txt").call();
|
generator.push(null, db.resolve(Constants.HEAD));
|
||||||
RevCommit c3 = git.commit().setMessage("create file").call();
|
assertEquals(3, generator.getResultContents().size());
|
||||||
|
|
||||||
try (BlameGenerator generator = new BlameGenerator(db, "file.txt")) {
|
assertTrue(generator.next());
|
||||||
generator.push(null, db.resolve(Constants.HEAD));
|
assertEquals(c3, generator.getSourceCommit());
|
||||||
assertEquals(3, generator.getResultContents().size());
|
assertEquals(0, generator.getResultStart());
|
||||||
|
assertEquals(3, generator.getResultEnd());
|
||||||
|
|
||||||
assertTrue(generator.next());
|
assertFalse(generator.next());
|
||||||
assertEquals(c3, generator.getSourceCommit());
|
}
|
||||||
assertEquals(0, generator.getResultStart());
|
|
||||||
assertEquals(3, generator.getResultEnd());
|
|
||||||
|
|
||||||
assertFalse(generator.next());
|
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
|
@ -77,260 +77,268 @@ public class DiffEntryTest extends RepositoryTestCase {
|
||||||
public void shouldListAddedFileInInitialCommit() throws Exception {
|
public void shouldListAddedFileInInitialCommit() throws Exception {
|
||||||
// given
|
// given
|
||||||
writeTrashFile("a.txt", "content");
|
writeTrashFile("a.txt", "content");
|
||||||
Git git = new Git(db);
|
try (Git git = new Git(db);
|
||||||
git.add().addFilepattern("a.txt").call();
|
TreeWalk walk = new TreeWalk(db)) {
|
||||||
RevCommit c = git.commit().setMessage("initial commit").call();
|
git.add().addFilepattern("a.txt").call();
|
||||||
|
RevCommit c = git.commit().setMessage("initial commit").call();
|
||||||
|
|
||||||
// when
|
// when
|
||||||
TreeWalk walk = new TreeWalk(db);
|
walk.addTree(new EmptyTreeIterator());
|
||||||
walk.addTree(new EmptyTreeIterator());
|
walk.addTree(c.getTree());
|
||||||
walk.addTree(c.getTree());
|
List<DiffEntry> result = DiffEntry.scan(walk);
|
||||||
List<DiffEntry> result = DiffEntry.scan(walk);
|
|
||||||
|
|
||||||
// then
|
// then
|
||||||
assertThat(result, notNullValue());
|
assertThat(result, notNullValue());
|
||||||
assertThat(Integer.valueOf(result.size()), is(Integer.valueOf(1)));
|
assertThat(Integer.valueOf(result.size()), is(Integer.valueOf(1)));
|
||||||
|
|
||||||
DiffEntry entry = result.get(0);
|
DiffEntry entry = result.get(0);
|
||||||
assertThat(entry.getChangeType(), is(ChangeType.ADD));
|
assertThat(entry.getChangeType(), is(ChangeType.ADD));
|
||||||
assertThat(entry.getNewPath(), is("a.txt"));
|
assertThat(entry.getNewPath(), is("a.txt"));
|
||||||
assertThat(entry.getOldPath(), is(DEV_NULL));
|
assertThat(entry.getOldPath(), is(DEV_NULL));
|
||||||
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
@Test
|
@Test
|
||||||
public void shouldListAddedFileBetweenTwoCommits() throws Exception {
|
public void shouldListAddedFileBetweenTwoCommits() throws Exception {
|
||||||
// given
|
// given
|
||||||
Git git = new Git(db);
|
try (Git git = new Git(db);
|
||||||
RevCommit c1 = git.commit().setMessage("initial commit").call();
|
TreeWalk walk = new TreeWalk(db)) {
|
||||||
writeTrashFile("a.txt", "content");
|
RevCommit c1 = git.commit().setMessage("initial commit").call();
|
||||||
git.add().addFilepattern("a.txt").call();
|
writeTrashFile("a.txt", "content");
|
||||||
RevCommit c2 = git.commit().setMessage("second commit").call();
|
git.add().addFilepattern("a.txt").call();
|
||||||
|
RevCommit c2 = git.commit().setMessage("second commit").call();
|
||||||
|
|
||||||
// when
|
// when
|
||||||
TreeWalk walk = new TreeWalk(db);
|
walk.addTree(c1.getTree());
|
||||||
walk.addTree(c1.getTree());
|
walk.addTree(c2.getTree());
|
||||||
walk.addTree(c2.getTree());
|
List<DiffEntry> result = DiffEntry.scan(walk);
|
||||||
List<DiffEntry> result = DiffEntry.scan(walk);
|
|
||||||
|
|
||||||
// then
|
// then
|
||||||
assertThat(result, notNullValue());
|
assertThat(result, notNullValue());
|
||||||
assertThat(Integer.valueOf(result.size()), is(Integer.valueOf(1)));
|
assertThat(Integer.valueOf(result.size()), is(Integer.valueOf(1)));
|
||||||
|
|
||||||
DiffEntry entry = result.get(0);
|
DiffEntry entry = result.get(0);
|
||||||
assertThat(entry.getChangeType(), is(ChangeType.ADD));
|
assertThat(entry.getChangeType(), is(ChangeType.ADD));
|
||||||
assertThat(entry.getNewPath(), is("a.txt"));
|
assertThat(entry.getNewPath(), is("a.txt"));
|
||||||
assertThat(entry.getOldPath(), is(DEV_NULL));
|
assertThat(entry.getOldPath(), is(DEV_NULL));
|
||||||
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
@Test
|
@Test
|
||||||
public void shouldListModificationBetweenTwoCommits() throws Exception {
|
public void shouldListModificationBetweenTwoCommits() throws Exception {
|
||||||
// given
|
// given
|
||||||
Git git = new Git(db);
|
try (Git git = new Git(db);
|
||||||
File file = writeTrashFile("a.txt", "content");
|
TreeWalk walk = new TreeWalk(db)) {
|
||||||
git.add().addFilepattern("a.txt").call();
|
File file = writeTrashFile("a.txt", "content");
|
||||||
RevCommit c1 = git.commit().setMessage("initial commit").call();
|
git.add().addFilepattern("a.txt").call();
|
||||||
write(file, "new content");
|
RevCommit c1 = git.commit().setMessage("initial commit").call();
|
||||||
RevCommit c2 = git.commit().setAll(true).setMessage("second commit")
|
write(file, "new content");
|
||||||
.call();
|
RevCommit c2 = git.commit().setAll(true).setMessage("second commit")
|
||||||
|
.call();
|
||||||
|
|
||||||
// when
|
// when
|
||||||
TreeWalk walk = new TreeWalk(db);
|
walk.addTree(c1.getTree());
|
||||||
walk.addTree(c1.getTree());
|
walk.addTree(c2.getTree());
|
||||||
walk.addTree(c2.getTree());
|
List<DiffEntry> result = DiffEntry.scan(walk);
|
||||||
List<DiffEntry> result = DiffEntry.scan(walk);
|
|
||||||
|
|
||||||
// then
|
// then
|
||||||
assertThat(result, notNullValue());
|
assertThat(result, notNullValue());
|
||||||
assertThat(Integer.valueOf(result.size()), is(Integer.valueOf(1)));
|
assertThat(Integer.valueOf(result.size()), is(Integer.valueOf(1)));
|
||||||
|
|
||||||
DiffEntry entry = result.get(0);
|
DiffEntry entry = result.get(0);
|
||||||
assertThat(entry.getChangeType(), is(ChangeType.MODIFY));
|
assertThat(entry.getChangeType(), is(ChangeType.MODIFY));
|
||||||
assertThat(entry.getNewPath(), is("a.txt"));
|
assertThat(entry.getNewPath(), is("a.txt"));
|
||||||
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
@Test
|
@Test
|
||||||
public void shouldListDeletionBetweenTwoCommits() throws Exception {
|
public void shouldListDeletionBetweenTwoCommits() throws Exception {
|
||||||
// given
|
// given
|
||||||
Git git = new Git(db);
|
try (Git git = new Git(db);
|
||||||
File file = writeTrashFile("a.txt", "content");
|
TreeWalk walk = new TreeWalk(db)) {
|
||||||
git.add().addFilepattern("a.txt").call();
|
File file = writeTrashFile("a.txt", "content");
|
||||||
RevCommit c1 = git.commit().setMessage("initial commit").call();
|
git.add().addFilepattern("a.txt").call();
|
||||||
delete(file);
|
RevCommit c1 = git.commit().setMessage("initial commit").call();
|
||||||
RevCommit c2 = git.commit().setAll(true).setMessage("delete a.txt")
|
delete(file);
|
||||||
.call();
|
RevCommit c2 = git.commit().setAll(true).setMessage("delete a.txt")
|
||||||
|
.call();
|
||||||
|
|
||||||
// when
|
// when
|
||||||
TreeWalk walk = new TreeWalk(db);
|
walk.addTree(c1.getTree());
|
||||||
walk.addTree(c1.getTree());
|
walk.addTree(c2.getTree());
|
||||||
walk.addTree(c2.getTree());
|
List<DiffEntry> result = DiffEntry.scan(walk);
|
||||||
List<DiffEntry> result = DiffEntry.scan(walk);
|
|
||||||
|
|
||||||
// then
|
// then
|
||||||
assertThat(result, notNullValue());
|
assertThat(result, notNullValue());
|
||||||
assertThat(Integer.valueOf(result.size()), is(Integer.valueOf(1)));
|
assertThat(Integer.valueOf(result.size()), is(Integer.valueOf(1)));
|
||||||
|
|
||||||
DiffEntry entry = result.get(0);
|
DiffEntry entry = result.get(0);
|
||||||
assertThat(entry.getOldPath(), is("a.txt"));
|
assertThat(entry.getOldPath(), is("a.txt"));
|
||||||
assertThat(entry.getNewPath(), is(DEV_NULL));
|
assertThat(entry.getNewPath(), is(DEV_NULL));
|
||||||
assertThat(entry.getChangeType(), is(ChangeType.DELETE));
|
assertThat(entry.getChangeType(), is(ChangeType.DELETE));
|
||||||
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
@Test
|
@Test
|
||||||
public void shouldListModificationInDirWithoutModifiedTrees()
|
public void shouldListModificationInDirWithoutModifiedTrees()
|
||||||
throws Exception {
|
throws Exception {
|
||||||
// given
|
// given
|
||||||
Git git = new Git(db);
|
try (Git git = new Git(db);
|
||||||
File tree = new File(new File(db.getWorkTree(), "a"), "b");
|
TreeWalk walk = new TreeWalk(db)) {
|
||||||
FileUtils.mkdirs(tree);
|
File tree = new File(new File(db.getWorkTree(), "a"), "b");
|
||||||
File file = new File(tree, "c.txt");
|
FileUtils.mkdirs(tree);
|
||||||
FileUtils.createNewFile(file);
|
File file = new File(tree, "c.txt");
|
||||||
write(file, "content");
|
FileUtils.createNewFile(file);
|
||||||
git.add().addFilepattern("a").call();
|
write(file, "content");
|
||||||
RevCommit c1 = git.commit().setMessage("initial commit").call();
|
git.add().addFilepattern("a").call();
|
||||||
write(file, "new line");
|
RevCommit c1 = git.commit().setMessage("initial commit").call();
|
||||||
RevCommit c2 = git.commit().setAll(true).setMessage("second commit")
|
write(file, "new line");
|
||||||
.call();
|
RevCommit c2 = git.commit().setAll(true).setMessage("second commit")
|
||||||
|
.call();
|
||||||
|
|
||||||
// when
|
// when
|
||||||
TreeWalk walk = new TreeWalk(db);
|
walk.addTree(c1.getTree());
|
||||||
walk.addTree(c1.getTree());
|
walk.addTree(c2.getTree());
|
||||||
walk.addTree(c2.getTree());
|
walk.setRecursive(true);
|
||||||
walk.setRecursive(true);
|
List<DiffEntry> result = DiffEntry.scan(walk);
|
||||||
List<DiffEntry> result = DiffEntry.scan(walk);
|
|
||||||
|
|
||||||
// then
|
// then
|
||||||
assertThat(result, notNullValue());
|
assertThat(result, notNullValue());
|
||||||
assertThat(Integer.valueOf(result.size()), is(Integer.valueOf(1)));
|
assertThat(Integer.valueOf(result.size()), is(Integer.valueOf(1)));
|
||||||
|
|
||||||
DiffEntry entry = result.get(0);
|
DiffEntry entry = result.get(0);
|
||||||
assertThat(entry.getChangeType(), is(ChangeType.MODIFY));
|
assertThat(entry.getChangeType(), is(ChangeType.MODIFY));
|
||||||
assertThat(entry.getNewPath(), is("a/b/c.txt"));
|
assertThat(entry.getNewPath(), is("a/b/c.txt"));
|
||||||
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
@Test
|
@Test
|
||||||
public void shouldListModificationInDirWithModifiedTrees() throws Exception {
|
public void shouldListModificationInDirWithModifiedTrees() throws Exception {
|
||||||
// given
|
// given
|
||||||
Git git = new Git(db);
|
try (Git git = new Git(db);
|
||||||
File tree = new File(new File(db.getWorkTree(), "a"), "b");
|
TreeWalk walk = new TreeWalk(db)) {
|
||||||
FileUtils.mkdirs(tree);
|
File tree = new File(new File(db.getWorkTree(), "a"), "b");
|
||||||
File file = new File(tree, "c.txt");
|
FileUtils.mkdirs(tree);
|
||||||
FileUtils.createNewFile(file);
|
File file = new File(tree, "c.txt");
|
||||||
write(file, "content");
|
FileUtils.createNewFile(file);
|
||||||
git.add().addFilepattern("a").call();
|
write(file, "content");
|
||||||
RevCommit c1 = git.commit().setMessage("initial commit").call();
|
git.add().addFilepattern("a").call();
|
||||||
write(file, "new line");
|
RevCommit c1 = git.commit().setMessage("initial commit").call();
|
||||||
RevCommit c2 = git.commit().setAll(true).setMessage("second commit")
|
write(file, "new line");
|
||||||
.call();
|
RevCommit c2 = git.commit().setAll(true).setMessage("second commit")
|
||||||
|
.call();
|
||||||
|
|
||||||
// when
|
// when
|
||||||
TreeWalk walk = new TreeWalk(db);
|
walk.addTree(c1.getTree());
|
||||||
walk.addTree(c1.getTree());
|
walk.addTree(c2.getTree());
|
||||||
walk.addTree(c2.getTree());
|
List<DiffEntry> result = DiffEntry.scan(walk, true);
|
||||||
List<DiffEntry> result = DiffEntry.scan(walk, true);
|
|
||||||
|
|
||||||
// then
|
// then
|
||||||
assertThat(result, notNullValue());
|
assertThat(result, notNullValue());
|
||||||
assertThat(Integer.valueOf(result.size()), is(Integer.valueOf(3)));
|
assertThat(Integer.valueOf(result.size()), is(Integer.valueOf(3)));
|
||||||
|
|
||||||
DiffEntry entry = result.get(0);
|
DiffEntry entry = result.get(0);
|
||||||
assertThat(entry.getChangeType(), is(ChangeType.MODIFY));
|
assertThat(entry.getChangeType(), is(ChangeType.MODIFY));
|
||||||
assertThat(entry.getNewPath(), is("a"));
|
assertThat(entry.getNewPath(), is("a"));
|
||||||
|
|
||||||
entry = result.get(1);
|
entry = result.get(1);
|
||||||
assertThat(entry.getChangeType(), is(ChangeType.MODIFY));
|
assertThat(entry.getChangeType(), is(ChangeType.MODIFY));
|
||||||
assertThat(entry.getNewPath(), is("a/b"));
|
assertThat(entry.getNewPath(), is("a/b"));
|
||||||
|
|
||||||
entry = result.get(2);
|
entry = result.get(2);
|
||||||
assertThat(entry.getChangeType(), is(ChangeType.MODIFY));
|
assertThat(entry.getChangeType(), is(ChangeType.MODIFY));
|
||||||
assertThat(entry.getNewPath(), is("a/b/c.txt"));
|
assertThat(entry.getNewPath(), is("a/b/c.txt"));
|
||||||
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
@Test
|
@Test
|
||||||
public void shouldListChangesInWorkingTree() throws Exception {
|
public void shouldListChangesInWorkingTree() throws Exception {
|
||||||
// given
|
// given
|
||||||
writeTrashFile("a.txt", "content");
|
writeTrashFile("a.txt", "content");
|
||||||
Git git = new Git(db);
|
try (Git git = new Git(db);
|
||||||
git.add().addFilepattern("a.txt").call();
|
TreeWalk walk = new TreeWalk(db)) {
|
||||||
RevCommit c = git.commit().setMessage("initial commit").call();
|
git.add().addFilepattern("a.txt").call();
|
||||||
writeTrashFile("b.txt", "new line");
|
RevCommit c = git.commit().setMessage("initial commit").call();
|
||||||
|
writeTrashFile("b.txt", "new line");
|
||||||
|
|
||||||
// when
|
// when
|
||||||
TreeWalk walk = new TreeWalk(db);
|
walk.addTree(c.getTree());
|
||||||
walk.addTree(c.getTree());
|
walk.addTree(new FileTreeIterator(db));
|
||||||
walk.addTree(new FileTreeIterator(db));
|
List<DiffEntry> result = DiffEntry.scan(walk, true);
|
||||||
List<DiffEntry> result = DiffEntry.scan(walk, true);
|
|
||||||
|
|
||||||
// then
|
// then
|
||||||
assertThat(Integer.valueOf(result.size()), is(Integer.valueOf(1)));
|
assertThat(Integer.valueOf(result.size()), is(Integer.valueOf(1)));
|
||||||
DiffEntry entry = result.get(0);
|
DiffEntry entry = result.get(0);
|
||||||
|
|
||||||
assertThat(entry.getChangeType(), is(ChangeType.ADD));
|
assertThat(entry.getChangeType(), is(ChangeType.ADD));
|
||||||
assertThat(entry.getNewPath(), is("b.txt"));
|
assertThat(entry.getNewPath(), is("b.txt"));
|
||||||
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
@Test
|
@Test
|
||||||
public void shouldMarkEntriesWhenGivenMarkTreeFilter() throws Exception {
|
public void shouldMarkEntriesWhenGivenMarkTreeFilter() throws Exception {
|
||||||
// given
|
// given
|
||||||
Git git = new Git(db);
|
try (Git git = new Git(db);
|
||||||
RevCommit c1 = git.commit().setMessage("initial commit").call();
|
TreeWalk walk = new TreeWalk(db)) {
|
||||||
FileUtils.mkdir(new File(db.getWorkTree(), "b"));
|
RevCommit c1 = git.commit().setMessage("initial commit").call();
|
||||||
writeTrashFile("a.txt", "a");
|
FileUtils.mkdir(new File(db.getWorkTree(), "b"));
|
||||||
writeTrashFile("b/1.txt", "b1");
|
writeTrashFile("a.txt", "a");
|
||||||
writeTrashFile("b/2.txt", "b2");
|
writeTrashFile("b/1.txt", "b1");
|
||||||
writeTrashFile("c.txt", "c");
|
writeTrashFile("b/2.txt", "b2");
|
||||||
git.add().addFilepattern("a.txt").addFilepattern("b")
|
writeTrashFile("c.txt", "c");
|
||||||
.addFilepattern("c.txt").call();
|
git.add().addFilepattern("a.txt").addFilepattern("b")
|
||||||
RevCommit c2 = git.commit().setMessage("second commit").call();
|
.addFilepattern("c.txt").call();
|
||||||
TreeFilter filterA = PathFilterGroup.createFromStrings("a.txt");
|
RevCommit c2 = git.commit().setMessage("second commit").call();
|
||||||
TreeFilter filterB = PathFilterGroup.createFromStrings("b");
|
TreeFilter filterA = PathFilterGroup.createFromStrings("a.txt");
|
||||||
TreeFilter filterB2 = PathFilterGroup.createFromStrings("b/2.txt");
|
TreeFilter filterB = PathFilterGroup.createFromStrings("b");
|
||||||
|
TreeFilter filterB2 = PathFilterGroup.createFromStrings("b/2.txt");
|
||||||
|
|
||||||
// when
|
// when
|
||||||
TreeWalk walk = new TreeWalk(db);
|
walk.addTree(c1.getTree());
|
||||||
walk.addTree(c1.getTree());
|
walk.addTree(c2.getTree());
|
||||||
walk.addTree(c2.getTree());
|
List<DiffEntry> result = DiffEntry.scan(walk, true, new TreeFilter[] {
|
||||||
List<DiffEntry> result = DiffEntry.scan(walk, true, new TreeFilter[] {
|
filterA, filterB, filterB2 });
|
||||||
filterA, filterB, filterB2 });
|
|
||||||
|
|
||||||
// then
|
// then
|
||||||
assertThat(result, notNullValue());
|
assertThat(result, notNullValue());
|
||||||
assertEquals(5, result.size());
|
assertEquals(5, result.size());
|
||||||
|
|
||||||
DiffEntry entryA = result.get(0);
|
DiffEntry entryA = result.get(0);
|
||||||
DiffEntry entryB = result.get(1);
|
DiffEntry entryB = result.get(1);
|
||||||
DiffEntry entryB1 = result.get(2);
|
DiffEntry entryB1 = result.get(2);
|
||||||
DiffEntry entryB2 = result.get(3);
|
DiffEntry entryB2 = result.get(3);
|
||||||
DiffEntry entryC = result.get(4);
|
DiffEntry entryC = result.get(4);
|
||||||
|
|
||||||
assertThat(entryA.getNewPath(), is("a.txt"));
|
assertThat(entryA.getNewPath(), is("a.txt"));
|
||||||
assertTrue(entryA.isMarked(0));
|
assertTrue(entryA.isMarked(0));
|
||||||
assertFalse(entryA.isMarked(1));
|
assertFalse(entryA.isMarked(1));
|
||||||
assertFalse(entryA.isMarked(2));
|
assertFalse(entryA.isMarked(2));
|
||||||
assertEquals(1, entryA.getTreeFilterMarks());
|
assertEquals(1, entryA.getTreeFilterMarks());
|
||||||
|
|
||||||
assertThat(entryB.getNewPath(), is("b"));
|
assertThat(entryB.getNewPath(), is("b"));
|
||||||
assertFalse(entryB.isMarked(0));
|
assertFalse(entryB.isMarked(0));
|
||||||
assertTrue(entryB.isMarked(1));
|
assertTrue(entryB.isMarked(1));
|
||||||
assertTrue(entryB.isMarked(2));
|
assertTrue(entryB.isMarked(2));
|
||||||
assertEquals(6, entryB.getTreeFilterMarks());
|
assertEquals(6, entryB.getTreeFilterMarks());
|
||||||
|
|
||||||
assertThat(entryB1.getNewPath(), is("b/1.txt"));
|
assertThat(entryB1.getNewPath(), is("b/1.txt"));
|
||||||
assertFalse(entryB1.isMarked(0));
|
assertFalse(entryB1.isMarked(0));
|
||||||
assertTrue(entryB1.isMarked(1));
|
assertTrue(entryB1.isMarked(1));
|
||||||
assertFalse(entryB1.isMarked(2));
|
assertFalse(entryB1.isMarked(2));
|
||||||
assertEquals(2, entryB1.getTreeFilterMarks());
|
assertEquals(2, entryB1.getTreeFilterMarks());
|
||||||
|
|
||||||
assertThat(entryB2.getNewPath(), is("b/2.txt"));
|
assertThat(entryB2.getNewPath(), is("b/2.txt"));
|
||||||
assertFalse(entryB2.isMarked(0));
|
assertFalse(entryB2.isMarked(0));
|
||||||
assertTrue(entryB2.isMarked(1));
|
assertTrue(entryB2.isMarked(1));
|
||||||
assertTrue(entryB2.isMarked(2));
|
assertTrue(entryB2.isMarked(2));
|
||||||
assertEquals(6, entryB2.getTreeFilterMarks());
|
assertEquals(6, entryB2.getTreeFilterMarks());
|
||||||
|
|
||||||
assertThat(entryC.getNewPath(), is("c.txt"));
|
assertThat(entryC.getNewPath(), is("c.txt"));
|
||||||
assertFalse(entryC.isMarked(0));
|
assertFalse(entryC.isMarked(0));
|
||||||
assertFalse(entryC.isMarked(1));
|
assertFalse(entryC.isMarked(1));
|
||||||
assertFalse(entryC.isMarked(2));
|
assertFalse(entryC.isMarked(2));
|
||||||
assertEquals(0, entryC.getTreeFilterMarks());
|
assertEquals(0, entryC.getTreeFilterMarks());
|
||||||
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
@Test(expected = IllegalArgumentException.class)
|
@Test(expected = IllegalArgumentException.class)
|
||||||
|
@ -339,9 +347,10 @@ public void shouldThrowIAEWhenTreeWalkHasLessThanTwoTrees()
|
||||||
// given - we don't need anything here
|
// given - we don't need anything here
|
||||||
|
|
||||||
// when
|
// when
|
||||||
TreeWalk walk = new TreeWalk(db);
|
try (TreeWalk walk = new TreeWalk(db)) {
|
||||||
walk.addTree(new EmptyTreeIterator());
|
walk.addTree(new EmptyTreeIterator());
|
||||||
DiffEntry.scan(walk);
|
DiffEntry.scan(walk);
|
||||||
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
@Test(expected = IllegalArgumentException.class)
|
@Test(expected = IllegalArgumentException.class)
|
||||||
|
@ -350,11 +359,12 @@ public void shouldThrowIAEWhenTreeWalkHasMoreThanTwoTrees()
|
||||||
// given - we don't need anything here
|
// given - we don't need anything here
|
||||||
|
|
||||||
// when
|
// when
|
||||||
TreeWalk walk = new TreeWalk(db);
|
try (TreeWalk walk = new TreeWalk(db)) {
|
||||||
walk.addTree(new EmptyTreeIterator());
|
walk.addTree(new EmptyTreeIterator());
|
||||||
walk.addTree(new EmptyTreeIterator());
|
walk.addTree(new EmptyTreeIterator());
|
||||||
walk.addTree(new EmptyTreeIterator());
|
walk.addTree(new EmptyTreeIterator());
|
||||||
DiffEntry.scan(walk);
|
DiffEntry.scan(walk);
|
||||||
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
@Test(expected = IllegalArgumentException.class)
|
@Test(expected = IllegalArgumentException.class)
|
||||||
|
@ -363,46 +373,47 @@ public void shouldThrowIAEWhenScanShouldIncludeTreesAndWalkIsRecursive()
|
||||||
// given - we don't need anything here
|
// given - we don't need anything here
|
||||||
|
|
||||||
// when
|
// when
|
||||||
TreeWalk walk = new TreeWalk(db);
|
try (TreeWalk walk = new TreeWalk(db)) {
|
||||||
walk.addTree(new EmptyTreeIterator());
|
walk.addTree(new EmptyTreeIterator());
|
||||||
walk.addTree(new EmptyTreeIterator());
|
walk.addTree(new EmptyTreeIterator());
|
||||||
walk.setRecursive(true);
|
walk.setRecursive(true);
|
||||||
DiffEntry.scan(walk, true);
|
DiffEntry.scan(walk, true);
|
||||||
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
@Test
|
@Test
|
||||||
public void shouldReportFileModeChange() throws Exception {
|
public void shouldReportFileModeChange() throws Exception {
|
||||||
writeTrashFile("a.txt", "content");
|
writeTrashFile("a.txt", "content");
|
||||||
Git git = new Git(db);
|
try (Git git = new Git(db);
|
||||||
git.add().addFilepattern("a.txt").call();
|
TreeWalk walk = new TreeWalk(db)) {
|
||||||
RevCommit c1 = git.commit().setMessage("initial commit").call();
|
git.add().addFilepattern("a.txt").call();
|
||||||
DirCache cache = db.lockDirCache();
|
RevCommit c1 = git.commit().setMessage("initial commit").call();
|
||||||
DirCacheEditor editor = cache.editor();
|
DirCache cache = db.lockDirCache();
|
||||||
final TreeWalk walk = new TreeWalk(db);
|
DirCacheEditor editor = cache.editor();
|
||||||
walk.addTree(c1.getTree());
|
walk.addTree(c1.getTree());
|
||||||
walk.setRecursive(true);
|
walk.setRecursive(true);
|
||||||
assertTrue(walk.next());
|
assertTrue(walk.next());
|
||||||
|
|
||||||
editor.add(new PathEdit("a.txt") {
|
editor.add(new PathEdit("a.txt") {
|
||||||
|
public void apply(DirCacheEntry ent) {
|
||||||
public void apply(DirCacheEntry ent) {
|
ent.setFileMode(FileMode.EXECUTABLE_FILE);
|
||||||
ent.setFileMode(FileMode.EXECUTABLE_FILE);
|
ent.setObjectId(walk.getObjectId(0));
|
||||||
ent.setObjectId(walk.getObjectId(0));
|
}
|
||||||
}
|
});
|
||||||
});
|
assertTrue(editor.commit());
|
||||||
assertTrue(editor.commit());
|
RevCommit c2 = git.commit().setMessage("second commit").call();
|
||||||
RevCommit c2 = git.commit().setMessage("second commit").call();
|
walk.reset();
|
||||||
walk.reset();
|
walk.addTree(c1.getTree());
|
||||||
walk.addTree(c1.getTree());
|
walk.addTree(c2.getTree());
|
||||||
walk.addTree(c2.getTree());
|
List<DiffEntry> diffs = DiffEntry.scan(walk, false);
|
||||||
List<DiffEntry> diffs = DiffEntry.scan(walk, false);
|
assertEquals(1, diffs.size());
|
||||||
assertEquals(1, diffs.size());
|
DiffEntry diff = diffs.get(0);
|
||||||
DiffEntry diff = diffs.get(0);
|
assertEquals(ChangeType.MODIFY,diff.getChangeType());
|
||||||
assertEquals(ChangeType.MODIFY,diff.getChangeType());
|
assertEquals(diff.getOldId(), diff.getNewId());
|
||||||
assertEquals(diff.getOldId(), diff.getNewId());
|
assertEquals("a.txt", diff.getOldPath());
|
||||||
assertEquals("a.txt", diff.getOldPath());
|
assertEquals(diff.getOldPath(), diff.getNewPath());
|
||||||
assertEquals(diff.getOldPath(), diff.getNewPath());
|
assertEquals(FileMode.EXECUTABLE_FILE, diff.getNewMode());
|
||||||
assertEquals(FileMode.EXECUTABLE_FILE, diff.getNewMode());
|
assertEquals(FileMode.REGULAR_FILE, diff.getOldMode());
|
||||||
assertEquals(FileMode.REGULAR_FILE, diff.getOldMode());
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
|
@ -84,7 +84,6 @@
|
||||||
import org.eclipse.jgit.util.FileUtils;
|
import org.eclipse.jgit.util.FileUtils;
|
||||||
import org.junit.Test;
|
import org.junit.Test;
|
||||||
|
|
||||||
@SuppressWarnings("deprecation")
|
|
||||||
public class T0003_BasicTest extends SampleDataRepositoryTestCase {
|
public class T0003_BasicTest extends SampleDataRepositoryTestCase {
|
||||||
|
|
||||||
@Test
|
@Test
|
||||||
|
|
|
@ -77,7 +77,6 @@
|
||||||
import org.eclipse.jgit.util.IO;
|
import org.eclipse.jgit.util.IO;
|
||||||
import org.junit.Test;
|
import org.junit.Test;
|
||||||
|
|
||||||
@SuppressWarnings("deprecation")
|
|
||||||
public class IndexDiffTest extends RepositoryTestCase {
|
public class IndexDiffTest extends RepositoryTestCase {
|
||||||
|
|
||||||
static PathEdit add(final Repository db, final File workdir,
|
static PathEdit add(final Repository db, final File workdir,
|
||||||
|
|
|
@ -53,7 +53,6 @@
|
||||||
import org.eclipse.jgit.lib.TreeFormatter;
|
import org.eclipse.jgit.lib.TreeFormatter;
|
||||||
import org.junit.Test;
|
import org.junit.Test;
|
||||||
|
|
||||||
@SuppressWarnings("deprecation")
|
|
||||||
public class ObjectWalkTest extends RevWalkTestCase {
|
public class ObjectWalkTest extends RevWalkTestCase {
|
||||||
protected ObjectWalk objw;
|
protected ObjectWalk objw;
|
||||||
|
|
||||||
|
|
|
@ -255,10 +255,11 @@ public void testComputeFileObjectId() throws Exception {
|
||||||
@Test
|
@Test
|
||||||
public void testDirCacheMatchingId() throws Exception {
|
public void testDirCacheMatchingId() throws Exception {
|
||||||
File f = writeTrashFile("file", "content");
|
File f = writeTrashFile("file", "content");
|
||||||
Git git = new Git(db);
|
try (Git git = new Git(db)) {
|
||||||
writeTrashFile("file", "content");
|
writeTrashFile("file", "content");
|
||||||
fsTick(f);
|
fsTick(f);
|
||||||
git.add().addFilepattern("file").call();
|
git.add().addFilepattern("file").call();
|
||||||
|
}
|
||||||
DirCacheEntry dce = db.readDirCache().getEntry("file");
|
DirCacheEntry dce = db.readDirCache().getEntry("file");
|
||||||
TreeWalk tw = new TreeWalk(db);
|
TreeWalk tw = new TreeWalk(db);
|
||||||
FileTreeIterator fti = new FileTreeIterator(trash, db.getFS(), db
|
FileTreeIterator fti = new FileTreeIterator(trash, db.getFS(), db
|
||||||
|
@ -282,11 +283,12 @@ public void testDirCacheMatchingId() throws Exception {
|
||||||
@Test
|
@Test
|
||||||
public void testIsModifiedSymlinkAsFile() throws Exception {
|
public void testIsModifiedSymlinkAsFile() throws Exception {
|
||||||
writeTrashFile("symlink", "content");
|
writeTrashFile("symlink", "content");
|
||||||
Git git = new Git(db);
|
try (Git git = new Git(db)) {
|
||||||
db.getConfig().setString(ConfigConstants.CONFIG_CORE_SECTION, null,
|
db.getConfig().setString(ConfigConstants.CONFIG_CORE_SECTION, null,
|
||||||
ConfigConstants.CONFIG_KEY_SYMLINKS, "false");
|
ConfigConstants.CONFIG_KEY_SYMLINKS, "false");
|
||||||
git.add().addFilepattern("symlink").call();
|
git.add().addFilepattern("symlink").call();
|
||||||
git.commit().setMessage("commit").call();
|
git.commit().setMessage("commit").call();
|
||||||
|
}
|
||||||
|
|
||||||
// Modify previously committed DirCacheEntry and write it back to disk
|
// Modify previously committed DirCacheEntry and write it back to disk
|
||||||
DirCacheEntry dce = db.readDirCache().getEntry("symlink");
|
DirCacheEntry dce = db.readDirCache().getEntry("symlink");
|
||||||
|
@ -305,20 +307,21 @@ public void testIsModifiedSymlinkAsFile() throws Exception {
|
||||||
@Test
|
@Test
|
||||||
public void testIsModifiedFileSmudged() throws Exception {
|
public void testIsModifiedFileSmudged() throws Exception {
|
||||||
File f = writeTrashFile("file", "content");
|
File f = writeTrashFile("file", "content");
|
||||||
Git git = new Git(db);
|
try (Git git = new Git(db)) {
|
||||||
// The idea of this test is to check the smudged handling
|
// The idea of this test is to check the smudged handling
|
||||||
// Hopefully fsTick will make sure our entry gets smudged
|
// Hopefully fsTick will make sure our entry gets smudged
|
||||||
fsTick(f);
|
fsTick(f);
|
||||||
writeTrashFile("file", "content");
|
writeTrashFile("file", "content");
|
||||||
long lastModified = f.lastModified();
|
long lastModified = f.lastModified();
|
||||||
git.add().addFilepattern("file").call();
|
git.add().addFilepattern("file").call();
|
||||||
writeTrashFile("file", "conten2");
|
writeTrashFile("file", "conten2");
|
||||||
f.setLastModified(lastModified);
|
f.setLastModified(lastModified);
|
||||||
// We cannot trust this to go fast enough on
|
// We cannot trust this to go fast enough on
|
||||||
// a system with less than one-second lastModified
|
// a system with less than one-second lastModified
|
||||||
// resolution, so we force the index to have the
|
// resolution, so we force the index to have the
|
||||||
// same timestamp as the file we look at.
|
// same timestamp as the file we look at.
|
||||||
db.getIndexFile().setLastModified(lastModified);
|
db.getIndexFile().setLastModified(lastModified);
|
||||||
|
}
|
||||||
DirCacheEntry dce = db.readDirCache().getEntry("file");
|
DirCacheEntry dce = db.readDirCache().getEntry("file");
|
||||||
FileTreeIterator fti = new FileTreeIterator(trash, db.getFS(), db
|
FileTreeIterator fti = new FileTreeIterator(trash, db.getFS(), db
|
||||||
.getConfig().get(WorkingTreeOptions.KEY));
|
.getConfig().get(WorkingTreeOptions.KEY));
|
||||||
|
@ -334,198 +337,204 @@ public void testIsModifiedFileSmudged() throws Exception {
|
||||||
|
|
||||||
@Test
|
@Test
|
||||||
public void submoduleHeadMatchesIndex() throws Exception {
|
public void submoduleHeadMatchesIndex() throws Exception {
|
||||||
Git git = new Git(db);
|
try (Git git = new Git(db);
|
||||||
writeTrashFile("file.txt", "content");
|
TreeWalk walk = new TreeWalk(db)) {
|
||||||
git.add().addFilepattern("file.txt").call();
|
writeTrashFile("file.txt", "content");
|
||||||
final RevCommit id = git.commit().setMessage("create file").call();
|
git.add().addFilepattern("file.txt").call();
|
||||||
final String path = "sub";
|
final RevCommit id = git.commit().setMessage("create file").call();
|
||||||
DirCache cache = db.lockDirCache();
|
final String path = "sub";
|
||||||
DirCacheEditor editor = cache.editor();
|
DirCache cache = db.lockDirCache();
|
||||||
editor.add(new PathEdit(path) {
|
DirCacheEditor editor = cache.editor();
|
||||||
|
editor.add(new PathEdit(path) {
|
||||||
|
|
||||||
|
public void apply(DirCacheEntry ent) {
|
||||||
|
ent.setFileMode(FileMode.GITLINK);
|
||||||
|
ent.setObjectId(id);
|
||||||
|
}
|
||||||
|
});
|
||||||
|
editor.commit();
|
||||||
|
|
||||||
public void apply(DirCacheEntry ent) {
|
Git.cloneRepository().setURI(db.getDirectory().toURI().toString())
|
||||||
ent.setFileMode(FileMode.GITLINK);
|
.setDirectory(new File(db.getWorkTree(), path)).call()
|
||||||
ent.setObjectId(id);
|
.getRepository().close();
|
||||||
}
|
|
||||||
});
|
|
||||||
editor.commit();
|
|
||||||
|
|
||||||
Git.cloneRepository().setURI(db.getDirectory().toURI().toString())
|
DirCacheIterator indexIter = new DirCacheIterator(db.readDirCache());
|
||||||
.setDirectory(new File(db.getWorkTree(), path)).call()
|
FileTreeIterator workTreeIter = new FileTreeIterator(db);
|
||||||
.getRepository().close();
|
walk.addTree(indexIter);
|
||||||
|
walk.addTree(workTreeIter);
|
||||||
TreeWalk walk = new TreeWalk(db);
|
walk.setFilter(PathFilter.create(path));
|
||||||
DirCacheIterator indexIter = new DirCacheIterator(db.readDirCache());
|
|
||||||
FileTreeIterator workTreeIter = new FileTreeIterator(db);
|
assertTrue(walk.next());
|
||||||
walk.addTree(indexIter);
|
assertTrue(indexIter.idEqual(workTreeIter));
|
||||||
walk.addTree(workTreeIter);
|
}
|
||||||
walk.setFilter(PathFilter.create(path));
|
|
||||||
|
|
||||||
assertTrue(walk.next());
|
|
||||||
assertTrue(indexIter.idEqual(workTreeIter));
|
|
||||||
}
|
}
|
||||||
|
|
||||||
@Test
|
@Test
|
||||||
public void submoduleWithNoGitDirectory() throws Exception {
|
public void submoduleWithNoGitDirectory() throws Exception {
|
||||||
Git git = new Git(db);
|
try (Git git = new Git(db);
|
||||||
writeTrashFile("file.txt", "content");
|
TreeWalk walk = new TreeWalk(db)) {
|
||||||
git.add().addFilepattern("file.txt").call();
|
writeTrashFile("file.txt", "content");
|
||||||
final RevCommit id = git.commit().setMessage("create file").call();
|
git.add().addFilepattern("file.txt").call();
|
||||||
final String path = "sub";
|
final RevCommit id = git.commit().setMessage("create file").call();
|
||||||
DirCache cache = db.lockDirCache();
|
final String path = "sub";
|
||||||
DirCacheEditor editor = cache.editor();
|
DirCache cache = db.lockDirCache();
|
||||||
editor.add(new PathEdit(path) {
|
DirCacheEditor editor = cache.editor();
|
||||||
|
editor.add(new PathEdit(path) {
|
||||||
|
|
||||||
public void apply(DirCacheEntry ent) {
|
public void apply(DirCacheEntry ent) {
|
||||||
ent.setFileMode(FileMode.GITLINK);
|
ent.setFileMode(FileMode.GITLINK);
|
||||||
ent.setObjectId(id);
|
ent.setObjectId(id);
|
||||||
}
|
}
|
||||||
});
|
});
|
||||||
editor.commit();
|
editor.commit();
|
||||||
|
|
||||||
File submoduleRoot = new File(db.getWorkTree(), path);
|
File submoduleRoot = new File(db.getWorkTree(), path);
|
||||||
assertTrue(submoduleRoot.mkdir());
|
assertTrue(submoduleRoot.mkdir());
|
||||||
assertTrue(new File(submoduleRoot, Constants.DOT_GIT).mkdir());
|
assertTrue(new File(submoduleRoot, Constants.DOT_GIT).mkdir());
|
||||||
|
|
||||||
TreeWalk walk = new TreeWalk(db);
|
DirCacheIterator indexIter = new DirCacheIterator(db.readDirCache());
|
||||||
DirCacheIterator indexIter = new DirCacheIterator(db.readDirCache());
|
FileTreeIterator workTreeIter = new FileTreeIterator(db);
|
||||||
FileTreeIterator workTreeIter = new FileTreeIterator(db);
|
walk.addTree(indexIter);
|
||||||
walk.addTree(indexIter);
|
walk.addTree(workTreeIter);
|
||||||
walk.addTree(workTreeIter);
|
walk.setFilter(PathFilter.create(path));
|
||||||
walk.setFilter(PathFilter.create(path));
|
|
||||||
|
|
||||||
assertTrue(walk.next());
|
assertTrue(walk.next());
|
||||||
assertFalse(indexIter.idEqual(workTreeIter));
|
assertFalse(indexIter.idEqual(workTreeIter));
|
||||||
assertEquals(ObjectId.zeroId(), workTreeIter.getEntryObjectId());
|
assertEquals(ObjectId.zeroId(), workTreeIter.getEntryObjectId());
|
||||||
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
@Test
|
@Test
|
||||||
public void submoduleWithNoHead() throws Exception {
|
public void submoduleWithNoHead() throws Exception {
|
||||||
Git git = new Git(db);
|
try (Git git = new Git(db);
|
||||||
writeTrashFile("file.txt", "content");
|
TreeWalk walk = new TreeWalk(db)) {
|
||||||
git.add().addFilepattern("file.txt").call();
|
writeTrashFile("file.txt", "content");
|
||||||
final RevCommit id = git.commit().setMessage("create file").call();
|
git.add().addFilepattern("file.txt").call();
|
||||||
final String path = "sub";
|
final RevCommit id = git.commit().setMessage("create file").call();
|
||||||
DirCache cache = db.lockDirCache();
|
final String path = "sub";
|
||||||
DirCacheEditor editor = cache.editor();
|
DirCache cache = db.lockDirCache();
|
||||||
editor.add(new PathEdit(path) {
|
DirCacheEditor editor = cache.editor();
|
||||||
|
editor.add(new PathEdit(path) {
|
||||||
|
|
||||||
public void apply(DirCacheEntry ent) {
|
public void apply(DirCacheEntry ent) {
|
||||||
ent.setFileMode(FileMode.GITLINK);
|
ent.setFileMode(FileMode.GITLINK);
|
||||||
ent.setObjectId(id);
|
ent.setObjectId(id);
|
||||||
}
|
}
|
||||||
});
|
});
|
||||||
editor.commit();
|
editor.commit();
|
||||||
|
|
||||||
assertNotNull(Git.init().setDirectory(new File(db.getWorkTree(), path))
|
assertNotNull(Git.init().setDirectory(new File(db.getWorkTree(), path))
|
||||||
.call().getRepository());
|
.call().getRepository());
|
||||||
|
|
||||||
TreeWalk walk = new TreeWalk(db);
|
DirCacheIterator indexIter = new DirCacheIterator(db.readDirCache());
|
||||||
DirCacheIterator indexIter = new DirCacheIterator(db.readDirCache());
|
FileTreeIterator workTreeIter = new FileTreeIterator(db);
|
||||||
FileTreeIterator workTreeIter = new FileTreeIterator(db);
|
walk.addTree(indexIter);
|
||||||
walk.addTree(indexIter);
|
walk.addTree(workTreeIter);
|
||||||
walk.addTree(workTreeIter);
|
walk.setFilter(PathFilter.create(path));
|
||||||
walk.setFilter(PathFilter.create(path));
|
|
||||||
|
|
||||||
assertTrue(walk.next());
|
assertTrue(walk.next());
|
||||||
assertFalse(indexIter.idEqual(workTreeIter));
|
assertFalse(indexIter.idEqual(workTreeIter));
|
||||||
assertEquals(ObjectId.zeroId(), workTreeIter.getEntryObjectId());
|
assertEquals(ObjectId.zeroId(), workTreeIter.getEntryObjectId());
|
||||||
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
@Test
|
@Test
|
||||||
public void submoduleDirectoryIterator() throws Exception {
|
public void submoduleDirectoryIterator() throws Exception {
|
||||||
Git git = new Git(db);
|
try (Git git = new Git(db);
|
||||||
writeTrashFile("file.txt", "content");
|
TreeWalk walk = new TreeWalk(db)) {
|
||||||
git.add().addFilepattern("file.txt").call();
|
writeTrashFile("file.txt", "content");
|
||||||
final RevCommit id = git.commit().setMessage("create file").call();
|
git.add().addFilepattern("file.txt").call();
|
||||||
final String path = "sub";
|
final RevCommit id = git.commit().setMessage("create file").call();
|
||||||
DirCache cache = db.lockDirCache();
|
final String path = "sub";
|
||||||
DirCacheEditor editor = cache.editor();
|
DirCache cache = db.lockDirCache();
|
||||||
editor.add(new PathEdit(path) {
|
DirCacheEditor editor = cache.editor();
|
||||||
|
editor.add(new PathEdit(path) {
|
||||||
|
|
||||||
public void apply(DirCacheEntry ent) {
|
public void apply(DirCacheEntry ent) {
|
||||||
ent.setFileMode(FileMode.GITLINK);
|
ent.setFileMode(FileMode.GITLINK);
|
||||||
ent.setObjectId(id);
|
ent.setObjectId(id);
|
||||||
}
|
}
|
||||||
});
|
});
|
||||||
editor.commit();
|
editor.commit();
|
||||||
|
|
||||||
Git.cloneRepository().setURI(db.getDirectory().toURI().toString())
|
Git.cloneRepository().setURI(db.getDirectory().toURI().toString())
|
||||||
.setDirectory(new File(db.getWorkTree(), path)).call()
|
.setDirectory(new File(db.getWorkTree(), path)).call()
|
||||||
.getRepository().close();
|
.getRepository().close();
|
||||||
|
|
||||||
TreeWalk walk = new TreeWalk(db);
|
DirCacheIterator indexIter = new DirCacheIterator(db.readDirCache());
|
||||||
DirCacheIterator indexIter = new DirCacheIterator(db.readDirCache());
|
FileTreeIterator workTreeIter = new FileTreeIterator(db.getWorkTree(),
|
||||||
FileTreeIterator workTreeIter = new FileTreeIterator(db.getWorkTree(),
|
db.getFS(), db.getConfig().get(WorkingTreeOptions.KEY));
|
||||||
db.getFS(), db.getConfig().get(WorkingTreeOptions.KEY));
|
walk.addTree(indexIter);
|
||||||
walk.addTree(indexIter);
|
walk.addTree(workTreeIter);
|
||||||
walk.addTree(workTreeIter);
|
walk.setFilter(PathFilter.create(path));
|
||||||
walk.setFilter(PathFilter.create(path));
|
|
||||||
|
|
||||||
assertTrue(walk.next());
|
assertTrue(walk.next());
|
||||||
assertTrue(indexIter.idEqual(workTreeIter));
|
assertTrue(indexIter.idEqual(workTreeIter));
|
||||||
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
@Test
|
@Test
|
||||||
public void submoduleNestedWithHeadMatchingIndex() throws Exception {
|
public void submoduleNestedWithHeadMatchingIndex() throws Exception {
|
||||||
Git git = new Git(db);
|
try (Git git = new Git(db);
|
||||||
writeTrashFile("file.txt", "content");
|
TreeWalk walk = new TreeWalk(db)) {
|
||||||
git.add().addFilepattern("file.txt").call();
|
writeTrashFile("file.txt", "content");
|
||||||
final RevCommit id = git.commit().setMessage("create file").call();
|
git.add().addFilepattern("file.txt").call();
|
||||||
final String path = "sub/dir1/dir2";
|
final RevCommit id = git.commit().setMessage("create file").call();
|
||||||
DirCache cache = db.lockDirCache();
|
final String path = "sub/dir1/dir2";
|
||||||
DirCacheEditor editor = cache.editor();
|
DirCache cache = db.lockDirCache();
|
||||||
editor.add(new PathEdit(path) {
|
DirCacheEditor editor = cache.editor();
|
||||||
|
editor.add(new PathEdit(path) {
|
||||||
|
|
||||||
public void apply(DirCacheEntry ent) {
|
public void apply(DirCacheEntry ent) {
|
||||||
ent.setFileMode(FileMode.GITLINK);
|
ent.setFileMode(FileMode.GITLINK);
|
||||||
ent.setObjectId(id);
|
ent.setObjectId(id);
|
||||||
}
|
}
|
||||||
});
|
});
|
||||||
editor.commit();
|
editor.commit();
|
||||||
|
|
||||||
Git.cloneRepository().setURI(db.getDirectory().toURI().toString())
|
Git.cloneRepository().setURI(db.getDirectory().toURI().toString())
|
||||||
.setDirectory(new File(db.getWorkTree(), path)).call()
|
.setDirectory(new File(db.getWorkTree(), path)).call()
|
||||||
.getRepository().close();
|
.getRepository().close();
|
||||||
|
|
||||||
TreeWalk walk = new TreeWalk(db);
|
DirCacheIterator indexIter = new DirCacheIterator(db.readDirCache());
|
||||||
DirCacheIterator indexIter = new DirCacheIterator(db.readDirCache());
|
FileTreeIterator workTreeIter = new FileTreeIterator(db);
|
||||||
FileTreeIterator workTreeIter = new FileTreeIterator(db);
|
walk.addTree(indexIter);
|
||||||
walk.addTree(indexIter);
|
walk.addTree(workTreeIter);
|
||||||
walk.addTree(workTreeIter);
|
walk.setFilter(PathFilter.create(path));
|
||||||
walk.setFilter(PathFilter.create(path));
|
|
||||||
|
|
||||||
assertTrue(walk.next());
|
assertTrue(walk.next());
|
||||||
assertTrue(indexIter.idEqual(workTreeIter));
|
assertTrue(indexIter.idEqual(workTreeIter));
|
||||||
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
@Test
|
@Test
|
||||||
public void idOffset() throws Exception {
|
public void idOffset() throws Exception {
|
||||||
Git git = new Git(db);
|
try (Git git = new Git(db);
|
||||||
writeTrashFile("fileAinfsonly", "A");
|
TreeWalk tw = new TreeWalk(db)) {
|
||||||
File fileBinindex = writeTrashFile("fileBinindex", "B");
|
writeTrashFile("fileAinfsonly", "A");
|
||||||
fsTick(fileBinindex);
|
File fileBinindex = writeTrashFile("fileBinindex", "B");
|
||||||
git.add().addFilepattern("fileBinindex").call();
|
fsTick(fileBinindex);
|
||||||
writeTrashFile("fileCinfsonly", "C");
|
git.add().addFilepattern("fileBinindex").call();
|
||||||
TreeWalk tw = new TreeWalk(db);
|
writeTrashFile("fileCinfsonly", "C");
|
||||||
DirCacheIterator indexIter = new DirCacheIterator(db.readDirCache());
|
DirCacheIterator indexIter = new DirCacheIterator(db.readDirCache());
|
||||||
FileTreeIterator workTreeIter = new FileTreeIterator(db);
|
FileTreeIterator workTreeIter = new FileTreeIterator(db);
|
||||||
tw.addTree(indexIter);
|
tw.addTree(indexIter);
|
||||||
tw.addTree(workTreeIter);
|
tw.addTree(workTreeIter);
|
||||||
workTreeIter.setDirCacheIterator(tw, 0);
|
workTreeIter.setDirCacheIterator(tw, 0);
|
||||||
assertEntry("d46c305e85b630558ee19cc47e73d2e5c8c64cdc", "a,", tw);
|
assertEntry("d46c305e85b630558ee19cc47e73d2e5c8c64cdc", "a,", tw);
|
||||||
assertEntry("58ee403f98538ec02409538b3f80adf610accdec", "a,b", tw);
|
assertEntry("58ee403f98538ec02409538b3f80adf610accdec", "a,b", tw);
|
||||||
assertEntry("0000000000000000000000000000000000000000", "a", tw);
|
assertEntry("0000000000000000000000000000000000000000", "a", tw);
|
||||||
assertEntry("b8d30ff397626f0f1d3538d66067edf865e201d6", "a0b", tw);
|
assertEntry("b8d30ff397626f0f1d3538d66067edf865e201d6", "a0b", tw);
|
||||||
// The reason for adding this test. Check that the id is correct for
|
// The reason for adding this test. Check that the id is correct for
|
||||||
// mixed
|
// mixed
|
||||||
assertEntry("8c7e5a667f1b771847fe88c01c3de34413a1b220",
|
assertEntry("8c7e5a667f1b771847fe88c01c3de34413a1b220",
|
||||||
"fileAinfsonly", tw);
|
"fileAinfsonly", tw);
|
||||||
assertEntry("7371f47a6f8bd23a8fa1a8b2a9479cdd76380e54", "fileBinindex",
|
assertEntry("7371f47a6f8bd23a8fa1a8b2a9479cdd76380e54", "fileBinindex",
|
||||||
tw);
|
tw);
|
||||||
assertEntry("96d80cd6c4e7158dbebd0849f4fb7ce513e5828c",
|
assertEntry("96d80cd6c4e7158dbebd0849f4fb7ce513e5828c",
|
||||||
"fileCinfsonly", tw);
|
"fileCinfsonly", tw);
|
||||||
assertFalse(tw.next());
|
assertFalse(tw.next());
|
||||||
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
private static void assertEntry(String sha1string, String path, TreeWalk tw)
|
private static void assertEntry(String sha1string, String path, TreeWalk tw)
|
||||||
|
|
Loading…
Reference in New Issue