motiejus
/
jgit
1
Fork 0
Code Releases Activity

Replace ExpectedException which was deprecated in junit 4.13 

Change-Id: I64b0c057dd0a12aef2f3d56fa0c8a10e3b23fffd
Signed-off-by: Matthias Sohn <matthias.sohn@sap.com>
This commit is contained in:
Matthias Sohn 2020-01-22 00:48:24 +01:00 committed by David Pursehouse
parent b5cabfbff2
commit 8ada9048c5
21 changed files with 252 additions and 294 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
WORKSPACE
View File

@ -177,6 +177,12 @@ maven_jar(
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(

9
lib/BUILD
View File

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

26
org.eclipse.jgit.http.test/tst/org/eclipse/jgit/http/test/SmartClientSmartServerTest.java
View File

@ -18,6 +18,7 @@
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;
@ -88,18 +89,12 @@
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;
@ -462,11 +457,12 @@ public void testFetchBySHA1Unreachable() throws Exception {
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())));
}
}
@ -484,11 +480,11 @@ protected Map<String, Ref> getAdvertisedRefs(Repository repository,
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"));
}
}

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

@ -12,6 +12,7 @@
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;
@ -22,15 +23,10 @@
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";
@ -49,10 +45,8 @@ public void testDownloadInvalidPathInfo()
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
@ -62,22 +56,18 @@ public void testDownloadInvalidId()
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")

26
org.eclipse.jgit.pgm.test/tst/org/eclipse/jgit/pgm/BlameTest.java
View File

@ -9,6 +9,7 @@
*/
package org.eclipse.jgit.pgm;
import static org.junit.Assert.assertThrows;
import static org.junit.Assert.assertTrue;
import org.eclipse.jgit.api.Git;
@ -17,24 +18,18 @@
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
@ -68,9 +63,8 @@ public void testBlameUnstaged() throws Exception {
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
@ -78,9 +72,8 @@ public void testBlameNonExisting() throws Exception {
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
@ -88,9 +81,8 @@ public void testBlameNonExistingInSubdir() throws Exception {
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

1
org.eclipse.jgit.test/BUILD
View File

@ -55,6 +55,7 @@ java_library(
srcs = HELPERS,
resources = DATA,
deps = [
"//lib:assertj-core",
"//lib:jsch",
"//lib:junit",
"//lib:mockito",

2
org.eclipse.jgit.test/META-INF/MANIFEST.MF
View File

@ -17,6 +17,7 @@ Import-Package: com.googlecode.javaewah;version="[1.1.6,2.0.0)",
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)",
@ -72,6 +73,7 @@ Import-Package: com.googlecode.javaewah;version="[1.1.6,2.0.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)",

5
org.eclipse.jgit.test/pom.xml
View File

@ -65,6 +65,11 @@
<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>

10
org.eclipse.jgit.test/tst/org/eclipse/jgit/api/RenameBranchCommandTest.java
View File

@ -14,6 +14,7 @@
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;
@ -25,9 +26,7 @@
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}
@ -40,9 +39,6 @@ public class RenameBranchCommandTest extends RepositoryTestCase {
private Git git;
@Rule
public ExpectedException thrown = ExpectedException.none();
@Override
@Before
public void setUp() throws Exception {
@ -57,8 +53,8 @@ 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

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

@ -40,23 +40,18 @@
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

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

@ -12,6 +12,7 @@
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;
@ -21,6 +22,7 @@
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;
@ -31,9 +33,7 @@
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 {
@ -113,9 +113,6 @@ public void testCompaction1024() throws Exception {
testCompaction(1024);
}
@Rule
public final ExpectedException thrown = ExpectedException.none();
@SuppressWarnings({ "resource", "unused" })
@Test
public void missingReftable() throws Exception {
@ -143,9 +140,9 @@ 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

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

@ -44,6 +44,7 @@
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;
@ -67,15 +68,10 @@
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 {
@ -199,8 +195,7 @@ public void testShallowFile()
}
@Test
public void testShallowFileCorrupt()
throws Exception {
public void testShallowFileCorrupt() throws Exception {
FileRepository repository = createBareRepository();
ObjectDirectory dir = repository.getObjectDatabase();
@ -210,11 +205,9 @@ public void testShallowFileCorrupt()
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(

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

@ -19,6 +19,7 @@
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;
@ -53,13 +54,9 @@
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() {
@ -311,10 +308,10 @@ public void test002_CreateBadTree() throws Exception {
// 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

70
org.eclipse.jgit.test/tst/org/eclipse/jgit/lib/ConfigTest.java
View File

@ -29,6 +29,7 @@
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;
@ -58,7 +59,6 @@
import org.junit.After;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.ExpectedException;
import org.junit.rules.TemporaryFolder;
/**
@ -75,9 +75,6 @@ public class ConfigTest {
private static final String REFS_BACKUP = "+refs/heads/*:refs/remotes/backup/*";
@Rule
public ExpectedException expectedEx = ExpectedException.none();
@Rule
public TemporaryFolder tmp = new TemporaryFolder();
@ -721,24 +718,22 @@ public void testReadMultipleValuesForName() throws ConfigInvalidException {
}
@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
@ -1269,25 +1264,24 @@ public void testTimeUnitDefaultValue() throws ConfigInvalidException {
}
@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
@ -1430,10 +1424,10 @@ public void testDropBackslashFromInvalidEscapeSequenceInSubsectionName()
}
@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
@ -1447,17 +1441,15 @@ public void testLfContinuation() throws ConfigInvalidException {
}
@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

20
org.eclipse.jgit.test/tst/org/eclipse/jgit/lib/ObjectCheckerTest.java
View File

@ -34,6 +34,7 @@
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;
@ -41,9 +42,7 @@
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() {
@ -84,9 +83,6 @@ public void endBlob(AnyObjectId id)
private ObjectChecker checker;
@Rule
public final ExpectedException thrown = ExpectedException.none();
@Before
public void setUp() throws Exception {
checker = new ObjectChecker();
@ -116,9 +112,9 @@ public void testCheckBlobNotCorrupt() throws CorruptObjectException {
}
@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
@ -129,11 +125,9 @@ public void testCheckBlobWithBlobObjectCheckerNotCorrupt()
}
@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

19
org.eclipse.jgit.test/tst/org/eclipse/jgit/transport/BundleWriterTest.java
View File

@ -17,6 +17,7 @@
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;
@ -44,36 +45,30 @@
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

14
org.eclipse.jgit.test/tst/org/eclipse/jgit/transport/ProtocolV2ParserTest.java
View File

@ -14,6 +14,7 @@
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;
@ -27,15 +28,10 @@
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
@ -236,8 +232,8 @@ public void testFetchMustNotHaveMultipleFilters() throws IOException {
ProtocolV2Parser parser = new ProtocolV2Parser(
ConfigBuilder.start().allowFilter().done());
thrown.expect(PackProtocolException.class);
parser.parseFetchRequest(pckIn);
assertThrows(PackProtocolException.class,
() -> parser.parseFetchRequest(pckIn));
}
@Test
@ -247,8 +243,8 @@ public void testFetchFilterWithoutAllowFilter() throws IOException {
ProtocolV2Parser parser = new ProtocolV2Parser(
ConfigBuilder.getDefault());
thrown.expect(PackProtocolException.class);
parser.parseFetchRequest(pckIn);
assertThrows(PackProtocolException.class,
() -> parser.parseFetchRequest(pckIn));
}
@Test

236
org.eclipse.jgit.test/tst/org/eclipse/jgit/transport/RequestValidatorTestCase.java
View File

@ -9,12 +9,15 @@
*/
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;
@ -25,17 +28,11 @@
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;
@ -111,156 +108,165 @@ public void setUp() throws Exception {
protected abstract boolean isUnreachableBlobValid();
@Test
public void validateReachableCommitWithBitmaps()
throws PackProtocolException, IOException {
if (!isReachableCommitValid()) {
thrown.expect(TransportException.class);
thrown.expectMessage(Matchers
.containsString(
"want " + reachableCommit.name() + " not valid"));
}
createValidator().checkWants(getUploadPack(getRepoWithBitmaps()),
public void validateReachableCommitWithBitmaps() throws Throwable {
ThrowingCallable c = () -> createValidator().checkWants(
getUploadPack(getRepoWithBitmaps()),
Arrays.asList(reachableCommit));
}
@Test
public void validateReachableCommitWithoutBitmaps()
throws PackProtocolException, IOException {
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()),
c.call();
}
@Test
public void validateReachableCommitWithoutBitmaps() throws Throwable {
ThrowingCallable c = () -> createValidator().checkWants(
getUploadPack(getRepoWithoutBitmaps()),
Arrays.asList(reachableCommit));
if (!isReachableCommitValid()) {
assertTransportException(c,
"want " + reachableCommit.name() + " not valid");
return;
}
c.call();
}
@Test
public void validateAdvertisedTipWithBitmaps()
throws PackProtocolException, IOException {
if (!isAdvertisedTipValid()) {
thrown.expect(TransportException.class);
thrown.expectMessage(Matchers.containsString(
"want " + tipAdvertisedCommit.name() + " not valid"));
}
createValidator().checkWants(getUploadPack(getRepoWithBitmaps()),
public void validateAdvertisedTipWithBitmaps() throws Throwable {
ThrowingCallable c = () -> createValidator().checkWants(
getUploadPack(getRepoWithBitmaps()),
Arrays.asList(tipAdvertisedCommit));
}
@Test
public void validateAdvertisedTipWithoutBitmaps()
throws PackProtocolException, IOException {
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()),
c.call();
}
@Test
public void validateAdvertisedTipWithoutBitmaps() throws Throwable {
ThrowingCallable c = () -> createValidator().checkWants(
getUploadPack(getRepoWithoutBitmaps()),
Arrays.asList(tipAdvertisedCommit));
if (!isAdvertisedTipValid()) {
assertTransportException(c,
"want " + tipAdvertisedCommit.name() + " not valid");
return;
}
c.call();
}
@Test
public void validateUnadvertisedTipWithBitmaps()
throws PackProtocolException, IOException {
if (!isUnadvertisedTipCommitValid()) {
thrown.expect(TransportException.class);
thrown.expectMessage(Matchers.containsString(
"want " + tipUnadvertisedCommit.name() + " not valid"));
}
createValidator().checkWants(getUploadPack(getRepoWithBitmaps()),
public void validateUnadvertisedTipWithBitmaps() throws Throwable {
ThrowingCallable c = () -> createValidator().checkWants(
getUploadPack(getRepoWithBitmaps()),
Arrays.asList(tipUnadvertisedCommit));
}
@Test
public void validateUnadvertisedTipWithoutBitmaps()
throws PackProtocolException, IOException {
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()),
c.call();
}
@Test
public void validateUnadvertisedTipWithoutBitmaps() throws Throwable {
ThrowingCallable c = () -> createValidator().checkWants(
getUploadPack(getRepoWithoutBitmaps()),
Arrays.asList(tipUnadvertisedCommit));
}
@Test
public void validateUnreachableCommitWithBitmaps()
throws PackProtocolException, IOException {
if (!isUnreachableCommitValid()) {
thrown.expect(TransportException.class);
thrown.expectMessage(Matchers.containsString(
"want " + unreachableCommit.name() + " not valid"));
if (!isUnadvertisedTipCommitValid()) {
assertTransportException(c,
"want " + tipUnadvertisedCommit.name() + " not valid");
return;
}
createValidator().checkWants(getUploadPack(getRepoWithBitmaps()),
Arrays.asList(unreachableCommit));
c.call();
}
@Test
public void validateUnreachableCommitWithoutBitmaps()
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(getRepoWithoutBitmaps()),
Arrays.asList(unreachableCommit));
c.call();
}
@Test
public void validateReachableBlobWithBitmaps()
throws PackProtocolException, IOException {
public void validateUnreachableCommitWithoutBitmaps() throws Throwable {
ThrowingCallable c = () -> createValidator().checkWants(
getUploadPack(getRepoWithoutBitmaps()),
Arrays.asList(unreachableCommit));
if (!isUnreachableCommitValid()) {
assertTransportException(c,
"want " + unreachableCommit.name() + " not valid");
return;
}
c.call();
}
@Test
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 {
if (!isUnreachableBlobValid()) {
thrown.expect(TransportException.class);
thrown.expectMessage(Matchers.containsString(
"want " + unreachableBlob.name() + " not valid"));
}
createValidator().checkWants(getUploadPack(getRepoWithBitmaps()),
public void validateUnreachableBlobWithBitmaps() throws Throwable {
ThrowingCallable c = () -> createValidator().checkWants(
getUploadPack(getRepoWithBitmaps()),
Arrays.asList(unreachableBlob));
if (!isUnreachableBlobValid()) {
assertTransportException(c,
"want " + unreachableBlob.name() + " not valid");
return;
}
c.call();
}
@Test
public void validateUnreachableBlobWithoutBitmaps()
throws PackProtocolException, IOException {
if (!isUnreachableBlobValid()) {
thrown.expect(TransportException.class);
thrown.expectMessage(Matchers.containsString(
"want " + unreachableBlob.name() + " not valid"));
}
createValidator().checkWants(getUploadPack(getRepoWithoutBitmaps()),
public void validateUnreachableBlobWithoutBitmaps() throws Throwable {
ThrowingCallable c = () -> createValidator().checkWants(
getUploadPack(getRepoWithoutBitmaps()),
Arrays.asList(unreachableBlob));
if (!isUnreachableBlobValid()) {
assertTransportException(c,
"want " + unreachableBlob.name() + " not valid");
return;
}
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 {

5
org.eclipse.jgit.test/tst/org/eclipse/jgit/transport/UploadPackReachabilityTest.java
View File

@ -32,9 +32,7 @@
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:
@ -46,9 +44,6 @@
*/
public class UploadPackReachabilityTest {
@Rule
public ExpectedException thrown = ExpectedException.none();
private URIish uri;
private TestProtocol<Object> testProtocol;

10
org.eclipse.jgit.test/tst/org/eclipse/jgit/util/RawParseUtils_LineMapTest.java
View File

@ -13,16 +13,12 @@
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 {
@ -62,8 +58,8 @@ public void testNulByte() {
@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

5
pom.xml
View File

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