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(
],
)
+java_library(
+ name = "assertj-core",
+ testonly = 1,
+ visibility = ["//visibility:public"],
+ exports = [
+ "@assertj-core//jar",
+ ],
+)
+
java_library(
name = "servlet-api",
visibility = [
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"));
}
}
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")
*/
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
srcs = HELPERS,
resources = DATA,
deps = [
+ "//lib:assertj-core",
"//lib:jsch",
"//lib:junit",
"//lib:mockito",
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)",
<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>
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
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
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
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(
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
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
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
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
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
*/
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 {
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;
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
<version>${bouncycastle-version}</version>
</dependency>
+ <dependency>
+ <groupId>org.assertj</groupId>
+ <artifactId>assertj-core</artifactId>
+ <version>3.14.0</version>
+ </dependency>
</dependencies>
</dependencyManagement>
projects / jgit.git / commitdiff