Merge branch 'master' into stable-6.2

* master:
  Adapt diff- and merge tool code for PGM and EGit usage
  Teach JGit to handle external diff/merge tools defined in
.gitattributes

Change-Id: I3aefc14160caaac859bd3548460dd755ebe42fc5

3 files changed, 477 insertions, 100 deletions

diff --git a/org.eclipse.jgit.test/tst/org/eclipse/jgit/internal/diffmergetool/ExternalDiffToolTest.java b/org.eclipse.jgit.test/tst/org/eclipse/jgit/internal/diffmergetool/ExternalDiffToolTest.java
index 4fd55c6cad..f69a1794ef 100644
--- a/org.eclipse.jgit.test/tst/org/eclipse/jgit/internal/diffmergetool/ExternalDiffToolTest.java
+++ b/org.eclipse.jgit.test/tst/org/eclipse/jgit/internal/diffmergetool/ExternalDiffToolTest.java
@@ -18,15 +18,25 @@ import static org.eclipse.jgit.lib.ConfigConstants.CONFIG_KEY_PROMPT;
 import static org.eclipse.jgit.lib.ConfigConstants.CONFIG_KEY_TOOL;
 import static org.eclipse.jgit.lib.ConfigConstants.CONFIG_KEY_TRUST_EXIT_CODE;
 import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
 import static org.junit.Assert.assertTrue;
 import static org.junit.Assert.fail;
 
+import java.io.File;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.util.Arrays;
 import java.util.Collections;
 import java.util.LinkedHashSet;
+import java.util.List;
 import java.util.Map;
+import java.util.Optional;
 import java.util.Set;
 
+import org.eclipse.jgit.junit.TestRepository;
+import org.eclipse.jgit.lib.Repository;
 import org.eclipse.jgit.lib.internal.BooleanTriState;
 import org.eclipse.jgit.storage.file.FileBasedConfig;
 import org.eclipse.jgit.util.FS.ExecutionResult;
@@ -48,14 +58,7 @@ public class ExternalDiffToolTest extends ExternalToolTestCase {
 		config.setString(CONFIG_DIFFTOOL_SECTION, toolName, CONFIG_KEY_CMD,
 				command);
 
-		DiffTools manager = new DiffTools(db);
-
-		BooleanTriState prompt = BooleanTriState.UNSET;
-		BooleanTriState gui = BooleanTriState.UNSET;
-		BooleanTriState trustExitCode = BooleanTriState.TRUE;
-
-		manager.compare(local, remote, merged, toolName, prompt, gui,
-				trustExitCode);
+		invokeCompare(toolName);
 
 		fail("Expected exception to be thrown due to external tool exiting with error code: "
 				+ errorReturnCode);
@@ -72,33 +75,91 @@ public class ExternalDiffToolTest extends ExternalToolTestCase {
 		config.setString(CONFIG_DIFFTOOL_SECTION, toolName, CONFIG_KEY_CMD,
 				command);
 
+		invokeCompare(toolName);
+		fail("Expected exception to be thrown due to external tool exiting with error code: "
+				+ errorReturnCode);
+	}
+
+	@Test
+	public void testUserDefinedTool() throws Exception {
+		String command = getEchoCommand();
+
+		FileBasedConfig config = db.getConfig();
+		String customToolName = "customTool";
+		config.setString(CONFIG_DIFFTOOL_SECTION, customToolName,
+				CONFIG_KEY_CMD, command);
+
 		DiffTools manager = new DiffTools(db);
 
-		BooleanTriState prompt = BooleanTriState.UNSET;
-		BooleanTriState gui = BooleanTriState.UNSET;
-		BooleanTriState trustExitCode = BooleanTriState.FALSE;
+		Map<String, ExternalDiffTool> tools = manager.getUserDefinedTools();
+		ExternalDiffTool externalTool = tools.get(customToolName);
+		boolean trustExitCode = true;
+		manager.compare(local, remote, externalTool, trustExitCode);
 
-		manager.compare(local, remote, merged, toolName, prompt, gui,
-				trustExitCode);
+		assertEchoCommandHasCorrectOutput();
+	}
 
-		fail("Expected exception to be thrown due to external tool exiting with error code: "
-				+ errorReturnCode);
+	@Test
+	public void testUserDefinedToolWithPrompt() throws Exception {
+		String command = getEchoCommand();
+
+		FileBasedConfig config = db.getConfig();
+		String customToolName = "customTool";
+		config.setString(CONFIG_DIFFTOOL_SECTION, customToolName,
+				CONFIG_KEY_CMD, command);
+
+		DiffTools manager = new DiffTools(db);
+
+		PromptHandler promptHandler = PromptHandler.acceptPrompt();
+		MissingToolHandler noToolHandler = new MissingToolHandler();
+
+		manager.compare(local, remote, Optional.of(customToolName),
+				BooleanTriState.TRUE, false, BooleanTriState.TRUE,
+				promptHandler, noToolHandler);
+
+		assertEchoCommandHasCorrectOutput();
+
+		List<String> actualToolPrompts = promptHandler.toolPrompts;
+		List<String> expectedToolPrompts = Arrays.asList("customTool");
+		assertEquals("Expected a user prompt for custom tool call",
+				expectedToolPrompts, actualToolPrompts);
+
+		assertEquals("Expected to no informing about missing tools",
+				Collections.EMPTY_LIST, noToolHandler.missingTools);
 	}
 
 	@Test
-	public void testToolNames() {
+	public void testUserDefinedToolWithCancelledPrompt() throws Exception {
+		String command = getEchoCommand();
+
+		FileBasedConfig config = db.getConfig();
+		String customToolName = "customTool";
+		config.setString(CONFIG_DIFFTOOL_SECTION, customToolName,
+				CONFIG_KEY_CMD, command);
+
 		DiffTools manager = new DiffTools(db);
-		Set<String> actualToolNames = manager.getToolNames();
-		Set<String> expectedToolNames = Collections.emptySet();
-		assertEquals("Incorrect set of external diff tool names",
-				expectedToolNames, actualToolNames);
+
+		PromptHandler promptHandler = PromptHandler.cancelPrompt();
+		MissingToolHandler noToolHandler = new MissingToolHandler();
+
+		Optional<ExecutionResult> result = manager.compare(local, remote,
+				Optional.of(customToolName), BooleanTriState.TRUE, false,
+				BooleanTriState.TRUE, promptHandler, noToolHandler);
+		assertFalse("Expected no result if user cancels the operation",
+				result.isPresent());
 	}
 
 	@Test
 	public void testAllTools() {
+		FileBasedConfig config = db.getConfig();
+		String customToolName = "customTool";
+		config.setString(CONFIG_DIFFTOOL_SECTION, customToolName,
+				CONFIG_KEY_CMD, "echo");
+
 		DiffTools manager = new DiffTools(db);
-		Set<String> actualToolNames = manager.getAvailableTools().keySet();
+		Set<String> actualToolNames = manager.getAllToolNames();
 		Set<String> expectedToolNames = new LinkedHashSet<>();
+		expectedToolNames.add(customToolName);
 		CommandLineDiffTool[] defaultTools = CommandLineDiffTool.values();
 		for (CommandLineDiffTool defaultTool : defaultTools) {
 			String toolName = defaultTool.name();
@@ -153,15 +214,6 @@ public class ExternalDiffToolTest extends ExternalToolTestCase {
 	}
 
 	@Test
-	public void testNotAvailableTools() {
-		DiffTools manager = new DiffTools(db);
-		Set<String> actualToolNames = manager.getNotAvailableTools().keySet();
-		Set<String> expectedToolNames = Collections.emptySet();
-		assertEquals("Incorrect set of not available external diff tools",
-				expectedToolNames, actualToolNames);
-	}
-
-	@Test
 	public void testCompare() throws ToolException {
 		String toolName = "customTool";
 
@@ -175,18 +227,12 @@ public class ExternalDiffToolTest extends ExternalToolTestCase {
 
 		config.setString(CONFIG_DIFFTOOL_SECTION, toolName, CONFIG_KEY_CMD,
 				command);
-
-		BooleanTriState prompt = BooleanTriState.UNSET;
-		BooleanTriState gui = BooleanTriState.UNSET;
-		BooleanTriState trustExitCode = BooleanTriState.UNSET;
-
-		DiffTools manager = new DiffTools(db);
-
+		Optional<ExecutionResult> result = invokeCompare(toolName);
+		assertTrue("Expected external diff tool result to be available",
+				result.isPresent());
 		int expectedCompareResult = 0;
-		ExecutionResult compareResult = manager.compare(local, remote, merged,
-				toolName, prompt, gui, trustExitCode);
 		assertEquals("Incorrect compare result for external diff tool",
-				expectedCompareResult, compareResult.getRc());
+				expectedCompareResult, result.get().getRc());
 	}
 
 	@Test
@@ -201,17 +247,17 @@ public class ExternalDiffToolTest extends ExternalToolTestCase {
 				toolName);
 
 		DiffTools manager = new DiffTools(db);
-		BooleanTriState gui = BooleanTriState.UNSET;
+		boolean gui = false;
 		String defaultToolName = manager.getDefaultToolName(gui);
 		assertEquals(
 				"Expected configured difftool to be the default external diff tool",
 				toolName, defaultToolName);
 
-		gui = BooleanTriState.TRUE;
+		gui = true;
 		String defaultGuiToolName = manager.getDefaultToolName(gui);
 		assertEquals(
-				"Expected configured difftool to be the default external diff tool",
-				"my_gui_tool", defaultGuiToolName);
+				"Expected default gui difftool to be the default tool if no gui tool is set",
+				toolName, defaultGuiToolName);
 
 		config.setString(CONFIG_DIFF_SECTION, subsection, CONFIG_KEY_GUITOOL,
 				guiToolName);
@@ -219,7 +265,7 @@ public class ExternalDiffToolTest extends ExternalToolTestCase {
 		defaultGuiToolName = manager.getDefaultToolName(gui);
 		assertEquals(
 				"Expected configured difftool to be the default external diff guitool",
-				"my_gui_tool", defaultGuiToolName);
+				guiToolName, defaultGuiToolName);
 	}
 
 	@Test
@@ -239,7 +285,7 @@ public class ExternalDiffToolTest extends ExternalToolTestCase {
 
 		DiffTools manager = new DiffTools(db);
 		Map<String, ExternalDiffTool> availableTools = manager
-				.getAvailableTools();
+				.getPredefinedTools(true);
 		ExternalDiffTool externalDiffTool = availableTools
 				.get(overridenToolName);
 		String actualDiffToolPath = externalDiffTool.getPath();
@@ -256,20 +302,152 @@ public class ExternalDiffToolTest extends ExternalToolTestCase {
 
 	@Test(expected = ToolException.class)
 	public void testUndefinedTool() throws Exception {
+		String toolName = "undefined";
+		invokeCompare(toolName);
+		fail("Expected exception to be thrown due to not defined external diff tool");
+	}
+
+	@Test
+	public void testDefaultToolExecutionWithPrompt() throws Exception {
+		FileBasedConfig config = db.getConfig();
+		// the default diff tool is configured without a subsection
+		String subsection = null;
+		config.setString("diff", subsection, "tool", "customTool");
+
+		String command = getEchoCommand();
+
+		config.setString("difftool", "customTool", "cmd", command);
+
+		DiffTools manager = new DiffTools(db);
+
+		PromptHandler promptHandler = PromptHandler.acceptPrompt();
+		MissingToolHandler noToolHandler = new MissingToolHandler();
+
+		manager.compare(local, remote, Optional.empty(), BooleanTriState.TRUE,
+				false, BooleanTriState.TRUE, promptHandler, noToolHandler);
+
+		assertEchoCommandHasCorrectOutput();
+	}
+
+	@Test
+	public void testNoDefaultToolName() {
+		DiffTools manager = new DiffTools(db);
+		boolean gui = false;
+		String defaultToolName = manager.getDefaultToolName(gui);
+		assertNull("Expected no default tool when none is configured",
+				defaultToolName);
+
+		gui = true;
+		defaultToolName = manager.getDefaultToolName(gui);
+		assertNull("Expected no default tool when none is configured",
+				defaultToolName);
+	}
+
+	@Test
+	public void testExternalToolInGitAttributes() throws Exception {
+		String content = "attributes:\n*.txt 		difftool=customTool";
+		File gitattributes = writeTrashFile(".gitattributes", content);
+		gitattributes.deleteOnExit();
+		try (TestRepository<Repository> testRepository = new TestRepository<>(
+				db)) {
+			FileBasedConfig config = db.getConfig();
+			config.setString("difftool", "customTool", "cmd", "echo");
+			testRepository.git().add().addFilepattern(localFile.getName())
+					.call();
+
+			testRepository.git().add().addFilepattern(".gitattributes").call();
+
+			testRepository.branch("master").commit().message("first commit")
+					.create();
+
+			DiffTools manager = new DiffTools(db);
+			Optional<String> tool = manager
+					.getExternalToolFromAttributes(localFile.getName());
+			assertTrue("Failed to find user defined tool", tool.isPresent());
+			assertEquals("Failed to find user defined tool", "customTool",
+					tool.get());
+		} finally {
+			Files.delete(gitattributes.toPath());
+		}
+	}
+
+	@Test
+	public void testNotExternalToolInGitAttributes() throws Exception {
+		String content = "";
+		File gitattributes = writeTrashFile(".gitattributes", content);
+		gitattributes.deleteOnExit();
+		try (TestRepository<Repository> testRepository = new TestRepository<>(
+				db)) {
+			FileBasedConfig config = db.getConfig();
+			config.setString("difftool", "customTool", "cmd", "echo");
+			testRepository.git().add().addFilepattern(localFile.getName())
+					.call();
+
+			testRepository.git().add().addFilepattern(".gitattributes").call();
+
+			testRepository.branch("master").commit().message("first commit")
+					.create();
+
+			DiffTools manager = new DiffTools(db);
+			Optional<String> tool = manager
+					.getExternalToolFromAttributes(localFile.getName());
+			assertFalse(
+					"Expected no external tool if no default tool is specified in .gitattributes",
+					tool.isPresent());
+		} finally {
+			Files.delete(gitattributes.toPath());
+		}
+	}
+
+	@Test(expected = ToolException.class)
+	public void testNullTool() throws Exception {
+		DiffTools manager = new DiffTools(db);
+
+		boolean trustExitCode = true;
+		ExternalDiffTool tool = null;
+		manager.compare(local, remote, tool, trustExitCode);
+	}
+
+	@Test(expected = ToolException.class)
+	public void testNullToolWithPrompt() throws Exception {
+		DiffTools manager = new DiffTools(db);
+
+		PromptHandler promptHandler = PromptHandler.cancelPrompt();
+		MissingToolHandler noToolHandler = new MissingToolHandler();
+
+		Optional<String> tool = null;
+		manager.compare(local, remote, tool, BooleanTriState.TRUE, false,
+				BooleanTriState.TRUE, promptHandler, noToolHandler);
+	}
+
+	private Optional<ExecutionResult> invokeCompare(String toolName)
+			throws ToolException {
 		DiffTools manager = new DiffTools(db);
 
-		String toolName = "undefined";
 		BooleanTriState prompt = BooleanTriState.UNSET;
-		BooleanTriState gui = BooleanTriState.UNSET;
-		BooleanTriState trustExitCode = BooleanTriState.UNSET;
+		boolean gui = false;
+		BooleanTriState trustExitCode = BooleanTriState.TRUE;
+		PromptHandler promptHandler = PromptHandler.acceptPrompt();
+		MissingToolHandler noToolHandler = new MissingToolHandler();
 
-		manager.compare(local, remote, merged, toolName, prompt, gui,
-				trustExitCode);
-		fail("Expected exception to be thrown due to not defined external diff tool");
+		Optional<ExecutionResult> result = manager.compare(local, remote,
+				Optional.of(toolName), prompt, gui, trustExitCode,
+				promptHandler, noToolHandler);
+		return result;
 	}
 
 	private String getEchoCommand() {
 		return "(echo \"$LOCAL\" \"$REMOTE\") > "
 				+ commandResult.getAbsolutePath();
 	}
+
+	private void assertEchoCommandHasCorrectOutput() throws IOException {
+		List<String> actualLines = Files.readAllLines(commandResult.toPath());
+		String actualContent = String.join(System.lineSeparator(), actualLines);
+		actualLines = Arrays.asList(actualContent.split(" "));
+		List<String> expectedLines = Arrays.asList(localFile.getAbsolutePath(),
+				remoteFile.getAbsolutePath());
+		assertEquals("Dummy test tool called with unexpected arguments",
+				expectedLines, actualLines);
+	}
 }
diff --git a/org.eclipse.jgit.test/tst/org/eclipse/jgit/internal/diffmergetool/ExternalMergeToolTest.java b/org.eclipse.jgit.test/tst/org/eclipse/jgit/internal/diffmergetool/ExternalMergeToolTest.java
index 50576682eb..94b67b374b 100644
--- a/org.eclipse.jgit.test/tst/org/eclipse/jgit/internal/diffmergetool/ExternalMergeToolTest.java
+++ b/org.eclipse.jgit.test/tst/org/eclipse/jgit/internal/diffmergetool/ExternalMergeToolTest.java
@@ -9,22 +9,30 @@
  */
 package org.eclipse.jgit.internal.diffmergetool;
 
-import static org.eclipse.jgit.lib.ConfigConstants.CONFIG_MERGETOOL_SECTION;
-import static org.eclipse.jgit.lib.ConfigConstants.CONFIG_MERGE_SECTION;
 import static org.eclipse.jgit.lib.ConfigConstants.CONFIG_KEY_CMD;
 import static org.eclipse.jgit.lib.ConfigConstants.CONFIG_KEY_GUITOOL;
 import static org.eclipse.jgit.lib.ConfigConstants.CONFIG_KEY_PATH;
 import static org.eclipse.jgit.lib.ConfigConstants.CONFIG_KEY_PROMPT;
 import static org.eclipse.jgit.lib.ConfigConstants.CONFIG_KEY_TOOL;
 import static org.eclipse.jgit.lib.ConfigConstants.CONFIG_KEY_TRUST_EXIT_CODE;
+import static org.eclipse.jgit.lib.ConfigConstants.CONFIG_MERGETOOL_SECTION;
+import static org.eclipse.jgit.lib.ConfigConstants.CONFIG_MERGE_SECTION;
 import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
 import static org.junit.Assert.assertTrue;
 import static org.junit.Assert.fail;
+import static org.junit.Assume.assumeTrue;
 
+import java.io.IOException;
+import java.nio.file.Files;
+import java.util.Arrays;
 import java.util.Collections;
 import java.util.LinkedHashSet;
+import java.util.List;
 import java.util.Map;
+import java.util.Optional;
 import java.util.Set;
 
 import org.eclipse.jgit.lib.internal.BooleanTriState;
@@ -50,12 +58,7 @@ public class ExternalMergeToolTest extends ExternalToolTestCase {
 		config.setString(CONFIG_MERGETOOL_SECTION, toolName,
 				CONFIG_KEY_TRUST_EXIT_CODE, String.valueOf(Boolean.TRUE));
 
-		MergeTools manager = new MergeTools(db);
-
-		BooleanTriState prompt = BooleanTriState.UNSET;
-		BooleanTriState gui = BooleanTriState.UNSET;
-
-		manager.merge(local, remote, merged, base, null, toolName, prompt, gui);
+		invokeMerge(toolName);
 
 		fail("Expected exception to be thrown due to external tool exiting with error code: "
 				+ errorReturnCode);
@@ -72,31 +75,112 @@ public class ExternalMergeToolTest extends ExternalToolTestCase {
 		config.setString(CONFIG_MERGETOOL_SECTION, toolName, CONFIG_KEY_CMD,
 				command);
 
+		invokeMerge(toolName);
+
+		fail("Expected exception to be thrown due to external tool exiting with error code: "
+				+ errorReturnCode);
+	}
+
+	@Test
+	public void testKdiff3() throws Exception {
+		assumePosixPlatform();
+
+		CommandLineMergeTool autoMergingTool = CommandLineMergeTool.kdiff3;
+		assumeMergeToolIsAvailable(autoMergingTool);
+
+		CommandLineMergeTool tool = autoMergingTool;
+		PreDefinedMergeTool externalTool = new PreDefinedMergeTool(tool.name(),
+				tool.getPath(), tool.getParameters(true),
+				tool.getParameters(false),
+				tool.isExitCodeTrustable() ? BooleanTriState.TRUE
+						: BooleanTriState.FALSE);
+
 		MergeTools manager = new MergeTools(db);
+		ExecutionResult result = manager.merge(local, remote, merged, null,
+				null, externalTool);
+		assertEquals("Expected merge tool to succeed", 0, result.getRc());
+
+		List<String> actualLines = Files.readAllLines(mergedFile.toPath());
+		String actualMergeResult = String.join(System.lineSeparator(),
+				actualLines);
+		String expectedMergeResult = DEFAULT_CONTENT;
+		assertEquals(
+				"Failed to merge equal local and remote versions with pre-defined tool: "
+						+ tool.getPath(),
+				expectedMergeResult, actualMergeResult);
+	}
 
-		BooleanTriState prompt = BooleanTriState.UNSET;
-		BooleanTriState gui = BooleanTriState.UNSET;
+	@Test
+	public void testUserDefinedTool() throws Exception {
+		String customToolName = "customTool";
+		String command = getEchoCommand();
 
-		manager.merge(local, remote, merged, base, null, toolName, prompt, gui);
+		FileBasedConfig config = db.getConfig();
+		config.setString(CONFIG_MERGETOOL_SECTION, customToolName,
+				CONFIG_KEY_CMD, command);
 
-		fail("Expected exception to be thrown due to external tool exiting with error code: "
-				+ errorReturnCode);
+		MergeTools manager = new MergeTools(db);
+		Map<String, ExternalMergeTool> tools = manager.getUserDefinedTools();
+		ExternalMergeTool externalTool = tools.get(customToolName);
+		manager.merge(local, remote, merged, base, null, externalTool);
+
+		assertEchoCommandHasCorrectOutput();
 	}
 
 	@Test
-	public void testToolNames() {
+	public void testUserDefinedToolWithPrompt() throws Exception {
+		String customToolName = "customTool";
+		String command = getEchoCommand();
+
+		FileBasedConfig config = db.getConfig();
+		config.setString(CONFIG_MERGETOOL_SECTION, customToolName,
+				CONFIG_KEY_CMD, command);
+
 		MergeTools manager = new MergeTools(db);
-		Set<String> actualToolNames = manager.getToolNames();
-		Set<String> expectedToolNames = Collections.emptySet();
-		assertEquals("Incorrect set of external merge tool names",
-				expectedToolNames, actualToolNames);
+
+		PromptHandler promptHandler = PromptHandler.acceptPrompt();
+		MissingToolHandler noToolHandler = new MissingToolHandler();
+
+		manager.merge(local, remote, merged, base, null,
+				Optional.of(customToolName), BooleanTriState.TRUE, false,
+				promptHandler, noToolHandler);
+
+		assertEchoCommandHasCorrectOutput();
+
+		List<String> actualToolPrompts = promptHandler.toolPrompts;
+		List<String> expectedToolPrompts = Arrays.asList("customTool");
+		assertEquals("Expected a user prompt for custom tool call",
+				expectedToolPrompts, actualToolPrompts);
+
+		assertEquals("Expected to no informing about missing tools",
+				Collections.EMPTY_LIST, noToolHandler.missingTools);
+	}
+
+	@Test
+	public void testUserDefinedToolWithCancelledPrompt() throws Exception {
+		MergeTools manager = new MergeTools(db);
+
+		PromptHandler promptHandler = PromptHandler.cancelPrompt();
+		MissingToolHandler noToolHandler = new MissingToolHandler();
+
+		Optional<ExecutionResult> result = manager.merge(local, remote, merged,
+				base, null, Optional.empty(), BooleanTriState.TRUE, false,
+				promptHandler, noToolHandler);
+		assertFalse("Expected no result if user cancels the operation",
+				result.isPresent());
 	}
 
 	@Test
 	public void testAllTools() {
+		FileBasedConfig config = db.getConfig();
+		String customToolName = "customTool";
+		config.setString(CONFIG_MERGETOOL_SECTION, customToolName,
+				CONFIG_KEY_CMD, "echo");
+
 		MergeTools manager = new MergeTools(db);
-		Set<String> actualToolNames = manager.getAvailableTools().keySet();
+		Set<String> actualToolNames = manager.getAllToolNames();
 		Set<String> expectedToolNames = new LinkedHashSet<>();
+		expectedToolNames.add(customToolName);
 		CommandLineMergeTool[] defaultTools = CommandLineMergeTool.values();
 		for (CommandLineMergeTool defaultTool : defaultTools) {
 			String toolName = defaultTool.name();
@@ -151,15 +235,6 @@ public class ExternalMergeToolTest extends ExternalToolTestCase {
 	}
 
 	@Test
-	public void testNotAvailableTools() {
-		MergeTools manager = new MergeTools(db);
-		Set<String> actualToolNames = manager.getNotAvailableTools().keySet();
-		Set<String> expectedToolNames = Collections.emptySet();
-		assertEquals("Incorrect set of not available external merge tools",
-				expectedToolNames, actualToolNames);
-	}
-
-	@Test
 	public void testCompare() throws ToolException {
 		String toolName = "customTool";
 
@@ -174,16 +249,12 @@ public class ExternalMergeToolTest extends ExternalToolTestCase {
 		config.setString(CONFIG_MERGETOOL_SECTION, toolName, CONFIG_KEY_CMD,
 				command);
 
-		BooleanTriState prompt = BooleanTriState.UNSET;
-		BooleanTriState gui = BooleanTriState.UNSET;
-
-		MergeTools manager = new MergeTools(db);
-
+		Optional<ExecutionResult> result = invokeMerge(toolName);
+		assertTrue("Expected external merge tool result to be available",
+				result.isPresent());
 		int expectedCompareResult = 0;
-		ExecutionResult compareResult = manager.merge(local, remote, merged,
-				base, null, toolName, prompt, gui);
 		assertEquals("Incorrect compare result for external merge tool",
-				expectedCompareResult, compareResult.getRc());
+				expectedCompareResult, result.get().getRc());
 	}
 
 	@Test
@@ -198,17 +269,16 @@ public class ExternalMergeToolTest extends ExternalToolTestCase {
 				toolName);
 
 		MergeTools manager = new MergeTools(db);
-		BooleanTriState gui = BooleanTriState.UNSET;
+		boolean gui = false;
 		String defaultToolName = manager.getDefaultToolName(gui);
 		assertEquals(
 				"Expected configured mergetool to be the default external merge tool",
 				toolName, defaultToolName);
 
-		gui = BooleanTriState.TRUE;
+		gui = true;
 		String defaultGuiToolName = manager.getDefaultToolName(gui);
-		assertEquals(
-				"Expected configured mergetool to be the default external merge tool",
-				"my_gui_tool", defaultGuiToolName);
+		assertNull("Expected default mergetool to not be set",
+				defaultGuiToolName);
 
 		config.setString(CONFIG_MERGE_SECTION, subsection, CONFIG_KEY_GUITOOL,
 				guiToolName);
@@ -216,7 +286,7 @@ public class ExternalMergeToolTest extends ExternalToolTestCase {
 		defaultGuiToolName = manager.getDefaultToolName(gui);
 		assertEquals(
 				"Expected configured mergetool to be the default external merge guitool",
-				"my_gui_tool", defaultGuiToolName);
+				guiToolName, defaultGuiToolName);
 	}
 
 	@Test
@@ -236,7 +306,7 @@ public class ExternalMergeToolTest extends ExternalToolTestCase {
 
 		MergeTools manager = new MergeTools(db);
 		Map<String, ExternalMergeTool> availableTools = manager
-				.getAvailableTools();
+				.getPredefinedTools(true);
 		ExternalMergeTool externalMergeTool = availableTools
 				.get(overridenToolName);
 		String actualMergeToolPath = externalMergeTool.getPath();
@@ -254,18 +324,110 @@ public class ExternalMergeToolTest extends ExternalToolTestCase {
 
 	@Test(expected = ToolException.class)
 	public void testUndefinedTool() throws Exception {
+		String toolName = "undefined";
+		invokeMerge(toolName);
+		fail("Expected exception to be thrown due to not defined external merge tool");
+	}
+
+	@Test
+	public void testDefaultToolExecutionWithPrompt() throws Exception {
+		FileBasedConfig config = db.getConfig();
+		// the default diff tool is configured without a subsection
+		String subsection = null;
+		config.setString("merge", subsection, "tool", "customTool");
+
+		String command = getEchoCommand();
+
+		config.setString("mergetool", "customTool", "cmd", command);
+
 		MergeTools manager = new MergeTools(db);
 
-		String toolName = "undefined";
+		PromptHandler promptHandler = PromptHandler.acceptPrompt();
+		MissingToolHandler noToolHandler = new MissingToolHandler();
+
+		manager.merge(local, remote, merged, base, null, Optional.empty(),
+				BooleanTriState.TRUE, false, promptHandler, noToolHandler);
+
+		assertEchoCommandHasCorrectOutput();
+	}
+
+	@Test
+	public void testNoDefaultToolName() {
+		MergeTools manager = new MergeTools(db);
+		boolean gui = false;
+		String defaultToolName = manager.getDefaultToolName(gui);
+		assertNull("Expected no default tool when none is configured",
+				defaultToolName);
+
+		gui = true;
+		defaultToolName = manager.getDefaultToolName(gui);
+		assertNull("Expected no default tool when none is configured",
+				defaultToolName);
+	}
+
+	@Test(expected = ToolException.class)
+	public void testNullTool() throws Exception {
+		MergeTools manager = new MergeTools(db);
+
+		PromptHandler promptHandler = null;
+		MissingToolHandler noToolHandler = null;
+
+		Optional<String> tool = null;
+
+		manager.merge(local, remote, merged, base, null, tool,
+				BooleanTriState.TRUE, false, promptHandler, noToolHandler);
+	}
+
+	@Test(expected = ToolException.class)
+	public void testNullToolWithPrompt() throws Exception {
+		MergeTools manager = new MergeTools(db);
+
+		PromptHandler promptHandler = PromptHandler.cancelPrompt();
+		MissingToolHandler noToolHandler = new MissingToolHandler();
+
+		Optional<String> tool = null;
+
+		manager.merge(local, remote, merged, base, null, tool,
+				BooleanTriState.TRUE, false, promptHandler, noToolHandler);
+	}
+
+	private Optional<ExecutionResult> invokeMerge(String toolName)
+			throws ToolException {
 		BooleanTriState prompt = BooleanTriState.UNSET;
-		BooleanTriState gui = BooleanTriState.UNSET;
+		boolean gui = false;
 
-		manager.merge(local, remote, merged, base, null, toolName, prompt, gui);
-		fail("Expected exception to be thrown due to not defined external merge tool");
+		MergeTools manager = new MergeTools(db);
+
+		PromptHandler promptHandler = PromptHandler.acceptPrompt();
+		MissingToolHandler noToolHandler = new MissingToolHandler();
+
+		Optional<ExecutionResult> result = manager.merge(local, remote, merged,
+				base, null, Optional.of(toolName), prompt, gui, promptHandler,
+				noToolHandler);
+		return result;
+	}
+
+	private void assumeMergeToolIsAvailable(
+			CommandLineMergeTool autoMergingTool) {
+		boolean isAvailable = ExternalToolUtils.isToolAvailable(db.getFS(),
+				db.getDirectory(), db.getWorkTree(), autoMergingTool.getPath());
+		assumeTrue("Assuming external tool is available: "
+				+ autoMergingTool.name(), isAvailable);
 	}
 
 	private String getEchoCommand() {
-		return "(echo \"$LOCAL\" \"$REMOTE\") > "
+		return "(echo $LOCAL $REMOTE $MERGED $BASE) > "
 				+ commandResult.getAbsolutePath();
 	}
+
+	private void assertEchoCommandHasCorrectOutput() throws IOException {
+		List<String> actualLines = Files.readAllLines(commandResult.toPath());
+		String actualContent = String.join(System.lineSeparator(), actualLines);
+		actualLines = Arrays.asList(actualContent.split(" "));
+		List<String> expectedLines = Arrays.asList(localFile.getAbsolutePath(),
+				remoteFile.getAbsolutePath(), mergedFile.getAbsolutePath(),
+				baseFile.getAbsolutePath());
+		assertEquals("Dummy test tool called with unexpected arguments",
+				expectedLines, actualLines);
+	}
 }
diff --git a/org.eclipse.jgit.test/tst/org/eclipse/jgit/internal/diffmergetool/ExternalToolTestCase.java b/org.eclipse.jgit.test/tst/org/eclipse/jgit/internal/diffmergetool/ExternalToolTestCase.java
index 0fd85cb456..7a6ff46578 100644
--- a/org.eclipse.jgit.test/tst/org/eclipse/jgit/internal/diffmergetool/ExternalToolTestCase.java
+++ b/org.eclipse.jgit.test/tst/org/eclipse/jgit/internal/diffmergetool/ExternalToolTestCase.java
@@ -11,6 +11,8 @@ package org.eclipse.jgit.internal.diffmergetool;
 
 import java.io.File;
 import java.nio.file.Files;
+import java.util.ArrayList;
+import java.util.List;
 
 import org.eclipse.jgit.junit.RepositoryTestCase;
 import org.eclipse.jgit.util.FS;
@@ -88,4 +90,39 @@ public abstract class ExternalToolTestCase extends RepositoryTestCase {
 				"This test can run only in Linux tests",
 				FS.DETECTED instanceof FS_POSIX);
 	}
+
+	protected static class PromptHandler implements PromptContinueHandler {
+
+		private final boolean promptResult;
+
+		final List<String> toolPrompts = new ArrayList<>();
+
+		private PromptHandler(boolean promptResult) {
+			this.promptResult = promptResult;
+		}
+
+		static PromptHandler acceptPrompt() {
+			return new PromptHandler(true);
+		}
+
+		static PromptHandler cancelPrompt() {
+			return new PromptHandler(false);
+		}
+
+		@Override
+		public boolean prompt(String toolName) {
+			toolPrompts.add(toolName);
+			return promptResult;
+		}
+	}
+
+	protected static class MissingToolHandler implements InformNoToolHandler {
+
+		final List<String> missingTools = new ArrayList<>();
+
+		@Override
+		public void inform(List<String> toolNames) {
+			missingTools.addAll(toolNames);
+		}
+	}
 }