Merge branch 'master' into next

* master: (193 commits)
  Add aarch64 environment to target platform configuration
  JGit blame very slow for large merge commits that rename files
  UploadPack: don't prematurely terminate timer in case of error
  Do not create reflog for remote tracking branches during clone
  UploadPack: do not check reachability of visible SHA1s
  Fix warnings about non-externalized string literals
  [sshd] Correct signature for RSA keys from an SSH agent
  Run tests that checks araxis output only on Linux
  Add missing package import javax.management to org.eclipse.jgit
  Add 4.25 target platform for Eclipse 2022-09
  Suppress API errors raised for new API introduced in 5.13.1
  Eclipse 4.24 was released, adapt p2 URL accordingly
  Fix DefaultCharset bug pattern flagged by error prone
  Use SystemReader#getDefaultCharset to read console input
  Annotate the exception with the possible failure reason when Bitmaps are not enabled.
  Prepare 5.13.2-SNAPSHOT builds
  JGit v5.13.1.202206130422-r
  AmazonS3: Add support for AWS API signature version 4
  Fix typo in DiffTools#compare javadoc
  Update jgit-last-release-version to 6.2.0.202206071550-r
  ...

Change-Id: I561a0178f6bc512e8ce7d75f1870a044cb051fac

4 files changed, 643 insertions, 1 deletions

diff --git a/org.eclipse.jgit.lfs.test/META-INF/MANIFEST.MF b/org.eclipse.jgit.lfs.test/META-INF/MANIFEST.MF
index 06f2a891df..0b93af2808 100644
--- a/org.eclipse.jgit.lfs.test/META-INF/MANIFEST.MF
+++ b/org.eclipse.jgit.lfs.test/META-INF/MANIFEST.MF
@@ -13,9 +13,12 @@ Import-Package: org.eclipse.jgit.api;version="[7.0.0,7.1.0)",
  org.eclipse.jgit.junit;version="[7.0.0,7.1.0)",
  org.eclipse.jgit.lfs;version="[7.0.0,7.1.0)",
  org.eclipse.jgit.lfs.errors;version="[7.0.0,7.1.0)",
+ org.eclipse.jgit.lfs.internal;version="[7.0.0,7.1.0)",
  org.eclipse.jgit.lfs.lib;version="[7.0.0,7.1.0)",
  org.eclipse.jgit.lib;version="[7.0.0,7.1.0)",
  org.eclipse.jgit.revwalk;version="[7.0.0,7.1.0)",
+ org.eclipse.jgit.transport;version="[7.0.0,7.1.0)",
+ org.eclipse.jgit.transport.http;version="[7.0.0,7.1.0)",
  org.eclipse.jgit.treewalk;version="[7.0.0,7.1.0)",
  org.eclipse.jgit.treewalk.filter;version="[7.0.0,7.1.0)",
  org.eclipse.jgit.util;version="[7.0.0,7.1.0)",
diff --git a/org.eclipse.jgit.lfs.test/tst/org/eclipse/jgit/lfs/LfsConfigGitTest.java b/org.eclipse.jgit.lfs.test/tst/org/eclipse/jgit/lfs/LfsConfigGitTest.java
new file mode 100644
index 0000000000..3ac41571a4
--- /dev/null
+++ b/org.eclipse.jgit.lfs.test/tst/org/eclipse/jgit/lfs/LfsConfigGitTest.java
@@ -0,0 +1,301 @@
+/*
+ * Copyright (C) 2022, Matthias Fromme <mfromme@dspace.de>
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Distribution License v. 1.0 which is available at
+ * https://www.eclipse.org/org/documents/edl-v10.php.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+package org.eclipse.jgit.lfs;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.util.ArrayList;
+import java.util.List;
+
+import org.eclipse.jgit.api.Git;
+import org.eclipse.jgit.api.ResetCommand.ResetType;
+import org.eclipse.jgit.attributes.FilterCommand;
+import org.eclipse.jgit.attributes.FilterCommandRegistry;
+import org.eclipse.jgit.junit.RepositoryTestCase;
+import org.eclipse.jgit.lfs.internal.LfsConnectionFactory;
+import org.eclipse.jgit.lfs.lib.Constants;
+import org.eclipse.jgit.lib.ConfigConstants;
+import org.eclipse.jgit.lib.Repository;
+import org.eclipse.jgit.lib.StoredConfig;
+import org.eclipse.jgit.transport.http.HttpConnection;
+import org.eclipse.jgit.util.HttpSupport;
+import org.junit.AfterClass;
+import org.junit.Before;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+/**
+ * Test if the lfs config is used in the correct way during checkout.
+ *
+ * Two lfs-files are created, one that comes before .gitattributes and
+ * .lfsconfig in git order (".aaa.txt") and one that comes after ("zzz.txt").
+ *
+ * During checkout/reset it is tested if the correct version of the lfs config
+ * is used.
+ *
+ * TODO: The current behavior seems a little bit strange/unintuitive. Some files
+ * are checked out before and some after the config files. This leads to the
+ * behavior, that during a single command the config changes. Since this seems
+ * to be the same way in native git, the behavior is accepted for now.
+ *
+ */
+public class LfsConfigGitTest extends RepositoryTestCase {
+
+	private static final String SMUDGE_NAME = org.eclipse.jgit.lib.Constants.BUILTIN_FILTER_PREFIX
+			+ Constants.ATTR_FILTER_DRIVER_PREFIX
+			+ org.eclipse.jgit.lib.Constants.ATTR_FILTER_TYPE_SMUDGE;
+
+	private static final String LFS_SERVER_URI1 = "https://lfs.server1/test/uri";
+
+	private static final String EXPECTED_SERVER_URL1 = LFS_SERVER_URI1
+			+ Protocol.OBJECTS_LFS_ENDPOINT;
+
+	private static final String LFS_SERVER_URI2 = "https://lfs.server2/test/uri";
+
+	private static final String EXPECTED_SERVER_URL2 = LFS_SERVER_URI2
+			+ Protocol.OBJECTS_LFS_ENDPOINT;
+
+	private static final String LFS_SERVER_URI3 = "https://lfs.server3/test/uri";
+
+	private static final String EXPECTED_SERVER_URL3 = LFS_SERVER_URI3
+			+ Protocol.OBJECTS_LFS_ENDPOINT;
+
+	private static final String FAKE_LFS_POINTER1 = "version https://git-lfs.github.com/spec/v1\n"
+			+ "oid sha256:6ce9fab52ee9a6c4c097def4e049c6acdeba44c99d26e83ba80adec1473c9b2d\n"
+			+ "size 253952\n";
+
+	private static final String FAKE_LFS_POINTER2 = "version https://git-lfs.github.com/spec/v1\n"
+			+ "oid sha256:a4b711cd989863ae2038758a62672138347abbbae4076a7ad3a545fda7d08f82\n"
+			+ "size 67072\n";
+
+	private static List<String> checkoutURLs = new ArrayList<>();
+
+	static class SmudgeFilterMock extends FilterCommand {
+		public SmudgeFilterMock(Repository db, InputStream in,
+				OutputStream out) throws IOException {
+			super(in, out);
+			HttpConnection lfsServerConn = LfsConnectionFactory.getLfsConnection(db,
+					HttpSupport.METHOD_POST, Protocol.OPERATION_DOWNLOAD);
+			checkoutURLs.add(lfsServerConn.getURL().toString());
+		}
+
+		@Override
+		public int run() throws IOException {
+			// Stupid no impl
+			in.transferTo(out);
+			return -1;
+		}
+	}
+
+	@BeforeClass
+	public static void installLfs() {
+		FilterCommandRegistry.register(SMUDGE_NAME, SmudgeFilterMock::new);
+	}
+
+	@AfterClass
+	public static void removeLfs() {
+		FilterCommandRegistry.unregister(SMUDGE_NAME);
+	}
+
+	private Git git;
+
+	@Override
+	@Before
+	public void setUp() throws Exception {
+		super.setUp();
+		git = new Git(db);
+		// commit something
+		writeTrashFile("Test.txt", "Hello world");
+		git.add().addFilepattern("Test.txt").call();
+		git.commit().setMessage("Initial commit").call();
+		// prepare the config for LFS
+		StoredConfig config = git.getRepository().getConfig();
+		config.setString("filter", "lfs", "smudge", SMUDGE_NAME);
+		config.setString(ConfigConstants.CONFIG_CORE_SECTION, null,
+				ConfigConstants.CONFIG_KEY_AUTOCRLF, "false");
+		config.save();
+
+		fileBefore = null;
+		fileAfter = null;
+		configFile = null;
+		gitAttributesFile = null;
+	}
+
+	File fileBefore;
+
+	File fileAfter;
+
+	File configFile;
+
+	File gitAttributesFile;
+
+	private void createLfsFiles(String lfsPointer) throws Exception {
+		//File to be checked out before lfs config
+		String fileNameBefore = ".aaa.txt";
+		fileBefore = writeTrashFile(fileNameBefore, lfsPointer);
+		git.add().addFilepattern(fileNameBefore).call();
+
+		// File to be checked out after lfs config
+		String fileNameAfter = "zzz.txt";
+		fileAfter = writeTrashFile(fileNameAfter, lfsPointer);
+		git.add().addFilepattern(fileNameAfter).call();
+
+		git.commit().setMessage("Commit LFS Pointer files").call();
+	}
+
+
+	private String addLfsConfigFiles(String lfsServerUrl) throws Exception {
+		// Add config files to the repo
+		String lfsConfig1 = createLfsConfig(lfsServerUrl);
+		git.add().addFilepattern(Constants.DOT_LFS_CONFIG).call();
+		// Modify gitattributes on second call, to force checkout too.
+		if (gitAttributesFile == null) {
+			gitAttributesFile = writeTrashFile(".gitattributes",
+				"*.txt filter=lfs");
+		} else {
+			gitAttributesFile = writeTrashFile(".gitattributes",
+					"*.txt filter=lfs\n");
+		}
+
+		git.add().addFilepattern(".gitattributes").call();
+		git.commit().setMessage("Commit config files").call();
+		return lfsConfig1;
+	}
+
+	private String createLfsConfig(String lfsServerUrl) throws IOException {
+		String lfsConfig1 = "[lfs]\n    url = " + lfsServerUrl;
+		configFile = writeTrashFile(Constants.DOT_LFS_CONFIG, lfsConfig1);
+		return lfsConfig1;
+	}
+
+	@Test
+	public void checkoutLfsObjects_reset() throws Exception {
+		createLfsFiles(FAKE_LFS_POINTER1);
+		String lfsConfig1 = addLfsConfigFiles(LFS_SERVER_URI1);
+
+		// Delete files to force action on reset
+		assertTrue(configFile.delete());
+		assertTrue(fileBefore.delete());
+		assertTrue(fileAfter.delete());
+
+		assertTrue(gitAttributesFile.delete());
+
+		// create config file with different url
+		createLfsConfig(LFS_SERVER_URI3);
+
+		checkoutURLs.clear();
+		git.reset().setMode(ResetType.HARD).call();
+
+		checkFile(configFile, lfsConfig1);
+		checkFile(fileBefore, FAKE_LFS_POINTER1);
+		checkFile(fileAfter, FAKE_LFS_POINTER1);
+
+		assertEquals(2, checkoutURLs.size());
+		// TODO: Should may be EXPECTED_SERVR_URL1
+		assertEquals(EXPECTED_SERVER_URL3, checkoutURLs.get(0));
+		assertEquals(EXPECTED_SERVER_URL1, checkoutURLs.get(1));
+	}
+
+	@Test
+	public void checkoutLfsObjects_BranchSwitch() throws Exception {
+		// Create a new branch "URL1" and add config files
+		git.checkout().setCreateBranch(true).setName("URL1").call();
+
+		createLfsFiles(FAKE_LFS_POINTER1);
+		String lfsConfig1 = addLfsConfigFiles(LFS_SERVER_URI1);
+
+		// Create a second new branch "URL2" and add config files
+		git.checkout().setCreateBranch(true).setName("URL2").call();
+
+		createLfsFiles(FAKE_LFS_POINTER2);
+		String lfsConfig2 = addLfsConfigFiles(LFS_SERVER_URI2);
+
+		checkFile(configFile, lfsConfig2);
+		checkFile(fileBefore, FAKE_LFS_POINTER2);
+		checkFile(fileAfter, FAKE_LFS_POINTER2);
+
+		checkoutURLs.clear();
+		git.checkout().setName("URL1").call();
+
+		checkFile(configFile, lfsConfig1);
+		checkFile(fileBefore, FAKE_LFS_POINTER1);
+		checkFile(fileAfter, FAKE_LFS_POINTER1);
+
+		assertEquals(2, checkoutURLs.size());
+		// TODO: Should may be EXPECTED_SERVR_URL1
+		assertEquals(EXPECTED_SERVER_URL2, checkoutURLs.get(0));
+		assertEquals(EXPECTED_SERVER_URL1, checkoutURLs.get(1));
+
+		checkoutURLs.clear();
+		git.checkout().setName("URL2").call();
+
+		checkFile(configFile, lfsConfig2);
+		checkFile(fileBefore, FAKE_LFS_POINTER2);
+		checkFile(fileAfter, FAKE_LFS_POINTER2);
+
+		assertEquals(2, checkoutURLs.size());
+		// TODO: Should may be EXPECTED_SERVR_URL2
+		assertEquals(EXPECTED_SERVER_URL1, checkoutURLs.get(0));
+		assertEquals(EXPECTED_SERVER_URL2, checkoutURLs.get(1));
+	}
+
+	@Test
+	public void checkoutLfsObjects_BranchSwitch_ModifiedLocal()
+			throws Exception {
+
+		// Create a new branch "URL1" and add config files
+		git.checkout().setCreateBranch(true).setName("URL1").call();
+
+		createLfsFiles(FAKE_LFS_POINTER1);
+		addLfsConfigFiles(LFS_SERVER_URI1);
+
+		// Create a second new branch "URL2" and add config files
+		git.checkout().setCreateBranch(true).setName("URL2").call();
+
+		createLfsFiles(FAKE_LFS_POINTER2);
+		addLfsConfigFiles(LFS_SERVER_URI1);
+
+		// create config file with different url
+		assertTrue(configFile.delete());
+		String lfsConfig3 = createLfsConfig(LFS_SERVER_URI3);
+
+		checkFile(configFile, lfsConfig3);
+		checkFile(fileBefore, FAKE_LFS_POINTER2);
+		checkFile(fileAfter, FAKE_LFS_POINTER2);
+
+		checkoutURLs.clear();
+		git.checkout().setName("URL1").call();
+
+		checkFile(fileBefore, FAKE_LFS_POINTER1);
+		checkFile(fileAfter, FAKE_LFS_POINTER1);
+		checkFile(configFile, lfsConfig3);
+
+		assertEquals(2, checkoutURLs.size());
+
+		assertEquals(EXPECTED_SERVER_URL3, checkoutURLs.get(0));
+		assertEquals(EXPECTED_SERVER_URL3, checkoutURLs.get(1));
+
+		checkoutURLs.clear();
+		git.checkout().setName("URL2").call();
+
+		checkFile(fileBefore, FAKE_LFS_POINTER2);
+		checkFile(fileAfter, FAKE_LFS_POINTER2);
+		checkFile(configFile, lfsConfig3);
+
+		assertEquals(2, checkoutURLs.size());
+		assertEquals(EXPECTED_SERVER_URL3, checkoutURLs.get(0));
+		assertEquals(EXPECTED_SERVER_URL3, checkoutURLs.get(1));
+	}
+}
diff --git a/org.eclipse.jgit.lfs.test/tst/org/eclipse/jgit/lfs/LfsGitTest.java b/org.eclipse.jgit.lfs.test/tst/org/eclipse/jgit/lfs/LfsGitTest.java
index 8964310e41..3e83c8ef49 100644
--- a/org.eclipse.jgit.lfs.test/tst/org/eclipse/jgit/lfs/LfsGitTest.java
+++ b/org.eclipse.jgit.lfs.test/tst/org/eclipse/jgit/lfs/LfsGitTest.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2021, Thomas Wolf <thomas.wolf@paranor.ch> and others
+ * Copyright (C) 2021, 2022 Thomas Wolf <thomas.wolf@paranor.ch> and others
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Distribution License v. 1.0 which is available at
@@ -68,6 +68,27 @@ public class LfsGitTest extends RepositoryTestCase {
 	}
 
 	@Test
+	public void testBranchSwitch() throws Exception {
+		git.branchCreate().setName("abranch").call();
+		git.checkout().setName("abranch").call();
+		File aFile = writeTrashFile("a.bin", "aaa");
+		writeTrashFile(".gitattributes", "a.bin filter=lfs");
+		git.add().addFilepattern(".").call();
+		git.commit().setMessage("acommit").call();
+		git.checkout().setName("master").call();
+		git.branchCreate().setName("bbranch").call();
+		git.checkout().setName("bbranch").call();
+		File bFile = writeTrashFile("b.bin", "bbb");
+		writeTrashFile(".gitattributes", "b.bin filter=lfs");
+		git.add().addFilepattern(".").call();
+		git.commit().setMessage("bcommit").call();
+		git.checkout().setName("abranch").call();
+		checkFile(aFile, "aaa");
+		git.checkout().setName("bbranch").call();
+		checkFile(bFile, "bbb");
+	}
+
+	@Test
 	public void checkoutNonLfsPointer() throws Exception {
 		String content = "size_t\nsome_function(void* ptr);\n";
 		File smallFile = writeTrashFile("Test.txt", content);
diff --git a/org.eclipse.jgit.lfs.test/tst/org/eclipse/jgit/lfs/internal/LfsConnectionFactoryTest.java b/org.eclipse.jgit.lfs.test/tst/org/eclipse/jgit/lfs/internal/LfsConnectionFactoryTest.java
new file mode 100644
index 0000000000..badcb7d7e5
--- /dev/null
+++ b/org.eclipse.jgit.lfs.test/tst/org/eclipse/jgit/lfs/internal/LfsConnectionFactoryTest.java
@@ -0,0 +1,317 @@
+/*
+ * Copyright (C) 2022 Nail Samatov <sanail@yandex.ru> and others
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Distribution License v. 1.0 which is available at
+ * https://www.eclipse.org/org/documents/edl-v10.php.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+package org.eclipse.jgit.lfs.internal;
+
+import static org.eclipse.jgit.lib.Constants.DEFAULT_REMOTE_NAME;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertThrows;
+import static org.junit.Assert.assertTrue;
+
+import java.io.File;
+import java.io.IOException;
+import java.io.PrintWriter;
+import java.io.StringWriter;
+
+import org.eclipse.jgit.api.Git;
+import org.eclipse.jgit.api.RemoteAddCommand;
+import org.eclipse.jgit.attributes.FilterCommandRegistry;
+import org.eclipse.jgit.junit.RepositoryTestCase;
+import org.eclipse.jgit.lfs.CleanFilter;
+import org.eclipse.jgit.lfs.Protocol;
+import org.eclipse.jgit.lfs.SmudgeFilter;
+import org.eclipse.jgit.lfs.errors.LfsConfigInvalidException;
+import org.eclipse.jgit.lfs.lib.Constants;
+import org.eclipse.jgit.lib.ConfigConstants;
+import org.eclipse.jgit.lib.Repository;
+import org.eclipse.jgit.lib.StoredConfig;
+import org.eclipse.jgit.transport.URIish;
+import org.eclipse.jgit.transport.http.HttpConnection;
+import org.eclipse.jgit.util.HttpSupport;
+import org.junit.AfterClass;
+import org.junit.Before;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+public class LfsConnectionFactoryTest extends RepositoryTestCase {
+
+	private static final String SMUDGE_NAME = org.eclipse.jgit.lib.Constants.BUILTIN_FILTER_PREFIX
+			+ Constants.ATTR_FILTER_DRIVER_PREFIX
+			+ org.eclipse.jgit.lib.Constants.ATTR_FILTER_TYPE_SMUDGE;
+
+	private static final String CLEAN_NAME = org.eclipse.jgit.lib.Constants.BUILTIN_FILTER_PREFIX
+			+ Constants.ATTR_FILTER_DRIVER_PREFIX
+			+ org.eclipse.jgit.lib.Constants.ATTR_FILTER_TYPE_CLEAN;
+
+	private final static String LFS_SERVER_URL1 = "https://lfs.server1/test/uri";
+
+	private final static String LFS_SERVER_URL2 = "https://lfs.server2/test/uri";
+
+	private final static String ORIGIN_URL = "https://git.server/test/uri";
+
+	private Git git;
+
+	@BeforeClass
+	public static void installLfs() {
+		FilterCommandRegistry.register(SMUDGE_NAME, SmudgeFilter.FACTORY);
+		FilterCommandRegistry.register(CLEAN_NAME, CleanFilter.FACTORY);
+	}
+
+	@AfterClass
+	public static void removeLfs() {
+		FilterCommandRegistry.unregister(SMUDGE_NAME);
+		FilterCommandRegistry.unregister(CLEAN_NAME);
+	}
+
+	@Override
+	@Before
+	public void setUp() throws Exception {
+		super.setUp();
+		git = new Git(db);
+
+		// Just to have a non empty repo
+		writeTrashFile("Test.txt", "Hello world from the LFS Factory Test");
+		git.add().addFilepattern("Test.txt").call();
+		git.commit().setMessage("Initial commit").call();
+	}
+
+	@Test
+	public void lfsUrlFromRemoteUrlWithDotGit() throws Exception {
+		addRemoteUrl("https://localhost/repo.git");
+		checkLfsUrl("https://localhost/repo.git/info/lfs");
+	}
+
+	@Test
+	public void lfsUrlFromRemoteUrlWithoutDotGit() throws Exception {
+		addRemoteUrl("https://localhost/repo");
+		checkLfsUrl("https://localhost/repo.git/info/lfs");
+	}
+
+	@Test
+	public void lfsUrlFromLocalConfig() throws Exception {
+		addRemoteUrl("https://localhost/repo");
+
+		StoredConfig cfg = ((Repository) db).getConfig();
+		cfg.setString(ConfigConstants.CONFIG_SECTION_LFS,
+				null,
+				ConfigConstants.CONFIG_KEY_URL,
+				"https://localhost/repo/lfs");
+		cfg.save();
+
+		checkLfsUrl("https://localhost/repo/lfs");
+	}
+
+	@Test
+	public void lfsUrlFromOriginConfig() throws Exception {
+		addRemoteUrl("https://localhost/repo");
+
+		StoredConfig cfg = ((Repository) db).getConfig();
+		cfg.setString(ConfigConstants.CONFIG_SECTION_LFS,
+				org.eclipse.jgit.lib.Constants.DEFAULT_REMOTE_NAME,
+				ConfigConstants.CONFIG_KEY_URL,
+				"https://localhost/repo/lfs");
+		cfg.save();
+
+		checkLfsUrl("https://localhost/repo/lfs");
+	}
+
+	@Test
+	public void lfsUrlNotConfigured() throws Exception {
+		assertThrows(LfsConfigInvalidException.class,
+				() -> LfsConnectionFactory.getLfsConnection(db,
+				HttpSupport.METHOD_POST, Protocol.OPERATION_DOWNLOAD));
+	}
+
+	@Test
+	public void checkGetLfsConnection_lfsurl_lfsconfigFromWorkingDir()
+			throws Exception {
+		writeLfsConfig();
+		checkLfsUrl(LFS_SERVER_URL1);
+	}
+
+	@Test
+	public void checkGetLfsConnection_lfsurl_lfsconfigFromIndex()
+			throws Exception {
+		writeLfsConfig();
+		git.add().addFilepattern(Constants.DOT_LFS_CONFIG).call();
+		deleteTrashFile(Constants.DOT_LFS_CONFIG);
+		checkLfsUrl(LFS_SERVER_URL1);
+	}
+
+	@Test
+	public void checkGetLfsConnection_lfsurl_lfsconfigFromHEAD()
+			throws Exception {
+		writeLfsConfig();
+		git.add().addFilepattern(Constants.DOT_LFS_CONFIG).call();
+		git.commit().setMessage("Commit LFS Config").call();
+
+		/*
+		 * reading .lfsconfig from HEAD seems only testable using a bare repo,
+		 * since otherwise working tree or index are used
+		 */
+		File directory = createTempDirectory("testBareRepo");
+		try (Repository bareRepoDb = Git.cloneRepository()
+				.setDirectory(directory)
+				.setURI(db.getDirectory().toURI().toString()).setBare(true)
+				.call().getRepository()) {
+
+			checkLfsUrl(LFS_SERVER_URL1);
+		}
+	}
+
+	@Test
+	public void checkGetLfsConnection_remote_lfsconfigFromWorkingDir()
+			throws Exception {
+		addRemoteUrl(ORIGIN_URL);
+		writeLfsConfig(LFS_SERVER_URL1, "lfs", DEFAULT_REMOTE_NAME, "url");
+		checkLfsUrl(LFS_SERVER_URL1);
+	}
+
+	/**
+	 * Test the config file precedence.
+	 *
+	 * Checking only with the local repository config is sufficient since from
+	 * that point the "normal" precedence is used.
+	 *
+	 * @throws Exception
+	 */
+	@Test
+	public void checkGetLfsConnection_ConfigFilePrecedence_lfsconfigFromWorkingDir()
+			throws Exception {
+		writeLfsConfig();
+		checkLfsUrl(LFS_SERVER_URL1);
+
+		StoredConfig config = git.getRepository().getConfig();
+		config.setString(ConfigConstants.CONFIG_SECTION_LFS, null,
+				ConfigConstants.CONFIG_KEY_URL, LFS_SERVER_URL2);
+		config.save();
+
+		checkLfsUrl(LFS_SERVER_URL2);
+	}
+
+	@Test
+	public void checkGetLfsConnection_InvalidLfsConfig_WorkingDir()
+			throws Exception {
+		writeInvalidLfsConfig();
+		LfsConfigInvalidException actualException = assertThrows(
+				LfsConfigInvalidException.class, () -> {
+			LfsConnectionFactory.getLfsConnection(db, HttpSupport.METHOD_POST,
+					Protocol.OPERATION_DOWNLOAD);
+		});
+		assertTrue(getStackTrace(actualException)
+				.contains("Invalid line in config file"));
+	}
+
+	@Test
+	public void checkGetLfsConnection_InvalidLfsConfig_Index()
+			throws Exception {
+		writeInvalidLfsConfig();
+		git.add().addFilepattern(Constants.DOT_LFS_CONFIG).call();
+		deleteTrashFile(Constants.DOT_LFS_CONFIG);
+		LfsConfigInvalidException actualException = assertThrows(
+				LfsConfigInvalidException.class, () -> {
+			LfsConnectionFactory.getLfsConnection(db, HttpSupport.METHOD_POST,
+					Protocol.OPERATION_DOWNLOAD);
+		});
+		assertTrue(getStackTrace(actualException)
+				.contains("Invalid line in config file"));
+	}
+
+	@Test
+	public void checkGetLfsConnection_InvalidLfsConfig_HEAD() throws Exception {
+		writeInvalidLfsConfig();
+		git.add().addFilepattern(Constants.DOT_LFS_CONFIG).call();
+		git.commit().setMessage("Commit LFS Config").call();
+
+		/*
+		 * reading .lfsconfig from HEAD seems only testable using a bare repo,
+		 * since otherwise working tree or index are used
+		 */
+		File directory = createTempDirectory("testBareRepo");
+		try (Repository bareRepoDb = Git.cloneRepository()
+				.setDirectory(directory)
+				.setURI(db.getDirectory().toURI().toString()).setBare(true)
+				.call().getRepository()) {
+			LfsConfigInvalidException actualException = assertThrows(
+					LfsConfigInvalidException.class,
+					() -> {
+						LfsConnectionFactory.getLfsConnection(db,
+								HttpSupport.METHOD_POST,
+								Protocol.OPERATION_DOWNLOAD);
+					});
+			assertTrue(getStackTrace(actualException)
+					.contains("Invalid line in config file"));
+		}
+	}
+
+	private void addRemoteUrl(String remotUrl) throws Exception {
+		RemoteAddCommand add = git.remoteAdd();
+		add.setUri(new URIish(remotUrl));
+		add.setName(org.eclipse.jgit.lib.Constants.DEFAULT_REMOTE_NAME);
+		add.call();
+	}
+
+	/**
+	 * Returns the stack trace of the provided exception as string
+	 *
+	 * @param actualException
+	 * @return The exception stack trace as string
+	 */
+	private String getStackTrace(Exception actualException) {
+		StringWriter sw = new StringWriter();
+		PrintWriter pw = new PrintWriter(sw);
+		actualException.printStackTrace(pw);
+		return sw.toString();
+	}
+
+	private void writeLfsConfig() throws IOException {
+		writeLfsConfig(LFS_SERVER_URL1, "lfs", "url");
+	}
+
+	private void writeLfsConfig(String lfsUrl, String section, String name)
+			throws IOException {
+		writeLfsConfig(lfsUrl, section, null, name);
+	}
+
+	/*
+	 * Write simple lfs config with single entry. Do not use FileBasedConfig to
+	 * avoid introducing new dependency (for now).
+	 */
+	private void writeLfsConfig(String lfsUrl, String section,
+			String subsection, String name) throws IOException {
+		StringBuilder config = new StringBuilder();
+		config.append("[");
+		config.append(section);
+		if (subsection != null) {
+			config.append(" \"");
+			config.append(subsection);
+			config.append("\"");
+		}
+		config.append("]\n");
+		config.append("    ");
+		config.append(name);
+		config.append(" = ");
+		config.append(lfsUrl);
+		writeTrashFile(Constants.DOT_LFS_CONFIG, config.toString());
+	}
+
+	private void writeInvalidLfsConfig() throws IOException {
+		writeTrashFile(Constants.DOT_LFS_CONFIG,
+				"{lfs]\n    url = " + LFS_SERVER_URL1);
+	}
+
+	private void checkLfsUrl(String lfsUrl) throws IOException {
+		HttpConnection lfsServerConn;
+		lfsServerConn = LfsConnectionFactory.getLfsConnection(db,
+				HttpSupport.METHOD_POST, Protocol.OPERATION_DOWNLOAD);
+
+		assertEquals(lfsUrl + Protocol.OBJECTS_LFS_ENDPOINT,
+				lfsServerConn.getURL().toString());
+	}
+}