You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@maven.apache.org by sl...@apache.org on 2026/09/19 21:53:58 UTC
(maven-jarsigner-plugin) branch agent/drop-hamcrest created (now 7ef6dc6)
This is an automated email from the ASF dual-hosted git repository.
slachiewicz pushed a change to branch agent/drop-hamcrest
in repository https://gitbox.apache.org/repos/asf/maven-jarsigner-plugin.git
at 7ef6dc6 Drop Hamcrest from tests
This branch includes the following new commits:
new 7ef6dc6 Drop Hamcrest from tests
The 1 revisions listed above as "new" are entirely new to this
repository and will be described in separate emails. The revisions
listed as "add" were already present in the repository and have only
been added to this reference.
(maven-jarsigner-plugin) 01/01: Drop Hamcrest from tests
Posted by sl...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
slachiewicz pushed a commit to branch agent/drop-hamcrest
in repository https://gitbox.apache.org/repos/asf/maven-jarsigner-plugin.git
commit 7ef6dc60abe0ec524477539ea52a7dcc8a63cc3e
Author: Sylwester Lachiewicz <sl...@apache.org>
AuthorDate: Sat Sep 19 23:53:43 2026 +0200
Drop Hamcrest from tests
---
pom.xml | 6 --
.../jarsigner/JarsignerSignMojoParallelTest.java | 4 +-
.../jarsigner/JarsignerSignMojoRetryTest.java | 11 +--
.../plugins/jarsigner/JarsignerSignMojoTest.java | 106 ++++++++++-----------
.../jarsigner/JarsignerSignMojoTsaTest.java | 11 +--
.../plugins/jarsigner/JarsignerVerifyMojoTest.java | 21 ++--
.../maven/plugins/jarsigner/RequestMatchers.java | 65 ++++++-------
7 files changed, 101 insertions(+), 123 deletions(-)
diff --git a/pom.xml b/pom.xml
index 4d9af3b..2eb5337 100644
--- a/pom.xml
+++ b/pom.xml
@@ -136,12 +136,6 @@ under the License.
<artifactId>junit-jupiter</artifactId>
<scope>test</scope>
</dependency>
- <dependency>
- <groupId>org.hamcrest</groupId>
- <artifactId>hamcrest</artifactId>
- <version>3.0</version>
- <scope>test</scope>
- </dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-api</artifactId>
diff --git a/src/test/java/org/apache/maven/plugins/jarsigner/JarsignerSignMojoParallelTest.java b/src/test/java/org/apache/maven/plugins/jarsigner/JarsignerSignMojoParallelTest.java
index 7ba8c3a..3ca475d 100644
--- a/src/test/java/org/apache/maven/plugins/jarsigner/JarsignerSignMojoParallelTest.java
+++ b/src/test/java/org/apache/maven/plugins/jarsigner/JarsignerSignMojoParallelTest.java
@@ -45,8 +45,6 @@ import org.junit.jupiter.api.io.TempDir;
import static org.apache.maven.plugins.jarsigner.TestJavaToolResults.RESULT_ERROR;
import static org.apache.maven.plugins.jarsigner.TestJavaToolResults.RESULT_OK;
-import static org.hamcrest.CoreMatchers.containsString;
-import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;
@@ -204,7 +202,7 @@ public class JarsignerSignMojoParallelTest {
mojo.execute();
});
- assertThat(mojoException.getMessage(), containsString(String.valueOf("Failed executing 'jarsigner ")));
+ assertTrue(mojoException.getMessage().contains("Failed executing 'jarsigner "));
Locale.setDefault(orginalLocale);
}
diff --git a/src/test/java/org/apache/maven/plugins/jarsigner/JarsignerSignMojoRetryTest.java b/src/test/java/org/apache/maven/plugins/jarsigner/JarsignerSignMojoRetryTest.java
index f5b2d21..68eb3a9 100644
--- a/src/test/java/org/apache/maven/plugins/jarsigner/JarsignerSignMojoRetryTest.java
+++ b/src/test/java/org/apache/maven/plugins/jarsigner/JarsignerSignMojoRetryTest.java
@@ -41,11 +41,10 @@ import org.junit.jupiter.api.io.TempDir;
import static org.apache.maven.plugins.jarsigner.TestJavaToolResults.RESULT_ERROR;
import static org.apache.maven.plugins.jarsigner.TestJavaToolResults.RESULT_OK;
-import static org.hamcrest.CoreMatchers.containsString;
-import static org.hamcrest.CoreMatchers.not;
-import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.contains;
import static org.mockito.Mockito.argThat;
@@ -267,7 +266,7 @@ public class JarsignerSignMojoRetryTest {
MojoExecutionException mojoException = assertThrows(MojoExecutionException.class, () -> {
mojo.waitAfterFailure(0, Duration.ofSeconds(10), iterruptedSleeper);
});
- assertThat(mojoException.getMessage(), containsString("interrupted while waiting after failure"));
+ assertTrue(mojoException.getMessage().contains("interrupted while waiting after failure"));
}
/** Check that the error returned from a re-try scenario where all execution fails is the "correct" error */
@@ -290,8 +289,8 @@ public class JarsignerSignMojoRetryTest {
});
// Make sure that the last error exit code is present
- assertThat(mojoException.getMessage(), containsString(String.valueOf(42)));
+ assertTrue(mojoException.getMessage().contains(String.valueOf(42)));
// Make sure that the first error exit code is not present
- assertThat(mojoException.getMessage(), not(containsString(String.valueOf(1))));
+ assertFalse(mojoException.getMessage().contains(String.valueOf(1)));
}
}
diff --git a/src/test/java/org/apache/maven/plugins/jarsigner/JarsignerSignMojoTest.java b/src/test/java/org/apache/maven/plugins/jarsigner/JarsignerSignMojoTest.java
index 5a4e796..7dabde7 100644
--- a/src/test/java/org/apache/maven/plugins/jarsigner/JarsignerSignMojoTest.java
+++ b/src/test/java/org/apache/maven/plugins/jarsigner/JarsignerSignMojoTest.java
@@ -40,21 +40,15 @@ import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.io.TempDir;
import org.mockito.ArgumentCaptor;
-import org.mockito.hamcrest.MockitoHamcrest;
import static org.apache.maven.plugins.jarsigner.TestJavaToolResults.RESULT_ERROR;
import static org.apache.maven.plugins.jarsigner.TestJavaToolResults.RESULT_OK;
-import static org.hamcrest.CoreMatchers.containsString;
-import static org.hamcrest.CoreMatchers.everyItem;
-import static org.hamcrest.CoreMatchers.hasItem;
-import static org.hamcrest.CoreMatchers.not;
-import static org.hamcrest.CoreMatchers.startsWith;
-import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertNull;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.mockito.ArgumentMatchers.argThat;
import static org.mockito.ArgumentMatchers.contains;
import static org.mockito.Mockito.any;
import static org.mockito.Mockito.mock;
@@ -116,7 +110,7 @@ public class JarsignerSignMojoTest {
assertNull(request.getProviderClass());
assertNull(request.getProviderArg());
assertNull(request.getMaxMemory());
- assertThat(request.getArguments()[0], startsWith("-J-Dfile.encoding="));
+ assertTrue(request.getArguments()[0].startsWith("-J-Dfile.encoding="));
assertEquals(projectDir, request.getWorkingDirectory());
assertEquals(mainArtifact.getFile(), request.getArchive());
assertFalse(request.isProtectedAuthenticationPath());
@@ -140,10 +134,10 @@ public class JarsignerSignMojoTest {
MojoExecutionException mojoException = assertThrows(MojoExecutionException.class, () -> {
mojo.execute();
});
- assertThat(mojoException.getMessage(), containsString(String.valueOf(RESULT_ERROR.getExitCode())));
- assertThat(
- mojoException.getMessage(),
- containsString(RESULT_ERROR.getCommandline().toString()));
+ assertTrue(mojoException.getMessage().contains(String.valueOf(RESULT_ERROR.getExitCode())));
+ assertTrue(mojoException
+ .getMessage()
+ .contains(RESULT_ERROR.getCommandline().toString()));
}
/** When JavaTool throws an exception on execute() (when executing jarsigner). */
@@ -157,7 +151,7 @@ public class JarsignerSignMojoTest {
MojoExecutionException mojoException = assertThrows(MojoExecutionException.class, () -> {
mojo.execute();
});
- assertThat(mojoException.getMessage(), containsString("test failure"));
+ assertTrue(mojoException.getMessage().contains("test failure"));
}
/** Standard POM project with nothing special configured */
@@ -210,8 +204,8 @@ public class JarsignerSignMojoTest {
mojo.execute();
// Make sure only the jar pointed by "archive" has been processed, but not the main artifact
- verify(jarSigner, never()).execute(MockitoHamcrest.argThat(RequestMatchers.hasFileName("my-project.jar")));
- verify(jarSigner).execute(MockitoHamcrest.argThat(RequestMatchers.hasFileName("archive.jar")));
+ verify(jarSigner, never()).execute(argThat(RequestMatchers.hasFileName("my-project.jar")));
+ verify(jarSigner).execute(argThat(RequestMatchers.hasFileName("archive.jar")));
}
/** Test that it is possible to disable processing of attached artifacts */
@@ -231,9 +225,8 @@ public class JarsignerSignMojoTest {
mojo.execute();
// Make sure that only the main artifact has been processed, but not the attached artifact
- verify(jarSigner).execute(MockitoHamcrest.argThat(RequestMatchers.hasFileName("my-project.jar")));
- verify(jarSigner, never())
- .execute(MockitoHamcrest.argThat(RequestMatchers.hasFileName("my-project-sources.jar")));
+ verify(jarSigner).execute(argThat(RequestMatchers.hasFileName("my-project.jar")));
+ verify(jarSigner, never()).execute(argThat(RequestMatchers.hasFileName("my-project-sources.jar")));
}
/** A Java project with 3 types of artifacts: main, javadoc and sources */
@@ -254,9 +247,9 @@ public class JarsignerSignMojoTest {
verify(jarSigner, times(3)).execute(requestArgument.capture());
List<JarSignerSignRequest> requests = requestArgument.getAllValues();
- assertThat(requests, hasItem(RequestMatchers.hasFileName("my-project.jar")));
- assertThat(requests, hasItem(RequestMatchers.hasFileName("my-project-sources.jar")));
- assertThat(requests, hasItem(RequestMatchers.hasFileName("my-project-javadoc.jar")));
+ assertTrue(requests.stream().anyMatch(RequestMatchers.hasFileName("my-project.jar")::matches));
+ assertTrue(requests.stream().anyMatch(RequestMatchers.hasFileName("my-project-sources.jar")::matches));
+ assertTrue(requests.stream().anyMatch(RequestMatchers.hasFileName("my-project-javadoc.jar")::matches));
}
/**
@@ -332,36 +325,43 @@ public class JarsignerSignMojoTest {
verify(jarSigner, times(5)).execute(requestArgument.capture());
List<JarSignerSignRequest> requests = requestArgument.getAllValues();
- assertThat(requests, everyItem(RequestMatchers.hasAlias("myalias")));
-
- assertThat(requests, hasItem(RequestMatchers.hasFileName("archive1.jar")));
- assertThat(requests, hasItem(RequestMatchers.hasFileName("previously_signed_archive.jar")));
- assertThat(requests, hasItem(not(RequestMatchers.hasFileName("archive_to_exclude.jar"))));
- assertThat(requests, hasItem(not(RequestMatchers.hasFileName("not_this.par"))));
-
- assertThat(requests, hasItem(RequestMatchers.hasFileName("my-project.jar")));
- assertThat(requests, hasItem(RequestMatchers.hasFileName("my-project-sources.jar")));
- assertThat(requests, hasItem(RequestMatchers.hasFileName("my-project-javadoc.jar")));
- assertThat(requests, hasItem(not(RequestMatchers.hasFileName("my-project-included_and_excluded.jar"))));
- assertThat(requests, hasItem(not(RequestMatchers.hasFileName("my-project-excluded_classifier.jar"))));
-
- assertThat(
- requests, everyItem(RequestMatchers.hasArguments(new String[] {"jarsigner-arg1", "jarsigner-arg2"})));
- assertThat(requests, everyItem(RequestMatchers.hasCertchain("mycertchain")));
- assertThat(requests, everyItem(RequestMatchers.hasKeypass("mykeypass")));
- assertThat(requests, everyItem(RequestMatchers.hasKeystore("mykeystore")));
- assertThat(requests, everyItem(RequestMatchers.hasMaxMemory("mymaxmemory")));
- assertThat(requests, everyItem(RequestMatchers.hasProtectedAuthenticationPath(true)));
- assertThat(requests, everyItem(RequestMatchers.hasProviderArg("myproviderarg")));
- assertThat(requests, everyItem(RequestMatchers.hasProviderClass("myproviderclass")));
- assertThat(requests, everyItem(RequestMatchers.hasProviderName("myprovidername")));
+ assertTrue(requests.stream().allMatch(RequestMatchers.hasAlias("myalias")::matches));
+
+ assertTrue(requests.stream().anyMatch(RequestMatchers.hasFileName("archive1.jar")::matches));
+ assertTrue(requests.stream().anyMatch(RequestMatchers.hasFileName("previously_signed_archive.jar")::matches));
+ assertTrue(requests.stream()
+ .anyMatch(r ->
+ !RequestMatchers.hasFileName("archive_to_exclude.jar").matches(r)));
+ assertTrue(requests.stream()
+ .anyMatch(r -> !RequestMatchers.hasFileName("not_this.par").matches(r)));
+
+ assertTrue(requests.stream().anyMatch(RequestMatchers.hasFileName("my-project.jar")::matches));
+ assertTrue(requests.stream().anyMatch(RequestMatchers.hasFileName("my-project-sources.jar")::matches));
+ assertTrue(requests.stream().anyMatch(RequestMatchers.hasFileName("my-project-javadoc.jar")::matches));
+ assertTrue(requests.stream()
+ .anyMatch(r -> !RequestMatchers.hasFileName("my-project-included_and_excluded.jar")
+ .matches(r)));
+ assertTrue(requests.stream()
+ .anyMatch(r -> !RequestMatchers.hasFileName("my-project-excluded_classifier.jar")
+ .matches(r)));
+
+ assertTrue(requests.stream()
+ .allMatch(RequestMatchers.hasArguments(new String[] {"jarsigner-arg1", "jarsigner-arg2"})::matches));
+ assertTrue(requests.stream().allMatch(RequestMatchers.hasCertchain("mycertchain")::matches));
+ assertTrue(requests.stream().allMatch(RequestMatchers.hasKeypass("mykeypass")::matches));
+ assertTrue(requests.stream().allMatch(RequestMatchers.hasKeystore("mykeystore")::matches));
+ assertTrue(requests.stream().allMatch(RequestMatchers.hasMaxMemory("mymaxmemory")::matches));
+ assertTrue(requests.stream().allMatch(RequestMatchers.hasProtectedAuthenticationPath(true)::matches));
+ assertTrue(requests.stream().allMatch(RequestMatchers.hasProviderArg("myproviderarg")::matches));
+ assertTrue(requests.stream().allMatch(RequestMatchers.hasProviderClass("myproviderclass")::matches));
+ assertTrue(requests.stream().allMatch(RequestMatchers.hasProviderName("myprovidername")::matches));
assertFalse(JarSignerUtil.isArchiveSigned(previouslySignedArchive)); // Make sure previous signing is gone
- assertThat(requests, everyItem(RequestMatchers.hasSigfile("mysigfile")));
- assertThat(requests, everyItem(RequestMatchers.hasStorepass("mystorepass")));
- assertThat(requests, everyItem(RequestMatchers.hasStoretype("mystoretype")));
- assertThat(requests, everyItem(RequestMatchers.hasTsa("mytsa")));
- assertThat(requests, everyItem(RequestMatchers.hasTsacert("mytsacert")));
- assertThat(requests, everyItem(RequestMatchers.hasVerbose(true)));
+ assertTrue(requests.stream().allMatch(RequestMatchers.hasSigfile("mysigfile")::matches));
+ assertTrue(requests.stream().allMatch(RequestMatchers.hasStorepass("mystorepass")::matches));
+ assertTrue(requests.stream().allMatch(RequestMatchers.hasStoretype("mystoretype")::matches));
+ assertTrue(requests.stream().allMatch(RequestMatchers.hasTsa("mytsa")::matches));
+ assertTrue(requests.stream().allMatch(RequestMatchers.hasTsacert("mytsacert")::matches));
+ assertTrue(requests.stream().allMatch(RequestMatchers.hasVerbose(true)::matches));
}
/** Make sure that if a custom ToolchainManager is set on the Mojo, it is used by jarSigner */
@@ -398,8 +398,8 @@ public class JarsignerSignMojoTest {
mojo.execute();
- verify(jarSigner).execute(MockitoHamcrest.argThat(RequestMatchers.hasKeypass("mykeypass")));
- verify(jarSigner).execute(MockitoHamcrest.argThat(RequestMatchers.hasStorepass("mystorepass")));
+ verify(jarSigner).execute(argThat(RequestMatchers.hasKeypass("mykeypass")));
+ verify(jarSigner).execute(argThat(RequestMatchers.hasStorepass("mystorepass")));
}
/** Make sure that a customer file encoding to jarsigner can be set and that it does not get duplicated */
@@ -414,7 +414,7 @@ public class JarsignerSignMojoTest {
mojo.execute();
verify(jarSigner)
- .execute(MockitoHamcrest.argThat(
+ .execute(argThat(
RequestMatchers.hasArguments(new String[] {"-J-Dfile.encoding=ISO-8859-1", "argument2"})));
}
diff --git a/src/test/java/org/apache/maven/plugins/jarsigner/JarsignerSignMojoTsaTest.java b/src/test/java/org/apache/maven/plugins/jarsigner/JarsignerSignMojoTsaTest.java
index fe79617..aed7843 100644
--- a/src/test/java/org/apache/maven/plugins/jarsigner/JarsignerSignMojoTsaTest.java
+++ b/src/test/java/org/apache/maven/plugins/jarsigner/JarsignerSignMojoTsaTest.java
@@ -39,9 +39,8 @@ import org.mockito.ArgumentCaptor;
import static org.apache.maven.plugins.jarsigner.TestJavaToolResults.RESULT_ERROR;
import static org.apache.maven.plugins.jarsigner.TestJavaToolResults.RESULT_OK;
-import static org.hamcrest.CoreMatchers.everyItem;
-import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.contains;
import static org.mockito.Mockito.mock;
@@ -97,10 +96,10 @@ public class JarsignerSignMojoTsaTest {
ArgumentCaptor<JarSignerSignRequest> requestArgument = ArgumentCaptor.forClass(JarSignerSignRequest.class);
verify(jarSigner, times(3)).execute(requestArgument.capture());
List<JarSignerSignRequest> requests = requestArgument.getAllValues();
- assertThat(requests, everyItem(RequestMatchers.hasTsa("http://my-timestamp.server.com")));
- assertThat(requests, everyItem(RequestMatchers.hasTsacert("mytsacertalias")));
- assertThat(requests, everyItem(RequestMatchers.hasTsaPolicyid("0.1.2.3.4")));
- assertThat(requests, everyItem(RequestMatchers.hasTsaDigestalg("SHA-384")));
+ assertTrue(requests.stream().allMatch(RequestMatchers.hasTsa("http://my-timestamp.server.com")::matches));
+ assertTrue(requests.stream().allMatch(RequestMatchers.hasTsacert("mytsacertalias")::matches));
+ assertTrue(requests.stream().allMatch(RequestMatchers.hasTsaPolicyid("0.1.2.3.4")::matches));
+ assertTrue(requests.stream().allMatch(RequestMatchers.hasTsaDigestalg("SHA-384")::matches));
}
@Test
diff --git a/src/test/java/org/apache/maven/plugins/jarsigner/JarsignerVerifyMojoTest.java b/src/test/java/org/apache/maven/plugins/jarsigner/JarsignerVerifyMojoTest.java
index 15b6497..8a65ffa 100644
--- a/src/test/java/org/apache/maven/plugins/jarsigner/JarsignerVerifyMojoTest.java
+++ b/src/test/java/org/apache/maven/plugins/jarsigner/JarsignerVerifyMojoTest.java
@@ -32,17 +32,14 @@ import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.io.TempDir;
import org.mockito.ArgumentCaptor;
-import org.mockito.hamcrest.MockitoHamcrest;
import static org.apache.maven.plugins.jarsigner.TestJavaToolResults.RESULT_ERROR;
import static org.apache.maven.plugins.jarsigner.TestJavaToolResults.RESULT_OK;
-import static org.hamcrest.CoreMatchers.containsString;
-import static org.hamcrest.CoreMatchers.startsWith;
-import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertNull;
import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.argThat;
import static org.mockito.Mockito.mock;
@@ -94,7 +91,7 @@ public class JarsignerVerifyMojoTest {
assertNull(request.getProviderClass());
assertNull(request.getProviderArg());
assertNull(request.getMaxMemory());
- assertThat(request.getArguments()[0], startsWith("-J-Dfile.encoding="));
+ assertTrue(request.getArguments()[0].startsWith("-J-Dfile.encoding="));
assertEquals(dummyMavenProjectDir, request.getWorkingDirectory());
assertEquals(mainArtifact.getFile(), request.getArchive());
assertFalse(request.isProtectedAuthenticationPath());
@@ -127,10 +124,10 @@ public class JarsignerVerifyMojoTest {
MojoExecutionException mojoException = assertThrows(MojoExecutionException.class, () -> {
mojo.execute();
});
- assertThat(mojoException.getMessage(), containsString(String.valueOf(RESULT_ERROR.getExitCode())));
- assertThat(
- mojoException.getMessage(),
- containsString(RESULT_ERROR.getCommandline().toString()));
+ assertTrue(mojoException.getMessage().contains(String.valueOf(RESULT_ERROR.getExitCode())));
+ assertTrue(mojoException
+ .getMessage()
+ .contains(RESULT_ERROR.getCommandline().toString()));
}
/** When setting errorWhenNotSigned, for file that has existing signing (should not fail) */
@@ -146,7 +143,7 @@ public class JarsignerVerifyMojoTest {
mojo.execute();
- verify(jarSigner).execute(MockitoHamcrest.argThat(RequestMatchers.hasFileName("my-project.jar")));
+ verify(jarSigner).execute(argThat(RequestMatchers.hasFileName("my-project.jar")));
}
/** When setting errorWhenNotSigned, for file that does not have existing signing (should fail) */
@@ -162,8 +159,6 @@ public class JarsignerVerifyMojoTest {
MojoExecutionException mojoException = assertThrows(MojoExecutionException.class, () -> {
mojo.execute();
});
- assertThat(
- mojoException.getMessage(),
- containsString(mainArtifact.getFile().getPath()));
+ assertTrue(mojoException.getMessage().contains(mainArtifact.getFile().getPath()));
}
}
diff --git a/src/test/java/org/apache/maven/plugins/jarsigner/RequestMatchers.java b/src/test/java/org/apache/maven/plugins/jarsigner/RequestMatchers.java
index be53d11..6334f9a 100644
--- a/src/test/java/org/apache/maven/plugins/jarsigner/RequestMatchers.java
+++ b/src/test/java/org/apache/maven/plugins/jarsigner/RequestMatchers.java
@@ -24,17 +24,16 @@ import java.util.function.Predicate;
import org.apache.maven.shared.jarsigner.AbstractJarSignerRequest;
import org.apache.maven.shared.jarsigner.JarSignerSignRequest;
-import org.hamcrest.Description;
-import org.hamcrest.TypeSafeMatcher;
+import org.mockito.ArgumentMatcher;
/**
- * Hamcrest matcher(s) to match properties on a JarSignerRequest request instances
+ * Mockito {@link ArgumentMatcher} factories to match properties on a JarSignerRequest request instances
*/
class RequestMatchers {
/** Matcher for parameters common for JarSignerRequest instances */
private static class AbstractJarSignerRequestMatcher<T extends AbstractJarSignerRequest>
- extends TypeSafeMatcher<T> {
+ implements ArgumentMatcher<T> {
private final String predicateDescription;
private final Object value;
private final Predicate<AbstractJarSignerRequest> predicate;
@@ -47,21 +46,18 @@ class RequestMatchers {
}
@Override
- protected boolean matchesSafely(AbstractJarSignerRequest request) {
+ public boolean matches(T request) {
return predicate.test(request);
}
@Override
- public void describeTo(Description description) {
- description
- .appendText("request that ")
- .appendText(predicateDescription)
- .appendValue(value);
+ public String toString() {
+ return "request that " + predicateDescription + value;
}
}
/** Matcher for parameters specific to JarSignerSignRequest instances */
- private static class JarSignerSignRequestMatcher extends TypeSafeMatcher<JarSignerSignRequest> {
+ private static class JarSignerSignRequestMatcher implements ArgumentMatcher<JarSignerSignRequest> {
private final String predicateDescription;
private final Object value;
private final Predicate<JarSignerSignRequest> predicate;
@@ -74,33 +70,30 @@ class RequestMatchers {
}
@Override
- protected boolean matchesSafely(JarSignerSignRequest request) {
+ public boolean matches(JarSignerSignRequest request) {
return predicate.test(request);
}
@Override
- public void describeTo(Description description) {
- description
- .appendText("request that ")
- .appendText(predicateDescription)
- .appendValue(value);
+ public String toString() {
+ return "request that " + predicateDescription + value;
}
}
/** Create a matcher that matches when the request is using a specific file name for the archive */
- static <T extends AbstractJarSignerRequest> TypeSafeMatcher<T> hasFileName(String expectedFileName) {
+ static <T extends AbstractJarSignerRequest> ArgumentMatcher<T> hasFileName(String expectedFileName) {
return new AbstractJarSignerRequestMatcher<T>(
"has archive file name ",
expectedFileName,
request -> request.getArchive().getPath().endsWith(expectedFileName));
}
- static <T extends AbstractJarSignerRequest> TypeSafeMatcher<T> hasAlias(String alias) {
+ static <T extends AbstractJarSignerRequest> ArgumentMatcher<T> hasAlias(String alias) {
return new AbstractJarSignerRequestMatcher<T>(
"has alias ", alias, request -> request.getAlias().equals(alias));
}
- static <T extends AbstractJarSignerRequest> TypeSafeMatcher<T> hasArguments(String[] arguments) {
+ static <T extends AbstractJarSignerRequest> ArgumentMatcher<T> hasArguments(String[] arguments) {
return new AbstractJarSignerRequestMatcher<T>("has arguments ", arguments, request -> {
List<String> haystack = Arrays.asList(request.getArguments());
for (String argumentNeedle : arguments) {
@@ -112,17 +105,17 @@ class RequestMatchers {
});
}
- static <T extends AbstractJarSignerRequest> TypeSafeMatcher<T> hasKeystore(String keystore) {
+ static <T extends AbstractJarSignerRequest> ArgumentMatcher<T> hasKeystore(String keystore) {
return new AbstractJarSignerRequestMatcher<T>(
"has keystore ", keystore, request -> request.getKeystore().equals(keystore));
}
- static <T extends AbstractJarSignerRequest> TypeSafeMatcher<T> hasMaxMemory(String maxMemory) {
+ static <T extends AbstractJarSignerRequest> ArgumentMatcher<T> hasMaxMemory(String maxMemory) {
return new AbstractJarSignerRequestMatcher<T>(
"has maxMemory ", maxMemory, request -> request.getMaxMemory().equals(maxMemory));
}
- static <T extends AbstractJarSignerRequest> TypeSafeMatcher<T> hasProtectedAuthenticationPath(
+ static <T extends AbstractJarSignerRequest> ArgumentMatcher<T> hasProtectedAuthenticationPath(
boolean protectedAuthenticationPath) {
return new AbstractJarSignerRequestMatcher<T>(
"has protectedAuthenticationPath ",
@@ -130,79 +123,79 @@ class RequestMatchers {
request -> request.isProtectedAuthenticationPath() == protectedAuthenticationPath);
}
- static <T extends AbstractJarSignerRequest> TypeSafeMatcher<T> hasProviderArg(String providerArg) {
+ static <T extends AbstractJarSignerRequest> ArgumentMatcher<T> hasProviderArg(String providerArg) {
return new AbstractJarSignerRequestMatcher<T>(
"has providerArg ",
providerArg,
request -> request.getProviderArg().equals(providerArg));
}
- static <T extends AbstractJarSignerRequest> TypeSafeMatcher<T> hasProviderClass(String providerClass) {
+ static <T extends AbstractJarSignerRequest> ArgumentMatcher<T> hasProviderClass(String providerClass) {
return new AbstractJarSignerRequestMatcher<T>(
"has providerClass ",
providerClass,
request -> request.getProviderClass().equals(providerClass));
}
- static <T extends AbstractJarSignerRequest> TypeSafeMatcher<T> hasProviderName(String providerName) {
+ static <T extends AbstractJarSignerRequest> ArgumentMatcher<T> hasProviderName(String providerName) {
return new AbstractJarSignerRequestMatcher<T>(
"has providerName ",
providerName,
request -> request.getProviderName().equals(providerName));
}
- static <T extends AbstractJarSignerRequest> TypeSafeMatcher<T> hasStorepass(String storepass) {
+ static <T extends AbstractJarSignerRequest> ArgumentMatcher<T> hasStorepass(String storepass) {
return new AbstractJarSignerRequestMatcher<T>(
"has storepass ", storepass, request -> request.getStorepass().equals(storepass));
}
- static <T extends AbstractJarSignerRequest> TypeSafeMatcher<T> hasStoretype(String storetype) {
+ static <T extends AbstractJarSignerRequest> ArgumentMatcher<T> hasStoretype(String storetype) {
return new AbstractJarSignerRequestMatcher<T>(
"has storetype ", storetype, request -> request.getStoretype().equals(storetype));
}
- static <T extends AbstractJarSignerRequest> TypeSafeMatcher<T> hasVerbose(boolean verbose) {
+ static <T extends AbstractJarSignerRequest> ArgumentMatcher<T> hasVerbose(boolean verbose) {
return new AbstractJarSignerRequestMatcher<T>(
"has verbose ", verbose, request -> request.isVerbose() == verbose);
}
/* ************************************ JarSignerSignRequest specific matchers ************************************/
- static TypeSafeMatcher<JarSignerSignRequest> hasKeypass(String keypass) {
+ static ArgumentMatcher<JarSignerSignRequest> hasKeypass(String keypass) {
return new JarSignerSignRequestMatcher(
"has keypass ", keypass, request -> request.getKeypass().equals(keypass));
}
- static TypeSafeMatcher<JarSignerSignRequest> hasSigfile(String sigfile) {
+ static ArgumentMatcher<JarSignerSignRequest> hasSigfile(String sigfile) {
return new JarSignerSignRequestMatcher(
"has sigfile ", sigfile, request -> request.getSigfile().equals(sigfile));
}
- static TypeSafeMatcher<JarSignerSignRequest> hasTsa(String tsa) {
+ static ArgumentMatcher<JarSignerSignRequest> hasTsa(String tsa) {
return new JarSignerSignRequestMatcher(
"has tsa ", tsa, request -> request.getTsaLocation().equals(tsa));
}
- static TypeSafeMatcher<JarSignerSignRequest> hasTsacert(String tsacert) {
+ static ArgumentMatcher<JarSignerSignRequest> hasTsacert(String tsacert) {
return new JarSignerSignRequestMatcher(
"has tsacert ", tsacert, request -> request.getTsaAlias().equals(tsacert));
}
- static TypeSafeMatcher<JarSignerSignRequest> hasTsaPolicyid(String tsapolicyid) {
+ static ArgumentMatcher<JarSignerSignRequest> hasTsaPolicyid(String tsapolicyid) {
return new JarSignerSignRequestMatcher(
"has tsapolicyid ",
tsapolicyid,
request -> request.getTsapolicyid().equals(tsapolicyid));
}
- static TypeSafeMatcher<JarSignerSignRequest> hasTsaDigestalg(String tsadigestalg) {
+ static ArgumentMatcher<JarSignerSignRequest> hasTsaDigestalg(String tsadigestalg) {
return new JarSignerSignRequestMatcher(
"has tsadigestalg ",
tsadigestalg,
request -> request.getTsadigestalg().equals(tsadigestalg));
}
- static TypeSafeMatcher<JarSignerSignRequest> hasCertchain(String certchain) {
+ static ArgumentMatcher<JarSignerSignRequest> hasCertchain(String certchain) {
return new JarSignerSignRequestMatcher(
"has certchain ",
certchain,