Merge branch 'stable-4.2'
* stable-4.2: BundleWriterTest: Open RevWalk in try-with-resource DiffFormatterTest: Remove accidentally added trailing whitespace CherryPickCommandTest: Create Git instances in try-with-resource DiffFormatterTest: Create auto-closeable instances in try-with-resource ConfigTest: Create Git instance in try-with-resource CommitAndLogCommandTest: Use assumeFalse to skip test on Windows CommitAndLogCommandTest: Create Git instances in try-with-resource AddCommandTest: Create Git instances in try-with-resource ArchiveCommandTest: Create Git instances in try-with-resource TagCommandTest: Instantiate Git and RevWalk objects in try-with-resource BlameCommandTest: Instantiate Git objects in try-with-resource SideBandOutputStreamTest: Use try-with-resource FileTreeIteratorJava7Test: Create Git instances in try-with-resource Change-Id: Ib572e98e6117b70442aee9cd7e7b8c3cf65562a7 Signed-off-by: Matthias Sohn <matthias.sohn@sap.com>
This commit is contained in:
commit
34b4a564ea
|
@ -60,7 +60,9 @@ public class ConfigTest extends CLIRepositoryTestCase {
|
|||
@Before
|
||||
public void setUp() throws Exception {
|
||||
super.setUp();
|
||||
new Git(db).commit().setMessage("initial commit").call();
|
||||
try (Git git = new Git(db)) {
|
||||
git.commit().setMessage("initial commit").call();
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
|
|
|
@ -78,9 +78,7 @@ public class AddCommandTest extends RepositoryTestCase {
|
|||
|
||||
@Test
|
||||
public void testAddNothing() throws GitAPIException {
|
||||
Git git = new Git(db);
|
||||
|
||||
try {
|
||||
try (Git git = new Git(db)) {
|
||||
git.add().call();
|
||||
fail("Expected IllegalArgumentException");
|
||||
} catch (NoFilepatternException e) {
|
||||
|
@ -91,11 +89,10 @@ public void testAddNothing() throws GitAPIException {
|
|||
|
||||
@Test
|
||||
public void testAddNonExistingSingleFile() throws GitAPIException {
|
||||
Git git = new Git(db);
|
||||
|
||||
DirCache dc = git.add().addFilepattern("a.txt").call();
|
||||
assertEquals(0, dc.getEntryCount());
|
||||
|
||||
try (Git git = new Git(db)) {
|
||||
DirCache dc = git.add().addFilepattern("a.txt").call();
|
||||
assertEquals(0, dc.getEntryCount());
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
|
@ -106,13 +103,13 @@ public void testAddExistingSingleFile() throws IOException, GitAPIException {
|
|||
writer.print("content");
|
||||
writer.close();
|
||||
|
||||
Git git = new Git(db);
|
||||
try (Git git = new Git(db)) {
|
||||
git.add().addFilepattern("a.txt").call();
|
||||
|
||||
git.add().addFilepattern("a.txt").call();
|
||||
|
||||
assertEquals(
|
||||
"[a.txt, mode:100644, content:content]",
|
||||
indexState(CONTENT));
|
||||
assertEquals(
|
||||
"[a.txt, mode:100644, content:content]",
|
||||
indexState(CONTENT));
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
|
@ -125,18 +122,19 @@ public void testCleanFilter() throws IOException,
|
|||
writeTrashFile("src/a.txt", "foo\n");
|
||||
File script = writeTempFile("sed s/o/e/g");
|
||||
|
||||
Git git = new Git(db);
|
||||
StoredConfig config = git.getRepository().getConfig();
|
||||
config.setString("filter", "tstFilter", "clean",
|
||||
"sh " + slashify(script.getPath()));
|
||||
config.save();
|
||||
try (Git git = new Git(db)) {
|
||||
StoredConfig config = git.getRepository().getConfig();
|
||||
config.setString("filter", "tstFilter", "clean",
|
||||
"sh " + slashify(script.getPath()));
|
||||
config.save();
|
||||
|
||||
git.add().addFilepattern("src/a.txt").addFilepattern("src/a.tmp")
|
||||
.call();
|
||||
git.add().addFilepattern("src/a.txt").addFilepattern("src/a.tmp")
|
||||
.call();
|
||||
|
||||
assertEquals(
|
||||
"[src/a.tmp, mode:100644, content:foo][src/a.txt, mode:100644, content:fee\n]",
|
||||
indexState(CONTENT));
|
||||
assertEquals(
|
||||
"[src/a.tmp, mode:100644, content:foo][src/a.txt, mode:100644, content:fee\n]",
|
||||
indexState(CONTENT));
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
|
@ -146,17 +144,18 @@ public void testCleanFilterEnvironment()
|
|||
writeTrashFile("src/a.txt", "foo");
|
||||
File script = writeTempFile("echo $GIT_DIR; echo 1 >xyz");
|
||||
|
||||
Git git = new Git(db);
|
||||
StoredConfig config = git.getRepository().getConfig();
|
||||
config.setString("filter", "tstFilter", "clean",
|
||||
"sh " + slashify(script.getPath()));
|
||||
config.save();
|
||||
git.add().addFilepattern("src/a.txt").call();
|
||||
try (Git git = new Git(db)) {
|
||||
StoredConfig config = git.getRepository().getConfig();
|
||||
config.setString("filter", "tstFilter", "clean",
|
||||
"sh " + slashify(script.getPath()));
|
||||
config.save();
|
||||
git.add().addFilepattern("src/a.txt").call();
|
||||
|
||||
String gitDir = db.getDirectory().getAbsolutePath();
|
||||
assertEquals("[src/a.txt, mode:100644, content:" + gitDir
|
||||
+ "\n]", indexState(CONTENT));
|
||||
assertTrue(new File(db.getWorkTree(), "xyz").exists());
|
||||
String gitDir = db.getDirectory().getAbsolutePath();
|
||||
assertEquals("[src/a.txt, mode:100644, content:" + gitDir
|
||||
+ "\n]", indexState(CONTENT));
|
||||
assertTrue(new File(db.getWorkTree(), "xyz").exists());
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
|
@ -170,22 +169,23 @@ public void testMultipleCleanFilter() throws IOException, GitAPIException {
|
|||
File script = writeTempFile("sed s/o/e/g");
|
||||
File script2 = writeTempFile("sed s/f/x/g");
|
||||
|
||||
Git git = new Git(db);
|
||||
StoredConfig config = git.getRepository().getConfig();
|
||||
config.setString("filter", "tstFilter", "clean",
|
||||
"sh " + slashify(script.getPath()));
|
||||
config.setString("filter", "tstFilter2", "clean",
|
||||
"sh " + slashify(script2.getPath()));
|
||||
config.save();
|
||||
try (Git git = new Git(db)) {
|
||||
StoredConfig config = git.getRepository().getConfig();
|
||||
config.setString("filter", "tstFilter", "clean",
|
||||
"sh " + slashify(script.getPath()));
|
||||
config.setString("filter", "tstFilter2", "clean",
|
||||
"sh " + slashify(script2.getPath()));
|
||||
config.save();
|
||||
|
||||
git.add().addFilepattern("src/a.txt").addFilepattern("src/a.tmp")
|
||||
.call();
|
||||
git.add().addFilepattern("src/a.txt").addFilepattern("src/a.tmp")
|
||||
.call();
|
||||
|
||||
assertEquals(
|
||||
"[src/a.tmp, mode:100644, content:xoo\n][src/a.txt, mode:100644, content:fee\n]",
|
||||
indexState(CONTENT));
|
||||
assertEquals(
|
||||
"[src/a.tmp, mode:100644, content:xoo\n][src/a.txt, mode:100644, content:fee\n]",
|
||||
indexState(CONTENT));
|
||||
|
||||
// TODO: multiple clean filters for one file???
|
||||
// TODO: multiple clean filters for one file???
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
|
@ -203,17 +203,18 @@ public void testCommandInjection() throws IOException, GitAPIException {
|
|||
writeTrashFile("; echo virus", "foo\n");
|
||||
File script = writeTempFile("sed s/o/e/g");
|
||||
|
||||
Git git = new Git(db);
|
||||
StoredConfig config = git.getRepository().getConfig();
|
||||
config.setString("filter", "tstFilter", "clean",
|
||||
"sh " + slashify(script.getPath()) + " %f");
|
||||
writeTrashFile(".gitattributes", "* filter=tstFilter");
|
||||
try (Git git = new Git(db)) {
|
||||
StoredConfig config = git.getRepository().getConfig();
|
||||
config.setString("filter", "tstFilter", "clean",
|
||||
"sh " + slashify(script.getPath()) + " %f");
|
||||
writeTrashFile(".gitattributes", "* filter=tstFilter");
|
||||
|
||||
git.add().addFilepattern("; echo virus").call();
|
||||
// Without proper escaping the content would be "feovirus". The sed
|
||||
// command and the "echo virus" would contribute to the content
|
||||
assertEquals("[; echo virus, mode:100644, content:fee\n]",
|
||||
indexState(CONTENT));
|
||||
git.add().addFilepattern("; echo virus").call();
|
||||
// Without proper escaping the content would be "feovirus". The sed
|
||||
// command and the "echo virus" would contribute to the content
|
||||
assertEquals("[; echo virus, mode:100644, content:fee\n]",
|
||||
indexState(CONTENT));
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
|
@ -221,18 +222,19 @@ public void testBadCleanFilter() throws IOException, GitAPIException {
|
|||
writeTrashFile("a.txt", "foo");
|
||||
File script = writeTempFile("sedfoo s/o/e/g");
|
||||
|
||||
Git git = new Git(db);
|
||||
StoredConfig config = git.getRepository().getConfig();
|
||||
config.setString("filter", "tstFilter", "clean",
|
||||
"sh " + script.getPath());
|
||||
config.save();
|
||||
writeTrashFile(".gitattributes", "*.txt filter=tstFilter");
|
||||
try (Git git = new Git(db)) {
|
||||
StoredConfig config = git.getRepository().getConfig();
|
||||
config.setString("filter", "tstFilter", "clean",
|
||||
"sh " + script.getPath());
|
||||
config.save();
|
||||
writeTrashFile(".gitattributes", "*.txt filter=tstFilter");
|
||||
|
||||
try {
|
||||
git.add().addFilepattern("a.txt").call();
|
||||
fail("Didn't received the expected exception");
|
||||
} catch (FilterFailedException e) {
|
||||
assertEquals(127, e.getReturnCode());
|
||||
try {
|
||||
git.add().addFilepattern("a.txt").call();
|
||||
fail("Didn't received the expected exception");
|
||||
} catch (FilterFailedException e) {
|
||||
assertEquals(127, e.getReturnCode());
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -241,18 +243,19 @@ public void testBadCleanFilter2() throws IOException, GitAPIException {
|
|||
writeTrashFile("a.txt", "foo");
|
||||
File script = writeTempFile("sed s/o/e/g");
|
||||
|
||||
Git git = new Git(db);
|
||||
StoredConfig config = git.getRepository().getConfig();
|
||||
config.setString("filter", "tstFilter", "clean",
|
||||
"shfoo " + script.getPath());
|
||||
config.save();
|
||||
writeTrashFile(".gitattributes", "*.txt filter=tstFilter");
|
||||
try (Git git = new Git(db)) {
|
||||
StoredConfig config = git.getRepository().getConfig();
|
||||
config.setString("filter", "tstFilter", "clean",
|
||||
"shfoo " + script.getPath());
|
||||
config.save();
|
||||
writeTrashFile(".gitattributes", "*.txt filter=tstFilter");
|
||||
|
||||
try {
|
||||
git.add().addFilepattern("a.txt").call();
|
||||
fail("Didn't received the expected exception");
|
||||
} catch (FilterFailedException e) {
|
||||
assertEquals(127, e.getReturnCode());
|
||||
try {
|
||||
git.add().addFilepattern("a.txt").call();
|
||||
fail("Didn't received the expected exception");
|
||||
} catch (FilterFailedException e) {
|
||||
assertEquals(127, e.getReturnCode());
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -262,18 +265,19 @@ public void testCleanFilterReturning12() throws IOException,
|
|||
writeTrashFile("a.txt", "foo");
|
||||
File script = writeTempFile("exit 12");
|
||||
|
||||
Git git = new Git(db);
|
||||
StoredConfig config = git.getRepository().getConfig();
|
||||
config.setString("filter", "tstFilter", "clean",
|
||||
"sh " + slashify(script.getPath()));
|
||||
config.save();
|
||||
writeTrashFile(".gitattributes", "*.txt filter=tstFilter");
|
||||
try (Git git = new Git(db)) {
|
||||
StoredConfig config = git.getRepository().getConfig();
|
||||
config.setString("filter", "tstFilter", "clean",
|
||||
"sh " + slashify(script.getPath()));
|
||||
config.save();
|
||||
writeTrashFile(".gitattributes", "*.txt filter=tstFilter");
|
||||
|
||||
try {
|
||||
git.add().addFilepattern("a.txt").call();
|
||||
fail("Didn't received the expected exception");
|
||||
} catch (FilterFailedException e) {
|
||||
assertEquals(12, e.getReturnCode());
|
||||
try {
|
||||
git.add().addFilepattern("a.txt").call();
|
||||
fail("Didn't received the expected exception");
|
||||
} catch (FilterFailedException e) {
|
||||
assertEquals(12, e.getReturnCode());
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -282,16 +286,18 @@ public void testNotApplicableFilter() throws IOException, GitAPIException {
|
|||
writeTrashFile("a.txt", "foo");
|
||||
File script = writeTempFile("sed s/o/e/g");
|
||||
|
||||
Git git = new Git(db);
|
||||
StoredConfig config = git.getRepository().getConfig();
|
||||
config.setString("filter", "tstFilter", "something",
|
||||
"sh " + script.getPath());
|
||||
config.save();
|
||||
writeTrashFile(".gitattributes", "*.txt filter=tstFilter");
|
||||
try (Git git = new Git(db)) {
|
||||
StoredConfig config = git.getRepository().getConfig();
|
||||
config.setString("filter", "tstFilter", "something",
|
||||
"sh " + script.getPath());
|
||||
config.save();
|
||||
writeTrashFile(".gitattributes", "*.txt filter=tstFilter");
|
||||
|
||||
git.add().addFilepattern("a.txt").call();
|
||||
git.add().addFilepattern("a.txt").call();
|
||||
|
||||
assertEquals("[a.txt, mode:100644, content:foo]", indexState(CONTENT));
|
||||
assertEquals("[a.txt, mode:100644, content:foo]",
|
||||
indexState(CONTENT));
|
||||
}
|
||||
}
|
||||
|
||||
private File writeTempFile(String body) throws IOException {
|
||||
|
@ -309,19 +315,20 @@ public void testAddExistingSingleSmallFileWithNewLine() throws IOException,
|
|||
writer.print("row1\r\nrow2");
|
||||
writer.close();
|
||||
|
||||
Git git = new Git(db);
|
||||
db.getConfig().setString("core", null, "autocrlf", "false");
|
||||
git.add().addFilepattern("a.txt").call();
|
||||
assertEquals("[a.txt, mode:100644, content:row1\r\nrow2]",
|
||||
indexState(CONTENT));
|
||||
db.getConfig().setString("core", null, "autocrlf", "true");
|
||||
git.add().addFilepattern("a.txt").call();
|
||||
assertEquals("[a.txt, mode:100644, content:row1\nrow2]",
|
||||
indexState(CONTENT));
|
||||
db.getConfig().setString("core", null, "autocrlf", "input");
|
||||
git.add().addFilepattern("a.txt").call();
|
||||
assertEquals("[a.txt, mode:100644, content:row1\nrow2]",
|
||||
indexState(CONTENT));
|
||||
try (Git git = new Git(db)) {
|
||||
db.getConfig().setString("core", null, "autocrlf", "false");
|
||||
git.add().addFilepattern("a.txt").call();
|
||||
assertEquals("[a.txt, mode:100644, content:row1\r\nrow2]",
|
||||
indexState(CONTENT));
|
||||
db.getConfig().setString("core", null, "autocrlf", "true");
|
||||
git.add().addFilepattern("a.txt").call();
|
||||
assertEquals("[a.txt, mode:100644, content:row1\nrow2]",
|
||||
indexState(CONTENT));
|
||||
db.getConfig().setString("core", null, "autocrlf", "input");
|
||||
git.add().addFilepattern("a.txt").call();
|
||||
assertEquals("[a.txt, mode:100644, content:row1\nrow2]",
|
||||
indexState(CONTENT));
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
|
@ -338,19 +345,20 @@ public void testAddExistingSingleMediumSizeFileWithNewLine()
|
|||
writer.print(crData);
|
||||
writer.close();
|
||||
String lfData = data.toString().replaceAll("\r", "");
|
||||
Git git = new Git(db);
|
||||
db.getConfig().setString("core", null, "autocrlf", "false");
|
||||
git.add().addFilepattern("a.txt").call();
|
||||
assertEquals("[a.txt, mode:100644, content:" + data + "]",
|
||||
indexState(CONTENT));
|
||||
db.getConfig().setString("core", null, "autocrlf", "true");
|
||||
git.add().addFilepattern("a.txt").call();
|
||||
assertEquals("[a.txt, mode:100644, content:" + lfData + "]",
|
||||
indexState(CONTENT));
|
||||
db.getConfig().setString("core", null, "autocrlf", "input");
|
||||
git.add().addFilepattern("a.txt").call();
|
||||
assertEquals("[a.txt, mode:100644, content:" + lfData + "]",
|
||||
indexState(CONTENT));
|
||||
try (Git git = new Git(db)) {
|
||||
db.getConfig().setString("core", null, "autocrlf", "false");
|
||||
git.add().addFilepattern("a.txt").call();
|
||||
assertEquals("[a.txt, mode:100644, content:" + data + "]",
|
||||
indexState(CONTENT));
|
||||
db.getConfig().setString("core", null, "autocrlf", "true");
|
||||
git.add().addFilepattern("a.txt").call();
|
||||
assertEquals("[a.txt, mode:100644, content:" + lfData + "]",
|
||||
indexState(CONTENT));
|
||||
db.getConfig().setString("core", null, "autocrlf", "input");
|
||||
git.add().addFilepattern("a.txt").call();
|
||||
assertEquals("[a.txt, mode:100644, content:" + lfData + "]",
|
||||
indexState(CONTENT));
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
|
@ -362,19 +370,20 @@ public void testAddExistingSingleBinaryFile() throws IOException,
|
|||
writer.print("row1\r\nrow2\u0000");
|
||||
writer.close();
|
||||
|
||||
Git git = new Git(db);
|
||||
db.getConfig().setString("core", null, "autocrlf", "false");
|
||||
git.add().addFilepattern("a.txt").call();
|
||||
assertEquals("[a.txt, mode:100644, content:row1\r\nrow2\u0000]",
|
||||
indexState(CONTENT));
|
||||
db.getConfig().setString("core", null, "autocrlf", "true");
|
||||
git.add().addFilepattern("a.txt").call();
|
||||
assertEquals("[a.txt, mode:100644, content:row1\r\nrow2\u0000]",
|
||||
indexState(CONTENT));
|
||||
db.getConfig().setString("core", null, "autocrlf", "input");
|
||||
git.add().addFilepattern("a.txt").call();
|
||||
assertEquals("[a.txt, mode:100644, content:row1\r\nrow2\u0000]",
|
||||
indexState(CONTENT));
|
||||
try (Git git = new Git(db)) {
|
||||
db.getConfig().setString("core", null, "autocrlf", "false");
|
||||
git.add().addFilepattern("a.txt").call();
|
||||
assertEquals("[a.txt, mode:100644, content:row1\r\nrow2\u0000]",
|
||||
indexState(CONTENT));
|
||||
db.getConfig().setString("core", null, "autocrlf", "true");
|
||||
git.add().addFilepattern("a.txt").call();
|
||||
assertEquals("[a.txt, mode:100644, content:row1\r\nrow2\u0000]",
|
||||
indexState(CONTENT));
|
||||
db.getConfig().setString("core", null, "autocrlf", "input");
|
||||
git.add().addFilepattern("a.txt").call();
|
||||
assertEquals("[a.txt, mode:100644, content:row1\r\nrow2\u0000]",
|
||||
indexState(CONTENT));
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
|
@ -387,13 +396,13 @@ public void testAddExistingSingleFileInSubDir() throws IOException,
|
|||
writer.print("content");
|
||||
writer.close();
|
||||
|
||||
Git git = new Git(db);
|
||||
try (Git git = new Git(db)) {
|
||||
git.add().addFilepattern("sub/a.txt").call();
|
||||
|
||||
git.add().addFilepattern("sub/a.txt").call();
|
||||
|
||||
assertEquals(
|
||||
"[sub/a.txt, mode:100644, content:content]",
|
||||
indexState(CONTENT));
|
||||
assertEquals(
|
||||
"[sub/a.txt, mode:100644, content:content]",
|
||||
indexState(CONTENT));
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
|
@ -405,20 +414,21 @@ public void testAddExistingSingleFileTwice() throws IOException,
|
|||
writer.print("content");
|
||||
writer.close();
|
||||
|
||||
Git git = new Git(db);
|
||||
DirCache dc = git.add().addFilepattern("a.txt").call();
|
||||
try (Git git = new Git(db)) {
|
||||
DirCache dc = git.add().addFilepattern("a.txt").call();
|
||||
|
||||
dc.getEntry(0).getObjectId();
|
||||
dc.getEntry(0).getObjectId();
|
||||
|
||||
writer = new PrintWriter(file);
|
||||
writer.print("other content");
|
||||
writer.close();
|
||||
writer = new PrintWriter(file);
|
||||
writer.print("other content");
|
||||
writer.close();
|
||||
|
||||
dc = git.add().addFilepattern("a.txt").call();
|
||||
dc = git.add().addFilepattern("a.txt").call();
|
||||
|
||||
assertEquals(
|
||||
"[a.txt, mode:100644, content:other content]",
|
||||
indexState(CONTENT));
|
||||
assertEquals(
|
||||
"[a.txt, mode:100644, content:other content]",
|
||||
indexState(CONTENT));
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
|
@ -429,22 +439,23 @@ public void testAddExistingSingleFileTwiceWithCommit() throws Exception {
|
|||
writer.print("content");
|
||||
writer.close();
|
||||
|
||||
Git git = new Git(db);
|
||||
DirCache dc = git.add().addFilepattern("a.txt").call();
|
||||
try (Git git = new Git(db)) {
|
||||
DirCache dc = git.add().addFilepattern("a.txt").call();
|
||||
|
||||
dc.getEntry(0).getObjectId();
|
||||
dc.getEntry(0).getObjectId();
|
||||
|
||||
git.commit().setMessage("commit a.txt").call();
|
||||
git.commit().setMessage("commit a.txt").call();
|
||||
|
||||
writer = new PrintWriter(file);
|
||||
writer.print("other content");
|
||||
writer.close();
|
||||
writer = new PrintWriter(file);
|
||||
writer.print("other content");
|
||||
writer.close();
|
||||
|
||||
dc = git.add().addFilepattern("a.txt").call();
|
||||
dc = git.add().addFilepattern("a.txt").call();
|
||||
|
||||
assertEquals(
|
||||
"[a.txt, mode:100644, content:other content]",
|
||||
indexState(CONTENT));
|
||||
assertEquals(
|
||||
"[a.txt, mode:100644, content:other content]",
|
||||
indexState(CONTENT));
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
|
@ -455,18 +466,19 @@ public void testAddRemovedFile() throws Exception {
|
|||
writer.print("content");
|
||||
writer.close();
|
||||
|
||||
Git git = new Git(db);
|
||||
DirCache dc = git.add().addFilepattern("a.txt").call();
|
||||
try (Git git = new Git(db)) {
|
||||
DirCache dc = git.add().addFilepattern("a.txt").call();
|
||||
|
||||
dc.getEntry(0).getObjectId();
|
||||
FileUtils.delete(file);
|
||||
dc.getEntry(0).getObjectId();
|
||||
FileUtils.delete(file);
|
||||
|
||||
// is supposed to do nothing
|
||||
dc = git.add().addFilepattern("a.txt").call();
|
||||
// is supposed to do nothing
|
||||
dc = git.add().addFilepattern("a.txt").call();
|
||||
|
||||
assertEquals(
|
||||
"[a.txt, mode:100644, content:content]",
|
||||
indexState(CONTENT));
|
||||
assertEquals(
|
||||
"[a.txt, mode:100644, content:content]",
|
||||
indexState(CONTENT));
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
|
@ -477,20 +489,21 @@ public void testAddRemovedCommittedFile() throws Exception {
|
|||
writer.print("content");
|
||||
writer.close();
|
||||
|
||||
Git git = new Git(db);
|
||||
DirCache dc = git.add().addFilepattern("a.txt").call();
|
||||
try (Git git = new Git(db)) {
|
||||
DirCache dc = git.add().addFilepattern("a.txt").call();
|
||||
|
||||
git.commit().setMessage("commit a.txt").call();
|
||||
git.commit().setMessage("commit a.txt").call();
|
||||
|
||||
dc.getEntry(0).getObjectId();
|
||||
FileUtils.delete(file);
|
||||
dc.getEntry(0).getObjectId();
|
||||
FileUtils.delete(file);
|
||||
|
||||
// is supposed to do nothing
|
||||
dc = git.add().addFilepattern("a.txt").call();
|
||||
// is supposed to do nothing
|
||||
dc = git.add().addFilepattern("a.txt").call();
|
||||
|
||||
assertEquals(
|
||||
"[a.txt, mode:100644, content:content]",
|
||||
indexState(CONTENT));
|
||||
assertEquals(
|
||||
"[a.txt, mode:100644, content:content]",
|
||||
indexState(CONTENT));
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
|
@ -538,13 +551,14 @@ public void testAddWithConflicts() throws Exception {
|
|||
|
||||
// now the test begins
|
||||
|
||||
Git git = new Git(db);
|
||||
dc = git.add().addFilepattern("a.txt").call();
|
||||
try (Git git = new Git(db)) {
|
||||
dc = git.add().addFilepattern("a.txt").call();
|
||||
|
||||
assertEquals(
|
||||
"[a.txt, mode:100644, content:our content]" +
|
||||
"[b.txt, mode:100644, content:content b]",
|
||||
indexState(CONTENT));
|
||||
assertEquals(
|
||||
"[a.txt, mode:100644, content:our content]" +
|
||||
"[b.txt, mode:100644, content:content b]",
|
||||
indexState(CONTENT));
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
|
@ -561,12 +575,13 @@ public void testAddTwoFiles() throws Exception {
|
|||
writer.print("content b");
|
||||
writer.close();
|
||||
|
||||
Git git = new Git(db);
|
||||
git.add().addFilepattern("a.txt").addFilepattern("b.txt").call();
|
||||
assertEquals(
|
||||
"[a.txt, mode:100644, content:content]" +
|
||||
"[b.txt, mode:100644, content:content b]",
|
||||
indexState(CONTENT));
|
||||
try (Git git = new Git(db)) {
|
||||
git.add().addFilepattern("a.txt").addFilepattern("b.txt").call();
|
||||
assertEquals(
|
||||
"[a.txt, mode:100644, content:content]" +
|
||||
"[b.txt, mode:100644, content:content b]",
|
||||
indexState(CONTENT));
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
|
@ -584,12 +599,13 @@ public void testAddFolder() throws Exception {
|
|||
writer.print("content b");
|
||||
writer.close();
|
||||
|
||||
Git git = new Git(db);
|
||||
git.add().addFilepattern("sub").call();
|
||||
assertEquals(
|
||||
"[sub/a.txt, mode:100644, content:content]" +
|
||||
"[sub/b.txt, mode:100644, content:content b]",
|
||||
indexState(CONTENT));
|
||||
try (Git git = new Git(db)) {
|
||||
git.add().addFilepattern("sub").call();
|
||||
assertEquals(
|
||||
"[sub/a.txt, mode:100644, content:content]" +
|
||||
"[sub/b.txt, mode:100644, content:content b]",
|
||||
indexState(CONTENT));
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
|
@ -613,12 +629,13 @@ public void testAddIgnoredFile() throws Exception {
|
|||
writer.print("content b");
|
||||
writer.close();
|
||||
|
||||
Git git = new Git(db);
|
||||
git.add().addFilepattern("sub").call();
|
||||
try (Git git = new Git(db)) {
|
||||
git.add().addFilepattern("sub").call();
|
||||
|
||||
assertEquals(
|
||||
"[sub/a.txt, mode:100644, content:content]",
|
||||
indexState(CONTENT));
|
||||
assertEquals(
|
||||
"[sub/a.txt, mode:100644, content:content]",
|
||||
indexState(CONTENT));
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
|
@ -636,12 +653,13 @@ public void testAddWholeRepo() throws Exception {
|
|||
writer.print("content b");
|
||||
writer.close();
|
||||
|
||||
Git git = new Git(db);
|
||||
git.add().addFilepattern(".").call();
|
||||
assertEquals(
|
||||
"[sub/a.txt, mode:100644, content:content]" +
|
||||
"[sub/b.txt, mode:100644, content:content b]",
|
||||
indexState(CONTENT));
|
||||
try (Git git = new Git(db)) {
|
||||
git.add().addFilepattern(".").call();
|
||||
assertEquals(
|
||||
"[sub/a.txt, mode:100644, content:content]" +
|
||||
"[sub/b.txt, mode:100644, content:content b]",
|
||||
indexState(CONTENT));
|
||||
}
|
||||
}
|
||||
|
||||
// the same three cases as in testAddWithParameterUpdate
|
||||
|
@ -663,40 +681,41 @@ public void testAddWithoutParameterUpdate() throws Exception {
|
|||
writer.print("content b");
|
||||
writer.close();
|
||||
|
||||
Git git = new Git(db);
|
||||
git.add().addFilepattern("sub").call();
|
||||
try (Git git = new Git(db)) {
|
||||
git.add().addFilepattern("sub").call();
|
||||
|
||||
assertEquals(
|
||||
"[sub/a.txt, mode:100644, content:content]" +
|
||||
"[sub/b.txt, mode:100644, content:content b]",
|
||||
indexState(CONTENT));
|
||||
assertEquals(
|
||||
"[sub/a.txt, mode:100644, content:content]" +
|
||||
"[sub/b.txt, mode:100644, content:content b]",
|
||||
indexState(CONTENT));
|
||||
|
||||
git.commit().setMessage("commit").call();
|
||||
git.commit().setMessage("commit").call();
|
||||
|
||||
// new unstaged file sub/c.txt
|
||||
File file3 = new File(db.getWorkTree(), "sub/c.txt");
|
||||
FileUtils.createNewFile(file3);
|
||||
writer = new PrintWriter(file3);
|
||||
writer.print("content c");
|
||||
writer.close();
|
||||
// new unstaged file sub/c.txt
|
||||
File file3 = new File(db.getWorkTree(), "sub/c.txt");
|
||||
FileUtils.createNewFile(file3);
|
||||
writer = new PrintWriter(file3);
|
||||
writer.print("content c");
|
||||
writer.close();
|
||||
|
||||
// file sub/a.txt is modified
|
||||
writer = new PrintWriter(file);
|
||||
writer.print("modified content");
|
||||
writer.close();
|
||||
// file sub/a.txt is modified
|
||||
writer = new PrintWriter(file);
|
||||
writer.print("modified content");
|
||||
writer.close();
|
||||
|
||||
// file sub/b.txt is deleted
|
||||
FileUtils.delete(file2);
|
||||
// file sub/b.txt is deleted
|
||||
FileUtils.delete(file2);
|
||||
|
||||
git.add().addFilepattern("sub").call();
|
||||
// change in sub/a.txt is staged
|
||||
// deletion of sub/b.txt is not staged
|
||||
// sub/c.txt is staged
|
||||
assertEquals(
|
||||
"[sub/a.txt, mode:100644, content:modified content]" +
|
||||
"[sub/b.txt, mode:100644, content:content b]" +
|
||||
"[sub/c.txt, mode:100644, content:content c]",
|
||||
indexState(CONTENT));
|
||||
git.add().addFilepattern("sub").call();
|
||||
// change in sub/a.txt is staged
|
||||
// deletion of sub/b.txt is not staged
|
||||
// sub/c.txt is staged
|
||||
assertEquals(
|
||||
"[sub/a.txt, mode:100644, content:modified content]" +
|
||||
"[sub/b.txt, mode:100644, content:content b]" +
|
||||
"[sub/c.txt, mode:100644, content:content c]",
|
||||
indexState(CONTENT));
|
||||
}
|
||||
}
|
||||
|
||||
// file a exists in workdir and in index -> added
|
||||
|
@ -717,70 +736,72 @@ public void testAddWithParameterUpdate() throws Exception {
|
|||
writer.print("content b");
|
||||
writer.close();
|
||||
|
||||
Git git = new Git(db);
|
||||
git.add().addFilepattern("sub").call();
|
||||
try (Git git = new Git(db)) {
|
||||
git.add().addFilepattern("sub").call();
|
||||
|
||||
assertEquals(
|
||||
"[sub/a.txt, mode:100644, content:content]" +
|
||||
"[sub/b.txt, mode:100644, content:content b]",
|
||||
indexState(CONTENT));
|
||||
assertEquals(
|
||||
"[sub/a.txt, mode:100644, content:content]" +
|
||||
"[sub/b.txt, mode:100644, content:content b]",
|
||||
indexState(CONTENT));
|
||||
|
||||
git.commit().setMessage("commit").call();
|
||||
git.commit().setMessage("commit").call();
|
||||
|
||||
// new unstaged file sub/c.txt
|
||||
File file3 = new File(db.getWorkTree(), "sub/c.txt");
|
||||
FileUtils.createNewFile(file3);
|
||||
writer = new PrintWriter(file3);
|
||||
writer.print("content c");
|
||||
writer.close();
|
||||
// new unstaged file sub/c.txt
|
||||
File file3 = new File(db.getWorkTree(), "sub/c.txt");
|
||||
FileUtils.createNewFile(file3);
|
||||
writer = new PrintWriter(file3);
|
||||
writer.print("content c");
|
||||
writer.close();
|
||||
|
||||
// file sub/a.txt is modified
|
||||
writer = new PrintWriter(file);
|
||||
writer.print("modified content");
|
||||
writer.close();
|
||||
// file sub/a.txt is modified
|
||||
writer = new PrintWriter(file);
|
||||
writer.print("modified content");
|
||||
writer.close();
|
||||
|
||||
FileUtils.delete(file2);
|
||||
FileUtils.delete(file2);
|
||||
|
||||
// change in sub/a.txt is staged
|
||||
// deletion of sub/b.txt is staged
|
||||
// sub/c.txt is not staged
|
||||
git.add().addFilepattern("sub").setUpdate(true).call();
|
||||
// change in sub/a.txt is staged
|
||||
assertEquals(
|
||||
"[sub/a.txt, mode:100644, content:modified content]",
|
||||
indexState(CONTENT));
|
||||
// change in sub/a.txt is staged
|
||||
// deletion of sub/b.txt is staged
|
||||
// sub/c.txt is not staged
|
||||
git.add().addFilepattern("sub").setUpdate(true).call();
|
||||
// change in sub/a.txt is staged
|
||||
assertEquals(
|
||||
"[sub/a.txt, mode:100644, content:modified content]",
|
||||
indexState(CONTENT));
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testAssumeUnchanged() throws Exception {
|
||||
Git git = new Git(db);
|
||||
String path = "a.txt";
|
||||
writeTrashFile(path, "content");
|
||||
git.add().addFilepattern(path).call();
|
||||
String path2 = "b.txt";
|
||||
writeTrashFile(path2, "content");
|
||||
git.add().addFilepattern(path2).call();
|
||||
git.commit().setMessage("commit").call();
|
||||
assertEquals("[a.txt, mode:100644, content:"
|
||||
+ "content, assume-unchanged:false]"
|
||||
+ "[b.txt, mode:100644, content:content, "
|
||||
+ "assume-unchanged:false]", indexState(CONTENT
|
||||
| ASSUME_UNCHANGED));
|
||||
assumeUnchanged(path2);
|
||||
assertEquals("[a.txt, mode:100644, content:content, "
|
||||
+ "assume-unchanged:false][b.txt, mode:100644, "
|
||||
+ "content:content, assume-unchanged:true]", indexState(CONTENT
|
||||
| ASSUME_UNCHANGED));
|
||||
writeTrashFile(path, "more content");
|
||||
writeTrashFile(path2, "more content");
|
||||
try (Git git = new Git(db)) {
|
||||
String path = "a.txt";
|
||||
writeTrashFile(path, "content");
|
||||
git.add().addFilepattern(path).call();
|
||||
String path2 = "b.txt";
|
||||
writeTrashFile(path2, "content");
|
||||
git.add().addFilepattern(path2).call();
|
||||
git.commit().setMessage("commit").call();
|
||||
assertEquals("[a.txt, mode:100644, content:"
|
||||
+ "content, assume-unchanged:false]"
|
||||
+ "[b.txt, mode:100644, content:content, "
|
||||
+ "assume-unchanged:false]", indexState(CONTENT
|
||||
| ASSUME_UNCHANGED));
|
||||
assumeUnchanged(path2);
|
||||
assertEquals("[a.txt, mode:100644, content:content, "
|
||||
+ "assume-unchanged:false][b.txt, mode:100644, "
|
||||
+ "content:content, assume-unchanged:true]", indexState(CONTENT
|
||||
| ASSUME_UNCHANGED));
|
||||
writeTrashFile(path, "more content");
|
||||
writeTrashFile(path2, "more content");
|
||||
|
||||
git.add().addFilepattern(".").call();
|
||||
git.add().addFilepattern(".").call();
|
||||
|
||||
assertEquals("[a.txt, mode:100644, content:more content,"
|
||||
+ " assume-unchanged:false][b.txt, mode:100644,"
|
||||
+ " content:content, assume-unchanged:true]",
|
||||
indexState(CONTENT
|
||||
| ASSUME_UNCHANGED));
|
||||
assertEquals("[a.txt, mode:100644, content:more content,"
|
||||
+ " assume-unchanged:false][b.txt, mode:100644,"
|
||||
+ " content:content, assume-unchanged:true]",
|
||||
indexState(CONTENT
|
||||
| ASSUME_UNCHANGED));
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
|
|
|
@ -85,103 +85,107 @@ public void tearDown() {
|
|||
|
||||
@Test
|
||||
public void archiveHeadAllFiles() throws IOException, GitAPIException {
|
||||
Git git = new Git(db);
|
||||
writeTrashFile("file_1.txt", "content_1_1");
|
||||
git.add().addFilepattern("file_1.txt").call();
|
||||
git.commit().setMessage("create file").call();
|
||||
try (Git git = new Git(db)) {
|
||||
writeTrashFile("file_1.txt", "content_1_1");
|
||||
git.add().addFilepattern("file_1.txt").call();
|
||||
git.commit().setMessage("create file").call();
|
||||
|
||||
writeTrashFile("file_1.txt", "content_1_2");
|
||||
writeTrashFile("file_2.txt", "content_2_2");
|
||||
git.add().addFilepattern(".").call();
|
||||
git.commit().setMessage("updated file").call();
|
||||
writeTrashFile("file_1.txt", "content_1_2");
|
||||
writeTrashFile("file_2.txt", "content_2_2");
|
||||
git.add().addFilepattern(".").call();
|
||||
git.commit().setMessage("updated file").call();
|
||||
|
||||
git.archive().setOutputStream(new MockOutputStream())
|
||||
.setFormat(format.SUFFIXES.get(0))
|
||||
.setTree(git.getRepository().resolve("HEAD")).call();
|
||||
git.archive().setOutputStream(new MockOutputStream())
|
||||
.setFormat(format.SUFFIXES.get(0))
|
||||
.setTree(git.getRepository().resolve("HEAD")).call();
|
||||
|
||||
assertEquals(UNEXPECTED_ARCHIVE_SIZE, 2, format.size());
|
||||
assertEquals(UNEXPECTED_FILE_CONTENTS, "content_1_2", format.getByPath("file_1.txt"));
|
||||
assertEquals(UNEXPECTED_FILE_CONTENTS, "content_2_2", format.getByPath("file_2.txt"));
|
||||
assertEquals(UNEXPECTED_ARCHIVE_SIZE, 2, format.size());
|
||||
assertEquals(UNEXPECTED_FILE_CONTENTS, "content_1_2", format.getByPath("file_1.txt"));
|
||||
assertEquals(UNEXPECTED_FILE_CONTENTS, "content_2_2", format.getByPath("file_2.txt"));
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void archiveHeadSpecificPath() throws IOException, GitAPIException {
|
||||
Git git = new Git(db);
|
||||
writeTrashFile("file_1.txt", "content_1_1");
|
||||
git.add().addFilepattern("file_1.txt").call();
|
||||
git.commit().setMessage("create file").call();
|
||||
try (Git git = new Git(db)) {
|
||||
writeTrashFile("file_1.txt", "content_1_1");
|
||||
git.add().addFilepattern("file_1.txt").call();
|
||||
git.commit().setMessage("create file").call();
|
||||
|
||||
writeTrashFile("file_1.txt", "content_1_2");
|
||||
String expectedFilePath = "some_directory/file_2.txt";
|
||||
writeTrashFile(expectedFilePath, "content_2_2");
|
||||
git.add().addFilepattern(".").call();
|
||||
git.commit().setMessage("updated file").call();
|
||||
writeTrashFile("file_1.txt", "content_1_2");
|
||||
String expectedFilePath = "some_directory/file_2.txt";
|
||||
writeTrashFile(expectedFilePath, "content_2_2");
|
||||
git.add().addFilepattern(".").call();
|
||||
git.commit().setMessage("updated file").call();
|
||||
|
||||
git.archive().setOutputStream(new MockOutputStream())
|
||||
.setFormat(format.SUFFIXES.get(0))
|
||||
.setTree(git.getRepository().resolve("HEAD"))
|
||||
.setPaths(expectedFilePath).call();
|
||||
git.archive().setOutputStream(new MockOutputStream())
|
||||
.setFormat(format.SUFFIXES.get(0))
|
||||
.setTree(git.getRepository().resolve("HEAD"))
|
||||
.setPaths(expectedFilePath).call();
|
||||
|
||||
assertEquals(UNEXPECTED_ARCHIVE_SIZE, 2, format.size());
|
||||
assertEquals(UNEXPECTED_FILE_CONTENTS, "content_2_2", format.getByPath(expectedFilePath));
|
||||
assertNull(UNEXPECTED_TREE_CONTENTS, format.getByPath("some_directory"));
|
||||
assertEquals(UNEXPECTED_ARCHIVE_SIZE, 2, format.size());
|
||||
assertEquals(UNEXPECTED_FILE_CONTENTS, "content_2_2", format.getByPath(expectedFilePath));
|
||||
assertNull(UNEXPECTED_TREE_CONTENTS, format.getByPath("some_directory"));
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void archiveByIdSpecificFile() throws IOException, GitAPIException {
|
||||
Git git = new Git(db);
|
||||
writeTrashFile("file_1.txt", "content_1_1");
|
||||
git.add().addFilepattern("file_1.txt").call();
|
||||
RevCommit first = git.commit().setMessage("create file").call();
|
||||
try (Git git = new Git(db)) {
|
||||
writeTrashFile("file_1.txt", "content_1_1");
|
||||
git.add().addFilepattern("file_1.txt").call();
|
||||
RevCommit first = git.commit().setMessage("create file").call();
|
||||
|
||||
writeTrashFile("file_1.txt", "content_1_2");
|
||||
String expectedFilePath = "some_directory/file_2.txt";
|
||||
writeTrashFile(expectedFilePath, "content_2_2");
|
||||
git.add().addFilepattern(".").call();
|
||||
git.commit().setMessage("updated file").call();
|
||||
writeTrashFile("file_1.txt", "content_1_2");
|
||||
String expectedFilePath = "some_directory/file_2.txt";
|
||||
writeTrashFile(expectedFilePath, "content_2_2");
|
||||
git.add().addFilepattern(".").call();
|
||||
git.commit().setMessage("updated file").call();
|
||||
|
||||
Map<String, Object> options = new HashMap<>();
|
||||
Integer opt = Integer.valueOf(42);
|
||||
options.put("foo", opt);
|
||||
MockOutputStream out = new MockOutputStream();
|
||||
git.archive().setOutputStream(out)
|
||||
.setFormat(format.SUFFIXES.get(0))
|
||||
.setFormatOptions(options)
|
||||
.setTree(first)
|
||||
.setPaths("file_1.txt").call();
|
||||
Map<String, Object> options = new HashMap<>();
|
||||
Integer opt = Integer.valueOf(42);
|
||||
options.put("foo", opt);
|
||||
MockOutputStream out = new MockOutputStream();
|
||||
git.archive().setOutputStream(out)
|
||||
.setFormat(format.SUFFIXES.get(0))
|
||||
.setFormatOptions(options)
|
||||
.setTree(first)
|
||||
.setPaths("file_1.txt").call();
|
||||
|
||||
assertEquals(opt.intValue(), out.getFoo());
|
||||
assertEquals(UNEXPECTED_ARCHIVE_SIZE, 1, format.size());
|
||||
assertEquals(UNEXPECTED_FILE_CONTENTS, "content_1_1", format.getByPath("file_1.txt"));
|
||||
assertEquals(opt.intValue(), out.getFoo());
|
||||
assertEquals(UNEXPECTED_ARCHIVE_SIZE, 1, format.size());
|
||||
assertEquals(UNEXPECTED_FILE_CONTENTS, "content_1_1", format.getByPath("file_1.txt"));
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void archiveByDirectoryPath() throws GitAPIException, IOException {
|
||||
Git git = new Git(db);
|
||||
writeTrashFile("file_0.txt", "content_0_1");
|
||||
git.add().addFilepattern("file_0.txt").call();
|
||||
git.commit().setMessage("commit_1").call();
|
||||
try (Git git = new Git(db)) {
|
||||
writeTrashFile("file_0.txt", "content_0_1");
|
||||
git.add().addFilepattern("file_0.txt").call();
|
||||
git.commit().setMessage("commit_1").call();
|
||||
|
||||
writeTrashFile("file_0.txt", "content_0_2");
|
||||
String expectedFilePath1 = "some_directory/file_1.txt";
|
||||
writeTrashFile(expectedFilePath1, "content_1_2");
|
||||
String expectedFilePath2 = "some_directory/file_2.txt";
|
||||
writeTrashFile(expectedFilePath2, "content_2_2");
|
||||
String expectedFilePath3 = "some_directory/nested_directory/file_3.txt";
|
||||
writeTrashFile(expectedFilePath3, "content_3_2");
|
||||
git.add().addFilepattern(".").call();
|
||||
git.commit().setMessage("commit_2").call();
|
||||
git.archive().setOutputStream(new MockOutputStream())
|
||||
.setFormat(format.SUFFIXES.get(0))
|
||||
.setTree(git.getRepository().resolve("HEAD"))
|
||||
.setPaths("some_directory/").call();
|
||||
writeTrashFile("file_0.txt", "content_0_2");
|
||||
String expectedFilePath1 = "some_directory/file_1.txt";
|
||||
writeTrashFile(expectedFilePath1, "content_1_2");
|
||||
String expectedFilePath2 = "some_directory/file_2.txt";
|
||||
writeTrashFile(expectedFilePath2, "content_2_2");
|
||||
String expectedFilePath3 = "some_directory/nested_directory/file_3.txt";
|
||||
writeTrashFile(expectedFilePath3, "content_3_2");
|
||||
git.add().addFilepattern(".").call();
|
||||
git.commit().setMessage("commit_2").call();
|
||||
git.archive().setOutputStream(new MockOutputStream())
|
||||
.setFormat(format.SUFFIXES.get(0))
|
||||
.setTree(git.getRepository().resolve("HEAD"))
|
||||
.setPaths("some_directory/").call();
|
||||
|
||||
assertEquals(UNEXPECTED_ARCHIVE_SIZE, 5, format.size());
|
||||
assertEquals(UNEXPECTED_FILE_CONTENTS, "content_1_2", format.getByPath(expectedFilePath1));
|
||||
assertEquals(UNEXPECTED_FILE_CONTENTS, "content_2_2", format.getByPath(expectedFilePath2));
|
||||
assertEquals(UNEXPECTED_FILE_CONTENTS, "content_3_2", format.getByPath(expectedFilePath3));
|
||||
assertNull(UNEXPECTED_TREE_CONTENTS, format.getByPath("some_directory"));
|
||||
assertNull(UNEXPECTED_TREE_CONTENTS, format.getByPath("some_directory/nested_directory"));
|
||||
assertEquals(UNEXPECTED_ARCHIVE_SIZE, 5, format.size());
|
||||
assertEquals(UNEXPECTED_FILE_CONTENTS, "content_1_2", format.getByPath(expectedFilePath1));
|
||||
assertEquals(UNEXPECTED_FILE_CONTENTS, "content_2_2", format.getByPath(expectedFilePath2));
|
||||
assertEquals(UNEXPECTED_FILE_CONTENTS, "content_3_2", format.getByPath(expectedFilePath3));
|
||||
assertNull(UNEXPECTED_TREE_CONTENTS, format.getByPath("some_directory"));
|
||||
assertNull(UNEXPECTED_TREE_CONTENTS, format.getByPath("some_directory/nested_directory"));
|
||||
}
|
||||
}
|
||||
|
||||
private class MockFormat implements ArchiveCommand.Format<MockOutputStream> {
|
||||
|
|
|
@ -72,53 +72,53 @@ private static String join(String... lines) {
|
|||
|
||||
@Test
|
||||
public void testSingleRevision() throws Exception {
|
||||
Git git = new Git(db);
|
||||
try (Git git = new Git(db)) {
|
||||
String[] content = new String[] { "first", "second", "third" };
|
||||
|
||||
String[] content = new String[] { "first", "second", "third" };
|
||||
writeTrashFile("file.txt", join(content));
|
||||
git.add().addFilepattern("file.txt").call();
|
||||
RevCommit commit = git.commit().setMessage("create file").call();
|
||||
|
||||
writeTrashFile("file.txt", join(content));
|
||||
git.add().addFilepattern("file.txt").call();
|
||||
RevCommit commit = git.commit().setMessage("create file").call();
|
||||
BlameCommand command = new BlameCommand(db);
|
||||
command.setFilePath("file.txt");
|
||||
BlameResult lines = command.call();
|
||||
assertNotNull(lines);
|
||||
assertEquals(3, lines.getResultContents().size());
|
||||
|
||||
BlameCommand command = new BlameCommand(db);
|
||||
command.setFilePath("file.txt");
|
||||
BlameResult lines = command.call();
|
||||
assertNotNull(lines);
|
||||
assertEquals(3, lines.getResultContents().size());
|
||||
|
||||
for (int i = 0; i < 3; i++) {
|
||||
assertEquals(commit, lines.getSourceCommit(i));
|
||||
assertEquals(i, lines.getSourceLine(i));
|
||||
for (int i = 0; i < 3; i++) {
|
||||
assertEquals(commit, lines.getSourceCommit(i));
|
||||
assertEquals(i, lines.getSourceLine(i));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testTwoRevisions() 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 commit1 = git.commit().setMessage("create file").call();
|
||||
|
||||
String[] content1 = new String[] { "first", "second" };
|
||||
writeTrashFile("file.txt", join(content1));
|
||||
git.add().addFilepattern("file.txt").call();
|
||||
RevCommit commit1 = git.commit().setMessage("create file").call();
|
||||
String[] content2 = new String[] { "first", "second", "third" };
|
||||
writeTrashFile("file.txt", join(content2));
|
||||
git.add().addFilepattern("file.txt").call();
|
||||
RevCommit commit2 = git.commit().setMessage("create file").call();
|
||||
|
||||
String[] content2 = new String[] { "first", "second", "third" };
|
||||
writeTrashFile("file.txt", join(content2));
|
||||
git.add().addFilepattern("file.txt").call();
|
||||
RevCommit commit2 = git.commit().setMessage("create file").call();
|
||||
BlameCommand command = new BlameCommand(db);
|
||||
command.setFilePath("file.txt");
|
||||
BlameResult lines = command.call();
|
||||
assertEquals(3, lines.getResultContents().size());
|
||||
|
||||
BlameCommand command = new BlameCommand(db);
|
||||
command.setFilePath("file.txt");
|
||||
BlameResult lines = command.call();
|
||||
assertEquals(3, lines.getResultContents().size());
|
||||
assertEquals(commit1, lines.getSourceCommit(0));
|
||||
assertEquals(0, lines.getSourceLine(0));
|
||||
|
||||
assertEquals(commit1, lines.getSourceCommit(0));
|
||||
assertEquals(0, lines.getSourceLine(0));
|
||||
assertEquals(commit1, lines.getSourceCommit(1));
|
||||
assertEquals(1, lines.getSourceLine(1));
|
||||
|
||||
assertEquals(commit1, lines.getSourceCommit(1));
|
||||
assertEquals(1, lines.getSourceLine(1));
|
||||
|
||||
assertEquals(commit2, lines.getSourceCommit(2));
|
||||
assertEquals(2, lines.getSourceLine(2));
|
||||
assertEquals(commit2, lines.getSourceCommit(2));
|
||||
assertEquals(2, lines.getSourceLine(2));
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
|
@ -138,200 +138,200 @@ public void testMoveToOtherDir() throws Exception {
|
|||
|
||||
private void testRename(final String sourcePath, final String destPath)
|
||||
throws Exception {
|
||||
Git git = new Git(db);
|
||||
try (Git git = new Git(db)) {
|
||||
String[] content1 = new String[] { "a", "b", "c" };
|
||||
writeTrashFile(sourcePath, join(content1));
|
||||
git.add().addFilepattern(sourcePath).call();
|
||||
RevCommit commit1 = git.commit().setMessage("create file").call();
|
||||
|
||||
String[] content1 = new String[] { "a", "b", "c" };
|
||||
writeTrashFile(sourcePath, join(content1));
|
||||
git.add().addFilepattern(sourcePath).call();
|
||||
RevCommit commit1 = git.commit().setMessage("create file").call();
|
||||
writeTrashFile(destPath, join(content1));
|
||||
git.add().addFilepattern(destPath).call();
|
||||
git.rm().addFilepattern(sourcePath).call();
|
||||
git.commit().setMessage("moving file").call();
|
||||
|
||||
writeTrashFile(destPath, join(content1));
|
||||
git.add().addFilepattern(destPath).call();
|
||||
git.rm().addFilepattern(sourcePath).call();
|
||||
git.commit().setMessage("moving file").call();
|
||||
String[] content2 = new String[] { "a", "b", "c2" };
|
||||
writeTrashFile(destPath, join(content2));
|
||||
git.add().addFilepattern(destPath).call();
|
||||
RevCommit commit3 = git.commit().setMessage("editing file").call();
|
||||
|
||||
String[] content2 = new String[] { "a", "b", "c2" };
|
||||
writeTrashFile(destPath, join(content2));
|
||||
git.add().addFilepattern(destPath).call();
|
||||
RevCommit commit3 = git.commit().setMessage("editing file").call();
|
||||
BlameCommand command = new BlameCommand(db);
|
||||
command.setFollowFileRenames(true);
|
||||
command.setFilePath(destPath);
|
||||
BlameResult lines = command.call();
|
||||
|
||||
BlameCommand command = new BlameCommand(db);
|
||||
command.setFollowFileRenames(true);
|
||||
command.setFilePath(destPath);
|
||||
BlameResult lines = command.call();
|
||||
assertEquals(commit1, lines.getSourceCommit(0));
|
||||
assertEquals(0, lines.getSourceLine(0));
|
||||
assertEquals(sourcePath, lines.getSourcePath(0));
|
||||
|
||||
assertEquals(commit1, lines.getSourceCommit(0));
|
||||
assertEquals(0, lines.getSourceLine(0));
|
||||
assertEquals(sourcePath, lines.getSourcePath(0));
|
||||
assertEquals(commit1, lines.getSourceCommit(1));
|
||||
assertEquals(1, lines.getSourceLine(1));
|
||||
assertEquals(sourcePath, lines.getSourcePath(1));
|
||||
|
||||
assertEquals(commit1, lines.getSourceCommit(1));
|
||||
assertEquals(1, lines.getSourceLine(1));
|
||||
assertEquals(sourcePath, lines.getSourcePath(1));
|
||||
|
||||
assertEquals(commit3, lines.getSourceCommit(2));
|
||||
assertEquals(2, lines.getSourceLine(2));
|
||||
assertEquals(destPath, lines.getSourcePath(2));
|
||||
assertEquals(commit3, lines.getSourceCommit(2));
|
||||
assertEquals(2, lines.getSourceLine(2));
|
||||
assertEquals(destPath, lines.getSourcePath(2));
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testTwoRenames() throws Exception {
|
||||
Git git = new Git(db);
|
||||
try (Git git = new Git(db)) {
|
||||
// Commit 1: Add file.txt
|
||||
String[] content1 = new String[] { "a" };
|
||||
writeTrashFile("file.txt", join(content1));
|
||||
git.add().addFilepattern("file.txt").call();
|
||||
RevCommit commit1 = git.commit().setMessage("create file").call();
|
||||
|
||||
// Commit 1: Add file.txt
|
||||
String[] content1 = new String[] { "a" };
|
||||
writeTrashFile("file.txt", join(content1));
|
||||
git.add().addFilepattern("file.txt").call();
|
||||
RevCommit commit1 = git.commit().setMessage("create file").call();
|
||||
// Commit 2: Rename to file1.txt
|
||||
writeTrashFile("file1.txt", join(content1));
|
||||
git.add().addFilepattern("file1.txt").call();
|
||||
git.rm().addFilepattern("file.txt").call();
|
||||
git.commit().setMessage("moving file").call();
|
||||
|
||||
// Commit 2: Rename to file1.txt
|
||||
writeTrashFile("file1.txt", join(content1));
|
||||
git.add().addFilepattern("file1.txt").call();
|
||||
git.rm().addFilepattern("file.txt").call();
|
||||
git.commit().setMessage("moving file").call();
|
||||
// Commit 3: Edit file1.txt
|
||||
String[] content2 = new String[] { "a", "b" };
|
||||
writeTrashFile("file1.txt", join(content2));
|
||||
git.add().addFilepattern("file1.txt").call();
|
||||
RevCommit commit3 = git.commit().setMessage("editing file").call();
|
||||
|
||||
// Commit 3: Edit file1.txt
|
||||
String[] content2 = new String[] { "a", "b" };
|
||||
writeTrashFile("file1.txt", join(content2));
|
||||
git.add().addFilepattern("file1.txt").call();
|
||||
RevCommit commit3 = git.commit().setMessage("editing file").call();
|
||||
// Commit 4: Rename to file2.txt
|
||||
writeTrashFile("file2.txt", join(content2));
|
||||
git.add().addFilepattern("file2.txt").call();
|
||||
git.rm().addFilepattern("file1.txt").call();
|
||||
git.commit().setMessage("moving file again").call();
|
||||
|
||||
// Commit 4: Rename to file2.txt
|
||||
writeTrashFile("file2.txt", join(content2));
|
||||
git.add().addFilepattern("file2.txt").call();
|
||||
git.rm().addFilepattern("file1.txt").call();
|
||||
git.commit().setMessage("moving file again").call();
|
||||
BlameCommand command = new BlameCommand(db);
|
||||
command.setFollowFileRenames(true);
|
||||
command.setFilePath("file2.txt");
|
||||
BlameResult lines = command.call();
|
||||
|
||||
BlameCommand command = new BlameCommand(db);
|
||||
command.setFollowFileRenames(true);
|
||||
command.setFilePath("file2.txt");
|
||||
BlameResult lines = command.call();
|
||||
assertEquals(commit1, lines.getSourceCommit(0));
|
||||
assertEquals(0, lines.getSourceLine(0));
|
||||
assertEquals("file.txt", lines.getSourcePath(0));
|
||||
|
||||
assertEquals(commit1, lines.getSourceCommit(0));
|
||||
assertEquals(0, lines.getSourceLine(0));
|
||||
assertEquals("file.txt", lines.getSourcePath(0));
|
||||
|
||||
assertEquals(commit3, lines.getSourceCommit(1));
|
||||
assertEquals(1, lines.getSourceLine(1));
|
||||
assertEquals("file1.txt", lines.getSourcePath(1));
|
||||
assertEquals(commit3, lines.getSourceCommit(1));
|
||||
assertEquals(1, lines.getSourceLine(1));
|
||||
assertEquals("file1.txt", lines.getSourcePath(1));
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testDeleteTrailingLines() throws Exception {
|
||||
Git git = new Git(db);
|
||||
try (Git git = new Git(db)) {
|
||||
String[] content1 = new String[] { "a", "b", "c", "d" };
|
||||
String[] content2 = new String[] { "a", "b" };
|
||||
|
||||
String[] content1 = new String[] { "a", "b", "c", "d" };
|
||||
String[] content2 = new String[] { "a", "b" };
|
||||
writeTrashFile("file.txt", join(content2));
|
||||
git.add().addFilepattern("file.txt").call();
|
||||
RevCommit commit1 = git.commit().setMessage("create file").call();
|
||||
|
||||
writeTrashFile("file.txt", join(content2));
|
||||
git.add().addFilepattern("file.txt").call();
|
||||
RevCommit commit1 = git.commit().setMessage("create file").call();
|
||||
writeTrashFile("file.txt", join(content1));
|
||||
git.add().addFilepattern("file.txt").call();
|
||||
git.commit().setMessage("edit file").call();
|
||||
|
||||
writeTrashFile("file.txt", join(content1));
|
||||
git.add().addFilepattern("file.txt").call();
|
||||
git.commit().setMessage("edit file").call();
|
||||
writeTrashFile("file.txt", join(content2));
|
||||
git.add().addFilepattern("file.txt").call();
|
||||
git.commit().setMessage("edit file").call();
|
||||
|
||||
writeTrashFile("file.txt", join(content2));
|
||||
git.add().addFilepattern("file.txt").call();
|
||||
git.commit().setMessage("edit file").call();
|
||||
BlameCommand command = new BlameCommand(db);
|
||||
|
||||
BlameCommand command = new BlameCommand(db);
|
||||
command.setFilePath("file.txt");
|
||||
BlameResult lines = command.call();
|
||||
assertEquals(content2.length, lines.getResultContents().size());
|
||||
|
||||
command.setFilePath("file.txt");
|
||||
BlameResult lines = command.call();
|
||||
assertEquals(content2.length, lines.getResultContents().size());
|
||||
assertEquals(commit1, lines.getSourceCommit(0));
|
||||
assertEquals(commit1, lines.getSourceCommit(1));
|
||||
|
||||
assertEquals(commit1, lines.getSourceCommit(0));
|
||||
assertEquals(commit1, lines.getSourceCommit(1));
|
||||
|
||||
assertEquals(0, lines.getSourceLine(0));
|
||||
assertEquals(1, lines.getSourceLine(1));
|
||||
assertEquals(0, lines.getSourceLine(0));
|
||||
assertEquals(1, lines.getSourceLine(1));
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testDeleteMiddleLines() throws Exception {
|
||||
Git git = new Git(db);
|
||||
try (Git git = new Git(db)) {
|
||||
String[] content1 = new String[] { "a", "b", "c", "d", "e" };
|
||||
String[] content2 = new String[] { "a", "c", "e" };
|
||||
|
||||
String[] content1 = new String[] { "a", "b", "c", "d", "e" };
|
||||
String[] content2 = new String[] { "a", "c", "e" };
|
||||
writeTrashFile("file.txt", join(content2));
|
||||
git.add().addFilepattern("file.txt").call();
|
||||
RevCommit commit1 = git.commit().setMessage("edit file").call();
|
||||
|
||||
writeTrashFile("file.txt", join(content2));
|
||||
git.add().addFilepattern("file.txt").call();
|
||||
RevCommit commit1 = git.commit().setMessage("edit file").call();
|
||||
writeTrashFile("file.txt", join(content1));
|
||||
git.add().addFilepattern("file.txt").call();
|
||||
git.commit().setMessage("edit file").call();
|
||||
|
||||
writeTrashFile("file.txt", join(content1));
|
||||
git.add().addFilepattern("file.txt").call();
|
||||
git.commit().setMessage("edit file").call();
|
||||
writeTrashFile("file.txt", join(content2));
|
||||
git.add().addFilepattern("file.txt").call();
|
||||
git.commit().setMessage("edit file").call();
|
||||
|
||||
writeTrashFile("file.txt", join(content2));
|
||||
git.add().addFilepattern("file.txt").call();
|
||||
git.commit().setMessage("edit file").call();
|
||||
BlameCommand command = new BlameCommand(db);
|
||||
|
||||
BlameCommand command = new BlameCommand(db);
|
||||
command.setFilePath("file.txt");
|
||||
BlameResult lines = command.call();
|
||||
assertEquals(content2.length, lines.getResultContents().size());
|
||||
|
||||
command.setFilePath("file.txt");
|
||||
BlameResult lines = command.call();
|
||||
assertEquals(content2.length, lines.getResultContents().size());
|
||||
assertEquals(commit1, lines.getSourceCommit(0));
|
||||
assertEquals(0, lines.getSourceLine(0));
|
||||
|
||||
assertEquals(commit1, lines.getSourceCommit(0));
|
||||
assertEquals(0, lines.getSourceLine(0));
|
||||
assertEquals(commit1, lines.getSourceCommit(1));
|
||||
assertEquals(1, lines.getSourceLine(1));
|
||||
|
||||
assertEquals(commit1, lines.getSourceCommit(1));
|
||||
assertEquals(1, lines.getSourceLine(1));
|
||||
|
||||
assertEquals(commit1, lines.getSourceCommit(2));
|
||||
assertEquals(2, lines.getSourceLine(2));
|
||||
assertEquals(commit1, lines.getSourceCommit(2));
|
||||
assertEquals(2, lines.getSourceLine(2));
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testEditAllLines() throws Exception {
|
||||
Git git = new Git(db);
|
||||
try (Git git = new Git(db)) {
|
||||
String[] content1 = new String[] { "a", "1" };
|
||||
String[] content2 = new String[] { "b", "2" };
|
||||
|
||||
String[] content1 = new String[] { "a", "1" };
|
||||
String[] content2 = new String[] { "b", "2" };
|
||||
writeTrashFile("file.txt", join(content1));
|
||||
git.add().addFilepattern("file.txt").call();
|
||||
git.commit().setMessage("edit file").call();
|
||||
|
||||
writeTrashFile("file.txt", join(content1));
|
||||
git.add().addFilepattern("file.txt").call();
|
||||
git.commit().setMessage("edit file").call();
|
||||
writeTrashFile("file.txt", join(content2));
|
||||
git.add().addFilepattern("file.txt").call();
|
||||
RevCommit commit2 = git.commit().setMessage("create file").call();
|
||||
|
||||
writeTrashFile("file.txt", join(content2));
|
||||
git.add().addFilepattern("file.txt").call();
|
||||
RevCommit commit2 = git.commit().setMessage("create file").call();
|
||||
BlameCommand command = new BlameCommand(db);
|
||||
|
||||
BlameCommand command = new BlameCommand(db);
|
||||
|
||||
command.setFilePath("file.txt");
|
||||
BlameResult lines = command.call();
|
||||
assertEquals(content2.length, lines.getResultContents().size());
|
||||
assertEquals(commit2, lines.getSourceCommit(0));
|
||||
assertEquals(commit2, lines.getSourceCommit(1));
|
||||
command.setFilePath("file.txt");
|
||||
BlameResult lines = command.call();
|
||||
assertEquals(content2.length, lines.getResultContents().size());
|
||||
assertEquals(commit2, lines.getSourceCommit(0));
|
||||
assertEquals(commit2, lines.getSourceCommit(1));
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testMiddleClearAllLines() throws Exception {
|
||||
Git git = new Git(db);
|
||||
try (Git git = new Git(db)) {
|
||||
String[] content1 = new String[] { "a", "b", "c" };
|
||||
|
||||
String[] content1 = new String[] { "a", "b", "c" };
|
||||
writeTrashFile("file.txt", join(content1));
|
||||
git.add().addFilepattern("file.txt").call();
|
||||
git.commit().setMessage("edit file").call();
|
||||
|
||||
writeTrashFile("file.txt", join(content1));
|
||||
git.add().addFilepattern("file.txt").call();
|
||||
git.commit().setMessage("edit file").call();
|
||||
writeTrashFile("file.txt", "");
|
||||
git.add().addFilepattern("file.txt").call();
|
||||
git.commit().setMessage("create file").call();
|
||||
|
||||
writeTrashFile("file.txt", "");
|
||||
git.add().addFilepattern("file.txt").call();
|
||||
git.commit().setMessage("create file").call();
|
||||
writeTrashFile("file.txt", join(content1));
|
||||
git.add().addFilepattern("file.txt").call();
|
||||
RevCommit commit3 = git.commit().setMessage("edit file").call();
|
||||
|
||||
writeTrashFile("file.txt", join(content1));
|
||||
git.add().addFilepattern("file.txt").call();
|
||||
RevCommit commit3 = git.commit().setMessage("edit file").call();
|
||||
BlameCommand command = new BlameCommand(db);
|
||||
|
||||
BlameCommand command = new BlameCommand(db);
|
||||
|
||||
command.setFilePath("file.txt");
|
||||
BlameResult lines = command.call();
|
||||
assertEquals(content1.length, lines.getResultContents().size());
|
||||
assertEquals(commit3, lines.getSourceCommit(0));
|
||||
assertEquals(commit3, lines.getSourceCommit(1));
|
||||
assertEquals(commit3, lines.getSourceCommit(2));
|
||||
command.setFilePath("file.txt");
|
||||
BlameResult lines = command.call();
|
||||
assertEquals(content1.length, lines.getResultContents().size());
|
||||
assertEquals(commit3, lines.getSourceCommit(0));
|
||||
assertEquals(commit3, lines.getSourceCommit(1));
|
||||
assertEquals(commit3, lines.getSourceCommit(2));
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
|
@ -361,130 +361,132 @@ public void testCoreAutoCrlf5() throws Exception {
|
|||
|
||||
private void testCoreAutoCrlf(AutoCRLF modeForCommitting,
|
||||
AutoCRLF modeForReset) throws Exception {
|
||||
Git git = new Git(db);
|
||||
FileBasedConfig config = db.getConfig();
|
||||
config.setEnum(ConfigConstants.CONFIG_CORE_SECTION, null,
|
||||
ConfigConstants.CONFIG_KEY_AUTOCRLF, modeForCommitting);
|
||||
config.save();
|
||||
try (Git git = new Git(db)) {
|
||||
FileBasedConfig config = db.getConfig();
|
||||
config.setEnum(ConfigConstants.CONFIG_CORE_SECTION, null,
|
||||
ConfigConstants.CONFIG_KEY_AUTOCRLF, modeForCommitting);
|
||||
config.save();
|
||||
|
||||
String joinedCrlf = "a\r\nb\r\nc\r\n";
|
||||
File trashFile = writeTrashFile("file.txt", joinedCrlf);
|
||||
git.add().addFilepattern("file.txt").call();
|
||||
RevCommit commit = git.commit().setMessage("create file").call();
|
||||
String joinedCrlf = "a\r\nb\r\nc\r\n";
|
||||
File trashFile = writeTrashFile("file.txt", joinedCrlf);
|
||||
git.add().addFilepattern("file.txt").call();
|
||||
RevCommit commit = git.commit().setMessage("create file").call();
|
||||
|
||||
// re-create file from the repo
|
||||
trashFile.delete();
|
||||
config.setEnum(ConfigConstants.CONFIG_CORE_SECTION, null,
|
||||
ConfigConstants.CONFIG_KEY_AUTOCRLF, modeForReset);
|
||||
config.save();
|
||||
git.reset().setMode(ResetType.HARD).call();
|
||||
// re-create file from the repo
|
||||
trashFile.delete();
|
||||
config.setEnum(ConfigConstants.CONFIG_CORE_SECTION, null,
|
||||
ConfigConstants.CONFIG_KEY_AUTOCRLF, modeForReset);
|
||||
config.save();
|
||||
git.reset().setMode(ResetType.HARD).call();
|
||||
|
||||
BlameCommand command = new BlameCommand(db);
|
||||
command.setFilePath("file.txt");
|
||||
BlameResult lines = command.call();
|
||||
BlameCommand command = new BlameCommand(db);
|
||||
command.setFilePath("file.txt");
|
||||
BlameResult lines = command.call();
|
||||
|
||||
assertEquals(3, lines.getResultContents().size());
|
||||
assertEquals(commit, lines.getSourceCommit(0));
|
||||
assertEquals(commit, lines.getSourceCommit(1));
|
||||
assertEquals(commit, lines.getSourceCommit(2));
|
||||
assertEquals(3, lines.getResultContents().size());
|
||||
assertEquals(commit, lines.getSourceCommit(0));
|
||||
assertEquals(commit, lines.getSourceCommit(1));
|
||||
assertEquals(commit, lines.getSourceCommit(2));
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testConflictingMerge1() throws Exception {
|
||||
Git git = new Git(db);
|
||||
try (Git git = new Git(db)) {
|
||||
RevCommit base = commitFile("file.txt", join("0", "1", "2", "3", "4"),
|
||||
"master");
|
||||
|
||||
RevCommit base = commitFile("file.txt", join("0", "1", "2", "3", "4"),
|
||||
"master");
|
||||
git.checkout().setName("side").setCreateBranch(true)
|
||||
.setStartPoint(base).call();
|
||||
RevCommit side = commitFile("file.txt",
|
||||
join("0", "1 side", "2", "3 on side", "4"), "side");
|
||||
|
||||
git.checkout().setName("side").setCreateBranch(true)
|
||||
.setStartPoint(base).call();
|
||||
RevCommit side = commitFile("file.txt",
|
||||
join("0", "1 side", "2", "3 on side", "4"), "side");
|
||||
commitFile("file.txt", join("0", "1", "2"), "master");
|
||||
|
||||
commitFile("file.txt", join("0", "1", "2"), "master");
|
||||
checkoutBranch("refs/heads/master");
|
||||
git.merge().include(side).call();
|
||||
|
||||
checkoutBranch("refs/heads/master");
|
||||
git.merge().include(side).call();
|
||||
// The merge results in a conflict, which we resolve using mostly the
|
||||
// side branch contents. Especially the "4" survives.
|
||||
RevCommit merge = commitFile("file.txt",
|
||||
join("0", "1 side", "2", "3 resolved", "4"), "master");
|
||||
|
||||
// The merge results in a conflict, which we resolve using mostly the
|
||||
// side branch contents. Especially the "4" survives.
|
||||
RevCommit merge = commitFile("file.txt",
|
||||
join("0", "1 side", "2", "3 resolved", "4"), "master");
|
||||
BlameCommand command = new BlameCommand(db);
|
||||
command.setFilePath("file.txt");
|
||||
BlameResult lines = command.call();
|
||||
|
||||
BlameCommand command = new BlameCommand(db);
|
||||
command.setFilePath("file.txt");
|
||||
BlameResult lines = command.call();
|
||||
|
||||
assertEquals(5, lines.getResultContents().size());
|
||||
assertEquals(base, lines.getSourceCommit(0));
|
||||
assertEquals(side, lines.getSourceCommit(1));
|
||||
assertEquals(base, lines.getSourceCommit(2));
|
||||
assertEquals(merge, lines.getSourceCommit(3));
|
||||
assertEquals(base, lines.getSourceCommit(4));
|
||||
assertEquals(5, lines.getResultContents().size());
|
||||
assertEquals(base, lines.getSourceCommit(0));
|
||||
assertEquals(side, lines.getSourceCommit(1));
|
||||
assertEquals(base, lines.getSourceCommit(2));
|
||||
assertEquals(merge, lines.getSourceCommit(3));
|
||||
assertEquals(base, lines.getSourceCommit(4));
|
||||
}
|
||||
}
|
||||
|
||||
// this test inverts the order of the master and side commit and is
|
||||
// otherwise identical to testConflictingMerge1
|
||||
@Test
|
||||
public void testConflictingMerge2() throws Exception {
|
||||
Git git = new Git(db);
|
||||
try (Git git = new Git(db)) {
|
||||
RevCommit base = commitFile("file.txt", join("0", "1", "2", "3", "4"),
|
||||
"master");
|
||||
|
||||
RevCommit base = commitFile("file.txt", join("0", "1", "2", "3", "4"),
|
||||
"master");
|
||||
commitFile("file.txt", join("0", "1", "2"), "master");
|
||||
|
||||
commitFile("file.txt", join("0", "1", "2"), "master");
|
||||
git.checkout().setName("side").setCreateBranch(true)
|
||||
.setStartPoint(base).call();
|
||||
RevCommit side = commitFile("file.txt",
|
||||
join("0", "1 side", "2", "3 on side", "4"), "side");
|
||||
|
||||
git.checkout().setName("side").setCreateBranch(true)
|
||||
.setStartPoint(base).call();
|
||||
RevCommit side = commitFile("file.txt",
|
||||
join("0", "1 side", "2", "3 on side", "4"), "side");
|
||||
checkoutBranch("refs/heads/master");
|
||||
git.merge().include(side).call();
|
||||
|
||||
checkoutBranch("refs/heads/master");
|
||||
git.merge().include(side).call();
|
||||
// The merge results in a conflict, which we resolve using mostly the
|
||||
// side branch contents. Especially the "4" survives.
|
||||
RevCommit merge = commitFile("file.txt",
|
||||
join("0", "1 side", "2", "3 resolved", "4"), "master");
|
||||
|
||||
// The merge results in a conflict, which we resolve using mostly the
|
||||
// side branch contents. Especially the "4" survives.
|
||||
RevCommit merge = commitFile("file.txt",
|
||||
join("0", "1 side", "2", "3 resolved", "4"), "master");
|
||||
BlameCommand command = new BlameCommand(db);
|
||||
command.setFilePath("file.txt");
|
||||
BlameResult lines = command.call();
|
||||
|
||||
BlameCommand command = new BlameCommand(db);
|
||||
command.setFilePath("file.txt");
|
||||
BlameResult lines = command.call();
|
||||
|
||||
assertEquals(5, lines.getResultContents().size());
|
||||
assertEquals(base, lines.getSourceCommit(0));
|
||||
assertEquals(side, lines.getSourceCommit(1));
|
||||
assertEquals(base, lines.getSourceCommit(2));
|
||||
assertEquals(merge, lines.getSourceCommit(3));
|
||||
assertEquals(base, lines.getSourceCommit(4));
|
||||
assertEquals(5, lines.getResultContents().size());
|
||||
assertEquals(base, lines.getSourceCommit(0));
|
||||
assertEquals(side, lines.getSourceCommit(1));
|
||||
assertEquals(base, lines.getSourceCommit(2));
|
||||
assertEquals(merge, lines.getSourceCommit(3));
|
||||
assertEquals(base, lines.getSourceCommit(4));
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testWhitespaceMerge() throws Exception {
|
||||
Git git = new Git(db);
|
||||
RevCommit base = commitFile("file.txt", join("0", "1", "2"), "master");
|
||||
RevCommit side = commitFile("file.txt", join("0", "1", " 2 side "),
|
||||
"side");
|
||||
try (Git git = new Git(db)) {
|
||||
RevCommit base = commitFile("file.txt", join("0", "1", "2"), "master");
|
||||
RevCommit side = commitFile("file.txt", join("0", "1", " 2 side "),
|
||||
"side");
|
||||
|
||||
checkoutBranch("refs/heads/master");
|
||||
git.merge().setFastForward(FastForwardMode.NO_FF).include(side).call();
|
||||
checkoutBranch("refs/heads/master");
|
||||
git.merge().setFastForward(FastForwardMode.NO_FF).include(side).call();
|
||||
|
||||
// change whitespace, so the merge content is not identical to side, but
|
||||
// is the same when ignoring whitespace
|
||||
writeTrashFile("file.txt", join("0", "1", "2 side"));
|
||||
RevCommit merge = git.commit().setAll(true).setMessage("merge")
|
||||
.setAmend(true)
|
||||
.call();
|
||||
// change whitespace, so the merge content is not identical to side, but
|
||||
// is the same when ignoring whitespace
|
||||
writeTrashFile("file.txt", join("0", "1", "2 side"));
|
||||
RevCommit merge = git.commit().setAll(true).setMessage("merge")
|
||||
.setAmend(true)
|
||||
.call();
|
||||
|
||||
BlameCommand command = new BlameCommand(db);
|
||||
command.setFilePath("file.txt")
|
||||
.setTextComparator(RawTextComparator.WS_IGNORE_ALL)
|
||||
.setStartCommit(merge.getId());
|
||||
BlameResult lines = command.call();
|
||||
BlameCommand command = new BlameCommand(db);
|
||||
command.setFilePath("file.txt")
|
||||
.setTextComparator(RawTextComparator.WS_IGNORE_ALL)
|
||||
.setStartCommit(merge.getId());
|
||||
BlameResult lines = command.call();
|
||||
|
||||
assertEquals(3, lines.getResultContents().size());
|
||||
assertEquals(base, lines.getSourceCommit(0));
|
||||
assertEquals(base, lines.getSourceCommit(1));
|
||||
assertEquals(side, lines.getSourceCommit(2));
|
||||
assertEquals(3, lines.getResultContents().size());
|
||||
assertEquals(base, lines.getSourceCommit(0));
|
||||
assertEquals(base, lines.getSourceCommit(1));
|
||||
assertEquals(side, lines.getSourceCommit(2));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
@ -88,136 +88,139 @@ public void testCherryPickNoCommit() throws IOException,
|
|||
private void doTestCherryPick(boolean noCommit) throws IOException,
|
||||
JGitInternalException,
|
||||
GitAPIException {
|
||||
Git git = new Git(db);
|
||||
try (Git git = new Git(db)) {
|
||||
writeTrashFile("a", "first line\nsec. line\nthird line\n");
|
||||
git.add().addFilepattern("a").call();
|
||||
RevCommit firstCommit = git.commit().setMessage("create a").call();
|
||||
|
||||
writeTrashFile("a", "first line\nsec. line\nthird line\n");
|
||||
git.add().addFilepattern("a").call();
|
||||
RevCommit firstCommit = git.commit().setMessage("create a").call();
|
||||
writeTrashFile("b", "content\n");
|
||||
git.add().addFilepattern("b").call();
|
||||
git.commit().setMessage("create b").call();
|
||||
|
||||
writeTrashFile("b", "content\n");
|
||||
git.add().addFilepattern("b").call();
|
||||
git.commit().setMessage("create b").call();
|
||||
writeTrashFile("a", "first line\nsec. line\nthird line\nfourth line\n");
|
||||
git.add().addFilepattern("a").call();
|
||||
git.commit().setMessage("enlarged a").call();
|
||||
|
||||
writeTrashFile("a", "first line\nsec. line\nthird line\nfourth line\n");
|
||||
git.add().addFilepattern("a").call();
|
||||
git.commit().setMessage("enlarged a").call();
|
||||
writeTrashFile("a",
|
||||
"first line\nsecond line\nthird line\nfourth line\n");
|
||||
git.add().addFilepattern("a").call();
|
||||
RevCommit fixingA = git.commit().setMessage("fixed a").call();
|
||||
|
||||
writeTrashFile("a",
|
||||
"first line\nsecond line\nthird line\nfourth line\n");
|
||||
git.add().addFilepattern("a").call();
|
||||
RevCommit fixingA = git.commit().setMessage("fixed a").call();
|
||||
git.branchCreate().setName("side").setStartPoint(firstCommit).call();
|
||||
checkoutBranch("refs/heads/side");
|
||||
|
||||
git.branchCreate().setName("side").setStartPoint(firstCommit).call();
|
||||
checkoutBranch("refs/heads/side");
|
||||
writeTrashFile("a", "first line\nsec. line\nthird line\nfeature++\n");
|
||||
git.add().addFilepattern("a").call();
|
||||
git.commit().setMessage("enhanced a").call();
|
||||
|
||||
writeTrashFile("a", "first line\nsec. line\nthird line\nfeature++\n");
|
||||
git.add().addFilepattern("a").call();
|
||||
git.commit().setMessage("enhanced a").call();
|
||||
CherryPickResult pickResult = git.cherryPick().include(fixingA)
|
||||
.setNoCommit(noCommit).call();
|
||||
|
||||
CherryPickResult pickResult = git.cherryPick().include(fixingA)
|
||||
.setNoCommit(noCommit).call();
|
||||
|
||||
assertEquals(CherryPickStatus.OK, pickResult.getStatus());
|
||||
assertFalse(new File(db.getWorkTree(), "b").exists());
|
||||
checkFile(new File(db.getWorkTree(), "a"),
|
||||
"first line\nsecond line\nthird line\nfeature++\n");
|
||||
Iterator<RevCommit> history = git.log().call().iterator();
|
||||
if (!noCommit)
|
||||
assertEquals("fixed a", history.next().getFullMessage());
|
||||
assertEquals("enhanced a", history.next().getFullMessage());
|
||||
assertEquals("create a", history.next().getFullMessage());
|
||||
assertFalse(history.hasNext());
|
||||
assertEquals(CherryPickStatus.OK, pickResult.getStatus());
|
||||
assertFalse(new File(db.getWorkTree(), "b").exists());
|
||||
checkFile(new File(db.getWorkTree(), "a"),
|
||||
"first line\nsecond line\nthird line\nfeature++\n");
|
||||
Iterator<RevCommit> history = git.log().call().iterator();
|
||||
if (!noCommit)
|
||||
assertEquals("fixed a", history.next().getFullMessage());
|
||||
assertEquals("enhanced a", history.next().getFullMessage());
|
||||
assertEquals("create a", history.next().getFullMessage());
|
||||
assertFalse(history.hasNext());
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testSequentialCherryPick() throws IOException, JGitInternalException,
|
||||
GitAPIException {
|
||||
Git git = new Git(db);
|
||||
try (Git git = new Git(db)) {
|
||||
writeTrashFile("a", "first line\nsec. line\nthird line\n");
|
||||
git.add().addFilepattern("a").call();
|
||||
RevCommit firstCommit = git.commit().setMessage("create a").call();
|
||||
|
||||
writeTrashFile("a", "first line\nsec. line\nthird line\n");
|
||||
git.add().addFilepattern("a").call();
|
||||
RevCommit firstCommit = git.commit().setMessage("create a").call();
|
||||
writeTrashFile("a", "first line\nsec. line\nthird line\nfourth line\n");
|
||||
git.add().addFilepattern("a").call();
|
||||
RevCommit enlargingA = git.commit().setMessage("enlarged a").call();
|
||||
|
||||
writeTrashFile("a", "first line\nsec. line\nthird line\nfourth line\n");
|
||||
git.add().addFilepattern("a").call();
|
||||
RevCommit enlargingA = git.commit().setMessage("enlarged a").call();
|
||||
writeTrashFile("a",
|
||||
"first line\nsecond line\nthird line\nfourth line\n");
|
||||
git.add().addFilepattern("a").call();
|
||||
RevCommit fixingA = git.commit().setMessage("fixed a").call();
|
||||
|
||||
writeTrashFile("a",
|
||||
"first line\nsecond line\nthird line\nfourth line\n");
|
||||
git.add().addFilepattern("a").call();
|
||||
RevCommit fixingA = git.commit().setMessage("fixed a").call();
|
||||
git.branchCreate().setName("side").setStartPoint(firstCommit).call();
|
||||
checkoutBranch("refs/heads/side");
|
||||
|
||||
git.branchCreate().setName("side").setStartPoint(firstCommit).call();
|
||||
checkoutBranch("refs/heads/side");
|
||||
writeTrashFile("b", "nothing to do with a");
|
||||
git.add().addFilepattern("b").call();
|
||||
git.commit().setMessage("create b").call();
|
||||
|
||||
writeTrashFile("b", "nothing to do with a");
|
||||
git.add().addFilepattern("b").call();
|
||||
git.commit().setMessage("create b").call();
|
||||
CherryPickResult result = git.cherryPick().include(enlargingA).include(fixingA).call();
|
||||
assertEquals(CherryPickResult.CherryPickStatus.OK, result.getStatus());
|
||||
|
||||
CherryPickResult result = git.cherryPick().include(enlargingA).include(fixingA).call();
|
||||
assertEquals(CherryPickResult.CherryPickStatus.OK, result.getStatus());
|
||||
|
||||
Iterator<RevCommit> history = git.log().call().iterator();
|
||||
assertEquals("fixed a", history.next().getFullMessage());
|
||||
assertEquals("enlarged a", history.next().getFullMessage());
|
||||
assertEquals("create b", history.next().getFullMessage());
|
||||
assertEquals("create a", history.next().getFullMessage());
|
||||
assertFalse(history.hasNext());
|
||||
Iterator<RevCommit> history = git.log().call().iterator();
|
||||
assertEquals("fixed a", history.next().getFullMessage());
|
||||
assertEquals("enlarged a", history.next().getFullMessage());
|
||||
assertEquals("create b", history.next().getFullMessage());
|
||||
assertEquals("create a", history.next().getFullMessage());
|
||||
assertFalse(history.hasNext());
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testCherryPickDirtyIndex() throws Exception {
|
||||
Git git = new Git(db);
|
||||
RevCommit sideCommit = prepareCherryPick(git);
|
||||
try (Git git = new Git(db)) {
|
||||
RevCommit sideCommit = prepareCherryPick(git);
|
||||
|
||||
// modify and add file a
|
||||
writeTrashFile("a", "a(modified)");
|
||||
git.add().addFilepattern("a").call();
|
||||
// do not commit
|
||||
// modify and add file a
|
||||
writeTrashFile("a", "a(modified)");
|
||||
git.add().addFilepattern("a").call();
|
||||
// do not commit
|
||||
|
||||
doCherryPickAndCheckResult(git, sideCommit,
|
||||
MergeFailureReason.DIRTY_INDEX);
|
||||
doCherryPickAndCheckResult(git, sideCommit,
|
||||
MergeFailureReason.DIRTY_INDEX);
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testCherryPickDirtyWorktree() throws Exception {
|
||||
Git git = new Git(db);
|
||||
RevCommit sideCommit = prepareCherryPick(git);
|
||||
try (Git git = new Git(db)) {
|
||||
RevCommit sideCommit = prepareCherryPick(git);
|
||||
|
||||
// modify file a
|
||||
writeTrashFile("a", "a(modified)");
|
||||
// do not add and commit
|
||||
// modify file a
|
||||
writeTrashFile("a", "a(modified)");
|
||||
// do not add and commit
|
||||
|
||||
doCherryPickAndCheckResult(git, sideCommit,
|
||||
MergeFailureReason.DIRTY_WORKTREE);
|
||||
doCherryPickAndCheckResult(git, sideCommit,
|
||||
MergeFailureReason.DIRTY_WORKTREE);
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testCherryPickConflictResolution() throws Exception {
|
||||
Git git = new Git(db);
|
||||
RevCommit sideCommit = prepareCherryPick(git);
|
||||
try (Git git = new Git(db)) {
|
||||
RevCommit sideCommit = prepareCherryPick(git);
|
||||
|
||||
CherryPickResult result = git.cherryPick().include(sideCommit.getId())
|
||||
.call();
|
||||
CherryPickResult result = git.cherryPick().include(sideCommit.getId())
|
||||
.call();
|
||||
|
||||
assertEquals(CherryPickStatus.CONFLICTING, result.getStatus());
|
||||
assertTrue(new File(db.getDirectory(), Constants.MERGE_MSG).exists());
|
||||
assertEquals("side\n\nConflicts:\n\ta\n", db.readMergeCommitMsg());
|
||||
assertTrue(new File(db.getDirectory(), Constants.CHERRY_PICK_HEAD)
|
||||
.exists());
|
||||
assertEquals(sideCommit.getId(), db.readCherryPickHead());
|
||||
assertEquals(RepositoryState.CHERRY_PICKING, db.getRepositoryState());
|
||||
assertEquals(CherryPickStatus.CONFLICTING, result.getStatus());
|
||||
assertTrue(new File(db.getDirectory(), Constants.MERGE_MSG).exists());
|
||||
assertEquals("side\n\nConflicts:\n\ta\n", db.readMergeCommitMsg());
|
||||
assertTrue(new File(db.getDirectory(), Constants.CHERRY_PICK_HEAD)
|
||||
.exists());
|
||||
assertEquals(sideCommit.getId(), db.readCherryPickHead());
|
||||
assertEquals(RepositoryState.CHERRY_PICKING, db.getRepositoryState());
|
||||
|
||||
// Resolve
|
||||
writeTrashFile("a", "a");
|
||||
git.add().addFilepattern("a").call();
|
||||
// Resolve
|
||||
writeTrashFile("a", "a");
|
||||
git.add().addFilepattern("a").call();
|
||||
|
||||
assertEquals(RepositoryState.CHERRY_PICKING_RESOLVED,
|
||||
db.getRepositoryState());
|
||||
assertEquals(RepositoryState.CHERRY_PICKING_RESOLVED,
|
||||
db.getRepositoryState());
|
||||
|
||||
git.commit().setOnly("a").setMessage("resolve").call();
|
||||
git.commit().setOnly("a").setMessage("resolve").call();
|
||||
|
||||
assertEquals(RepositoryState.SAFE, db.getRepositoryState());
|
||||
assertEquals(RepositoryState.SAFE, db.getRepositoryState());
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
|
@ -251,85 +254,88 @@ public void testCherryPickConflictResolutionNoCOmmit() throws Exception {
|
|||
|
||||
@Test
|
||||
public void testCherryPickConflictReset() throws Exception {
|
||||
Git git = new Git(db);
|
||||
try (Git git = new Git(db)) {
|
||||
RevCommit sideCommit = prepareCherryPick(git);
|
||||
|
||||
RevCommit sideCommit = prepareCherryPick(git);
|
||||
CherryPickResult result = git.cherryPick().include(sideCommit.getId())
|
||||
.call();
|
||||
|
||||
CherryPickResult result = git.cherryPick().include(sideCommit.getId())
|
||||
.call();
|
||||
assertEquals(CherryPickStatus.CONFLICTING, result.getStatus());
|
||||
assertEquals(RepositoryState.CHERRY_PICKING, db.getRepositoryState());
|
||||
assertTrue(new File(db.getDirectory(), Constants.CHERRY_PICK_HEAD)
|
||||
.exists());
|
||||
|
||||
assertEquals(CherryPickStatus.CONFLICTING, result.getStatus());
|
||||
assertEquals(RepositoryState.CHERRY_PICKING, db.getRepositoryState());
|
||||
assertTrue(new File(db.getDirectory(), Constants.CHERRY_PICK_HEAD)
|
||||
.exists());
|
||||
git.reset().setMode(ResetType.MIXED).setRef("HEAD").call();
|
||||
|
||||
git.reset().setMode(ResetType.MIXED).setRef("HEAD").call();
|
||||
|
||||
assertEquals(RepositoryState.SAFE, db.getRepositoryState());
|
||||
assertFalse(new File(db.getDirectory(), Constants.CHERRY_PICK_HEAD)
|
||||
.exists());
|
||||
assertEquals(RepositoryState.SAFE, db.getRepositoryState());
|
||||
assertFalse(new File(db.getDirectory(), Constants.CHERRY_PICK_HEAD)
|
||||
.exists());
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testCherryPickOverExecutableChangeOnNonExectuableFileSystem()
|
||||
throws Exception {
|
||||
Git git = new Git(db);
|
||||
File file = writeTrashFile("test.txt", "a");
|
||||
assertNotNull(git.add().addFilepattern("test.txt").call());
|
||||
assertNotNull(git.commit().setMessage("commit1").call());
|
||||
try (Git git = new Git(db)) {
|
||||
File file = writeTrashFile("test.txt", "a");
|
||||
assertNotNull(git.add().addFilepattern("test.txt").call());
|
||||
assertNotNull(git.commit().setMessage("commit1").call());
|
||||
|
||||
assertNotNull(git.checkout().setCreateBranch(true).setName("a").call());
|
||||
assertNotNull(git.checkout().setCreateBranch(true).setName("a").call());
|
||||
|
||||
writeTrashFile("test.txt", "b");
|
||||
assertNotNull(git.add().addFilepattern("test.txt").call());
|
||||
RevCommit commit2 = git.commit().setMessage("commit2").call();
|
||||
assertNotNull(commit2);
|
||||
writeTrashFile("test.txt", "b");
|
||||
assertNotNull(git.add().addFilepattern("test.txt").call());
|
||||
RevCommit commit2 = git.commit().setMessage("commit2").call();
|
||||
assertNotNull(commit2);
|
||||
|
||||
assertNotNull(git.checkout().setName(Constants.MASTER).call());
|
||||
assertNotNull(git.checkout().setName(Constants.MASTER).call());
|
||||
|
||||
DirCache cache = db.lockDirCache();
|
||||
cache.getEntry("test.txt").setFileMode(FileMode.EXECUTABLE_FILE);
|
||||
cache.write();
|
||||
assertTrue(cache.commit());
|
||||
cache.unlock();
|
||||
DirCache cache = db.lockDirCache();
|
||||
cache.getEntry("test.txt").setFileMode(FileMode.EXECUTABLE_FILE);
|
||||
cache.write();
|
||||
assertTrue(cache.commit());
|
||||
cache.unlock();
|
||||
|
||||
assertNotNull(git.commit().setMessage("commit3").call());
|
||||
assertNotNull(git.commit().setMessage("commit3").call());
|
||||
|
||||
db.getFS().setExecute(file, false);
|
||||
git.getRepository()
|
||||
.getConfig()
|
||||
.setBoolean(ConfigConstants.CONFIG_CORE_SECTION, null,
|
||||
ConfigConstants.CONFIG_KEY_FILEMODE, false);
|
||||
db.getFS().setExecute(file, false);
|
||||
git.getRepository()
|
||||
.getConfig()
|
||||
.setBoolean(ConfigConstants.CONFIG_CORE_SECTION, null,
|
||||
ConfigConstants.CONFIG_KEY_FILEMODE, false);
|
||||
|
||||
CherryPickResult result = git.cherryPick().include(commit2).call();
|
||||
assertNotNull(result);
|
||||
assertEquals(CherryPickStatus.OK, result.getStatus());
|
||||
CherryPickResult result = git.cherryPick().include(commit2).call();
|
||||
assertNotNull(result);
|
||||
assertEquals(CherryPickStatus.OK, result.getStatus());
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testCherryPickConflictMarkers() throws Exception {
|
||||
Git git = new Git(db);
|
||||
RevCommit sideCommit = prepareCherryPick(git);
|
||||
try (Git git = new Git(db)) {
|
||||
RevCommit sideCommit = prepareCherryPick(git);
|
||||
|
||||
CherryPickResult result = git.cherryPick().include(sideCommit.getId())
|
||||
.call();
|
||||
assertEquals(CherryPickStatus.CONFLICTING, result.getStatus());
|
||||
CherryPickResult result = git.cherryPick().include(sideCommit.getId())
|
||||
.call();
|
||||
assertEquals(CherryPickStatus.CONFLICTING, result.getStatus());
|
||||
|
||||
String expected = "<<<<<<< master\na(master)\n=======\na(side)\n>>>>>>> 527460a side\n";
|
||||
checkFile(new File(db.getWorkTree(), "a"), expected);
|
||||
String expected = "<<<<<<< master\na(master)\n=======\na(side)\n>>>>>>> 527460a side\n";
|
||||
checkFile(new File(db.getWorkTree(), "a"), expected);
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testCherryPickOurCommitName() throws Exception {
|
||||
Git git = new Git(db);
|
||||
RevCommit sideCommit = prepareCherryPick(git);
|
||||
try (Git git = new Git(db)) {
|
||||
RevCommit sideCommit = prepareCherryPick(git);
|
||||
|
||||
CherryPickResult result = git.cherryPick().include(sideCommit.getId())
|
||||
.setOurCommitName("custom name").call();
|
||||
assertEquals(CherryPickStatus.CONFLICTING, result.getStatus());
|
||||
CherryPickResult result = git.cherryPick().include(sideCommit.getId())
|
||||
.setOurCommitName("custom name").call();
|
||||
assertEquals(CherryPickStatus.CONFLICTING, result.getStatus());
|
||||
|
||||
String expected = "<<<<<<< custom name\na(master)\n=======\na(side)\n>>>>>>> 527460a side\n";
|
||||
checkFile(new File(db.getWorkTree(), "a"), expected);
|
||||
String expected = "<<<<<<< custom name\na(master)\n=======\na(side)\n>>>>>>> 527460a side\n";
|
||||
checkFile(new File(db.getWorkTree(), "a"), expected);
|
||||
}
|
||||
}
|
||||
|
||||
private RevCommit prepareCherryPick(final Git git) throws Exception {
|
||||
|
@ -399,43 +405,43 @@ private void doCherryPickAndCheckResult(final Git git,
|
|||
*/
|
||||
@Test
|
||||
public void testCherryPickMerge() throws Exception {
|
||||
Git git = new Git(db);
|
||||
try (Git git = new Git(db)) {
|
||||
commitFile("file", "1\n2\n3\n", "master");
|
||||
commitFile("file", "1\n2\n3\n", "side");
|
||||
checkoutBranch("refs/heads/side");
|
||||
RevCommit commitD = commitFile("file", "1\n2\n3\n4\n5\n", "side2");
|
||||
commitFile("file", "a\n2\n3\n", "side");
|
||||
MergeResult mergeResult = git.merge().include(commitD).call();
|
||||
ObjectId commitM = mergeResult.getNewHead();
|
||||
checkoutBranch("refs/heads/master");
|
||||
RevCommit commitT = commitFile("another", "t", "master");
|
||||
|
||||
commitFile("file", "1\n2\n3\n", "master");
|
||||
commitFile("file", "1\n2\n3\n", "side");
|
||||
checkoutBranch("refs/heads/side");
|
||||
RevCommit commitD = commitFile("file", "1\n2\n3\n4\n5\n", "side2");
|
||||
commitFile("file", "a\n2\n3\n", "side");
|
||||
MergeResult mergeResult = git.merge().include(commitD).call();
|
||||
ObjectId commitM = mergeResult.getNewHead();
|
||||
checkoutBranch("refs/heads/master");
|
||||
RevCommit commitT = commitFile("another", "t", "master");
|
||||
try {
|
||||
git.cherryPick().include(commitM).call();
|
||||
fail("merges should not be cherry-picked by default");
|
||||
} catch (MultipleParentsNotAllowedException e) {
|
||||
// expected
|
||||
}
|
||||
try {
|
||||
git.cherryPick().include(commitM).setMainlineParentNumber(3).call();
|
||||
fail("specifying a non-existent parent should fail");
|
||||
} catch (JGitInternalException e) {
|
||||
// expected
|
||||
assertTrue(e.getMessage().endsWith(
|
||||
"does not have a parent number 3."));
|
||||
}
|
||||
|
||||
try {
|
||||
git.cherryPick().include(commitM).call();
|
||||
fail("merges should not be cherry-picked by default");
|
||||
} catch (MultipleParentsNotAllowedException e) {
|
||||
// expected
|
||||
CherryPickResult result = git.cherryPick().include(commitM)
|
||||
.setMainlineParentNumber(1).call();
|
||||
assertEquals(CherryPickStatus.OK, result.getStatus());
|
||||
checkFile(new File(db.getWorkTree(), "file"), "1\n2\n3\n4\n5\n");
|
||||
|
||||
git.reset().setMode(ResetType.HARD).setRef(commitT.getName()).call();
|
||||
|
||||
CherryPickResult result2 = git.cherryPick().include(commitM)
|
||||
.setMainlineParentNumber(2).call();
|
||||
assertEquals(CherryPickStatus.OK, result2.getStatus());
|
||||
checkFile(new File(db.getWorkTree(), "file"), "a\n2\n3\n");
|
||||
}
|
||||
try {
|
||||
git.cherryPick().include(commitM).setMainlineParentNumber(3).call();
|
||||
fail("specifying a non-existent parent should fail");
|
||||
} catch (JGitInternalException e) {
|
||||
// expected
|
||||
assertTrue(e.getMessage().endsWith(
|
||||
"does not have a parent number 3."));
|
||||
}
|
||||
|
||||
CherryPickResult result = git.cherryPick().include(commitM)
|
||||
.setMainlineParentNumber(1).call();
|
||||
assertEquals(CherryPickStatus.OK, result.getStatus());
|
||||
checkFile(new File(db.getWorkTree(), "file"), "1\n2\n3\n4\n5\n");
|
||||
|
||||
git.reset().setMode(ResetType.HARD).setRef(commitT.getName()).call();
|
||||
|
||||
CherryPickResult result2 = git.cherryPick().include(commitM)
|
||||
.setMainlineParentNumber(2).call();
|
||||
assertEquals(CherryPickStatus.OK, result2.getStatus());
|
||||
checkFile(new File(db.getWorkTree(), "file"), "a\n2\n3\n");
|
||||
}
|
||||
}
|
||||
|
|
|
@ -46,6 +46,7 @@
|
|||
import static org.junit.Assert.assertFalse;
|
||||
import static org.junit.Assert.assertTrue;
|
||||
import static org.junit.Assert.fail;
|
||||
import static org.junit.Assume.assumeFalse;
|
||||
|
||||
import java.io.File;
|
||||
import java.io.IOException;
|
||||
|
@ -78,96 +79,96 @@ public void testSomeCommits() throws JGitInternalException, IOException,
|
|||
GitAPIException {
|
||||
|
||||
// do 4 commits
|
||||
Git git = new Git(db);
|
||||
git.commit().setMessage("initial commit").call();
|
||||
git.commit().setMessage("second commit").setCommitter(committer).call();
|
||||
git.commit().setMessage("third commit").setAuthor(author).call();
|
||||
git.commit().setMessage("fourth commit").setAuthor(author)
|
||||
.setCommitter(committer).call();
|
||||
Iterable<RevCommit> commits = git.log().call();
|
||||
try (Git git = new Git(db)) {
|
||||
git.commit().setMessage("initial commit").call();
|
||||
git.commit().setMessage("second commit").setCommitter(committer).call();
|
||||
git.commit().setMessage("third commit").setAuthor(author).call();
|
||||
git.commit().setMessage("fourth commit").setAuthor(author)
|
||||
.setCommitter(committer).call();
|
||||
Iterable<RevCommit> commits = git.log().call();
|
||||
|
||||
// check that all commits came in correctly
|
||||
PersonIdent defaultCommitter = new PersonIdent(db);
|
||||
PersonIdent expectedAuthors[] = new PersonIdent[] { defaultCommitter,
|
||||
committer, author, author };
|
||||
PersonIdent expectedCommitters[] = new PersonIdent[] {
|
||||
defaultCommitter, committer, defaultCommitter, committer };
|
||||
String expectedMessages[] = new String[] { "initial commit",
|
||||
"second commit", "third commit", "fourth commit" };
|
||||
int l = expectedAuthors.length - 1;
|
||||
for (RevCommit c : commits) {
|
||||
assertEquals(expectedAuthors[l].getName(), c.getAuthorIdent()
|
||||
.getName());
|
||||
assertEquals(expectedCommitters[l].getName(), c.getCommitterIdent()
|
||||
.getName());
|
||||
assertEquals(c.getFullMessage(), expectedMessages[l]);
|
||||
l--;
|
||||
// check that all commits came in correctly
|
||||
PersonIdent defaultCommitter = new PersonIdent(db);
|
||||
PersonIdent expectedAuthors[] = new PersonIdent[] { defaultCommitter,
|
||||
committer, author, author };
|
||||
PersonIdent expectedCommitters[] = new PersonIdent[] {
|
||||
defaultCommitter, committer, defaultCommitter, committer };
|
||||
String expectedMessages[] = new String[] { "initial commit",
|
||||
"second commit", "third commit", "fourth commit" };
|
||||
int l = expectedAuthors.length - 1;
|
||||
for (RevCommit c : commits) {
|
||||
assertEquals(expectedAuthors[l].getName(), c.getAuthorIdent()
|
||||
.getName());
|
||||
assertEquals(expectedCommitters[l].getName(), c.getCommitterIdent()
|
||||
.getName());
|
||||
assertEquals(c.getFullMessage(), expectedMessages[l]);
|
||||
l--;
|
||||
}
|
||||
assertEquals(l, -1);
|
||||
ReflogReader reader = db.getReflogReader(Constants.HEAD);
|
||||
assertTrue(reader.getLastEntry().getComment().startsWith("commit:"));
|
||||
reader = db.getReflogReader(db.getBranch());
|
||||
assertTrue(reader.getLastEntry().getComment().startsWith("commit:"));
|
||||
}
|
||||
assertEquals(l, -1);
|
||||
ReflogReader reader = db.getReflogReader(Constants.HEAD);
|
||||
assertTrue(reader.getLastEntry().getComment().startsWith("commit:"));
|
||||
reader = db.getReflogReader(db.getBranch());
|
||||
assertTrue(reader.getLastEntry().getComment().startsWith("commit:"));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testLogWithFilter() throws IOException, JGitInternalException,
|
||||
GitAPIException {
|
||||
|
||||
Git git = new Git(db);
|
||||
try (Git git = new Git(db)) {
|
||||
// create first file
|
||||
File file = new File(db.getWorkTree(), "a.txt");
|
||||
FileUtils.createNewFile(file);
|
||||
PrintWriter writer = new PrintWriter(file);
|
||||
writer.print("content1");
|
||||
writer.close();
|
||||
|
||||
// create first file
|
||||
File file = new File(db.getWorkTree(), "a.txt");
|
||||
FileUtils.createNewFile(file);
|
||||
PrintWriter writer = new PrintWriter(file);
|
||||
writer.print("content1");
|
||||
writer.close();
|
||||
// First commit - a.txt file
|
||||
git.add().addFilepattern("a.txt").call();
|
||||
git.commit().setMessage("commit1").setCommitter(committer).call();
|
||||
|
||||
// First commit - a.txt file
|
||||
git.add().addFilepattern("a.txt").call();
|
||||
git.commit().setMessage("commit1").setCommitter(committer).call();
|
||||
// create second file
|
||||
file = new File(db.getWorkTree(), "b.txt");
|
||||
FileUtils.createNewFile(file);
|
||||
writer = new PrintWriter(file);
|
||||
writer.print("content2");
|
||||
writer.close();
|
||||
|
||||
// create second file
|
||||
file = new File(db.getWorkTree(), "b.txt");
|
||||
FileUtils.createNewFile(file);
|
||||
writer = new PrintWriter(file);
|
||||
writer.print("content2");
|
||||
writer.close();
|
||||
// Second commit - b.txt file
|
||||
git.add().addFilepattern("b.txt").call();
|
||||
git.commit().setMessage("commit2").setCommitter(committer).call();
|
||||
|
||||
// Second commit - b.txt file
|
||||
git.add().addFilepattern("b.txt").call();
|
||||
git.commit().setMessage("commit2").setCommitter(committer).call();
|
||||
// First log - a.txt filter
|
||||
int count = 0;
|
||||
for (RevCommit c : git.log().addPath("a.txt").call()) {
|
||||
assertEquals("commit1", c.getFullMessage());
|
||||
count++;
|
||||
}
|
||||
assertEquals(1, count);
|
||||
|
||||
// First log - a.txt filter
|
||||
int count = 0;
|
||||
for (RevCommit c : git.log().addPath("a.txt").call()) {
|
||||
assertEquals("commit1", c.getFullMessage());
|
||||
count++;
|
||||
// Second log - b.txt filter
|
||||
count = 0;
|
||||
for (RevCommit c : git.log().addPath("b.txt").call()) {
|
||||
assertEquals("commit2", c.getFullMessage());
|
||||
count++;
|
||||
}
|
||||
assertEquals(1, count);
|
||||
|
||||
// Third log - without filter
|
||||
count = 0;
|
||||
for (RevCommit c : git.log().call()) {
|
||||
assertEquals(committer, c.getCommitterIdent());
|
||||
count++;
|
||||
}
|
||||
assertEquals(2, count);
|
||||
}
|
||||
assertEquals(1, count);
|
||||
|
||||
// Second log - b.txt filter
|
||||
count = 0;
|
||||
for (RevCommit c : git.log().addPath("b.txt").call()) {
|
||||
assertEquals("commit2", c.getFullMessage());
|
||||
count++;
|
||||
}
|
||||
assertEquals(1, count);
|
||||
|
||||
// Third log - without filter
|
||||
count = 0;
|
||||
for (RevCommit c : git.log().call()) {
|
||||
assertEquals(committer, c.getCommitterIdent());
|
||||
count++;
|
||||
}
|
||||
assertEquals(2, count);
|
||||
}
|
||||
|
||||
// try to do a commit without specifying a message. Should fail!
|
||||
@Test
|
||||
public void testWrongParams() throws GitAPIException {
|
||||
Git git = new Git(db);
|
||||
try {
|
||||
try (Git git = new Git(db)) {
|
||||
git.commit().setAuthor(author).call();
|
||||
fail("Didn't get the expected exception");
|
||||
} catch (NoMessageException e) {
|
||||
|
@ -179,48 +180,50 @@ public void testWrongParams() throws GitAPIException {
|
|||
// exceptions
|
||||
@Test
|
||||
public void testMultipleInvocations() throws GitAPIException {
|
||||
Git git = new Git(db);
|
||||
CommitCommand commitCmd = git.commit();
|
||||
commitCmd.setMessage("initial commit").call();
|
||||
try {
|
||||
// check that setters can't be called after invocation
|
||||
commitCmd.setAuthor(author);
|
||||
fail("didn't catch the expected exception");
|
||||
} catch (IllegalStateException e) {
|
||||
// expected
|
||||
}
|
||||
LogCommand logCmd = git.log();
|
||||
logCmd.call();
|
||||
try {
|
||||
// check that call can't be called twice
|
||||
try (Git git = new Git(db)) {
|
||||
CommitCommand commitCmd = git.commit();
|
||||
commitCmd.setMessage("initial commit").call();
|
||||
try {
|
||||
// check that setters can't be called after invocation
|
||||
commitCmd.setAuthor(author);
|
||||
fail("didn't catch the expected exception");
|
||||
} catch (IllegalStateException e) {
|
||||
// expected
|
||||
}
|
||||
LogCommand logCmd = git.log();
|
||||
logCmd.call();
|
||||
fail("didn't catch the expected exception");
|
||||
} catch (IllegalStateException e) {
|
||||
// expected
|
||||
try {
|
||||
// check that call can't be called twice
|
||||
logCmd.call();
|
||||
fail("didn't catch the expected exception");
|
||||
} catch (IllegalStateException e) {
|
||||
// expected
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testMergeEmptyBranches() throws IOException,
|
||||
JGitInternalException, GitAPIException {
|
||||
Git git = new Git(db);
|
||||
git.commit().setMessage("initial commit").call();
|
||||
RefUpdate r = db.updateRef("refs/heads/side");
|
||||
r.setNewObjectId(db.resolve(Constants.HEAD));
|
||||
assertEquals(r.forceUpdate(), RefUpdate.Result.NEW);
|
||||
RevCommit second = git.commit().setMessage("second commit").setCommitter(committer).call();
|
||||
db.updateRef(Constants.HEAD).link("refs/heads/side");
|
||||
RevCommit firstSide = git.commit().setMessage("first side commit").setAuthor(author).call();
|
||||
try (Git git = new Git(db)) {
|
||||
git.commit().setMessage("initial commit").call();
|
||||
RefUpdate r = db.updateRef("refs/heads/side");
|
||||
r.setNewObjectId(db.resolve(Constants.HEAD));
|
||||
assertEquals(r.forceUpdate(), RefUpdate.Result.NEW);
|
||||
RevCommit second = git.commit().setMessage("second commit").setCommitter(committer).call();
|
||||
db.updateRef(Constants.HEAD).link("refs/heads/side");
|
||||
RevCommit firstSide = git.commit().setMessage("first side commit").setAuthor(author).call();
|
||||
|
||||
write(new File(db.getDirectory(), Constants.MERGE_HEAD), ObjectId
|
||||
.toString(db.resolve("refs/heads/master")));
|
||||
write(new File(db.getDirectory(), Constants.MERGE_MSG), "merging");
|
||||
write(new File(db.getDirectory(), Constants.MERGE_HEAD), ObjectId
|
||||
.toString(db.resolve("refs/heads/master")));
|
||||
write(new File(db.getDirectory(), Constants.MERGE_MSG), "merging");
|
||||
|
||||
RevCommit commit = git.commit().call();
|
||||
RevCommit[] parents = commit.getParents();
|
||||
assertEquals(parents[0], firstSide);
|
||||
assertEquals(parents[1], second);
|
||||
assertEquals(2, parents.length);
|
||||
RevCommit commit = git.commit().call();
|
||||
RevCommit[] parents = commit.getParents();
|
||||
assertEquals(parents[0], firstSide);
|
||||
assertEquals(parents[1], second);
|
||||
assertEquals(2, parents.length);
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
|
@ -232,56 +235,56 @@ public void testAddUnstagedChanges() throws IOException,
|
|||
writer.print("content");
|
||||
writer.close();
|
||||
|
||||
Git git = new Git(db);
|
||||
git.add().addFilepattern("a.txt").call();
|
||||
RevCommit commit = git.commit().setMessage("initial commit").call();
|
||||
TreeWalk tw = TreeWalk.forPath(db, "a.txt", commit.getTree());
|
||||
assertEquals("6b584e8ece562ebffc15d38808cd6b98fc3d97ea",
|
||||
tw.getObjectId(0).getName());
|
||||
try (Git git = new Git(db)) {
|
||||
git.add().addFilepattern("a.txt").call();
|
||||
RevCommit commit = git.commit().setMessage("initial commit").call();
|
||||
TreeWalk tw = TreeWalk.forPath(db, "a.txt", commit.getTree());
|
||||
assertEquals("6b584e8ece562ebffc15d38808cd6b98fc3d97ea",
|
||||
tw.getObjectId(0).getName());
|
||||
|
||||
writer = new PrintWriter(file);
|
||||
writer.print("content2");
|
||||
writer.close();
|
||||
commit = git.commit().setMessage("second commit").call();
|
||||
tw = TreeWalk.forPath(db, "a.txt", commit.getTree());
|
||||
assertEquals("6b584e8ece562ebffc15d38808cd6b98fc3d97ea",
|
||||
tw.getObjectId(0).getName());
|
||||
writer = new PrintWriter(file);
|
||||
writer.print("content2");
|
||||
writer.close();
|
||||
commit = git.commit().setMessage("second commit").call();
|
||||
tw = TreeWalk.forPath(db, "a.txt", commit.getTree());
|
||||
assertEquals("6b584e8ece562ebffc15d38808cd6b98fc3d97ea",
|
||||
tw.getObjectId(0).getName());
|
||||
|
||||
commit = git.commit().setAll(true).setMessage("third commit")
|
||||
.setAll(true).call();
|
||||
tw = TreeWalk.forPath(db, "a.txt", commit.getTree());
|
||||
assertEquals("db00fd65b218578127ea51f3dffac701f12f486a",
|
||||
tw.getObjectId(0).getName());
|
||||
commit = git.commit().setAll(true).setMessage("third commit")
|
||||
.setAll(true).call();
|
||||
tw = TreeWalk.forPath(db, "a.txt", commit.getTree());
|
||||
assertEquals("db00fd65b218578127ea51f3dffac701f12f486a",
|
||||
tw.getObjectId(0).getName());
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testModeChange() throws IOException, GitAPIException {
|
||||
if (System.getProperty("os.name").startsWith("Windows"))
|
||||
return; // SKIP
|
||||
Git git = new Git(db);
|
||||
assumeFalse(System.getProperty("os.name").startsWith("Windows"));// SKIP
|
||||
try (Git git = new Git(db)) {
|
||||
// create file
|
||||
File file = new File(db.getWorkTree(), "a.txt");
|
||||
FileUtils.createNewFile(file);
|
||||
PrintWriter writer = new PrintWriter(file);
|
||||
writer.print("content1");
|
||||
writer.close();
|
||||
|
||||
// create file
|
||||
File file = new File(db.getWorkTree(), "a.txt");
|
||||
FileUtils.createNewFile(file);
|
||||
PrintWriter writer = new PrintWriter(file);
|
||||
writer.print("content1");
|
||||
writer.close();
|
||||
// First commit - a.txt file
|
||||
git.add().addFilepattern("a.txt").call();
|
||||
git.commit().setMessage("commit1").setCommitter(committer).call();
|
||||
|
||||
// First commit - a.txt file
|
||||
git.add().addFilepattern("a.txt").call();
|
||||
git.commit().setMessage("commit1").setCommitter(committer).call();
|
||||
// pure mode change should be committable
|
||||
FS fs = db.getFS();
|
||||
fs.setExecute(file, true);
|
||||
git.add().addFilepattern("a.txt").call();
|
||||
git.commit().setMessage("mode change").setCommitter(committer).call();
|
||||
|
||||
// pure mode change should be committable
|
||||
FS fs = db.getFS();
|
||||
fs.setExecute(file, true);
|
||||
git.add().addFilepattern("a.txt").call();
|
||||
git.commit().setMessage("mode change").setCommitter(committer).call();
|
||||
|
||||
// pure mode change should be committable with -o option
|
||||
fs.setExecute(file, false);
|
||||
git.add().addFilepattern("a.txt").call();
|
||||
git.commit().setMessage("mode change").setCommitter(committer)
|
||||
.setOnly("a.txt").call();
|
||||
// pure mode change should be committable with -o option
|
||||
fs.setExecute(file, false);
|
||||
git.add().addFilepattern("a.txt").call();
|
||||
git.commit().setMessage("mode change").setCommitter(committer)
|
||||
.setOnly("a.txt").call();
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
|
@ -289,112 +292,115 @@ public void testCommitRange() throws GitAPIException,
|
|||
JGitInternalException, MissingObjectException,
|
||||
IncorrectObjectTypeException {
|
||||
// do 4 commits and set the range to the second and fourth one
|
||||
Git git = new Git(db);
|
||||
git.commit().setMessage("first commit").call();
|
||||
RevCommit second = git.commit().setMessage("second commit")
|
||||
.setCommitter(committer).call();
|
||||
git.commit().setMessage("third commit").setAuthor(author).call();
|
||||
RevCommit last = git.commit().setMessage("fourth commit").setAuthor(
|
||||
author)
|
||||
.setCommitter(committer).call();
|
||||
Iterable<RevCommit> commits = git.log().addRange(second.getId(),
|
||||
last.getId()).call();
|
||||
try (Git git = new Git(db)) {
|
||||
git.commit().setMessage("first commit").call();
|
||||
RevCommit second = git.commit().setMessage("second commit")
|
||||
.setCommitter(committer).call();
|
||||
git.commit().setMessage("third commit").setAuthor(author).call();
|
||||
RevCommit last = git.commit().setMessage("fourth commit").setAuthor(
|
||||
author)
|
||||
.setCommitter(committer).call();
|
||||
Iterable<RevCommit> commits = git.log().addRange(second.getId(),
|
||||
last.getId()).call();
|
||||
|
||||
// check that we have the third and fourth commit
|
||||
PersonIdent defaultCommitter = new PersonIdent(db);
|
||||
PersonIdent expectedAuthors[] = new PersonIdent[] { author, author };
|
||||
PersonIdent expectedCommitters[] = new PersonIdent[] {
|
||||
defaultCommitter, committer };
|
||||
String expectedMessages[] = new String[] { "third commit",
|
||||
"fourth commit" };
|
||||
int l = expectedAuthors.length - 1;
|
||||
for (RevCommit c : commits) {
|
||||
assertEquals(expectedAuthors[l].getName(), c.getAuthorIdent()
|
||||
.getName());
|
||||
assertEquals(expectedCommitters[l].getName(), c.getCommitterIdent()
|
||||
.getName());
|
||||
assertEquals(c.getFullMessage(), expectedMessages[l]);
|
||||
l--;
|
||||
// check that we have the third and fourth commit
|
||||
PersonIdent defaultCommitter = new PersonIdent(db);
|
||||
PersonIdent expectedAuthors[] = new PersonIdent[] { author, author };
|
||||
PersonIdent expectedCommitters[] = new PersonIdent[] {
|
||||
defaultCommitter, committer };
|
||||
String expectedMessages[] = new String[] { "third commit",
|
||||
"fourth commit" };
|
||||
int l = expectedAuthors.length - 1;
|
||||
for (RevCommit c : commits) {
|
||||
assertEquals(expectedAuthors[l].getName(), c.getAuthorIdent()
|
||||
.getName());
|
||||
assertEquals(expectedCommitters[l].getName(), c.getCommitterIdent()
|
||||
.getName());
|
||||
assertEquals(c.getFullMessage(), expectedMessages[l]);
|
||||
l--;
|
||||
}
|
||||
assertEquals(l, -1);
|
||||
}
|
||||
assertEquals(l, -1);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testCommitAmend() throws JGitInternalException, IOException,
|
||||
GitAPIException {
|
||||
Git git = new Git(db);
|
||||
git.commit().setMessage("first comit").call(); // typo
|
||||
git.commit().setAmend(true).setMessage("first commit").call();
|
||||
try (Git git = new Git(db)) {
|
||||
git.commit().setMessage("first comit").call(); // typo
|
||||
git.commit().setAmend(true).setMessage("first commit").call();
|
||||
|
||||
Iterable<RevCommit> commits = git.log().call();
|
||||
int c = 0;
|
||||
for (RevCommit commit : commits) {
|
||||
assertEquals("first commit", commit.getFullMessage());
|
||||
c++;
|
||||
Iterable<RevCommit> commits = git.log().call();
|
||||
int c = 0;
|
||||
for (RevCommit commit : commits) {
|
||||
assertEquals("first commit", commit.getFullMessage());
|
||||
c++;
|
||||
}
|
||||
assertEquals(1, c);
|
||||
ReflogReader reader = db.getReflogReader(Constants.HEAD);
|
||||
assertTrue(reader.getLastEntry().getComment()
|
||||
.startsWith("commit (amend):"));
|
||||
reader = db.getReflogReader(db.getBranch());
|
||||
assertTrue(reader.getLastEntry().getComment()
|
||||
.startsWith("commit (amend):"));
|
||||
}
|
||||
assertEquals(1, c);
|
||||
ReflogReader reader = db.getReflogReader(Constants.HEAD);
|
||||
assertTrue(reader.getLastEntry().getComment()
|
||||
.startsWith("commit (amend):"));
|
||||
reader = db.getReflogReader(db.getBranch());
|
||||
assertTrue(reader.getLastEntry().getComment()
|
||||
.startsWith("commit (amend):"));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testInsertChangeId() throws JGitInternalException,
|
||||
GitAPIException {
|
||||
Git git = new Git(db);
|
||||
String messageHeader = "Some header line\n\nSome detail explanation\n";
|
||||
String changeIdTemplate = "\nChange-Id: I"
|
||||
+ ObjectId.zeroId().getName() + "\n";
|
||||
String messageFooter = "Some foooter lines\nAnother footer line\n";
|
||||
RevCommit commit = git.commit().setMessage(
|
||||
messageHeader + messageFooter)
|
||||
.setInsertChangeId(true).call();
|
||||
// we should find a real change id (at the end of the file)
|
||||
byte[] chars = commit.getFullMessage().getBytes();
|
||||
int lastLineBegin = RawParseUtils.prevLF(chars, chars.length - 2);
|
||||
String lastLine = RawParseUtils.decode(chars, lastLineBegin + 1,
|
||||
chars.length);
|
||||
assertTrue(lastLine.contains("Change-Id:"));
|
||||
assertFalse(lastLine.contains(
|
||||
"Change-Id: I" + ObjectId.zeroId().getName()));
|
||||
try (Git git = new Git(db)) {
|
||||
String messageHeader = "Some header line\n\nSome detail explanation\n";
|
||||
String changeIdTemplate = "\nChange-Id: I"
|
||||
+ ObjectId.zeroId().getName() + "\n";
|
||||
String messageFooter = "Some foooter lines\nAnother footer line\n";
|
||||
RevCommit commit = git.commit().setMessage(
|
||||
messageHeader + messageFooter)
|
||||
.setInsertChangeId(true).call();
|
||||
// we should find a real change id (at the end of the file)
|
||||
byte[] chars = commit.getFullMessage().getBytes();
|
||||
int lastLineBegin = RawParseUtils.prevLF(chars, chars.length - 2);
|
||||
String lastLine = RawParseUtils.decode(chars, lastLineBegin + 1,
|
||||
chars.length);
|
||||
assertTrue(lastLine.contains("Change-Id:"));
|
||||
assertFalse(lastLine.contains(
|
||||
"Change-Id: I" + ObjectId.zeroId().getName()));
|
||||
|
||||
commit = git.commit().setMessage(
|
||||
messageHeader + changeIdTemplate + messageFooter)
|
||||
.setInsertChangeId(true).call();
|
||||
// we should find a real change id (in the line as dictated by the
|
||||
// template)
|
||||
chars = commit.getFullMessage().getBytes();
|
||||
int lineStart = 0;
|
||||
int lineEnd = 0;
|
||||
for (int i = 0; i < 4; i++) {
|
||||
lineStart = RawParseUtils.nextLF(chars, lineStart);
|
||||
commit = git.commit().setMessage(
|
||||
messageHeader + changeIdTemplate + messageFooter)
|
||||
.setInsertChangeId(true).call();
|
||||
// we should find a real change id (in the line as dictated by the
|
||||
// template)
|
||||
chars = commit.getFullMessage().getBytes();
|
||||
int lineStart = 0;
|
||||
int lineEnd = 0;
|
||||
for (int i = 0; i < 4; i++) {
|
||||
lineStart = RawParseUtils.nextLF(chars, lineStart);
|
||||
}
|
||||
lineEnd = RawParseUtils.nextLF(chars, lineStart);
|
||||
|
||||
String line = RawParseUtils.decode(chars, lineStart, lineEnd);
|
||||
|
||||
assertTrue(line.contains("Change-Id:"));
|
||||
assertFalse(line.contains(
|
||||
"Change-Id: I" + ObjectId.zeroId().getName()));
|
||||
|
||||
commit = git.commit().setMessage(
|
||||
messageHeader + changeIdTemplate + messageFooter)
|
||||
.setInsertChangeId(false).call();
|
||||
// we should find the untouched template
|
||||
chars = commit.getFullMessage().getBytes();
|
||||
lineStart = 0;
|
||||
lineEnd = 0;
|
||||
for (int i = 0; i < 4; i++) {
|
||||
lineStart = RawParseUtils.nextLF(chars, lineStart);
|
||||
}
|
||||
lineEnd = RawParseUtils.nextLF(chars, lineStart);
|
||||
|
||||
line = RawParseUtils.decode(chars, lineStart, lineEnd);
|
||||
|
||||
assertTrue(commit.getFullMessage().contains(
|
||||
"Change-Id: I" + ObjectId.zeroId().getName()));
|
||||
}
|
||||
lineEnd = RawParseUtils.nextLF(chars, lineStart);
|
||||
|
||||
String line = RawParseUtils.decode(chars, lineStart, lineEnd);
|
||||
|
||||
assertTrue(line.contains("Change-Id:"));
|
||||
assertFalse(line.contains(
|
||||
"Change-Id: I" + ObjectId.zeroId().getName()));
|
||||
|
||||
commit = git.commit().setMessage(
|
||||
messageHeader + changeIdTemplate + messageFooter)
|
||||
.setInsertChangeId(false).call();
|
||||
// we should find the untouched template
|
||||
chars = commit.getFullMessage().getBytes();
|
||||
lineStart = 0;
|
||||
lineEnd = 0;
|
||||
for (int i = 0; i < 4; i++) {
|
||||
lineStart = RawParseUtils.nextLF(chars, lineStart);
|
||||
}
|
||||
lineEnd = RawParseUtils.nextLF(chars, lineStart);
|
||||
|
||||
line = RawParseUtils.decode(chars, lineStart, lineEnd);
|
||||
|
||||
assertTrue(commit.getFullMessage().contains(
|
||||
"Change-Id: I" + ObjectId.zeroId().getName()));
|
||||
}
|
||||
}
|
||||
|
|
|
@ -62,171 +62,185 @@ public class TagCommandTest extends RepositoryTestCase {
|
|||
|
||||
@Test
|
||||
public void testTaggingOnHead() throws GitAPIException, IOException {
|
||||
Git git = new Git(db);
|
||||
RevCommit commit = git.commit().setMessage("initial commit").call();
|
||||
Ref tagRef = git.tag().setName("tag").call();
|
||||
assertEquals(commit.getId(), db.peel(tagRef).getPeeledObjectId());
|
||||
RevWalk walk = new RevWalk(db);
|
||||
assertEquals("tag", walk.parseTag(tagRef.getObjectId()).getTagName());
|
||||
try (Git git = new Git(db);
|
||||
RevWalk walk = new RevWalk(db)) {
|
||||
RevCommit commit = git.commit().setMessage("initial commit").call();
|
||||
Ref tagRef = git.tag().setName("tag").call();
|
||||
assertEquals(commit.getId(), db.peel(tagRef).getPeeledObjectId());
|
||||
assertEquals("tag", walk.parseTag(tagRef.getObjectId()).getTagName());
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testTagging() throws GitAPIException, JGitInternalException {
|
||||
Git git = new Git(db);
|
||||
git.commit().setMessage("initial commit").call();
|
||||
RevCommit commit = git.commit().setMessage("second commit").call();
|
||||
git.commit().setMessage("third commit").call();
|
||||
Ref tagRef = git.tag().setObjectId(commit).setName("tag").call();
|
||||
assertEquals(commit.getId(), db.peel(tagRef).getPeeledObjectId());
|
||||
try (Git git = new Git(db)) {
|
||||
git.commit().setMessage("initial commit").call();
|
||||
RevCommit commit = git.commit().setMessage("second commit").call();
|
||||
git.commit().setMessage("third commit").call();
|
||||
Ref tagRef = git.tag().setObjectId(commit).setName("tag").call();
|
||||
assertEquals(commit.getId(), db.peel(tagRef).getPeeledObjectId());
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testUnannotatedTagging() throws GitAPIException,
|
||||
JGitInternalException {
|
||||
Git git = new Git(db);
|
||||
git.commit().setMessage("initial commit").call();
|
||||
RevCommit commit = git.commit().setMessage("second commit").call();
|
||||
git.commit().setMessage("third commit").call();
|
||||
Ref tagRef = git.tag().setObjectId(commit).setName("tag")
|
||||
.setAnnotated(false).call();
|
||||
assertEquals(commit.getId(), tagRef.getObjectId());
|
||||
try (Git git = new Git(db)) {
|
||||
git.commit().setMessage("initial commit").call();
|
||||
RevCommit commit = git.commit().setMessage("second commit").call();
|
||||
git.commit().setMessage("third commit").call();
|
||||
Ref tagRef = git.tag().setObjectId(commit).setName("tag")
|
||||
.setAnnotated(false).call();
|
||||
assertEquals(commit.getId(), tagRef.getObjectId());
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testEmptyTagName() throws GitAPIException {
|
||||
Git git = new Git(db);
|
||||
git.commit().setMessage("initial commit").call();
|
||||
try {
|
||||
// forget to tag name
|
||||
git.tag().setMessage("some message").call();
|
||||
fail("We should have failed without a tag name");
|
||||
} catch (InvalidTagNameException e) {
|
||||
// should hit here
|
||||
try (Git git = new Git(db)) {
|
||||
git.commit().setMessage("initial commit").call();
|
||||
try {
|
||||
// forget to tag name
|
||||
git.tag().setMessage("some message").call();
|
||||
fail("We should have failed without a tag name");
|
||||
} catch (InvalidTagNameException e) {
|
||||
// should hit here
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testInvalidTagName() throws GitAPIException {
|
||||
Git git = new Git(db);
|
||||
git.commit().setMessage("initial commit").call();
|
||||
try {
|
||||
git.tag().setName("bad~tag~name").setMessage("some message").call();
|
||||
fail("We should have failed due to a bad tag name");
|
||||
} catch (InvalidTagNameException e) {
|
||||
// should hit here
|
||||
try (Git git = new Git(db)) {
|
||||
git.commit().setMessage("initial commit").call();
|
||||
try {
|
||||
git.tag().setName("bad~tag~name").setMessage("some message").call();
|
||||
fail("We should have failed due to a bad tag name");
|
||||
} catch (InvalidTagNameException e) {
|
||||
// should hit here
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testFailureOnSignedTags() throws GitAPIException {
|
||||
Git git = new Git(db);
|
||||
git.commit().setMessage("initial commit").call();
|
||||
try {
|
||||
git.tag().setSigned(true).setName("tag").call();
|
||||
fail("We should have failed with an UnsupportedOperationException due to signed tag");
|
||||
} catch (UnsupportedOperationException e) {
|
||||
// should hit here
|
||||
try (Git git = new Git(db)) {
|
||||
git.commit().setMessage("initial commit").call();
|
||||
try {
|
||||
git.tag().setSigned(true).setName("tag").call();
|
||||
fail("We should have failed with an UnsupportedOperationException due to signed tag");
|
||||
} catch (UnsupportedOperationException e) {
|
||||
// should hit here
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testDelete() throws Exception {
|
||||
Git git = new Git(db);
|
||||
git.commit().setMessage("initial commit").call();
|
||||
Ref tagRef = git.tag().setName("tag").call();
|
||||
assertEquals(1, db.getTags().size());
|
||||
try (Git git = new Git(db)) {
|
||||
git.commit().setMessage("initial commit").call();
|
||||
Ref tagRef = git.tag().setName("tag").call();
|
||||
assertEquals(1, db.getTags().size());
|
||||
|
||||
List<String> deleted = git.tagDelete().setTags(tagRef.getName())
|
||||
.call();
|
||||
assertEquals(1, deleted.size());
|
||||
assertEquals(tagRef.getName(), deleted.get(0));
|
||||
assertEquals(0, db.getTags().size());
|
||||
List<String> deleted = git.tagDelete().setTags(tagRef.getName())
|
||||
.call();
|
||||
assertEquals(1, deleted.size());
|
||||
assertEquals(tagRef.getName(), deleted.get(0));
|
||||
assertEquals(0, db.getTags().size());
|
||||
|
||||
Ref tagRef1 = git.tag().setName("tag1").call();
|
||||
Ref tagRef2 = git.tag().setName("tag2").call();
|
||||
assertEquals(2, db.getTags().size());
|
||||
deleted = git.tagDelete().setTags(tagRef1.getName(), tagRef2.getName())
|
||||
.call();
|
||||
assertEquals(2, deleted.size());
|
||||
assertEquals(0, db.getTags().size());
|
||||
Ref tagRef1 = git.tag().setName("tag1").call();
|
||||
Ref tagRef2 = git.tag().setName("tag2").call();
|
||||
assertEquals(2, db.getTags().size());
|
||||
deleted = git.tagDelete().setTags(tagRef1.getName(), tagRef2.getName())
|
||||
.call();
|
||||
assertEquals(2, deleted.size());
|
||||
assertEquals(0, db.getTags().size());
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testDeleteFullName() throws Exception {
|
||||
Git git = new Git(db);
|
||||
git.commit().setMessage("initial commit").call();
|
||||
Ref tagRef = git.tag().setName("tag").call();
|
||||
assertEquals(1, db.getTags().size());
|
||||
try (Git git = new Git(db)) {
|
||||
git.commit().setMessage("initial commit").call();
|
||||
Ref tagRef = git.tag().setName("tag").call();
|
||||
assertEquals(1, db.getTags().size());
|
||||
|
||||
List<String> deleted = git.tagDelete()
|
||||
.setTags(Repository.shortenRefName(tagRef.getName())).call();
|
||||
assertEquals(1, deleted.size());
|
||||
assertEquals(tagRef.getName(), deleted.get(0));
|
||||
assertEquals(0, db.getTags().size());
|
||||
List<String> deleted = git.tagDelete()
|
||||
.setTags(Repository.shortenRefName(tagRef.getName())).call();
|
||||
assertEquals(1, deleted.size());
|
||||
assertEquals(tagRef.getName(), deleted.get(0));
|
||||
assertEquals(0, db.getTags().size());
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testDeleteEmptyTagNames() throws Exception {
|
||||
Git git = new Git(db);
|
||||
git.commit().setMessage("initial commit").call();
|
||||
try (Git git = new Git(db)) {
|
||||
git.commit().setMessage("initial commit").call();
|
||||
|
||||
List<String> deleted = git.tagDelete().setTags().call();
|
||||
assertEquals(0, deleted.size());
|
||||
List<String> deleted = git.tagDelete().setTags().call();
|
||||
assertEquals(0, deleted.size());
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testDeleteNonExisting() throws Exception {
|
||||
Git git = new Git(db);
|
||||
git.commit().setMessage("initial commit").call();
|
||||
try (Git git = new Git(db)) {
|
||||
git.commit().setMessage("initial commit").call();
|
||||
|
||||
List<String> deleted = git.tagDelete().setTags("tag").call();
|
||||
assertEquals(0, deleted.size());
|
||||
List<String> deleted = git.tagDelete().setTags("tag").call();
|
||||
assertEquals(0, deleted.size());
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testDeleteBadName() throws Exception {
|
||||
Git git = new Git(db);
|
||||
git.commit().setMessage("initial commit").call();
|
||||
try (Git git = new Git(db)) {
|
||||
git.commit().setMessage("initial commit").call();
|
||||
|
||||
List<String> deleted = git.tagDelete().setTags("bad~tag~name")
|
||||
.call();
|
||||
assertEquals(0, deleted.size());
|
||||
List<String> deleted = git.tagDelete().setTags("bad~tag~name")
|
||||
.call();
|
||||
assertEquals(0, deleted.size());
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testShouldNotBlowUpIfThereAreNoTagsInRepository()
|
||||
throws Exception {
|
||||
Git git = new Git(db);
|
||||
git.add().addFilepattern("*").call();
|
||||
git.commit().setMessage("initial commit").call();
|
||||
List<Ref> list = git.tagList().call();
|
||||
assertEquals(0, list.size());
|
||||
try (Git git = new Git(db)) {
|
||||
git.add().addFilepattern("*").call();
|
||||
git.commit().setMessage("initial commit").call();
|
||||
List<Ref> list = git.tagList().call();
|
||||
assertEquals(0, list.size());
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testShouldNotBlowUpIfThereAreNoCommitsInRepository()
|
||||
throws Exception {
|
||||
Git git = new Git(db);
|
||||
List<Ref> list = git.tagList().call();
|
||||
assertEquals(0, list.size());
|
||||
try (Git git = new Git(db)) {
|
||||
List<Ref> list = git.tagList().call();
|
||||
assertEquals(0, list.size());
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testListAllTagsInRepositoryInOrder() throws Exception {
|
||||
Git git = new Git(db);
|
||||
git.add().addFilepattern("*").call();
|
||||
git.commit().setMessage("initial commit").call();
|
||||
try (Git git = new Git(db)) {
|
||||
git.add().addFilepattern("*").call();
|
||||
git.commit().setMessage("initial commit").call();
|
||||
|
||||
git.tag().setName("v3").call();
|
||||
git.tag().setName("v2").call();
|
||||
git.tag().setName("v10").call();
|
||||
git.tag().setName("v3").call();
|
||||
git.tag().setName("v2").call();
|
||||
git.tag().setName("v10").call();
|
||||
|
||||
List<Ref> list = git.tagList().call();
|
||||
List<Ref> list = git.tagList().call();
|
||||
|
||||
assertEquals(3, list.size());
|
||||
assertEquals("refs/tags/v10", list.get(0).getName());
|
||||
assertEquals("refs/tags/v2", list.get(1).getName());
|
||||
assertEquals("refs/tags/v3", list.get(2).getName());
|
||||
assertEquals(3, list.size());
|
||||
assertEquals("refs/tags/v10", list.get(0).getName());
|
||||
assertEquals("refs/tags/v2", list.get(1).getName());
|
||||
assertEquals("refs/tags/v3", list.get(2).getName());
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
|
|
@ -317,30 +317,31 @@ public void testDiff() throws Exception {
|
|||
File folder = new File(db.getDirectory().getParent(), "folder");
|
||||
FileUtils.mkdir(folder);
|
||||
write(new File(folder, "folder.txt"), "folder");
|
||||
Git git = new Git(db);
|
||||
git.add().addFilepattern(".").call();
|
||||
git.commit().setMessage("Initial commit").call();
|
||||
write(new File(folder, "folder.txt"), "folder change");
|
||||
try (Git git = new Git(db);
|
||||
ByteArrayOutputStream os = new ByteArrayOutputStream();
|
||||
DiffFormatter dfmt = new DiffFormatter(new SafeBufferedOutputStream(os))) {
|
||||
git.add().addFilepattern(".").call();
|
||||
git.commit().setMessage("Initial commit").call();
|
||||
write(new File(folder, "folder.txt"), "folder change");
|
||||
dfmt.setRepository(db);
|
||||
dfmt.setPathFilter(PathFilter.create("folder"));
|
||||
DirCacheIterator oldTree = new DirCacheIterator(db.readDirCache());
|
||||
FileTreeIterator newTree = new FileTreeIterator(db);
|
||||
|
||||
ByteArrayOutputStream os = new ByteArrayOutputStream();
|
||||
DiffFormatter dfmt = new DiffFormatter(new SafeBufferedOutputStream(os));
|
||||
dfmt.setRepository(db);
|
||||
dfmt.setPathFilter(PathFilter.create("folder"));
|
||||
DirCacheIterator oldTree = new DirCacheIterator(db.readDirCache());
|
||||
FileTreeIterator newTree = new FileTreeIterator(db);
|
||||
dfmt.format(oldTree, newTree);
|
||||
dfmt.flush();
|
||||
dfmt.format(oldTree, newTree);
|
||||
dfmt.flush();
|
||||
|
||||
String actual = os.toString("UTF-8");
|
||||
String expected =
|
||||
"diff --git a/folder/folder.txt b/folder/folder.txt\n"
|
||||
+ "index 0119635..95c4c65 100644\n"
|
||||
+ "--- a/folder/folder.txt\n" + "+++ b/folder/folder.txt\n"
|
||||
+ "@@ -1 +1 @@\n" + "-folder\n"
|
||||
+ "\\ No newline at end of file\n" + "+folder change\n"
|
||||
+ "\\ No newline at end of file\n";
|
||||
String actual = os.toString("UTF-8");
|
||||
String expected =
|
||||
"diff --git a/folder/folder.txt b/folder/folder.txt\n"
|
||||
+ "index 0119635..95c4c65 100644\n"
|
||||
+ "--- a/folder/folder.txt\n" + "+++ b/folder/folder.txt\n"
|
||||
+ "@@ -1 +1 @@\n" + "-folder\n"
|
||||
+ "\\ No newline at end of file\n" + "+folder change\n"
|
||||
+ "\\ No newline at end of file\n";
|
||||
|
||||
assertEquals(expected, actual);
|
||||
assertEquals(expected, actual);
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
|
@ -349,29 +350,30 @@ public void testDiffRootNullToTree() throws Exception {
|
|||
File folder = new File(db.getDirectory().getParent(), "folder");
|
||||
FileUtils.mkdir(folder);
|
||||
write(new File(folder, "folder.txt"), "folder");
|
||||
Git git = new Git(db);
|
||||
git.add().addFilepattern(".").call();
|
||||
RevCommit commit = git.commit().setMessage("Initial commit").call();
|
||||
write(new File(folder, "folder.txt"), "folder change");
|
||||
try (Git git = new Git(db);
|
||||
ByteArrayOutputStream os = new ByteArrayOutputStream();
|
||||
DiffFormatter dfmt = new DiffFormatter(new SafeBufferedOutputStream(os))) {
|
||||
git.add().addFilepattern(".").call();
|
||||
RevCommit commit = git.commit().setMessage("Initial commit").call();
|
||||
write(new File(folder, "folder.txt"), "folder change");
|
||||
|
||||
ByteArrayOutputStream os = new ByteArrayOutputStream();
|
||||
DiffFormatter dfmt = new DiffFormatter(new SafeBufferedOutputStream(os));
|
||||
dfmt.setRepository(db);
|
||||
dfmt.setPathFilter(PathFilter.create("folder"));
|
||||
dfmt.format(null, commit.getTree().getId());
|
||||
dfmt.flush();
|
||||
dfmt.setRepository(db);
|
||||
dfmt.setPathFilter(PathFilter.create("folder"));
|
||||
dfmt.format(null, commit.getTree().getId());
|
||||
dfmt.flush();
|
||||
|
||||
String actual = os.toString("UTF-8");
|
||||
String expected = "diff --git a/folder/folder.txt b/folder/folder.txt\n"
|
||||
+ "new file mode 100644\n"
|
||||
+ "index 0000000..0119635\n"
|
||||
+ "--- /dev/null\n"
|
||||
+ "+++ b/folder/folder.txt\n"
|
||||
+ "@@ -0,0 +1 @@\n"
|
||||
+ "+folder\n"
|
||||
+ "\\ No newline at end of file\n";
|
||||
String actual = os.toString("UTF-8");
|
||||
String expected = "diff --git a/folder/folder.txt b/folder/folder.txt\n"
|
||||
+ "new file mode 100644\n"
|
||||
+ "index 0000000..0119635\n"
|
||||
+ "--- /dev/null\n"
|
||||
+ "+++ b/folder/folder.txt\n"
|
||||
+ "@@ -0,0 +1 @@\n"
|
||||
+ "+folder\n"
|
||||
+ "\\ No newline at end of file\n";
|
||||
|
||||
assertEquals(expected, actual);
|
||||
assertEquals(expected, actual);
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
|
@ -380,43 +382,45 @@ public void testDiffRootTreeToNull() throws Exception {
|
|||
File folder = new File(db.getDirectory().getParent(), "folder");
|
||||
FileUtils.mkdir(folder);
|
||||
write(new File(folder, "folder.txt"), "folder");
|
||||
Git git = new Git(db);
|
||||
git.add().addFilepattern(".").call();
|
||||
RevCommit commit = git.commit().setMessage("Initial commit").call();
|
||||
write(new File(folder, "folder.txt"), "folder change");
|
||||
try (Git git = new Git(db);
|
||||
ByteArrayOutputStream os = new ByteArrayOutputStream();
|
||||
DiffFormatter dfmt = new DiffFormatter(new SafeBufferedOutputStream(os));) {
|
||||
git.add().addFilepattern(".").call();
|
||||
RevCommit commit = git.commit().setMessage("Initial commit").call();
|
||||
write(new File(folder, "folder.txt"), "folder change");
|
||||
|
||||
ByteArrayOutputStream os = new ByteArrayOutputStream();
|
||||
DiffFormatter dfmt = new DiffFormatter(new SafeBufferedOutputStream(os));
|
||||
dfmt.setRepository(db);
|
||||
dfmt.setPathFilter(PathFilter.create("folder"));
|
||||
dfmt.format(commit.getTree().getId(), null);
|
||||
dfmt.flush();
|
||||
dfmt.setRepository(db);
|
||||
dfmt.setPathFilter(PathFilter.create("folder"));
|
||||
dfmt.format(commit.getTree().getId(), null);
|
||||
dfmt.flush();
|
||||
|
||||
String actual = os.toString("UTF-8");
|
||||
String expected = "diff --git a/folder/folder.txt b/folder/folder.txt\n"
|
||||
+ "deleted file mode 100644\n"
|
||||
+ "index 0119635..0000000\n"
|
||||
+ "--- a/folder/folder.txt\n"
|
||||
+ "+++ /dev/null\n"
|
||||
+ "@@ -1 +0,0 @@\n"
|
||||
+ "-folder\n"
|
||||
+ "\\ No newline at end of file\n";
|
||||
String actual = os.toString("UTF-8");
|
||||
String expected = "diff --git a/folder/folder.txt b/folder/folder.txt\n"
|
||||
+ "deleted file mode 100644\n"
|
||||
+ "index 0119635..0000000\n"
|
||||
+ "--- a/folder/folder.txt\n"
|
||||
+ "+++ /dev/null\n"
|
||||
+ "@@ -1 +0,0 @@\n"
|
||||
+ "-folder\n"
|
||||
+ "\\ No newline at end of file\n";
|
||||
|
||||
assertEquals(expected, actual);
|
||||
assertEquals(expected, actual);
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testDiffNullToNull() throws Exception {
|
||||
ByteArrayOutputStream os = new ByteArrayOutputStream();
|
||||
DiffFormatter dfmt = new DiffFormatter(new SafeBufferedOutputStream(os));
|
||||
dfmt.setRepository(db);
|
||||
dfmt.format((AnyObjectId) null, null);
|
||||
dfmt.flush();
|
||||
try (ByteArrayOutputStream os = new ByteArrayOutputStream();
|
||||
DiffFormatter dfmt = new DiffFormatter(new SafeBufferedOutputStream(os))) {
|
||||
dfmt.setRepository(db);
|
||||
dfmt.format((AnyObjectId) null, null);
|
||||
dfmt.flush();
|
||||
|
||||
String actual = os.toString("UTF-8");
|
||||
String expected = "";
|
||||
String actual = os.toString("UTF-8");
|
||||
String expected = "";
|
||||
|
||||
assertEquals(expected, actual);
|
||||
assertEquals(expected, actual);
|
||||
}
|
||||
}
|
||||
|
||||
private static String makeDiffHeader(String pathA, String pathB,
|
||||
|
|
|
@ -126,24 +126,26 @@ public void testIncrementalBundle() throws Exception {
|
|||
assertNull(newRepo.resolve("refs/heads/a"));
|
||||
|
||||
// Next an incremental bundle
|
||||
bundle = makeBundle("refs/heads/cc", db.resolve("c").name(),
|
||||
new RevWalk(db).parseCommit(db.resolve("a").toObjectId()));
|
||||
fetchResult = fetchFromBundle(newRepo, bundle);
|
||||
advertisedRef = fetchResult.getAdvertisedRef("refs/heads/cc");
|
||||
assertEquals(db.resolve("c").name(), advertisedRef.getObjectId().name());
|
||||
assertEquals(db.resolve("c").name(), newRepo.resolve("refs/heads/cc")
|
||||
.name());
|
||||
assertNull(newRepo.resolve("refs/heads/c"));
|
||||
assertNull(newRepo.resolve("refs/heads/a")); // still unknown
|
||||
try (RevWalk rw = new RevWalk(db)) {
|
||||
bundle = makeBundle("refs/heads/cc", db.resolve("c").name(),
|
||||
rw.parseCommit(db.resolve("a").toObjectId()));
|
||||
fetchResult = fetchFromBundle(newRepo, bundle);
|
||||
advertisedRef = fetchResult.getAdvertisedRef("refs/heads/cc");
|
||||
assertEquals(db.resolve("c").name(), advertisedRef.getObjectId().name());
|
||||
assertEquals(db.resolve("c").name(), newRepo.resolve("refs/heads/cc")
|
||||
.name());
|
||||
assertNull(newRepo.resolve("refs/heads/c"));
|
||||
assertNull(newRepo.resolve("refs/heads/a")); // still unknown
|
||||
|
||||
try {
|
||||
// Check that we actually needed the first bundle
|
||||
Repository newRepo2 = createBareRepository();
|
||||
fetchResult = fetchFromBundle(newRepo2, bundle);
|
||||
fail("We should not be able to fetch from bundle with prerequisites that are not fulfilled");
|
||||
} catch (MissingBundlePrerequisiteException e) {
|
||||
assertTrue(e.getMessage()
|
||||
.indexOf(db.resolve("refs/heads/a").name()) >= 0);
|
||||
try {
|
||||
// Check that we actually needed the first bundle
|
||||
Repository newRepo2 = createBareRepository();
|
||||
fetchResult = fetchFromBundle(newRepo2, bundle);
|
||||
fail("We should not be able to fetch from bundle with prerequisites that are not fulfilled");
|
||||
} catch (MissingBundlePrerequisiteException e) {
|
||||
assertTrue(e.getMessage()
|
||||
.indexOf(db.resolve("refs/heads/a").name()) >= 0);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
@ -195,25 +195,31 @@ public void flush() throws IOException {
|
|||
assertEquals(1, flushCnt[0]);
|
||||
}
|
||||
|
||||
@SuppressWarnings("unused")
|
||||
private void createSideBandOutputStream(int chan, int sz, OutputStream os)
|
||||
throws Exception {
|
||||
try (SideBandOutputStream s = new SideBandOutputStream(chan, sz, os)) {
|
||||
// Unused
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testConstructor_RejectsBadChannel() {
|
||||
public void testConstructor_RejectsBadChannel() throws Exception {
|
||||
try {
|
||||
new SideBandOutputStream(-1, MAX_BUF, rawOut);
|
||||
createSideBandOutputStream(-1, MAX_BUF, rawOut);
|
||||
fail("Accepted -1 channel number");
|
||||
} catch (IllegalArgumentException e) {
|
||||
assertEquals("channel -1 must be in range [1, 255]", e.getMessage());
|
||||
}
|
||||
|
||||
try {
|
||||
new SideBandOutputStream(0, MAX_BUF, rawOut);
|
||||
createSideBandOutputStream(0, MAX_BUF, rawOut);
|
||||
fail("Accepted 0 channel number");
|
||||
} catch (IllegalArgumentException e) {
|
||||
assertEquals("channel 0 must be in range [1, 255]", e.getMessage());
|
||||
}
|
||||
|
||||
try {
|
||||
new SideBandOutputStream(256, MAX_BUF, rawOut);
|
||||
createSideBandOutputStream(256, MAX_BUF, rawOut);
|
||||
fail("Accepted 256 channel number");
|
||||
} catch (IllegalArgumentException e) {
|
||||
assertEquals("channel 256 must be in range [1, 255]", e
|
||||
|
@ -221,32 +227,31 @@ public void testConstructor_RejectsBadChannel() {
|
|||
}
|
||||
}
|
||||
|
||||
@SuppressWarnings("unused")
|
||||
@Test
|
||||
public void testConstructor_RejectsBadBufferSize() {
|
||||
public void testConstructor_RejectsBadBufferSize() throws Exception {
|
||||
try {
|
||||
new SideBandOutputStream(CH_DATA, -1, rawOut);
|
||||
createSideBandOutputStream(CH_DATA, -1, rawOut);
|
||||
fail("Accepted -1 for buffer size");
|
||||
} catch (IllegalArgumentException e) {
|
||||
assertEquals("packet size -1 must be >= 5", e.getMessage());
|
||||
}
|
||||
|
||||
try {
|
||||
new SideBandOutputStream(CH_DATA, 0, rawOut);
|
||||
createSideBandOutputStream(CH_DATA, 0, rawOut);
|
||||
fail("Accepted 0 for buffer size");
|
||||
} catch (IllegalArgumentException e) {
|
||||
assertEquals("packet size 0 must be >= 5", e.getMessage());
|
||||
}
|
||||
|
||||
try {
|
||||
new SideBandOutputStream(CH_DATA, 1, rawOut);
|
||||
createSideBandOutputStream(CH_DATA, 1, rawOut);
|
||||
fail("Accepted 1 for buffer size");
|
||||
} catch (IllegalArgumentException e) {
|
||||
assertEquals("packet size 1 must be >= 5", e.getMessage());
|
||||
}
|
||||
|
||||
try {
|
||||
new SideBandOutputStream(CH_DATA, Integer.MAX_VALUE, rawOut);
|
||||
createSideBandOutputStream(CH_DATA, Integer.MAX_VALUE, rawOut);
|
||||
fail("Accepted " + Integer.MAX_VALUE + " for buffer size");
|
||||
} catch (IllegalArgumentException e) {
|
||||
assertEquals(MessageFormat.format(
|
||||
|
|
|
@ -103,18 +103,20 @@ public void apply(DirCacheEntry ent) {
|
|||
});
|
||||
assertTrue(dce.commit());
|
||||
}
|
||||
new Git(db).commit().setMessage("Adding link").call();
|
||||
new Git(db).reset().setMode(ResetType.HARD).call();
|
||||
DirCacheIterator dci = new DirCacheIterator(db.readDirCache());
|
||||
FileTreeIterator fti = new FileTreeIterator(db);
|
||||
try (Git git = new Git(db)) {
|
||||
git.commit().setMessage("Adding link").call();
|
||||
git.reset().setMode(ResetType.HARD).call();
|
||||
DirCacheIterator dci = new DirCacheIterator(db.readDirCache());
|
||||
FileTreeIterator fti = new FileTreeIterator(db);
|
||||
|
||||
// self-check
|
||||
assertEquals("link", fti.getEntryPathString());
|
||||
assertEquals("link", dci.getEntryPathString());
|
||||
// self-check
|
||||
assertEquals("link", fti.getEntryPathString());
|
||||
assertEquals("link", dci.getEntryPathString());
|
||||
|
||||
// test
|
||||
assertFalse(fti.isModified(dci.getDirCacheEntry(), true,
|
||||
db.newObjectReader()));
|
||||
// test
|
||||
assertFalse(fti.isModified(dci.getDirCacheEntry(), true,
|
||||
db.newObjectReader()));
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
|
@ -142,18 +144,20 @@ public void apply(DirCacheEntry ent) {
|
|||
});
|
||||
assertTrue(dce.commit());
|
||||
}
|
||||
new Git(db).commit().setMessage("Adding link").call();
|
||||
new Git(db).reset().setMode(ResetType.HARD).call();
|
||||
DirCacheIterator dci = new DirCacheIterator(db.readDirCache());
|
||||
FileTreeIterator fti = new FileTreeIterator(db);
|
||||
try (Git git = new Git(db)) {
|
||||
git.commit().setMessage("Adding link").call();
|
||||
git.reset().setMode(ResetType.HARD).call();
|
||||
DirCacheIterator dci = new DirCacheIterator(db.readDirCache());
|
||||
FileTreeIterator fti = new FileTreeIterator(db);
|
||||
|
||||
// self-check
|
||||
assertEquals("link", fti.getEntryPathString());
|
||||
assertEquals("link", dci.getEntryPathString());
|
||||
// self-check
|
||||
assertEquals("link", fti.getEntryPathString());
|
||||
assertEquals("link", dci.getEntryPathString());
|
||||
|
||||
// test
|
||||
assertFalse(fti.isModified(dci.getDirCacheEntry(), true,
|
||||
db.newObjectReader()));
|
||||
// test
|
||||
assertFalse(fti.isModified(dci.getDirCacheEntry(), true,
|
||||
db.newObjectReader()));
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
|
@ -182,20 +186,22 @@ public void apply(DirCacheEntry ent) {
|
|||
});
|
||||
assertTrue(dce.commit());
|
||||
}
|
||||
new Git(db).commit().setMessage("Adding link").call();
|
||||
new Git(db).reset().setMode(ResetType.HARD).call();
|
||||
try (Git git = new Git(db)) {
|
||||
git.commit().setMessage("Adding link").call();
|
||||
git.reset().setMode(ResetType.HARD).call();
|
||||
|
||||
FileUtils.delete(new File(trash, "link"), FileUtils.NONE);
|
||||
FS.DETECTED.createSymLink(new File(trash, "link"), "newtarget");
|
||||
DirCacheIterator dci = new DirCacheIterator(db.readDirCache());
|
||||
FileTreeIterator fti = new FileTreeIterator(db);
|
||||
FileUtils.delete(new File(trash, "link"), FileUtils.NONE);
|
||||
FS.DETECTED.createSymLink(new File(trash, "link"), "newtarget");
|
||||
DirCacheIterator dci = new DirCacheIterator(db.readDirCache());
|
||||
FileTreeIterator fti = new FileTreeIterator(db);
|
||||
|
||||
// self-check
|
||||
assertEquals("link", fti.getEntryPathString());
|
||||
assertEquals("link", dci.getEntryPathString());
|
||||
// self-check
|
||||
assertEquals("link", fti.getEntryPathString());
|
||||
assertEquals("link", dci.getEntryPathString());
|
||||
|
||||
// test
|
||||
assertTrue(fti.isModified(dci.getDirCacheEntry(), true,
|
||||
db.newObjectReader()));
|
||||
// test
|
||||
assertTrue(fti.isModified(dci.getDirCacheEntry(), true,
|
||||
db.newObjectReader()));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
Loading…
Reference in New Issue