Replace ExpectedException which was deprecated in junit 4.13

Change-Id: I64b0c057dd0a12aef2f3d56fa0c8a10e3b23fffd
Signed-off-by: Matthias Sohn <matthias.sohn@sap.com>

WORKSPACE

     sha1 = "497ddb32fd5d01f9dbe99a2ec790aeb931dff1b1",
 )
 
+maven_jar(
+    name = "assertj-core",
+    artifact = "org.assertj:assertj-core:3.14.0",
+    sha1 = "3b7b0fcac821f3d167764e9926573cd64f78f9e9",
+)
+
 BYTE_BUDDY_VERSION = "1.9.0"
 
 maven_jar(

lib/BUILD

     ],
 )
 
+java_library(
+    name = "assertj-core",
+    testonly = 1,
+    visibility = ["//visibility:public"],
+    exports = [
+        "@assertj-core//jar",
+    ],
+)
+
 java_library(
     name = "servlet-api",
     visibility = [

org.eclipse.jgit.http.test/tst/org/eclipse/jgit/http/test/SmartClientSmartServerTest.java

 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertNotNull;
 import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertThrows;
 import static org.junit.Assert.assertTrue;
 import static org.junit.Assert.fail;
 
 import org.eclipse.jgit.transport.http.HttpConnectionFactory;
 import org.eclipse.jgit.util.HttpSupport;
 import org.eclipse.jgit.util.SystemReader;
-import org.hamcrest.Matchers;
 import org.junit.Before;
-import org.junit.Rule;
 import org.junit.Test;
-import org.junit.rules.ExpectedException;
 
 public class SmartClientSmartServerTest extends AllFactoriesHttpTestCase {
 	private static final String HDR_TRANSFER_ENCODING = "Transfer-Encoding";
 
-	@Rule
-	public ExpectedException thrown = ExpectedException.none();
-
 	private AdvertiseRefsHook advertiseRefsHook;
 
 	private Repository remoteRepository;
 		try (Repository dst = createBareRepository();
 				Transport t = Transport.open(dst, remoteURI)) {
 			assertFalse(dst.getObjectDatabase().has(A_txt));
-			thrown.expect(TransportException.class);
-			thrown.expectMessage(Matchers.containsString(
+			Exception e = assertThrows(TransportException.class,
+					() -> t.fetch(NullProgressMonitor.INSTANCE,
+							Collections.singletonList(
+									new RefSpec(unreachableCommit.name()))));
+			assertTrue(e.getMessage().contains(
 					"want " + unreachableCommit.name() + " not valid"));
-			t.fetch(NullProgressMonitor.INSTANCE, Collections
-					.singletonList(new RefSpec(unreachableCommit.name())));
 		}
 	}
 
 		try (Repository dst = createBareRepository();
 				Transport t = Transport.open(dst, remoteURI)) {
 			assertFalse(dst.getObjectDatabase().has(A_txt));
-			thrown.expect(TransportException.class);
-			thrown.expectMessage(Matchers.containsString(
-					"want " + A.name() + " not valid"));
-			t.fetch(NullProgressMonitor.INSTANCE, Collections
-					.singletonList(new RefSpec(A.name())));
+			Exception e = assertThrows(TransportException.class,
+					() -> t.fetch(NullProgressMonitor.INSTANCE,
+							Collections.singletonList(new RefSpec(A.name()))));
+			assertTrue(
+					e.getMessage().contains("want " + A.name() + " not valid"));
 		}
 	}
 

org.eclipse.jgit.lfs.server.test/tst/org/eclipse/jgit/lfs/server/fs/DownloadTest.java

 import static org.apache.http.HttpStatus.SC_NOT_FOUND;
 import static org.apache.http.HttpStatus.SC_UNPROCESSABLE_ENTITY;
 import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertThrows;
 
 import java.io.IOException;
 import java.nio.file.Path;
 import org.eclipse.jgit.lfs.lib.AnyLongObjectId;
 import org.eclipse.jgit.lfs.test.LongObjectIdTestUtils;
 import org.eclipse.jgit.util.FileUtils;
-import org.junit.Rule;
 import org.junit.Test;
-import org.junit.rules.ExpectedException;
 
 public class DownloadTest extends LfsServerTest {
 
-	@Rule
-	public ExpectedException exception = ExpectedException.none();
-
 	@Test
 	public void testDownload() throws Exception {
 		String TEXT = "test";
 		Path f = Paths.get(getTempDirectory().toString(), "download");
 		String error = String.format(
 				"Invalid pathInfo: '/%s' does not match '/{SHA-256}'", id);
-		exception.expect(RuntimeException.class);
-		exception.expectMessage(
-				formatErrorMessage(SC_UNPROCESSABLE_ENTITY, error));
-		getContent(id, f);
+		assertThrows(formatErrorMessage(SC_UNPROCESSABLE_ENTITY, error),
+				RuntimeException.class, () -> getContent(id, f));
 	}
 
 	@Test
 		String id = putContent(TEXT).name().replace('f', 'z');
 		Path f = Paths.get(getTempDirectory().toString(), "download");
 		String error = String.format("Invalid id: %s", id);
-		exception.expect(RuntimeException.class);
-		exception.expectMessage(
-				formatErrorMessage(SC_UNPROCESSABLE_ENTITY, error));
-		getContent(id, f);
+		assertThrows(formatErrorMessage(SC_UNPROCESSABLE_ENTITY, error),
+				RuntimeException.class, () -> getContent(id, f));
 	}
 
 	@Test
-	public void testDownloadNotFound()
-			throws ClientProtocolException, IOException {
+	public void testDownloadNotFound() {
 		String TEXT = "test";
 		AnyLongObjectId id = LongObjectIdTestUtils.hash(TEXT);
 		Path f = Paths.get(getTempDirectory().toString(), "download");
 		String error = String.format("Object '%s' not found", id.getName());
-		exception.expect(RuntimeException.class);
-		exception.expectMessage(formatErrorMessage(SC_NOT_FOUND, error));
-		getContent(id, f);
+		assertThrows(formatErrorMessage(SC_NOT_FOUND, error),
+				RuntimeException.class, () -> getContent(id, f));
 	}
 
 	@SuppressWarnings("boxing")

org.eclipse.jgit.pgm.test/tst/org/eclipse/jgit/pgm/BlameTest.java

  */
 package org.eclipse.jgit.pgm;
 
+import static org.junit.Assert.assertThrows;
 import static org.junit.Assert.assertTrue;
 
 import org.eclipse.jgit.api.Git;
 import org.eclipse.jgit.lib.Constants;
 import org.eclipse.jgit.lib.PersonIdent;
 import org.eclipse.jgit.revwalk.RevCommit;
-import org.junit.Rule;
 import org.junit.Test;
-import org.junit.rules.ExpectedException;
 
 public class BlameTest extends CLIRepositoryTestCase {
 
-	@Rule
-	public ExpectedException thrown = ExpectedException.none();
-
 	@Test
 	public void testBlameNoHead() throws Exception {
 		try (Git git = new Git(db)) {
 			writeTrashFile("inIndex.txt", "index");
 			git.add().addFilepattern("inIndex.txt").call();
 		}
-		thrown.expect(Die.class);
-		thrown.expectMessage("no such ref: HEAD");
-		execute("git blame inIndex.txt");
+		assertThrows("no such ref: HEAD", Die.class,
+				() -> execute("git blame inIndex.txt"));
 	}
 
 	@Test
 			git.commit().setMessage("initial commit").call();
 		}
 		writeTrashFile("onlyInWorkingTree.txt", "not in repo");
-		thrown.expect(Die.class);
-		thrown.expectMessage("no such path 'onlyInWorkingTree.txt' in HEAD");
-		execute("git blame onlyInWorkingTree.txt");
+		assertThrows("no such path 'onlyInWorkingTree.txt' in HEAD", Die.class,
+				() -> execute("git blame onlyInWorkingTree.txt"));
 	}
 
 	@Test
 		try (Git git = new Git(db)) {
 			git.commit().setMessage("initial commit").call();
 		}
-		thrown.expect(Die.class);
-		thrown.expectMessage("no such path 'does_not_exist.txt' in HEAD");
-		execute("git blame does_not_exist.txt");
+		assertThrows("no such path 'does_not_exist.txt' in HEAD", Die.class,
+				() -> execute("git blame does_not_exist.txt"));
 	}
 
 	@Test
 		try (Git git = new Git(db)) {
 			git.commit().setMessage("initial commit").call();
 		}
-		thrown.expect(Die.class);
-		thrown.expectMessage("no such path 'sub/does_not_exist.txt' in HEAD");
-		execute("git blame sub/does_not_exist.txt");
+		assertThrows("no such path 'sub/does_not_exist.txt' in HEAD", Die.class,
+				() -> execute("git blame sub/does_not_exist.txt"));
 	}
 
 	@Test

org.eclipse.jgit.test/BUILD

     srcs = HELPERS,
     resources = DATA,
     deps = [
+        "//lib:assertj-core",
         "//lib:jsch",
         "//lib:junit",
         "//lib:mockito",

org.eclipse.jgit.test/META-INF/MANIFEST.MF

  org.apache.commons.compress.compressors.bzip2;version="[1.15.0,2.0)",
  org.apache.commons.compress.compressors.gzip;version="[1.15.0,2.0)",
  org.apache.commons.compress.compressors.xz;version="[1.15.0,2.0)",
+ org.assertj.core.api;version="[3.14.0,4.0.0)",
  org.bouncycastle.util.encoders;version="[1.61.0,2.0.0)",
  org.eclipse.jgit.annotations;version="[5.7.0,5.8.0)",
  org.eclipse.jgit.api;version="[5.7.0,5.8.0)",
  org.eclipse.jgit.util.sha1;version="[5.7.0,5.8.0)",
  org.junit;version="[4.13,5.0.0)",
  org.junit.experimental.theories;version="[4.13,5.0.0)",
+ org.junit.function;version="[4.13.0,5.0.0)",
  org.junit.rules;version="[4.13,5.0.0)",
  org.junit.runner;version="[4.13,5.0.0)",
  org.junit.runners;version="[4.13,5.0.0)",

org.eclipse.jgit.test/pom.xml

       <version>[1.1.0,2.0.0)</version>
     </dependency>
 
+    <dependency>
+      <groupId>org.assertj</groupId>
+      <artifactId>assertj-core</artifactId>
+    </dependency>
+
     <dependency>
       <groupId>org.mockito</groupId>
       <artifactId>mockito-core</artifactId>

org.eclipse.jgit.test/tst/org/eclipse/jgit/api/RenameBranchCommandTest.java

 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertNotNull;
 import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertThrows;
 import static org.junit.Assert.assertTrue;
 
 import org.eclipse.jgit.api.errors.RefAlreadyExistsException;
 import org.eclipse.jgit.lib.StoredConfig;
 import org.eclipse.jgit.revwalk.RevCommit;
 import org.junit.Before;
-import org.junit.Rule;
 import org.junit.Test;
-import org.junit.rules.ExpectedException;
 
 /**
  * Unit tests of {@link RenameBranchCommand}
 
 	private Git git;
 
-	@Rule
-	public ExpectedException thrown = ExpectedException.none();
-
 	@Override
 	@Before
 	public void setUp() throws Exception {
 	@Test
 	public void renameToExisting() throws Exception {
 		assertNotNull(git.branchCreate().setName("foo").call());
-		thrown.expect(RefAlreadyExistsException.class);
-		git.branchRename().setOldName("master").setNewName("foo").call();
+		assertThrows(RefAlreadyExistsException.class, () -> git.branchRename()
+				.setOldName("master").setNewName("foo").call());
 	}
 
 	@Test

org.eclipse.jgit.test/tst/org/eclipse/jgit/internal/storage/dfs/DfsBlockCacheConfigTest.java

 
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.hamcrest.Matchers.is;
+import static org.junit.Assert.assertThrows;
 
 import org.eclipse.jgit.internal.JGitText;
-import org.junit.Rule;
 import org.junit.Test;
-import org.junit.rules.ExpectedException;
 
 public class DfsBlockCacheConfigTest {
 
-	@Rule
-	public ExpectedException thrown = ExpectedException.none();
-
 	@Test
 	public void blockSizeNotPowerOfTwoExpectsException() {
-		thrown.expect(IllegalArgumentException.class);
-		thrown.expectMessage(is(JGitText.get().blockSizeNotPowerOf2));
-
-		new DfsBlockCacheConfig().setBlockSize(1000);
+		assertThrows(JGitText.get().blockSizeNotPowerOf2,
+				IllegalArgumentException.class,
+				() -> new DfsBlockCacheConfig().setBlockSize(1000));
 	}
 
 	@Test

org.eclipse.jgit.test/tst/org/eclipse/jgit/internal/storage/file/FileReftableStackTest.java

 
 import static org.eclipse.jgit.lib.Ref.Storage.PACKED;
 import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertThrows;
 import static org.junit.Assert.assertTrue;
 
 import java.io.File;
 import java.util.Collections;
 import java.util.List;
 import java.util.stream.Collectors;
+
 import org.eclipse.jgit.internal.storage.file.FileReftableStack.Segment;
 import org.eclipse.jgit.internal.storage.reftable.MergedReftable;
 import org.eclipse.jgit.internal.storage.reftable.RefCursor;
 import org.eclipse.jgit.util.FileUtils;
 import org.junit.After;
 import org.junit.Before;
-import org.junit.Rule;
 import org.junit.Test;
-import org.junit.rules.ExpectedException;
 
 public class FileReftableStackTest {
 
 		testCompaction(1024);
 	}
 
-	@Rule
-	public final ExpectedException thrown = ExpectedException.none();
-
 	@SuppressWarnings({ "resource", "unused" })
 	@Test
 	public void missingReftable() throws Exception {
 				}
 			}
 		}
-		thrown.expect(FileNotFoundException.class);
-		new FileReftableStack(new File(reftableDir, "refs"), reftableDir, null,
-				() -> new Config());
+		assertThrows(FileNotFoundException.class,
+				() -> new FileReftableStack(new File(reftableDir, "refs"),
+						reftableDir, null, () -> new Config()));
 	}
 
 	@Test

org.eclipse.jgit.test/tst/org/eclipse/jgit/internal/storage/file/ObjectDirectoryTest.java

 
 import static java.nio.charset.StandardCharsets.UTF_8;
 import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertThrows;
 import static org.junit.Assert.assertTrue;
 
 import java.io.File;
 import org.eclipse.jgit.storage.file.FileBasedConfig;
 import org.eclipse.jgit.util.FS;
 import org.junit.Assume;
-import org.junit.Rule;
 import org.junit.Test;
-import org.junit.rules.ExpectedException;
 
 public class ObjectDirectoryTest extends RepositoryTestCase {
 
-	@Rule
-	public ExpectedException expectedEx = ExpectedException.none();
-
 	@Test
 	public void testConcurrentInsertionOfBlobsToTheSameNewFanOutDirectory()
 			throws Exception {
 	}
 
 	@Test
-	public void testShallowFileCorrupt()
-			throws Exception {
+	public void testShallowFileCorrupt() throws Exception {
 		FileRepository repository = createBareRepository();
 		ObjectDirectory dir = repository.getObjectDatabase();
 
 				UTF_8.name())) {
 			writer.println(commit);
 		}
-
-		expectedEx.expect(IOException.class);
-		expectedEx.expectMessage(MessageFormat
-				.format(JGitText.get().badShallowLine, commit));
-		dir.getShallowCommits();
+		assertThrows(
+				MessageFormat.format(JGitText.get().badShallowLine, commit),
+				IOException.class, () -> dir.getShallowCommits());
 	}
 
 	private Collection<Callable<ObjectId>> blobInsertersForTheSameFanOutDir(

org.eclipse.jgit.test/tst/org/eclipse/jgit/internal/storage/file/T0003_BasicTest.java

 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertNotNull;
 import static org.junit.Assert.assertNotSame;
+import static org.junit.Assert.assertThrows;
 import static org.junit.Assert.assertTrue;
 import static org.junit.Assert.fail;
 
 import org.eclipse.jgit.util.FS;
 import org.eclipse.jgit.util.FileUtils;
 import org.eclipse.jgit.util.IO;
-import org.junit.Rule;
 import org.junit.Test;
-import org.junit.rules.ExpectedException;
 
 public class T0003_BasicTest extends SampleDataRepositoryTestCase {
-	@Rule
-	public ExpectedException expectedException = ExpectedException.none();
 
 	@Test
 	public void test001_Initalize() {
 		// We won't create a tree entry with an empty filename
 		//
 		final TreeFormatter formatter = new TreeFormatter();
-		expectedException.expect(IllegalArgumentException.class);
-		expectedException.expectMessage(JGitText.get().invalidTreeZeroLengthName);
-		formatter.append("", FileMode.TREE,
-				ObjectId.fromString("4b825dc642cb6eb9a060e54bf8d69288fbee4904"));
+		assertThrows(JGitText.get().invalidTreeZeroLengthName,
+				IllegalArgumentException.class,
+				() -> formatter.append("", FileMode.TREE, ObjectId.fromString(
+						"4b825dc642cb6eb9a060e54bf8d69288fbee4904")));
 	}
 
 	@Test

org.eclipse.jgit.test/tst/org/eclipse/jgit/lib/ConfigTest.java

 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertNull;
 import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertThrows;
 import static org.junit.Assert.assertTrue;
 import static org.junit.Assert.fail;
 
 import org.junit.After;
 import org.junit.Rule;
 import org.junit.Test;
-import org.junit.rules.ExpectedException;
 import org.junit.rules.TemporaryFolder;
 
 /**
 
 	private static final String REFS_BACKUP = "+refs/heads/*:refs/remotes/backup/*";
 
-	@Rule
-	public ExpectedException expectedEx = ExpectedException.none();
-
 	@Rule
 	public TemporaryFolder tmp = new TemporaryFolder();
 
 	}
 
 	@Test
-	public void testIncludeInvalidName() throws ConfigInvalidException {
-		expectedEx.expect(ConfigInvalidException.class);
-		expectedEx.expectMessage(JGitText.get().invalidLineInConfigFile);
-		parse("[include]\nbar\n");
+	public void testIncludeInvalidName() {
+		assertThrows(JGitText.get().invalidLineInConfigFile,
+				ConfigInvalidException.class, () -> parse("[include]\nbar\n"));
 	}
 
 	@Test
-	public void testIncludeNoValue() throws ConfigInvalidException {
-		expectedEx.expect(ConfigInvalidException.class);
-		expectedEx.expectMessage(JGitText.get().invalidLineInConfigFile);
-		parse("[include]\npath\n");
+	public void testIncludeNoValue() {
+		assertThrows(JGitText.get().invalidLineInConfigFile,
+				ConfigInvalidException.class, () -> parse("[include]\npath\n"));
 	}
 
 	@Test
-	public void testIncludeEmptyValue() throws ConfigInvalidException {
-		expectedEx.expect(ConfigInvalidException.class);
-		expectedEx.expectMessage(JGitText.get().invalidLineInConfigFile);
-		parse("[include]\npath=\n");
+	public void testIncludeEmptyValue() {
+		assertThrows(JGitText.get().invalidLineInConfigFile,
+				ConfigInvalidException.class,
+				() -> parse("[include]\npath=\n"));
 	}
 
 	@Test
 	}
 
 	@Test
-	public void testTimeUnitInvalid() throws ConfigInvalidException {
-		expectedEx.expect(IllegalArgumentException.class);
-		expectedEx
-				.expectMessage("Invalid time unit value: a.a=1 monttthhh");
-		parseTime("1 monttthhh", DAYS);
+	public void testTimeUnitInvalid() {
+		assertThrows("Invalid time unit value: a.a=1 monttthhh",
+				IllegalArgumentException.class,
+				() -> parseTime("1 monttthhh", DAYS));
 	}
 
 	@Test
 	public void testTimeUnitInvalidWithSection() throws ConfigInvalidException {
 		Config c = parse("[a \"b\"]\na=1 monttthhh\n");
-		expectedEx.expect(IllegalArgumentException.class);
-		expectedEx.expectMessage("Invalid time unit value: a.b.a=1 monttthhh");
-		c.getTimeUnit("a", "b", "a", 0, DAYS);
+		assertThrows("Invalid time unit value: a.b.a=1 monttthhh",
+				IllegalArgumentException.class,
+				() -> c.getTimeUnit("a", "b", "a", 0, DAYS));
 	}
 
 	@Test
-	public void testTimeUnitNegative() throws ConfigInvalidException {
-		expectedEx.expect(IllegalArgumentException.class);
-		parseTime("-1", MILLISECONDS);
+	public void testTimeUnitNegative() {
+		assertThrows(IllegalArgumentException.class,
+				() -> parseTime("-1", MILLISECONDS));
 	}
 
 	@Test
 	}
 
 	@Test
-	public void testInvalidGroupHeader() throws ConfigInvalidException {
-		expectedEx.expect(ConfigInvalidException.class);
-		expectedEx.expectMessage(JGitText.get().badGroupHeader);
-		parse("[foo \"bar\" ]\nfoo=bar\n");
+	public void testInvalidGroupHeader() {
+		assertThrows(JGitText.get().badGroupHeader,
+				ConfigInvalidException.class,
+				() -> parse("[foo \"bar\" ]\nfoo=bar\n"));
 	}
 
 	@Test
 	}
 
 	@Test
-	public void testCrCharContinuation() throws ConfigInvalidException {
-		expectedEx.expect(ConfigInvalidException.class);
-		expectedEx.expectMessage("Bad escape: \\u000d");
-		parseEscapedValue("tr\\\rue");
+	public void testCrCharContinuation() {
+		assertThrows("Bad escape: \\u000d", ConfigInvalidException.class,
+				() -> parseEscapedValue("tr\\\rue"));
 	}
 
 	@Test
-	public void testCrEOFContinuation() throws ConfigInvalidException {
-		expectedEx.expect(ConfigInvalidException.class);
-		expectedEx.expectMessage("Bad escape: \\u000d");
-		parseEscapedValue("tr\\\r");
+	public void testCrEOFContinuation() {
+		assertThrows("Bad escape: \\u000d", ConfigInvalidException.class,
+				() -> parseEscapedValue("tr\\\r"));
 	}
 
 	@Test

org.eclipse.jgit.test/tst/org/eclipse/jgit/lib/ObjectCheckerTest.java

 import static org.eclipse.jgit.util.RawParseUtils.decode;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertThrows;
 import static org.junit.Assert.fail;
 
 import java.text.MessageFormat;
 import org.eclipse.jgit.errors.CorruptObjectException;
 import org.eclipse.jgit.internal.JGitText;
 import org.junit.Before;
-import org.junit.Rule;
 import org.junit.Test;
-import org.junit.rules.ExpectedException;
 
 public class ObjectCheckerTest {
 	private static final ObjectChecker SECRET_KEY_CHECKER = new ObjectChecker() {
 
 	private ObjectChecker checker;
 
-	@Rule
-	public final ExpectedException thrown = ExpectedException.none();
-
 	@Before
 	public void setUp() throws Exception {
 		checker = new ObjectChecker();
 	}
 
 	@Test
-	public void testCheckBlobCorrupt() throws CorruptObjectException {
-		thrown.expect(CorruptObjectException.class);
-		SECRET_KEY_CHECKER.check(OBJ_BLOB, encodeASCII("key = \"secret_key\""));
+	public void testCheckBlobCorrupt() {
+		assertThrows(CorruptObjectException.class, () -> SECRET_KEY_CHECKER
+				.check(OBJ_BLOB, encodeASCII("key = \"secret_key\"")));
 	}
 
 	@Test
 	}
 
 	@Test
-	public void testCheckBlobWithBlobObjectCheckerCorrupt()
-			throws CorruptObjectException {
-		thrown.expect(CorruptObjectException.class);
-		SECRET_KEY_BLOB_CHECKER.check(OBJ_BLOB,
-				encodeASCII("key = \"secret_key\""));
+	public void testCheckBlobWithBlobObjectCheckerCorrupt() {
+		assertThrows(CorruptObjectException.class, () -> SECRET_KEY_BLOB_CHECKER
+				.check(OBJ_BLOB, encodeASCII("key = \"secret_key\"")));
 	}
 
 	@Test

org.eclipse.jgit.test/tst/org/eclipse/jgit/transport/BundleWriterTest.java

 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertNotNull;
 import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertThrows;
 import static org.junit.Assert.assertTrue;
 import static org.junit.Assert.fail;
 
 import org.eclipse.jgit.revwalk.RevCommit;
 import org.eclipse.jgit.revwalk.RevWalk;
 import org.eclipse.jgit.test.resources.SampleDataRepositoryTestCase;
-import org.junit.Rule;
 import org.junit.Test;
-import org.junit.rules.ExpectedException;
 
 public class BundleWriterTest extends SampleDataRepositoryTestCase {
 
-	@Rule
-	public ExpectedException thrown = ExpectedException.none();
-
 	@Test
 	public void testEmptyBundleFails() throws Exception {
 		Repository newRepo = createBareRepository();
-		thrown.expect(TransportException.class);
-		fetchFromBundle(newRepo, new byte[0]);
+		assertThrows(TransportException.class,
+				() -> fetchFromBundle(newRepo, new byte[0]));
 	}
 
 	@Test
 	public void testNonBundleFails() throws Exception {
 		Repository newRepo = createBareRepository();
-		thrown.expect(TransportException.class);
-		fetchFromBundle(newRepo, "Not a bundle file".getBytes(UTF_8));
+		assertThrows(TransportException.class, () -> fetchFromBundle(newRepo,
+				"Not a bundle file".getBytes(UTF_8)));
 	}
 
 	@Test
 	public void testGarbageBundleFails() throws Exception {
 		Repository newRepo = createBareRepository();
-		thrown.expect(TransportException.class);
-		fetchFromBundle(newRepo,
+		assertThrows(TransportException.class, () -> fetchFromBundle(newRepo,
 				(TransportBundle.V2_BUNDLE_SIGNATURE + '\n' + "Garbage")
-						.getBytes(UTF_8));
+						.getBytes(UTF_8)));
 	}
 
 	@Test

org.eclipse.jgit.test/tst/org/eclipse/jgit/transport/ProtocolV2ParserTest.java

 import static org.hamcrest.Matchers.hasItems;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertThrows;
 import static org.junit.Assert.assertTrue;
 
 import java.io.ByteArrayInputStream;
 import org.eclipse.jgit.lib.Config;
 import org.eclipse.jgit.revwalk.RevCommit;
 import org.junit.Before;
-import org.junit.Rule;
 import org.junit.Test;
-import org.junit.rules.ExpectedException;
 
 public class ProtocolV2ParserTest {
 
-	@Rule
-	public ExpectedException thrown = ExpectedException.none();
-
 	private TestRepository<InMemoryRepository> testRepo;
 
 	@Before
 		ProtocolV2Parser parser = new ProtocolV2Parser(
 				ConfigBuilder.start().allowFilter().done());
 
-		thrown.expect(PackProtocolException.class);
-		parser.parseFetchRequest(pckIn);
+		assertThrows(PackProtocolException.class,
+				() -> parser.parseFetchRequest(pckIn));
 	}
 
 	@Test
 		ProtocolV2Parser parser = new ProtocolV2Parser(
 				ConfigBuilder.getDefault());
 
-		thrown.expect(PackProtocolException.class);
-		parser.parseFetchRequest(pckIn);
+		assertThrows(PackProtocolException.class,
+				() -> parser.parseFetchRequest(pckIn));
 	}
 
 	@Test

org.eclipse.jgit.test/tst/org/eclipse/jgit/transport/RequestValidatorTestCase.java

  */
 package org.eclipse.jgit.transport;
 
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.catchThrowableOfType;
+
 import java.io.IOException;
 import java.util.Arrays;
 import java.util.HashMap;
 import java.util.Map;
 
-import org.eclipse.jgit.errors.PackProtocolException;
+import org.assertj.core.api.ThrowableAssert.ThrowingCallable;
 import org.eclipse.jgit.errors.TransportException;
 import org.eclipse.jgit.internal.storage.dfs.DfsGarbageCollector;
 import org.eclipse.jgit.internal.storage.dfs.DfsRepositoryDescription;
 import org.eclipse.jgit.revwalk.RevBlob;
 import org.eclipse.jgit.revwalk.RevCommit;
 import org.eclipse.jgit.transport.UploadPack.RequestValidator;
-import org.hamcrest.Matchers;
 import org.junit.Before;
-import org.junit.Rule;
 import org.junit.Test;
-import org.junit.rules.ExpectedException;
 
 public abstract class RequestValidatorTestCase {
 
-	@Rule
-	public ExpectedException thrown = ExpectedException.none();
-
 	private RevCommit reachableCommit;
 
 	private RevCommit tipAdvertisedCommit;
 	protected abstract boolean isUnreachableBlobValid();
 
 	@Test
-	public void validateReachableCommitWithBitmaps()
-			throws PackProtocolException, IOException {
+	public void validateReachableCommitWithBitmaps() throws Throwable {
+		ThrowingCallable c = () -> createValidator().checkWants(
+				getUploadPack(getRepoWithBitmaps()),
+				Arrays.asList(reachableCommit));
 		if (!isReachableCommitValid()) {
-			thrown.expect(TransportException.class);
-			thrown.expectMessage(Matchers
-					.containsString(
-							"want " + reachableCommit.name() + " not valid"));
-
+			assertTransportException(c,
+					"want " + reachableCommit.name() + " not valid");
+			return;
 		}
-		createValidator().checkWants(getUploadPack(getRepoWithBitmaps()),
-				Arrays.asList(reachableCommit));
+		c.call();
 	}
 
 	@Test
-	public void validateReachableCommitWithoutBitmaps()
-			throws PackProtocolException, IOException {
+	public void validateReachableCommitWithoutBitmaps() throws Throwable {
+		ThrowingCallable c = () -> createValidator().checkWants(
+				getUploadPack(getRepoWithoutBitmaps()),
+				Arrays.asList(reachableCommit));
 		if (!isReachableCommitValid()) {
-			thrown.expect(TransportException.class);
-			thrown.expectMessage(Matchers.containsString(
-					"want " + reachableCommit.name() + " not valid"));
-
+			assertTransportException(c,
+					"want " + reachableCommit.name() + " not valid");
+			return;
 		}
-		createValidator().checkWants(getUploadPack(getRepoWithoutBitmaps()),
-				Arrays.asList(reachableCommit));
+		c.call();
 	}
 
 	@Test
-	public void validateAdvertisedTipWithBitmaps()
-			throws PackProtocolException, IOException {
+	public void validateAdvertisedTipWithBitmaps() throws Throwable {
+		ThrowingCallable c = () -> createValidator().checkWants(
+				getUploadPack(getRepoWithBitmaps()),
+				Arrays.asList(tipAdvertisedCommit));
 		if (!isAdvertisedTipValid()) {
-			thrown.expect(TransportException.class);
-			thrown.expectMessage(Matchers.containsString(
-					"want " + tipAdvertisedCommit.name() + " not valid"));
-
+			assertTransportException(c,
+					"want " + tipAdvertisedCommit.name() + " not valid");
+			return;
 		}
-		createValidator().checkWants(getUploadPack(getRepoWithBitmaps()),
-				Arrays.asList(tipAdvertisedCommit));
+		c.call();
 	}
 
 	@Test
-	public void validateAdvertisedTipWithoutBitmaps()
-			throws PackProtocolException, IOException {
+	public void validateAdvertisedTipWithoutBitmaps() throws Throwable {
+		ThrowingCallable c = () -> createValidator().checkWants(
+				getUploadPack(getRepoWithoutBitmaps()),
+				Arrays.asList(tipAdvertisedCommit));
 		if (!isAdvertisedTipValid()) {
-			thrown.expect(TransportException.class);
-			thrown.expectMessage(Matchers.containsString(
-					"want " + tipAdvertisedCommit.name() + " not valid"));
-
+			assertTransportException(c,
+					"want " + tipAdvertisedCommit.name() + " not valid");
+			return;
 		}
-		createValidator().checkWants(getUploadPack(getRepoWithoutBitmaps()),
-				Arrays.asList(tipAdvertisedCommit));
+		c.call();
 	}
 
 	@Test
-	public void validateUnadvertisedTipWithBitmaps()
-			throws PackProtocolException, IOException {
+	public void validateUnadvertisedTipWithBitmaps() throws Throwable {
+		ThrowingCallable c = () -> createValidator().checkWants(
+				getUploadPack(getRepoWithBitmaps()),
+				Arrays.asList(tipUnadvertisedCommit));
 		if (!isUnadvertisedTipCommitValid()) {
-			thrown.expect(TransportException.class);
-			thrown.expectMessage(Matchers.containsString(
-					"want " + tipUnadvertisedCommit.name() + " not valid"));
-
+			assertTransportException(c,
+					"want " + tipUnadvertisedCommit.name() + " not valid");
+			return;
 		}
-		createValidator().checkWants(getUploadPack(getRepoWithBitmaps()),
-				Arrays.asList(tipUnadvertisedCommit));
+		c.call();
 	}
 
 	@Test
-	public void validateUnadvertisedTipWithoutBitmaps()
-			throws PackProtocolException, IOException {
+	public void validateUnadvertisedTipWithoutBitmaps() throws Throwable {
+		ThrowingCallable c = () -> createValidator().checkWants(
+				getUploadPack(getRepoWithoutBitmaps()),
+				Arrays.asList(tipUnadvertisedCommit));
 		if (!isUnadvertisedTipCommitValid()) {
-			thrown.expect(TransportException.class);
-			thrown.expectMessage(Matchers.containsString(
-					"want " + tipUnadvertisedCommit.name() + " not valid"));
-
+			assertTransportException(c,
+					"want " + tipUnadvertisedCommit.name() + " not valid");
+			return;
 		}
-		createValidator().checkWants(getUploadPack(getRepoWithoutBitmaps()),
-				Arrays.asList(tipUnadvertisedCommit));
+		c.call();
 	}
 
 	@Test
-	public void validateUnreachableCommitWithBitmaps()
-			throws PackProtocolException, IOException {
+	public void validateUnreachableCommitWithBitmaps() throws Throwable {
+		ThrowingCallable c = () -> createValidator().checkWants(
+				getUploadPack(getRepoWithBitmaps()),
+				Arrays.asList(unreachableCommit));
 		if (!isUnreachableCommitValid()) {
-			thrown.expect(TransportException.class);
-			thrown.expectMessage(Matchers.containsString(
-					"want " + unreachableCommit.name() + " not valid"));
-
+			assertTransportException(c,
+					"want " + unreachableCommit.name() + " not valid");
+			return;
 		}
-		createValidator().checkWants(getUploadPack(getRepoWithBitmaps()),
-				Arrays.asList(unreachableCommit));
+		c.call();
 	}
 
 	@Test
-	public void validateUnreachableCommitWithoutBitmaps()
-			throws PackProtocolException, IOException {
+	public void validateUnreachableCommitWithoutBitmaps() throws Throwable {
+		ThrowingCallable c = () -> createValidator().checkWants(
+				getUploadPack(getRepoWithoutBitmaps()),
+				Arrays.asList(unreachableCommit));
 		if (!isUnreachableCommitValid()) {
-			thrown.expect(TransportException.class);
-			thrown.expectMessage(Matchers.containsString(
-					"want " + unreachableCommit.name() + " not valid"));
-
+			assertTransportException(c,
+					"want " + unreachableCommit.name() + " not valid");
+			return;
 		}
-		createValidator().checkWants(getUploadPack(getRepoWithoutBitmaps()),
-				Arrays.asList(unreachableCommit));
+		c.call();
 	}
 
 	@Test
-	public void validateReachableBlobWithBitmaps()
-			throws PackProtocolException, IOException {
+	public void validateReachableBlobWithBitmaps() throws Throwable {
+		ThrowingCallable c = () -> createValidator().checkWants(
+				getUploadPack(getRepoWithBitmaps()),
+				Arrays.asList(reachableBlob));
 		if (!isReachableBlobValid_withBitmaps()) {
-			thrown.expect(TransportException.class);
-			thrown.expectMessage(Matchers.containsString(
-					"want " + reachableBlob.name() + " not valid"));
+			assertTransportException(c,
+					"want " + reachableBlob.name() + " not valid");
+			return;
 		}
-		createValidator().checkWants(getUploadPack(getRepoWithBitmaps()),
-				Arrays.asList(reachableBlob));
+		c.call();
 	}
 
 	@Test
-	public void validateReachableBlobWithoutBitmaps()
-			throws PackProtocolException, IOException {
+	public void validateReachableBlobWithoutBitmaps() throws Throwable {
+		ThrowingCallable c = () -> createValidator().checkWants(
+				getUploadPack(getRepoWithoutBitmaps()),
+				Arrays.asList(reachableBlob));
 		if (!isReachableBlobValid_withoutBitmaps()) {
-			thrown.expect(TransportException.class);
-			thrown.expectMessage(Matchers.containsString(
-					"want " + reachableBlob.name() + " not valid"));
+			assertTransportException(c,
+					"want " + reachableBlob.name() + " not valid");
+			return;
 		}
-		createValidator().checkWants(getUploadPack(getRepoWithoutBitmaps()),
-				Arrays.asList(reachableBlob));
+		c.call();
 	}
 
 	@Test
-	public void validateUnreachableBlobWithBitmaps()
-			throws PackProtocolException, IOException {
+	public void validateUnreachableBlobWithBitmaps() throws Throwable {
+		ThrowingCallable c = () -> createValidator().checkWants(
+				getUploadPack(getRepoWithBitmaps()),
+				Arrays.asList(unreachableBlob));
 		if (!isUnreachableBlobValid()) {
-			thrown.expect(TransportException.class);
-			thrown.expectMessage(Matchers.containsString(
-					"want " + unreachableBlob.name() + " not valid"));
+			assertTransportException(c,
+					"want " + unreachableBlob.name() + " not valid");
+			return;
 		}
-		createValidator().checkWants(getUploadPack(getRepoWithBitmaps()),
-				Arrays.asList(unreachableBlob));
+		c.call();
 	}
 
 	@Test
-	public void validateUnreachableBlobWithoutBitmaps()
-			throws PackProtocolException, IOException {
+	public void validateUnreachableBlobWithoutBitmaps() throws Throwable {
+		ThrowingCallable c = () -> createValidator().checkWants(
+				getUploadPack(getRepoWithoutBitmaps()),
+				Arrays.asList(unreachableBlob));
 		if (!isUnreachableBlobValid()) {
-			thrown.expect(TransportException.class);
-			thrown.expectMessage(Matchers.containsString(
-					"want " + unreachableBlob.name() + " not valid"));
+			assertTransportException(c,
+					"want " + unreachableBlob.name() + " not valid");
+			return;
 		}
-		createValidator().checkWants(getUploadPack(getRepoWithoutBitmaps()),
-				Arrays.asList(unreachableBlob));
+		c.call();
+	}
+
+	private void assertTransportException(ThrowingCallable c,
+			String messageContent) throws AssertionError {
+		assertThat(catchThrowableOfType(c, TransportException.class))
+				.hasMessageContaining(messageContent);
 	}
 
 	private UploadPack getUploadPack(Repository repository) throws IOException {

org.eclipse.jgit.test/tst/org/eclipse/jgit/transport/UploadPackReachabilityTest.java

 import org.eclipse.jgit.transport.resolver.UploadPackFactory;
 import org.junit.After;
 import org.junit.Before;
-import org.junit.Rule;
 import org.junit.Test;
-import org.junit.rules.ExpectedException;
 
 /**
  * Test combinations of:
  */
 public class UploadPackReachabilityTest {
 
-	@Rule
-	public ExpectedException thrown = ExpectedException.none();
-
 	private URIish uri;
 
 	private TestProtocol<Object> testProtocol;

org.eclipse.jgit.test/tst/org/eclipse/jgit/util/RawParseUtils_LineMapTest.java

 import static java.nio.charset.StandardCharsets.ISO_8859_1;
 import static org.junit.Assert.assertArrayEquals;
 import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertThrows;
 
 import org.eclipse.jgit.errors.BinaryBlobException;
-import org.junit.Rule;
 import org.junit.Test;
-import org.junit.rules.ExpectedException;
 
 public class RawParseUtils_LineMapTest {
-	@Rule
-	public ExpectedException exception = ExpectedException.none();
-
 
 	@Test
 	public void testEmpty() throws Exception {
 	@Test
 	public void testLineMapOrBinary() throws Exception {
 		final byte[] buf = "xxxfoo\nb\0ar".getBytes(ISO_8859_1);
-		exception.expect(BinaryBlobException.class);
-		RawParseUtils.lineMapOrBinary(buf, 3, buf.length);
+		assertThrows(BinaryBlobException.class,
+				() -> RawParseUtils.lineMapOrBinary(buf, 3, buf.length));
 	}
 
 	@Test

pom.xml

         <version>${bouncycastle-version}</version>
       </dependency>
 
+      <dependency>
+        <groupId>org.assertj</groupId>
+        <artifactId>assertj-core</artifactId>
+        <version>3.14.0</version>
+      </dependency>
     </dependencies>
   </dependencyManagement>