This is an automated email from the ASF dual-hosted git repository.

slachiewicz pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/maven-dependency-analyzer.git


The following commit(s) were added to refs/heads/master by this push:
     new d10def8  Migrate tests from AssertJ to JUnit 5 assertions
d10def8 is described below

commit d10def87145a1e752d8ee452739f7f6fd870cc06
Author: Sylwester Lachiewicz <[email protected]>
AuthorDate: Thu Nov 19 12:51:08 2026 +0100

    Migrate tests from AssertJ to JUnit 5 assertions
---
 pom.xml                                            |  16 --
 .../analyzer/ClassFileVisitorUtilsTest.java        |  29 ++--
 .../analyzer/CollectorClassFileVisitorTest.java    |   9 +-
 .../analyzer/DefaultClassAnalyzerTest.java         |  12 +-
 .../DefaultProjectDependencyAnalyzerTest.java      | 138 +++++++++--------
 .../analyzer/ProjectDependencyAnalysisTest.java    |  40 ++---
 .../ProjectDependencyAnalyzerExceptionTest.java    |   8 +-
 .../analyzer/asm/ASMDependencyAnalyzerTest.java    |  19 +--
 .../analyzer/asm/DependencyVisitorTest.java        | 170 ++++++++++++---------
 .../analyzer/asm/ResultCollectorTest.java          |  30 ++--
 .../DefaultMainDependencyClassesProviderTest.java  |   4 +-
 .../DefaultTestDependencyClassesProviderTest.java  |   4 +-
 .../WarMainDependencyClassesProviderTest.java      |  18 ++-
 13 files changed, 268 insertions(+), 229 deletions(-)

diff --git a/pom.xml b/pom.xml
index bddb901..a030b75 100644
--- a/pom.xml
+++ b/pom.xml
@@ -62,17 +62,6 @@
     
<project.build.outputTimestamp>2026-09-05T18:06:14Z</project.build.outputTimestamp>
   </properties>
 
-  <dependencyManagement>
-    <dependencies>
-      <dependency>
-        <groupId>org.assertj</groupId>
-        <artifactId>assertj-bom</artifactId>
-        <version>3.27.7</version>
-        <type>pom</type>
-        <scope>import</scope>
-      </dependency>
-    </dependencies>
-  </dependencyManagement>
   <dependencies>
 
     <dependency>
@@ -136,11 +125,6 @@
       <artifactId>junit-jupiter-params</artifactId>
       <scope>test</scope>
     </dependency>
-    <dependency>
-      <groupId>org.assertj</groupId>
-      <artifactId>assertj-core</artifactId>
-      <scope>test</scope>
-    </dependency>
     <dependency>
       <groupId>org.mockito</groupId>
       <artifactId>mockito-core</artifactId>
diff --git 
a/src/test/java/org/apache/maven/shared/dependency/analyzer/ClassFileVisitorUtilsTest.java
 
b/src/test/java/org/apache/maven/shared/dependency/analyzer/ClassFileVisitorUtilsTest.java
index fc93bbe..1fc8f86 100644
--- 
a/src/test/java/org/apache/maven/shared/dependency/analyzer/ClassFileVisitorUtilsTest.java
+++ 
b/src/test/java/org/apache/maven/shared/dependency/analyzer/ClassFileVisitorUtilsTest.java
@@ -34,8 +34,9 @@ import java.util.zip.ZipEntry;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.io.TempDir;
 
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.assertj.core.api.Assertions.fail;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.junit.jupiter.api.Assertions.fail;
 
 /**
  * Tests <code>ClassFileVisitorUtils</code>.
@@ -74,10 +75,10 @@ class ClassFileVisitorUtilsTest {
 
         ClassFileVisitorUtils.accept(path.toUri().toURL(), visitor);
 
-        assertThat(visitor.classNames).contains("a.b.c");
-        assertThat(visitor.classNames).contains("x.y.z");
-        assertThat(visitor.data).contains("class a.b.c");
-        assertThat(visitor.data).contains("class x.y.z");
+        assertTrue(visitor.classNames.contains("a.b.c"));
+        assertTrue(visitor.classNames.contains("x.y.z"));
+        assertTrue(visitor.data.contains("class a.b.c"));
+        assertTrue(visitor.data.contains("class x.y.z"));
     }
 
     @Test
@@ -90,7 +91,7 @@ class ClassFileVisitorUtilsTest {
 
         ClassFileVisitorUtils.accept(path.toUri().toURL(), visitor);
 
-        assertThat(visitor.classNames).isEmpty();
+        assertTrue(visitor.classNames.isEmpty());
     }
 
     @Test
@@ -105,10 +106,10 @@ class ClassFileVisitorUtilsTest {
 
         ClassFileVisitorUtils.accept(dir.toUri().toURL(), visitor);
 
-        assertThat(visitor.classNames).contains("a.b.c");
-        assertThat(visitor.classNames).contains("x.y.z");
-        assertThat(visitor.data).contains("class a.b.c");
-        assertThat(visitor.data).contains("class x.y.z");
+        assertTrue(visitor.classNames.contains("a.b.c"));
+        assertTrue(visitor.classNames.contains("x.y.z"));
+        assertTrue(visitor.data.contains("class a.b.c"));
+        assertTrue(visitor.data.contains("class x.y.z"));
     }
 
     @Test
@@ -120,7 +121,7 @@ class ClassFileVisitorUtilsTest {
 
         ClassFileVisitorUtils.accept(dir.toUri().toURL(), visitor);
 
-        assertThat(visitor.classNames).isEmpty();
+        assertTrue(visitor.classNames.isEmpty());
     }
 
     @Test
@@ -132,7 +133,7 @@ class ClassFileVisitorUtilsTest {
             ClassFileVisitorUtils.accept(url, visitor);
             fail("expected IllegalArgumentException");
         } catch (IllegalArgumentException exception) {
-            assertThat(exception).hasMessage("Cannot accept visitor on URL: " 
+ url);
+            assertEquals("Cannot accept visitor on URL: " + url, 
exception.getMessage());
         }
     }
 
@@ -144,7 +145,7 @@ class ClassFileVisitorUtilsTest {
             ClassFileVisitorUtils.accept(url, visitor);
             fail("expected IllegalArgumentException");
         } catch (IllegalArgumentException exception) {
-            assertThat(exception).hasMessage("Cannot accept visitor on URL: " 
+ url);
+            assertEquals("Cannot accept visitor on URL: " + url, 
exception.getMessage());
         }
     }
 
diff --git 
a/src/test/java/org/apache/maven/shared/dependency/analyzer/CollectorClassFileVisitorTest.java
 
b/src/test/java/org/apache/maven/shared/dependency/analyzer/CollectorClassFileVisitorTest.java
index 015dfc8..260ff60 100644
--- 
a/src/test/java/org/apache/maven/shared/dependency/analyzer/CollectorClassFileVisitorTest.java
+++ 
b/src/test/java/org/apache/maven/shared/dependency/analyzer/CollectorClassFileVisitorTest.java
@@ -18,13 +18,14 @@
  */
 package org.apache.maven.shared.dependency.analyzer;
 
+import java.util.Arrays;
 import java.util.HashSet;
 import java.util.Set;
 
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 
-import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertEquals;
 
 /**
  * Tests <code>CollectorClassFileVisitor</code>.
@@ -49,7 +50,7 @@ class CollectorClassFileVisitorTest {
         expected.add("a.b.c");
         expected.add("x.y.z");
 
-        assertThat(visitor.getClasses()).isEqualTo(expected);
+        assertEquals(expected, visitor.getClasses());
     }
 
     @Test
@@ -57,6 +58,8 @@ class CollectorClassFileVisitorTest {
         visitor.visitClass("a.b.Outer$Inner", null);
         visitor.visitClass("x.y.Outer$Inner$Nested", null);
 
-        
assertThat(visitor.getClasses()).containsExactlyInAnyOrder("a.b.Outer$Inner", 
"x.y.Outer$Inner$Nested");
+        assertEquals(
+                new HashSet<>(Arrays.asList("a.b.Outer$Inner", 
"x.y.Outer$Inner$Nested")),
+                new HashSet<>(visitor.getClasses()));
     }
 }
diff --git 
a/src/test/java/org/apache/maven/shared/dependency/analyzer/DefaultClassAnalyzerTest.java
 
b/src/test/java/org/apache/maven/shared/dependency/analyzer/DefaultClassAnalyzerTest.java
index d794eda..cd762e8 100644
--- 
a/src/test/java/org/apache/maven/shared/dependency/analyzer/DefaultClassAnalyzerTest.java
+++ 
b/src/test/java/org/apache/maven/shared/dependency/analyzer/DefaultClassAnalyzerTest.java
@@ -35,8 +35,10 @@ import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.io.TempDir;
 
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.assertj.core.api.Assertions.fail;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertIterableEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.junit.jupiter.api.Assertions.fail;
 
 /**
  * Tests <code>DefaultClassAnalyzer</code>.
@@ -69,7 +71,7 @@ class DefaultClassAnalyzerTest {
         DefaultClassAnalyzer analyzer = new DefaultClassAnalyzer();
         Set<String> actualClasses = analyzer.analyze(file.toUri().toURL());
 
-        assertThat(actualClasses).isEqualTo(expectedClasses);
+        assertEquals(expectedClasses, actualClasses);
     }
 
     @Test
@@ -88,7 +90,7 @@ class DefaultClassAnalyzerTest {
             analyzer.analyze(file.toUri().toURL());
             fail("Exception expected");
         } catch (ZipException e) {
-            assertThat(e).hasMessageStartingWith("Cannot process Jar entry on 
URL:");
+            assertTrue(e.getMessage().startsWith("Cannot process Jar entry on 
URL:"));
         }
     }
 
@@ -103,7 +105,7 @@ class DefaultClassAnalyzerTest {
                 tempDir.resolve("classes").toUri().toURL(),
                 new 
ClassesPatterns(Collections.singleton("library\\.Outer\\$Inner")));
 
-        assertThat(actualClasses).containsExactly("library.Dollar$Class");
+        
assertIterableEquals(Collections.singletonList("library.Dollar$Class"), 
actualClasses);
     }
 
     private void addZipEntry(JarOutputStream out, String fileName, String 
content) throws IOException {
diff --git 
a/src/test/java/org/apache/maven/shared/dependency/analyzer/DefaultProjectDependencyAnalyzerTest.java
 
b/src/test/java/org/apache/maven/shared/dependency/analyzer/DefaultProjectDependencyAnalyzerTest.java
index c56730a..76eedbb 100644
--- 
a/src/test/java/org/apache/maven/shared/dependency/analyzer/DefaultProjectDependencyAnalyzerTest.java
+++ 
b/src/test/java/org/apache/maven/shared/dependency/analyzer/DefaultProjectDependencyAnalyzerTest.java
@@ -52,7 +52,12 @@ import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 import org.mockito.ArgumentCaptor;
 
-import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertIterableEquals;
+import static org.junit.jupiter.api.Assertions.assertNotSame;
+import static org.junit.jupiter.api.Assertions.assertSame;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.ArgumentMatchers.anyString;
 import static org.mockito.ArgumentMatchers.eq;
@@ -97,9 +102,9 @@ class DefaultProjectDependencyAnalyzerTest {
 
         Map<String, Artifact> result = 
DefaultProjectDependencyAnalyzer.buildClassToArtifactMap(artifactClassMap);
 
-        assertThat(result).hasSize(2);
-        assertThat(result.get("class1")).isEqualTo(artifact1);
-        assertThat(result.get("class2")).isEqualTo(artifact2);
+        assertEquals(2, result.size());
+        assertEquals(artifact1, result.get("class1"));
+        assertEquals(artifact2, result.get("class2"));
     }
 
     @Test
@@ -113,9 +118,9 @@ class DefaultProjectDependencyAnalyzerTest {
 
         Map<String, Artifact> result = 
DefaultProjectDependencyAnalyzer.buildClassToArtifactMap(artifactClassMap);
 
-        assertThat(result).hasSize(1);
+        assertEquals(1, result.size());
         // Should favor the first artifact encountered
-        assertThat(result.get("duplicateClass")).isEqualTo(artifact1);
+        assertEquals(artifact1, result.get("duplicateClass"));
     }
 
     @Test
@@ -130,9 +135,9 @@ class DefaultProjectDependencyAnalyzerTest {
         Map<String, Artifact> result = 
DefaultProjectDependencyAnalyzer.buildClassToArtifactMap(
                 artifactClassMap, Collections.singleton(declared));
 
-        assertThat(result).hasSize(2);
-        assertThat(result.get("duplicateClass")).isEqualTo(declared);
-        assertThat(result.get("otherClass")).isEqualTo(undeclared);
+        assertEquals(2, result.size());
+        assertEquals(declared, result.get("duplicateClass"));
+        assertEquals(undeclared, result.get("otherClass"));
     }
 
     @Test
@@ -148,7 +153,7 @@ class DefaultProjectDependencyAnalyzerTest {
         Map<String, Artifact> result = 
DefaultProjectDependencyAnalyzer.buildClassToArtifactMap(
                 artifactClassMap, Collections.singleton(declaredButAbsent));
 
-        assertThat(result.get("duplicateClass")).isEqualTo(artifact1);
+        assertEquals(artifact1, result.get("duplicateClass"));
     }
 
     @Test
@@ -165,7 +170,7 @@ class DefaultProjectDependencyAnalyzerTest {
         Map<Artifact, Set<DependencyUsage>> used = 
DefaultProjectDependencyAnalyzer.buildUsedArtifacts(
                 classToArtifactMap, Collections.singleton(new 
DependencyUsage("Xpp3Dom", "Main")));
 
-        assertThat(used.keySet()).containsExactly(plexusXml);
+        assertIterableEquals(Collections.singletonList(plexusXml), 
used.keySet());
     }
 
     @Test
@@ -185,8 +190,8 @@ class DefaultProjectDependencyAnalyzerTest {
         DefaultProjectDependencyAnalyzer.creditClasslessAggregators(
                 artifactClassMap, Collections.singleton(jupiter), used);
 
-        assertThat(used.keySet()).containsExactly(jupiter);
-        assertThat(used.get(jupiter)).hasSize(1);
+        assertIterableEquals(Collections.singletonList(jupiter), 
used.keySet());
+        assertEquals(1, used.get(jupiter).size());
     }
 
     @Test
@@ -201,7 +206,7 @@ class DefaultProjectDependencyAnalyzerTest {
         DefaultProjectDependencyAnalyzer.creditClasslessAggregators(
                 artifactClassMap, Collections.singleton(jupiter), used);
 
-        assertThat(used).isEmpty();
+        assertTrue(used.isEmpty());
     }
 
     @Test
@@ -221,7 +226,7 @@ class DefaultProjectDependencyAnalyzerTest {
         DefaultProjectDependencyAnalyzer.creditClasslessAggregators(
                 artifactClassMap, new HashSet<>(Arrays.asList(jupiter, api)), 
used);
 
-        assertThat(used.keySet()).containsExactlyInAnyOrder(jupiter, api);
+        assertEquals(new HashSet<>(Arrays.asList(jupiter, api)), new 
HashSet<>(used.keySet()));
     }
 
     @Test
@@ -240,7 +245,7 @@ class DefaultProjectDependencyAnalyzerTest {
 
         
DefaultProjectDependencyAnalyzer.creditClasslessAggregators(artifactClassMap, 
Collections.singleton(lib), used);
 
-        assertThat(used.keySet()).containsExactly(child);
+        assertIterableEquals(Collections.singletonList(child), used.keySet());
     }
 
     @Test
@@ -252,9 +257,9 @@ class DefaultProjectDependencyAnalyzerTest {
 
         Map<String, Artifact> result = 
DefaultProjectDependencyAnalyzer.buildClassToArtifactMap(artifactClassMap);
 
-        assertThat(result).hasSize(2);
-        assertThat(result.get("class1")).isEqualTo(artifact1);
-        assertThat(result.get("class2")).isEqualTo(artifact1);
+        assertEquals(2, result.size());
+        assertEquals(artifact1, result.get("class1"));
+        assertEquals(artifact1, result.get("class2"));
     }
 
     @Test
@@ -266,9 +271,9 @@ class DefaultProjectDependencyAnalyzerTest {
         Map<Artifact, Set<DependencyUsage>> result =
                 
DefaultProjectDependencyAnalyzer.buildUsedArtifacts(classToArtifactMap, 
dependencyClasses);
 
-        assertThat(result).hasSize(1);
-        assertThat(result.get(artifact1)).hasSize(1);
-        
assertThat(result.get(artifact1).iterator().next().getDependencyClass()).isEqualTo("class1");
+        assertEquals(1, result.size());
+        assertEquals(1, result.get(artifact1).size());
+        assertEquals("class1", 
result.get(artifact1).iterator().next().getDependencyClass());
     }
 
     @Test
@@ -281,8 +286,8 @@ class DefaultProjectDependencyAnalyzerTest {
         Map<Artifact, Set<DependencyUsage>> result =
                 
DefaultProjectDependencyAnalyzer.buildUsedArtifacts(classToArtifactMap, 
dependencyClasses);
 
-        assertThat(result).hasSize(1);
-        assertThat(result.get(artifact1)).hasSize(2);
+        assertEquals(1, result.size());
+        assertEquals(2, result.get(artifact1).size());
     }
 
     @Test
@@ -295,17 +300,14 @@ class DefaultProjectDependencyAnalyzerTest {
                 
DefaultProjectDependencyAnalyzer.buildUsedArtifacts(classToArtifactMap, 
dependencyClasses);
 
         // Being in JDK, it should be excluded from used artifacts
-        assertThat(result).isEmpty();
+        assertTrue(result.isEmpty());
     }
 
     @Test
     void testIncludedInJDK() {
-        
assertThat(DefaultProjectDependencyAnalyzer.includedInJDK(aTestArtifact("xml-apis",
 "xml-apis")))
-                .isTrue();
-        
assertThat(DefaultProjectDependencyAnalyzer.includedInJDK(aTestArtifact("xerces",
 "xmlParserAPIs")))
-                .isTrue();
-        
assertThat(DefaultProjectDependencyAnalyzer.includedInJDK(aTestArtifact("groupId",
 "artifactId")))
-                .isFalse();
+        
assertTrue(DefaultProjectDependencyAnalyzer.includedInJDK(aTestArtifact("xml-apis",
 "xml-apis")));
+        
assertTrue(DefaultProjectDependencyAnalyzer.includedInJDK(aTestArtifact("xerces",
 "xmlParserAPIs")));
+        
assertFalse(DefaultProjectDependencyAnalyzer.includedInJDK(aTestArtifact("groupId",
 "artifactId")));
     }
 
     @Test
@@ -316,10 +318,10 @@ class DefaultProjectDependencyAnalyzerTest {
         
project.setDependencies(Collections.singletonList(toDependency(direct)));
         project.setArtifacts(new LinkedHashSet<>(Arrays.asList(direct, 
transitive)));
 
-        
assertThat(DefaultProjectDependencyAnalyzer.buildDeclaredArtifacts(project, 
artifactHandlerManager))
-                .containsExactly(direct)
-                .first()
-                .isSameAs(direct);
+        Set<Artifact> declaredArtifacts =
+                
DefaultProjectDependencyAnalyzer.buildDeclaredArtifacts(project, 
artifactHandlerManager);
+        assertIterableEquals(Collections.singletonList(direct), 
declaredArtifacts);
+        assertSame(direct, declaredArtifacts.iterator().next());
     }
 
     @Test
@@ -341,8 +343,9 @@ class DefaultProjectDependencyAnalyzerTest {
         
when(artifactHandlerManager.getArtifactHandler("test-jar")).thenReturn(testJarHandler);
         when(testJarHandler.getClassifier()).thenReturn("tests");
 
-        
assertThat(DefaultProjectDependencyAnalyzer.buildDeclaredArtifacts(project, 
artifactHandlerManager))
-                .containsExactly(testJar);
+        assertIterableEquals(
+                Collections.singletonList(testJar),
+                
DefaultProjectDependencyAnalyzer.buildDeclaredArtifacts(project, 
artifactHandlerManager));
     }
 
     @Test
@@ -356,22 +359,23 @@ class DefaultProjectDependencyAnalyzerTest {
         Artifact relocated = aTestArtifact("org.apache.axis", "axis-ant");
         project.setArtifacts(Collections.singleton(relocated));
 
-        
assertThat(DefaultProjectDependencyAnalyzer.buildDeclaredArtifacts(project, 
artifactHandlerManager))
-                .singleElement()
-                .satisfies(artifact -> {
-                    assertThat(artifact.getGroupId()).isEqualTo("axis");
-                    assertThat(artifact.getArtifactId()).isEqualTo("axis-ant");
-                    assertThat(artifact.getVersion()).isEqualTo("1.4");
-                    assertThat(artifact).isNotSameAs(relocated);
-                });
+        Set<Artifact> declaredArtifacts =
+                
DefaultProjectDependencyAnalyzer.buildDeclaredArtifacts(project, 
artifactHandlerManager);
+        assertEquals(1, declaredArtifacts.size());
+        Artifact artifact = declaredArtifacts.iterator().next();
+        assertEquals("axis", artifact.getGroupId());
+        assertEquals("axis-ant", artifact.getArtifactId());
+        assertEquals("1.4", artifact.getVersion());
+        assertNotSame(relocated, artifact);
     }
 
     @Test
     void testRetainsTestOnlyCompileDependencyWithoutRepositorySession() {
         Artifact candidate = aTestArtifact("candidate");
 
-        assertThat(analyzer.getTestArtifactsWithNonTestScope(new 
MavenProject(), Collections.singleton(candidate)))
-                .containsExactly(candidate);
+        assertIterableEquals(
+                Collections.singletonList(candidate),
+                analyzer.getTestArtifactsWithNonTestScope(new MavenProject(), 
Collections.singleton(candidate)));
         verifyNoInteractions(repositorySystem);
     }
 
@@ -384,8 +388,9 @@ class DefaultProjectDependencyAnalyzerTest {
                 .thenReturn(dependencyGraph("candidate", "2.0"))
                 .thenThrow(new DependencyCollectionException(new 
CollectResult(failedRequest)));
 
-        assertThat(analyzer.getTestArtifactsWithNonTestScope(project, 
Collections.singleton(candidate)))
-                .containsExactly(candidate);
+        assertIterableEquals(
+                Collections.singletonList(candidate),
+                analyzer.getTestArtifactsWithNonTestScope(project, 
Collections.singleton(candidate)));
     }
 
     @Test
@@ -406,28 +411,30 @@ class DefaultProjectDependencyAnalyzerTest {
         project.setRemoteArtifactRepositories(Collections.singletonList(new 
MavenArtifactRepository(
                 "central", "https://repo.example.org";, new 
DefaultRepositoryLayout(), null, null)));
         List<RemoteRepository> remoteRepositories = 
project.getRemoteProjectRepositories();
-        assertThat(remoteRepositories).hasSize(1);
+        assertEquals(1, remoteRepositories.size());
 
         
when(repositorySystem.collectDependencies(any(RepositorySystemSession.class), 
any(CollectRequest.class)))
                 .thenReturn(dependencyGraph("compile-candidate", "2.0"), 
dependencyGraph("runtime-candidate", "2.0"));
 
         Set<Artifact> candidates = new 
LinkedHashSet<>(Arrays.asList(compileCandidate, runtimeCandidate));
-        assertThat(analyzer.getTestArtifactsWithNonTestScope(project, 
candidates))
-                .isEmpty();
+        assertTrue(
+                analyzer.getTestArtifactsWithNonTestScope(project, 
candidates).isEmpty());
 
         ArgumentCaptor<CollectRequest> requestCaptor = 
ArgumentCaptor.forClass(CollectRequest.class);
         verify(repositorySystem, times(2))
                 .collectDependencies(eq(mavenSession.getRepositorySession()), 
requestCaptor.capture());
         List<CollectRequest> requests = requestCaptor.getAllValues();
-        
assertThat(artifactIds(requests.get(0))).containsExactlyInAnyOrder("compile", 
"provided", "system");
-        
assertThat(artifactIds(requests.get(1))).containsExactlyInAnyOrder("compile", 
"runtime");
-        assertThat(requests).allSatisfy(request -> {
-            assertThat(request.getRequestContext()).isEqualTo("project");
-            
assertThat(request.getRepositories()).isEqualTo(remoteRepositories);
-            assertThat(request.getManagedDependencies())
-                    .extracting(d -> d.getArtifact().getArtifactId())
-                    .containsExactly("managed");
-        });
+        assertEquals(new HashSet<>(Arrays.asList("compile", "provided", 
"system")), artifactIds(requests.get(0)));
+        assertEquals(new HashSet<>(Arrays.asList("compile", "runtime")), 
artifactIds(requests.get(1)));
+        for (CollectRequest request : requests) {
+            assertEquals("project", request.getRequestContext());
+            assertEquals(remoteRepositories, request.getRepositories());
+            assertEquals(
+                    Collections.singletonList("managed"),
+                    request.getManagedDependencies().stream()
+                            .map(d -> d.getArtifact().getArtifactId())
+                            .collect(Collectors.toList()));
+        }
     }
 
     @Test
@@ -444,8 +451,9 @@ class DefaultProjectDependencyAnalyzerTest {
         
when(repositorySystem.collectDependencies(any(RepositorySystemSession.class), 
any(CollectRequest.class)))
                 .thenReturn(dependencyGraph("other", "1.0"));
 
-        assertThat(analyzer.getTestArtifactsWithNonTestScope(project, 
Collections.singleton(candidate)))
-                .containsExactly(candidate);
+        assertIterableEquals(
+                Collections.singletonList(candidate),
+                analyzer.getTestArtifactsWithNonTestScope(project, 
Collections.singleton(candidate)));
         verify(repositorySystem, times(2)).collectDependencies(eq(decorated), 
any(CollectRequest.class));
     }
 
@@ -512,7 +520,7 @@ class DefaultProjectDependencyAnalyzerTest {
         Map<String, Set<Artifact>> candidates =
                 
DefaultProjectDependencyAnalyzer.buildCandidateArtifactsByUsedClass(artifactClassMap,
 used);
 
-        assertThat(candidates.get("com.example.Cls")).containsExactly(first, 
second);
+        assertIterableEquals(Arrays.asList(first, second), 
candidates.get("com.example.Cls"));
     }
 
     @Test
@@ -530,6 +538,6 @@ class DefaultProjectDependencyAnalyzerTest {
         Map<String, Artifact> selected =
                 
DefaultProjectDependencyAnalyzer.buildSelectedArtifactByUsedClass(classToArtifactMap,
 used);
 
-        assertThat(selected.get("com.example.Cls")).isEqualTo(first);
+        assertEquals(first, selected.get("com.example.Cls"));
     }
 }
diff --git 
a/src/test/java/org/apache/maven/shared/dependency/analyzer/ProjectDependencyAnalysisTest.java
 
b/src/test/java/org/apache/maven/shared/dependency/analyzer/ProjectDependencyAnalysisTest.java
index d8deacd..d50e67d 100644
--- 
a/src/test/java/org/apache/maven/shared/dependency/analyzer/ProjectDependencyAnalysisTest.java
+++ 
b/src/test/java/org/apache/maven/shared/dependency/analyzer/ProjectDependencyAnalysisTest.java
@@ -30,7 +30,10 @@ import org.apache.maven.artifact.DefaultArtifact;
 import org.apache.maven.artifact.versioning.VersionRange;
 import org.junit.jupiter.api.Test;
 
-import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertIterableEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
 /**
  * Tests <code>ProjectDependencyAnalysis</code>.
@@ -49,9 +52,9 @@ class ProjectDependencyAnalysisTest {
         ProjectDependencyAnalysis analysis = new ProjectDependencyAnalysis(
                 usedDeclaredArtifacts, usedUndeclaredArtifacts, 
unusedDeclaredArtifacts, testArtifactsWithNonTestScope);
 
-        
assertThat(analysis.getUsedDeclaredArtifacts()).isEqualTo(usedDeclaredArtifacts);
-        
assertThat(analysis.getUsedUndeclaredArtifacts()).isEqualTo(usedUndeclaredArtifacts);
-        
assertThat(analysis.getUnusedDeclaredArtifacts()).isEqualTo(unusedDeclaredArtifacts);
+        assertEquals(usedDeclaredArtifacts, 
analysis.getUsedDeclaredArtifacts());
+        assertEquals(usedUndeclaredArtifacts, 
analysis.getUsedUndeclaredArtifacts());
+        assertEquals(unusedDeclaredArtifacts, 
analysis.getUnusedDeclaredArtifacts());
     }
 
     @Test
@@ -68,14 +71,15 @@ class ProjectDependencyAnalysisTest {
 
         ProjectDependencyAnalysis compileOnlyAnalysis = 
analysis.ignoreNonCompile();
 
-        assertThat(compileOnlyAnalysis.getUsedDeclaredArtifacts()).hasSize(3);
-        
assertThat(compileOnlyAnalysis.getUsedUndeclaredArtifacts()).hasSize(3);
+        assertEquals(3, compileOnlyAnalysis.getUsedDeclaredArtifacts().size());
+        assertEquals(3, 
compileOnlyAnalysis.getUsedUndeclaredArtifacts().size());
 
-        assertThat(compileOnlyAnalysis.getUnusedDeclaredArtifacts())
-                .hasSize(1)
-                .allSatisfy(a -> 
assertThat(a.getScope()).isEqualTo(Artifact.SCOPE_COMPILE));
+        assertEquals(1, 
compileOnlyAnalysis.getUnusedDeclaredArtifacts().size());
+        for (Artifact a : compileOnlyAnalysis.getUnusedDeclaredArtifacts()) {
+            assertEquals(Artifact.SCOPE_COMPILE, a.getScope());
+        }
 
-        
assertThat(compileOnlyAnalysis.getTestArtifactsWithNonTestScope()).hasSize(3);
+        assertEquals(3, 
compileOnlyAnalysis.getTestArtifactsWithNonTestScope().size());
     }
 
     @Test
@@ -99,11 +103,13 @@ class ProjectDependencyAnalysisTest {
                 candidates,
                 selected);
 
-        
assertThat(analysis.getUsedDependencyClasses()).containsExactlyInAnyOrder("a.B",
 "c.D");
-        
assertThat(analysis.getCandidateArtifactsByUsedClass().get("a.B")).containsExactly(declared,
 other);
-        
assertThat(analysis.getSelectedArtifactByUsedClass().get("a.B")).isEqualTo(declared);
-        
assertThat(analysis.getAmbiguousUsedDependencyClasses()).containsExactly("a.B");
-        assertThat(analysis.getUnmappedUsedDependencyClasses()).isEmpty();
+        assertEquals(new HashSet<>(Arrays.asList("a.B", "c.D")), new 
HashSet<>(analysis.getUsedDependencyClasses()));
+        assertIterableEquals(
+                Arrays.asList(declared, other),
+                analysis.getCandidateArtifactsByUsedClass().get("a.B"));
+        assertEquals(declared, 
analysis.getSelectedArtifactByUsedClass().get("a.B"));
+        assertIterableEquals(Collections.singletonList("a.B"), 
analysis.getAmbiguousUsedDependencyClasses());
+        assertTrue(analysis.getUnmappedUsedDependencyClasses().isEmpty());
     }
 
     @Test
@@ -121,8 +127,8 @@ class ProjectDependencyAnalysisTest {
                 candidates,
                 Collections.emptyMap());
 
-        
assertThat(analysis.getUnmappedUsedDependencyClasses()).containsExactly("a.B");
-        
assertThat(analysis.getSelectedArtifactByUsedClass()).doesNotContainKey("a.B");
+        assertIterableEquals(Collections.singletonList("a.B"), 
analysis.getUnmappedUsedDependencyClasses());
+        
assertFalse(analysis.getSelectedArtifactByUsedClass().containsKey("a.B"));
     }
 
     private <T> Set<T> asSet(T... items) {
diff --git 
a/src/test/java/org/apache/maven/shared/dependency/analyzer/ProjectDependencyAnalyzerExceptionTest.java
 
b/src/test/java/org/apache/maven/shared/dependency/analyzer/ProjectDependencyAnalyzerExceptionTest.java
index 1d2f72c..5bea57d 100644
--- 
a/src/test/java/org/apache/maven/shared/dependency/analyzer/ProjectDependencyAnalyzerExceptionTest.java
+++ 
b/src/test/java/org/apache/maven/shared/dependency/analyzer/ProjectDependencyAnalyzerExceptionTest.java
@@ -20,7 +20,8 @@ package org.apache.maven.shared.dependency.analyzer;
 
 import org.junit.jupiter.api.Test;
 
-import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertSame;
 
 /**
  * Tests <code>ProjectDependencyAnalyzerException</code>.
@@ -31,7 +32,7 @@ import static org.assertj.core.api.Assertions.assertThat;
 class ProjectDependencyAnalyzerExceptionTest {
     @Test
     void testConstructor() {
-        assertThat(new 
ProjectDependencyAnalyzerException("a")).hasMessage("a");
+        assertEquals("a", new 
ProjectDependencyAnalyzerException("a").getMessage());
     }
 
     @Test
@@ -39,6 +40,7 @@ class ProjectDependencyAnalyzerExceptionTest {
         Throwable throwable = new Exception();
         ProjectDependencyAnalyzerException exception = new 
ProjectDependencyAnalyzerException("a", throwable);
 
-        assertThat(exception).hasMessage("a").hasCause(throwable);
+        assertEquals("a", exception.getMessage());
+        assertSame(throwable, exception.getCause());
     }
 }
diff --git 
a/src/test/java/org/apache/maven/shared/dependency/analyzer/asm/ASMDependencyAnalyzerTest.java
 
b/src/test/java/org/apache/maven/shared/dependency/analyzer/asm/ASMDependencyAnalyzerTest.java
index f886bc5..ac97cb8 100644
--- 
a/src/test/java/org/apache/maven/shared/dependency/analyzer/asm/ASMDependencyAnalyzerTest.java
+++ 
b/src/test/java/org/apache/maven/shared/dependency/analyzer/asm/ASMDependencyAnalyzerTest.java
@@ -28,7 +28,9 @@ import 
org.apache.maven.shared.dependency.analyzer.ClassesPatterns;
 import org.apache.maven.shared.dependency.analyzer.DependencyAnalyzer;
 import org.junit.jupiter.api.Test;
 
-import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
 class ASMDependencyAnalyzerTest {
     private final DependencyAnalyzer analyzer = new ASMDependencyAnalyzer();
@@ -36,13 +38,13 @@ class ASMDependencyAnalyzerTest {
     @Test
     void test() throws Exception {
         URL jarUrl = 
this.getClass().getResource("/org/objectweb/asm/ClassReader.class");
-        assertThat(jarUrl).isNotNull();
+        assertNotNull(jarUrl);
         String fileUrl =
                 jarUrl.toString().substring("jar:".length(), 
jarUrl.toString().indexOf("!/"));
 
         Set<String> result = analyzer.analyze(new URL(fileUrl));
 
-        assertThat(result).isNotEmpty();
+        assertFalse(result.isEmpty());
     }
 
     @Test
@@ -50,8 +52,8 @@ class ASMDependencyAnalyzerTest {
         Path file = 
Paths.get("target/test-classes/org/apache/maven/shared/dependency/analyzer/testcases/analyze");
 
         Set<String> result = analyzer.analyze(file.toUri().toURL());
-        
assertThat(result).contains("org.apache.maven.artifact.resolver.ArtifactResolutionRequest");
-        assertThat(result).contains("java.util.regex.Pattern");
+        
assertTrue(result.contains("org.apache.maven.artifact.resolver.ArtifactResolutionRequest"));
+        assertTrue(result.contains("java.util.regex.Pattern"));
     }
 
     @Test
@@ -60,9 +62,8 @@ class ASMDependencyAnalyzerTest {
 
         Set<String> result =
                 analyzer.analyze(file.toUri().toURL(), new 
ClassesPatterns(Collections.singleton("ClassToExclude")));
-        
assertThat(result).contains("org.apache.maven.artifact.resolver.ArtifactResolutionRequest");
-        assertThat(result).doesNotContain("java.util.regex.Pattern");
-        assertThat(result)
-                
.doesNotContain("org.apache.maven.shared.dependency.analyzer.testcases.analyze.ClassToExclude");
+        
assertTrue(result.contains("org.apache.maven.artifact.resolver.ArtifactResolutionRequest"));
+        assertFalse(result.contains("java.util.regex.Pattern"));
+        
assertFalse(result.contains("org.apache.maven.shared.dependency.analyzer.testcases.analyze.ClassToExclude"));
     }
 }
diff --git 
a/src/test/java/org/apache/maven/shared/dependency/analyzer/asm/DependencyVisitorTest.java
 
b/src/test/java/org/apache/maven/shared/dependency/analyzer/asm/DependencyVisitorTest.java
index 18aab18..849952c 100644
--- 
a/src/test/java/org/apache/maven/shared/dependency/analyzer/asm/DependencyVisitorTest.java
+++ 
b/src/test/java/org/apache/maven/shared/dependency/analyzer/asm/DependencyVisitorTest.java
@@ -18,6 +18,9 @@
  */
 package org.apache.maven.shared.dependency.analyzer.asm;
 
+import java.util.Arrays;
+import java.util.HashSet;
+
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 import org.objectweb.asm.AnnotationVisitor;
@@ -29,7 +32,8 @@ import org.objectweb.asm.Opcodes;
 import org.objectweb.asm.Type;
 import org.objectweb.asm.signature.SignatureVisitor;
 
-import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
 /**
  * Tests <code>DependencyVisitor</code>.
@@ -58,7 +62,8 @@ class DependencyVisitorTest {
         // class a.b.c
         visitor.visit(50, 0, "a/b/c", null, "java/lang/Object", null);
 
-        
assertThat(resultCollector.getDependencies()).containsOnly("java.lang.Object");
+        assertEquals(
+                new HashSet<>(Arrays.asList("java.lang.Object")), new 
HashSet<>(resultCollector.getDependencies()));
     }
 
     @Test
@@ -66,7 +71,7 @@ class DependencyVisitorTest {
         // class a.b.c
         visitor.visit(50, 0, "a/b/c", null, "x/y/z", null);
 
-        assertThat(resultCollector.getDependencies()).containsOnly("x.y.z");
+        assertEquals(new HashSet<>(Arrays.asList("x.y.z")), new 
HashSet<>(resultCollector.getDependencies()));
     }
 
     @Test
@@ -74,7 +79,9 @@ class DependencyVisitorTest {
         // class a.b.c implements x.y.z
         visitor.visit(50, 0, "a/b/c", null, "java/lang/Object", new String[] 
{"x/y/z"});
 
-        
assertThat(resultCollector.getDependencies()).containsOnly("java.lang.Object", 
"x.y.z");
+        assertEquals(
+                new HashSet<>(Arrays.asList("java.lang.Object", "x.y.z")),
+                new HashSet<>(resultCollector.getDependencies()));
     }
 
     @Test
@@ -82,7 +89,9 @@ class DependencyVisitorTest {
         // class a.b.c implements p.q.r, x.y.z
         visitor.visit(50, 0, "a/b/c", null, "java/lang/Object", new String[] 
{"p/q/r", "x/y/z"});
 
-        
assertThat(resultCollector.getDependencies()).containsOnly("java.lang.Object", 
"p.q.r", "x.y.z");
+        assertEquals(
+                new HashSet<>(Arrays.asList("java.lang.Object", "p.q.r", 
"x.y.z")),
+                new HashSet<>(resultCollector.getDependencies()));
     }
 
     @Test
@@ -92,7 +101,8 @@ class DependencyVisitorTest {
 
         visitor.visit(50, 0, "a/b/c", signature, "java/lang/Object", null);
 
-        
assertThat(resultCollector.getDependencies()).containsOnly("java.lang.Object");
+        assertEquals(
+                new HashSet<>(Arrays.asList("java.lang.Object")), new 
HashSet<>(resultCollector.getDependencies()));
     }
 
     @Test
@@ -102,7 +112,9 @@ class DependencyVisitorTest {
 
         visitor.visit(50, 0, "a/b/c", signature, "java/lang/Object", null);
 
-        
assertThat(resultCollector.getDependencies()).containsOnly("java.lang.Object", 
"x.y.z");
+        assertEquals(
+                new HashSet<>(Arrays.asList("java.lang.Object", "x.y.z")),
+                new HashSet<>(resultCollector.getDependencies()));
     }
 
     @Test
@@ -112,7 +124,9 @@ class DependencyVisitorTest {
 
         visitor.visit(50, 0, "a/b/c", signature, "java/lang/Object", null);
 
-        
assertThat(resultCollector.getDependencies()).containsOnly("java.lang.Object", 
"p.q.r", "x.y.z");
+        assertEquals(
+                new HashSet<>(Arrays.asList("java.lang.Object", "p.q.r", 
"x.y.z")),
+                new HashSet<>(resultCollector.getDependencies()));
     }
 
     @Test
@@ -122,7 +136,9 @@ class DependencyVisitorTest {
 
         visitor.visit(50, 0, "a/b/c", signature, "java/lang/Object", new 
String[] {"p.q.r"});
 
-        
assertThat(resultCollector.getDependencies()).containsOnly("java.lang.Object", 
"p.q.r", "x.y.z");
+        assertEquals(
+                new HashSet<>(Arrays.asList("java.lang.Object", "p.q.r", 
"x.y.z")),
+                new HashSet<>(resultCollector.getDependencies()));
     }
 
     @Test
@@ -132,7 +148,9 @@ class DependencyVisitorTest {
 
         visitor.visit(50, 0, "a/b/c", signature, "java/lang/Object", new 
String[] {"x.y.z"});
 
-        
assertThat(resultCollector.getDependencies()).containsOnly("java.lang.Object", 
"x.y.z");
+        assertEquals(
+                new HashSet<>(Arrays.asList("java.lang.Object", "x.y.z")),
+                new HashSet<>(resultCollector.getDependencies()));
     }
 
     // visitSource tests ------------------------------------------------------
@@ -141,7 +159,7 @@ class DependencyVisitorTest {
     void testVisitSource() {
         visitor.visitSource(null, null);
 
-        assertThat(resultCollector.getDependencies()).isEmpty();
+        assertTrue(resultCollector.getDependencies().isEmpty());
     }
 
     // visitOuterClass tests --------------------------------------------------
@@ -156,7 +174,7 @@ class DependencyVisitorTest {
         // }
         visitor.visitOuterClass("a/b/c", null, null);
 
-        assertThat(resultCollector.getDependencies()).isEmpty();
+        assertTrue(resultCollector.getDependencies().isEmpty());
     }
 
     @Test
@@ -172,7 +190,7 @@ class DependencyVisitorTest {
         // }
         visitor.visitOuterClass("a/b/c", "x", "(Lp/q/r;)Lx/y/z;");
 
-        assertThat(resultCollector.getDependencies()).isEmpty();
+        assertTrue(resultCollector.getDependencies().isEmpty());
     }
 
     // visitAnnotation tests --------------------------------------------------
@@ -181,14 +199,14 @@ class DependencyVisitorTest {
     void testVisitAnnotation() {
         assertVisitor(visitor.visitAnnotation("La/b/c;", false));
 
-        assertThat(resultCollector.getDependencies()).containsOnly("a.b.c");
+        assertEquals(new HashSet<>(Arrays.asList("a.b.c")), new 
HashSet<>(resultCollector.getDependencies()));
     }
 
     @Test
     void testVisitAnnotationWithRuntimeVisibility() {
         assertVisitor(visitor.visitAnnotation("La/b/c;", true));
 
-        assertThat(resultCollector.getDependencies()).containsOnly("a.b.c");
+        assertEquals(new HashSet<>(Arrays.asList("a.b.c")), new 
HashSet<>(resultCollector.getDependencies()));
     }
 
     // visitAttribute tests ---------------------------------------------------
@@ -197,7 +215,7 @@ class DependencyVisitorTest {
     void testVisitAttribute() {
         visitor.visitAttribute(new MockAttribute("a"));
 
-        assertThat(resultCollector.getDependencies()).isEmpty();
+        assertTrue(resultCollector.getDependencies().isEmpty());
     }
 
     // visitInnerClass tests --------------------------------------------------
@@ -207,7 +225,7 @@ class DependencyVisitorTest {
         // class a.b.c { class x { } }
         visitor.visitInnerClass("a/b/c$x", "a/b/c", "x", 0);
 
-        assertThat(resultCollector.getDependencies()).isEmpty();
+        assertTrue(resultCollector.getDependencies().isEmpty());
     }
 
     @Test
@@ -215,7 +233,7 @@ class DependencyVisitorTest {
         // class a.b.c { new class x.y.z { } }
         visitor.visitInnerClass("x/y/z$1", "a/b/c", null, 0);
 
-        assertThat(resultCollector.getDependencies()).isEmpty();
+        assertTrue(resultCollector.getDependencies().isEmpty());
     }
 
     // visitField tests -------------------------------------------------------
@@ -225,7 +243,7 @@ class DependencyVisitorTest {
         // a.b.c a
         assertVisitor(visitor.visitField(0, "a", "La/b/c;", null, null));
 
-        assertThat(resultCollector.getDependencies()).containsOnly("a.b.c");
+        assertEquals(new HashSet<>(Arrays.asList("a.b.c")), new 
HashSet<>(resultCollector.getDependencies()));
     }
 
     @Test
@@ -233,7 +251,7 @@ class DependencyVisitorTest {
         // a.b.c a = x.y.z.class
         assertVisitor(visitor.visitField(0, "a", "La/b/c;", null, 
Type.getType("Lx/y/z;")));
 
-        assertThat(resultCollector.getDependencies()).containsOnly("a.b.c", 
"x.y.z");
+        assertEquals(new HashSet<>(Arrays.asList("a.b.c", "x.y.z")), new 
HashSet<>(resultCollector.getDependencies()));
     }
 
     @Test
@@ -241,7 +259,7 @@ class DependencyVisitorTest {
         // a.b.c[] a
         assertVisitor(visitor.visitField(0, "a", "[La/b/c;", null, null));
 
-        assertThat(resultCollector.getDependencies()).containsOnly("a.b.c");
+        assertEquals(new HashSet<>(Arrays.asList("a.b.c")), new 
HashSet<>(resultCollector.getDependencies()));
     }
 
     @Test
@@ -249,7 +267,7 @@ class DependencyVisitorTest {
         // a.b.c<x.y.z> a
         assertVisitor(visitor.visitField(0, "a", "La/b/c;", 
"La/b/c<Lx/y/z;>;", null));
 
-        assertThat(resultCollector.getDependencies()).containsOnly("a.b.c", 
"x.y.z");
+        assertEquals(new HashSet<>(Arrays.asList("a.b.c", "x.y.z")), new 
HashSet<>(resultCollector.getDependencies()));
     }
 
     // visitMethod tests ------------------------------------------------------
@@ -259,7 +277,7 @@ class DependencyVisitorTest {
         // void a()
         assertVisitor(visitor.visitMethod(0, "a", "()V", null, null));
 
-        assertThat(resultCollector.getDependencies()).isEmpty();
+        assertTrue(resultCollector.getDependencies().isEmpty());
     }
 
     @Test
@@ -267,7 +285,7 @@ class DependencyVisitorTest {
         // void a(int)
         assertVisitor(visitor.visitMethod(0, "a", "(I)V", null, null));
 
-        assertThat(resultCollector.getDependencies()).isEmpty();
+        assertTrue(resultCollector.getDependencies().isEmpty());
     }
 
     @Test
@@ -275,7 +293,7 @@ class DependencyVisitorTest {
         // void a(int[])
         assertVisitor(visitor.visitMethod(0, "a", "([I)V", null, null));
 
-        assertThat(resultCollector.getDependencies()).isEmpty();
+        assertTrue(resultCollector.getDependencies().isEmpty());
     }
 
     @Test
@@ -283,7 +301,7 @@ class DependencyVisitorTest {
         // void a(a.b.c)
         assertVisitor(visitor.visitMethod(0, "a", "(La/b/c;)V", null, null));
 
-        assertThat(resultCollector.getDependencies()).containsOnly("a.b.c");
+        assertEquals(new HashSet<>(Arrays.asList("a.b.c")), new 
HashSet<>(resultCollector.getDependencies()));
     }
 
     @Test
@@ -291,7 +309,7 @@ class DependencyVisitorTest {
         // void a(a.b.c, x.y.z)
         assertVisitor(visitor.visitMethod(0, "a", "(La/b/c;Lx/y/z;)V", null, 
null));
 
-        assertThat(resultCollector.getDependencies()).containsOnly("a.b.c", 
"x.y.z");
+        assertEquals(new HashSet<>(Arrays.asList("a.b.c", "x.y.z")), new 
HashSet<>(resultCollector.getDependencies()));
     }
 
     @Test
@@ -299,7 +317,7 @@ class DependencyVisitorTest {
         // void a(a.b.c[])
         assertVisitor(visitor.visitMethod(0, "a", "([La/b/c;)V", null, null));
 
-        assertThat(resultCollector.getDependencies()).containsOnly("a.b.c");
+        assertEquals(new HashSet<>(Arrays.asList("a.b.c")), new 
HashSet<>(resultCollector.getDependencies()));
     }
 
     @Test
@@ -307,7 +325,7 @@ class DependencyVisitorTest {
         // void a(a.b.c<x.y.z>)
         assertVisitor(visitor.visitMethod(0, "a", "(La/b/c;)V", 
"(La/b/c<Lx/y/z;>;)V", null));
 
-        assertThat(resultCollector.getDependencies()).containsOnly("a.b.c", 
"x.y.z");
+        assertEquals(new HashSet<>(Arrays.asList("a.b.c", "x.y.z")), new 
HashSet<>(resultCollector.getDependencies()));
     }
 
     @Test
@@ -315,7 +333,7 @@ class DependencyVisitorTest {
         // int a()
         assertVisitor(visitor.visitMethod(0, "a", "()I", null, null));
 
-        assertThat(resultCollector.getDependencies()).isEmpty();
+        assertTrue(resultCollector.getDependencies().isEmpty());
     }
 
     @Test
@@ -323,7 +341,7 @@ class DependencyVisitorTest {
         // int[] a()
         assertVisitor(visitor.visitMethod(0, "a", "()[I", null, null));
 
-        assertThat(resultCollector.getDependencies()).isEmpty();
+        assertTrue(resultCollector.getDependencies().isEmpty());
     }
 
     @Test
@@ -331,7 +349,7 @@ class DependencyVisitorTest {
         // a.b.c a()
         assertVisitor(visitor.visitMethod(0, "a", "()La/b/c;", null, null));
 
-        assertThat(resultCollector.getDependencies()).containsOnly("a.b.c");
+        assertEquals(new HashSet<>(Arrays.asList("a.b.c")), new 
HashSet<>(resultCollector.getDependencies()));
     }
 
     @Test
@@ -339,7 +357,7 @@ class DependencyVisitorTest {
         // a.b.c[] a()
         assertVisitor(visitor.visitMethod(0, "a", "()[La/b/c;", null, null));
 
-        assertThat(resultCollector.getDependencies()).containsOnly("a.b.c");
+        assertEquals(new HashSet<>(Arrays.asList("a.b.c")), new 
HashSet<>(resultCollector.getDependencies()));
     }
 
     @Test
@@ -347,7 +365,7 @@ class DependencyVisitorTest {
         // void a() throws a.b.c
         assertVisitor(visitor.visitMethod(0, "a", "()V", null, new String[] 
{"a/b/c"}));
 
-        assertThat(resultCollector.getDependencies()).containsOnly("a.b.c");
+        assertEquals(new HashSet<>(Arrays.asList("a.b.c")), new 
HashSet<>(resultCollector.getDependencies()));
     }
 
     @Test
@@ -355,7 +373,7 @@ class DependencyVisitorTest {
         // void a() throws a.b.c, x.y.z
         assertVisitor(visitor.visitMethod(0, "a", "()V", null, new String[] 
{"a/b/c", "x/y/z"}));
 
-        assertThat(resultCollector.getDependencies()).containsOnly("a.b.c", 
"x.y.z");
+        assertEquals(new HashSet<>(Arrays.asList("a.b.c", "x.y.z")), new 
HashSet<>(resultCollector.getDependencies()));
     }
 
     // visitAnnotationDefault tests -------------------------------------------
@@ -363,7 +381,7 @@ class DependencyVisitorTest {
     @Test
     void testVisitAnnotationDefault() {
         assertVisitor(mv.visitAnnotationDefault());
-        assertThat(resultCollector.getDependencies()).isEmpty();
+        assertTrue(resultCollector.getDependencies().isEmpty());
     }
 
     // visitParameterAnnotation tests 
-------------------------------------------
@@ -373,7 +391,7 @@ class DependencyVisitorTest {
         // @a.b.c
         assertVisitor(mv.visitParameterAnnotation(0, "La/b/c;", false));
 
-        assertThat(resultCollector.getDependencies()).containsOnly("a.b.c");
+        assertEquals(new HashSet<>(Arrays.asList("a.b.c")), new 
HashSet<>(resultCollector.getDependencies()));
     }
 
     // visitCode tests --------------------------------------------------------
@@ -382,7 +400,7 @@ class DependencyVisitorTest {
     void testVisitCode() {
         mv.visitCode();
 
-        assertThat(resultCollector.getDependencies()).isEmpty();
+        assertTrue(resultCollector.getDependencies().isEmpty());
     }
 
     // visitFrame tests -------------------------------------------------------
@@ -391,7 +409,7 @@ class DependencyVisitorTest {
     void testVisitFrame() {
         mv.visitFrame(Opcodes.F_NEW, 0, new Object[0], 0, new Object[0]);
 
-        assertThat(resultCollector.getDependencies()).isEmpty();
+        assertTrue(resultCollector.getDependencies().isEmpty());
     }
 
     // visitInsn tests --------------------------------------------------------
@@ -400,7 +418,7 @@ class DependencyVisitorTest {
     void testVisitInsn() {
         mv.visitInsn(Opcodes.NOP);
 
-        assertThat(resultCollector.getDependencies()).isEmpty();
+        assertTrue(resultCollector.getDependencies().isEmpty());
     }
 
     // visitIntInsn tests -----------------------------------------------------
@@ -409,7 +427,7 @@ class DependencyVisitorTest {
     void testVisitIntInsn() {
         mv.visitIntInsn(Opcodes.BIPUSH, 0);
 
-        assertThat(resultCollector.getDependencies()).isEmpty();
+        assertTrue(resultCollector.getDependencies().isEmpty());
     }
 
     // visitVarInsn tests -----------------------------------------------------
@@ -418,7 +436,7 @@ class DependencyVisitorTest {
     void testVisitVarInsn() {
         mv.visitVarInsn(Opcodes.ILOAD, 0);
 
-        assertThat(resultCollector.getDependencies()).isEmpty();
+        assertTrue(resultCollector.getDependencies().isEmpty());
     }
 
     // visitTypeInsn tests ----------------------------------------------------
@@ -427,7 +445,7 @@ class DependencyVisitorTest {
     void testVisitTypeInsn() {
         mv.visitTypeInsn(Opcodes.NEW, "a/b/c");
 
-        assertThat(resultCollector.getDependencies()).containsOnly("a.b.c");
+        assertEquals(new HashSet<>(Arrays.asList("a.b.c")), new 
HashSet<>(resultCollector.getDependencies()));
     }
 
     // visitFieldInsn tests ---------------------------------------------------
@@ -436,14 +454,14 @@ class DependencyVisitorTest {
     void testVisitFieldInsnWithPrimitive() {
         mv.visitFieldInsn(Opcodes.GETFIELD, "a/b/c", "x", "I");
 
-        assertThat(resultCollector.getDependencies()).containsOnly("a.b.c");
+        assertEquals(new HashSet<>(Arrays.asList("a.b.c")), new 
HashSet<>(resultCollector.getDependencies()));
     }
 
     @Test
     void testVisitFieldInsnWithObject() {
         mv.visitFieldInsn(Opcodes.GETFIELD, "a/b/c", "x", "Lx/y/z;");
 
-        assertThat(resultCollector.getDependencies()).containsOnly("a.b.c");
+        assertEquals(new HashSet<>(Arrays.asList("a.b.c")), new 
HashSet<>(resultCollector.getDependencies()));
     }
 
     // visitMethodInsn tests --------------------------------------------------
@@ -452,70 +470,70 @@ class DependencyVisitorTest {
     void testVisitMethodInsn() {
         mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "a/b/c", "x", "()V", false);
 
-        assertThat(resultCollector.getDependencies()).containsOnly("a.b.c");
+        assertEquals(new HashSet<>(Arrays.asList("a.b.c")), new 
HashSet<>(resultCollector.getDependencies()));
     }
 
     @Test
     void testVisitMethodInsnWithPrimitiveArgument() {
         mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "a/b/c", "x", "(I)V", false);
 
-        assertThat(resultCollector.getDependencies()).containsOnly("a.b.c");
+        assertEquals(new HashSet<>(Arrays.asList("a.b.c")), new 
HashSet<>(resultCollector.getDependencies()));
     }
 
     @Test
     void testVisitMethodInsnWithPrimitiveArrayArgument() {
         mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "a/b/c", "x", "([I)V", 
false);
 
-        assertThat(resultCollector.getDependencies()).containsOnly("a.b.c");
+        assertEquals(new HashSet<>(Arrays.asList("a.b.c")), new 
HashSet<>(resultCollector.getDependencies()));
     }
 
     @Test
     void testVisitMethodInsnWithObjectArgument() {
         mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "a/b/c", "x", "(Lx/y/z;)V", 
false);
 
-        assertThat(resultCollector.getDependencies()).containsOnly("a.b.c");
+        assertEquals(new HashSet<>(Arrays.asList("a.b.c")), new 
HashSet<>(resultCollector.getDependencies()));
     }
 
     @Test
     void testVisitMethodInsnWithObjectArguments() {
         mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "a/b/c", "x", 
"(Lp/q/r;Lx/y/z;)V", false);
 
-        assertThat(resultCollector.getDependencies()).containsOnly("a.b.c");
+        assertEquals(new HashSet<>(Arrays.asList("a.b.c")), new 
HashSet<>(resultCollector.getDependencies()));
     }
 
     @Test
     void testVisitMethodInsnWithObjectArrayArgument() {
         mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "a/b/c", "x", "([Lx/y/z;)V", 
false);
 
-        assertThat(resultCollector.getDependencies()).containsOnly("a.b.c");
+        assertEquals(new HashSet<>(Arrays.asList("a.b.c")), new 
HashSet<>(resultCollector.getDependencies()));
     }
 
     @Test
     void testVisitMethodInsnWithPrimitiveReturnType() {
         mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "a/b/c", "x", "()I", false);
 
-        assertThat(resultCollector.getDependencies()).containsOnly("a.b.c");
+        assertEquals(new HashSet<>(Arrays.asList("a.b.c")), new 
HashSet<>(resultCollector.getDependencies()));
     }
 
     @Test
     void testVisitMethodInsnWithPrimitiveArrayReturnType() {
         mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "a/b/c", "x", "()[I", false);
 
-        assertThat(resultCollector.getDependencies()).containsOnly("a.b.c");
+        assertEquals(new HashSet<>(Arrays.asList("a.b.c")), new 
HashSet<>(resultCollector.getDependencies()));
     }
 
     @Test
     void testVisitMethodInsnWithObjectReturnType() {
         mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "a/b/c", "x", "()Lx/y/z;", 
false);
 
-        assertThat(resultCollector.getDependencies()).containsOnly("a.b.c");
+        assertEquals(new HashSet<>(Arrays.asList("a.b.c")), new 
HashSet<>(resultCollector.getDependencies()));
     }
 
     @Test
     void testVisitMethodInsnWithObjectArrayReturnType() {
         mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "a/b/c", "x", "()[Lx/y/z;", 
false);
 
-        assertThat(resultCollector.getDependencies()).containsOnly("a.b.c");
+        assertEquals(new HashSet<>(Arrays.asList("a.b.c")), new 
HashSet<>(resultCollector.getDependencies()));
     }
 
     // visitJumpInsn tests ----------------------------------------------------
@@ -524,7 +542,7 @@ class DependencyVisitorTest {
     void testVisitJumpInsn() {
         mv.visitJumpInsn(Opcodes.IFEQ, new Label());
 
-        assertThat(resultCollector.getDependencies()).isEmpty();
+        assertTrue(resultCollector.getDependencies().isEmpty());
     }
 
     // visitLabel tests -------------------------------------------------------
@@ -533,7 +551,7 @@ class DependencyVisitorTest {
     void testVisitLabel() {
         mv.visitLabel(new Label());
 
-        assertThat(resultCollector.getDependencies()).isEmpty();
+        assertTrue(resultCollector.getDependencies().isEmpty());
     }
 
     // visitLdcInsn tests -----------------------------------------------------
@@ -542,21 +560,21 @@ class DependencyVisitorTest {
     void testVisitLdcInsnWithNonType() {
         mv.visitLdcInsn("a");
 
-        assertThat(resultCollector.getDependencies()).isEmpty();
+        assertTrue(resultCollector.getDependencies().isEmpty());
     }
 
     @Test
     void testVisitLdcInsnWithPrimitiveType() {
         mv.visitLdcInsn(Type.INT_TYPE);
 
-        assertThat(resultCollector.getDependencies()).isEmpty();
+        assertTrue(resultCollector.getDependencies().isEmpty());
     }
 
     @Test
     void testVisitLdcInsnWithObjectType() {
         mv.visitLdcInsn(Type.getType("La/b/c;"));
 
-        assertThat(resultCollector.getDependencies()).containsOnly("a.b.c");
+        assertEquals(new HashSet<>(Arrays.asList("a.b.c")), new 
HashSet<>(resultCollector.getDependencies()));
     }
 
     // visitIincInsn tests ----------------------------------------------------
@@ -565,7 +583,7 @@ class DependencyVisitorTest {
     void testVisitIincInsn() {
         mv.visitIincInsn(0, 1);
 
-        assertThat(resultCollector.getDependencies()).isEmpty();
+        assertTrue(resultCollector.getDependencies().isEmpty());
     }
 
     // visitTableSwitchInsn tests ---------------------------------------------
@@ -574,7 +592,7 @@ class DependencyVisitorTest {
     void testVisitTableSwitchInsn() {
         mv.visitTableSwitchInsn(0, 1, new Label(), new Label());
 
-        assertThat(resultCollector.getDependencies()).isEmpty();
+        assertTrue(resultCollector.getDependencies().isEmpty());
     }
 
     // visitLookupSwitchInsn tests --------------------------------------------
@@ -583,7 +601,7 @@ class DependencyVisitorTest {
     void testVisitLookupSwitchInsn() {
         mv.visitLookupSwitchInsn(new Label(), new int[] {0}, new Label[] {new 
Label()});
 
-        assertThat(resultCollector.getDependencies()).isEmpty();
+        assertTrue(resultCollector.getDependencies().isEmpty());
     }
 
     // visitMultiANewArrayInsn tests ------------------------------------------
@@ -592,14 +610,14 @@ class DependencyVisitorTest {
     void testVisitMultiANewArrayInsnWithPrimitive() {
         mv.visitMultiANewArrayInsn("I", 2);
 
-        assertThat(resultCollector.getDependencies()).isEmpty();
+        assertTrue(resultCollector.getDependencies().isEmpty());
     }
 
     @Test
     void testVisitMultiANewArrayInsnWithObject() {
         mv.visitMultiANewArrayInsn("La/b/c;", 2);
 
-        assertThat(resultCollector.getDependencies()).containsOnly("a.b.c");
+        assertEquals(new HashSet<>(Arrays.asList("a.b.c")), new 
HashSet<>(resultCollector.getDependencies()));
     }
 
     // visitTryCatchBlock tests -----------------------------------------------
@@ -608,14 +626,14 @@ class DependencyVisitorTest {
     void testVisitTryCatchBlock() {
         mv.visitTryCatchBlock(new Label(), new Label(), new Label(), "a/b/c");
 
-        assertThat(resultCollector.getDependencies()).containsOnly("a.b.c");
+        assertEquals(new HashSet<>(Arrays.asList("a.b.c")), new 
HashSet<>(resultCollector.getDependencies()));
     }
 
     @Test
     void testVisitTryCatchBlockForFinally() {
         mv.visitTryCatchBlock(new Label(), new Label(), new Label(), null);
 
-        assertThat(resultCollector.getDependencies()).isEmpty();
+        assertTrue(resultCollector.getDependencies().isEmpty());
     }
 
     // visitLocalVariable tests -----------------------------------------------
@@ -624,42 +642,42 @@ class DependencyVisitorTest {
     void testVisitLocalVariableWithPrimitive() {
         mv.visitLocalVariable("a", "I", null, new Label(), new Label(), 0);
 
-        assertThat(resultCollector.getDependencies()).isEmpty();
+        assertTrue(resultCollector.getDependencies().isEmpty());
     }
 
     @Test
     void testVisitLocalVariableWithPrimitiveArray() {
         mv.visitLocalVariable("a", "[I", null, new Label(), new Label(), 0);
 
-        assertThat(resultCollector.getDependencies()).isEmpty();
+        assertTrue(resultCollector.getDependencies().isEmpty());
     }
 
     @Test
     void testVisitLocalVariableWithObject() {
         mv.visitLocalVariable("a", "La/b/c;", null, new Label(), new Label(), 
0);
 
-        assertThat(resultCollector.getDependencies()).containsOnly("a.b.c");
+        assertEquals(new HashSet<>(Arrays.asList("a.b.c")), new 
HashSet<>(resultCollector.getDependencies()));
     }
 
     @Test
     void testVisitLocalVariableWithObjectArray() {
         mv.visitLocalVariable("a", "[La/b/c;", null, new Label(), new Label(), 
0);
 
-        assertThat(resultCollector.getDependencies()).containsOnly("a.b.c");
+        assertEquals(new HashSet<>(Arrays.asList("a.b.c")), new 
HashSet<>(resultCollector.getDependencies()));
     }
 
     @Test
     void testVisitLocalVariableWithGenericObject() {
         mv.visitLocalVariable("a", "La/b/c;", "La/b/c<Lx/y/z;>;", new Label(), 
new Label(), 0);
 
-        assertThat(resultCollector.getDependencies()).containsOnly("a.b.c", 
"x.y.z");
+        assertEquals(new HashSet<>(Arrays.asList("a.b.c", "x.y.z")), new 
HashSet<>(resultCollector.getDependencies()));
     }
 
     @Test
     void testVisitLocalVariableWithGenericObjectArray() {
         mv.visitLocalVariable("a", "La/b/c;", "[La/b/c<Lx/y/z;>;", new 
Label(), new Label(), 0);
 
-        assertThat(resultCollector.getDependencies()).containsOnly("a.b.c", 
"x.y.z");
+        assertEquals(new HashSet<>(Arrays.asList("a.b.c", "x.y.z")), new 
HashSet<>(resultCollector.getDependencies()));
     }
 
     // visitLineNumber tests --------------------------------------------------
@@ -668,7 +686,7 @@ class DependencyVisitorTest {
     void testVisitLineNumber() {
         mv.visitLineNumber(0, new Label());
 
-        assertThat(resultCollector.getDependencies()).isEmpty();
+        assertTrue(resultCollector.getDependencies().isEmpty());
     }
 
     // visitMaxs tests --------------------------------------------------------
@@ -677,7 +695,7 @@ class DependencyVisitorTest {
     void testVisitMaxs() {
         mv.visitMaxs(0, 0);
 
-        assertThat(resultCollector.getDependencies()).isEmpty();
+        assertTrue(resultCollector.getDependencies().isEmpty());
     }
 
     // visitInvokeDynamicInsn tests -------------------------------------------
@@ -685,7 +703,7 @@ class DependencyVisitorTest {
     void testVisitInvokeDynamic() {
         Type type = Type.getType("(La/b/C;)V");
         mv.visitInvokeDynamicInsn("a", "", null, type);
-        assertThat(resultCollector.getDependencies()).contains("a.b.C");
+        assertTrue(resultCollector.getDependencies().contains("a.b.C"));
     }
 
     private void assertVisitor(Object actualVisitor) {
diff --git 
a/src/test/java/org/apache/maven/shared/dependency/analyzer/asm/ResultCollectorTest.java
 
b/src/test/java/org/apache/maven/shared/dependency/analyzer/asm/ResultCollectorTest.java
index 36ed3fa..eb413d0 100644
--- 
a/src/test/java/org/apache/maven/shared/dependency/analyzer/asm/ResultCollectorTest.java
+++ 
b/src/test/java/org/apache/maven/shared/dependency/analyzer/asm/ResultCollectorTest.java
@@ -36,8 +36,10 @@ import org.objectweb.asm.ClassWriter;
 import org.objectweb.asm.MethodVisitor;
 import org.objectweb.asm.Opcodes;
 
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.assertj.core.api.Assertions.assertThatCode;
+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;
 
 class ResultCollectorTest {
 
@@ -71,7 +73,7 @@ class ResultCollectorTest {
         try (InputStream is = Files.newInputStream(path)) {
             visitor.visitClass("recordinvokedynamic.RecordInvokeDynamic", is);
         }
-        
assertThat(visitor.getDependencies()).contains("recordinvokedynamic.RecordInvokeDynamic");
+        
assertTrue(visitor.getDependencies().contains("recordinvokedynamic.RecordInvokeDynamic"));
     }
 
     @ParameterizedTest
@@ -89,8 +91,9 @@ class ResultCollectorTest {
             })
     void testOssFuzz(String name) {
         // Add a non-"class" suffix so that surefire does not try to read the 
file and fail the build
-        assertThatCode(() -> visitClass(ROOT + "/ossfuzz/" + name + 
"/Test.class.clazz"))
-                .isExactlyInstanceOf(VisitClassException.class);
+        VisitClassException exception = assertThrows(
+                VisitClassException.class, () -> visitClass(ROOT + "/ossfuzz/" 
+ name + "/Test.class.clazz"));
+        assertEquals(VisitClassException.class, exception.getClass());
     }
 
     private void visitClass(String location) throws IOException {
@@ -104,23 +107,27 @@ class ResultCollectorTest {
     @Test
     void testArrayCases() throws Exception {
         Set<String> dependencies = getDependencies(ArrayCases.class);
-        assertThat(dependencies).doesNotContain("[I");
-        assertThat(dependencies).allSatisfy(dependency -> 
assertThat(dependency).doesNotStartWith("["));
-        
assertThat(dependencies).contains("java.lang.annotation.Annotation").contains("java.lang.reflect.Constructor");
+        assertFalse(dependencies.contains("[I"));
+        for (String dependency : dependencies) {
+            assertFalse(dependency.startsWith("["));
+        }
+        assertTrue(dependencies.contains("java.lang.annotation.Annotation"));
+        assertTrue(dependencies.contains("java.lang.reflect.Constructor"));
     }
 
     @Test
     void testNoMethodHandle() throws Exception {
         Set<String> dependencies = getDependencies(MethodHandleCases.class);
         for (String dependency : dependencies) {
-            assertThat(dependency).doesNotStartWith("(");
+            assertFalse(dependency.startsWith("("));
         }
     }
 
     @Test
     void testInnerClassNamePreserved() throws Exception {
         Set<String> dependencies = getDependencies(InnerClassCase.class);
-        assertThat(dependencies).contains("java.lang.System", 
"java.lang.invoke.MethodHandles$Lookup");
+        assertTrue(dependencies.contains("java.lang.System"));
+        
assertTrue(dependencies.contains("java.lang.invoke.MethodHandles$Lookup"));
     }
 
     @Test
@@ -142,6 +149,7 @@ class ResultCollectorTest {
         DependencyClassFileVisitor visitor = new DependencyClassFileVisitor();
         visitor.visitClass("consumer.Example", new 
ByteArrayInputStream(writer.toByteArray()));
 
-        
assertThat(visitor.getDependencies()).contains("dependency.Outer$Inner").doesNotContain("dependency.Outer");
+        
assertTrue(visitor.getDependencies().contains("dependency.Outer$Inner"));
+        assertFalse(visitor.getDependencies().contains("dependency.Outer"));
     }
 }
diff --git 
a/src/test/java/org/apache/maven/shared/dependency/analyzer/dependencyclasses/DefaultMainDependencyClassesProviderTest.java
 
b/src/test/java/org/apache/maven/shared/dependency/analyzer/dependencyclasses/DefaultMainDependencyClassesProviderTest.java
index cc164f6..1e6e0be 100644
--- 
a/src/test/java/org/apache/maven/shared/dependency/analyzer/dependencyclasses/DefaultMainDependencyClassesProviderTest.java
+++ 
b/src/test/java/org/apache/maven/shared/dependency/analyzer/dependencyclasses/DefaultMainDependencyClassesProviderTest.java
@@ -32,7 +32,7 @@ import org.mockito.Mock;
 import org.mockito.Mockito;
 import org.mockito.junit.jupiter.MockitoExtension;
 
-import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
 
@@ -54,7 +54,7 @@ class DefaultMainDependencyClassesProviderTest {
 
         Set<DependencyUsage> dependencyUsages = 
provider.getDependencyClasses(project, null);
 
-        assertThat(dependencyUsages).isNotNull();
+        assertNotNull(dependencyUsages);
 
         verify(analyzer).analyzeUsages(new 
File("target/classes").toURI().toURL(), null);
     }
diff --git 
a/src/test/java/org/apache/maven/shared/dependency/analyzer/dependencyclasses/DefaultTestDependencyClassesProviderTest.java
 
b/src/test/java/org/apache/maven/shared/dependency/analyzer/dependencyclasses/DefaultTestDependencyClassesProviderTest.java
index 2bd332b..fcb247d 100644
--- 
a/src/test/java/org/apache/maven/shared/dependency/analyzer/dependencyclasses/DefaultTestDependencyClassesProviderTest.java
+++ 
b/src/test/java/org/apache/maven/shared/dependency/analyzer/dependencyclasses/DefaultTestDependencyClassesProviderTest.java
@@ -32,7 +32,7 @@ import org.mockito.Mock;
 import org.mockito.Mockito;
 import org.mockito.junit.jupiter.MockitoExtension;
 
-import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
 
@@ -54,7 +54,7 @@ class DefaultTestDependencyClassesProviderTest {
 
         Set<DependencyUsage> dependencyUsages = 
provider.getDependencyClasses(project, null);
 
-        assertThat(dependencyUsages).isNotNull();
+        assertNotNull(dependencyUsages);
 
         verify(analyzer).analyzeUsages(new 
File("target/test-classes").toURI().toURL(), null);
     }
diff --git 
a/src/test/java/org/apache/maven/shared/dependency/analyzer/dependencyclasses/WarMainDependencyClassesProviderTest.java
 
b/src/test/java/org/apache/maven/shared/dependency/analyzer/dependencyclasses/WarMainDependencyClassesProviderTest.java
index 6eae507..9aca9d6 100644
--- 
a/src/test/java/org/apache/maven/shared/dependency/analyzer/dependencyclasses/WarMainDependencyClassesProviderTest.java
+++ 
b/src/test/java/org/apache/maven/shared/dependency/analyzer/dependencyclasses/WarMainDependencyClassesProviderTest.java
@@ -21,8 +21,11 @@ package 
org.apache.maven.shared.dependency.analyzer.dependencyclasses;
 import java.net.URISyntaxException;
 import java.nio.file.Path;
 import java.nio.file.Paths;
+import java.util.Arrays;
 import java.util.Collections;
+import java.util.HashSet;
 import java.util.Set;
+import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
 import org.apache.maven.model.Build;
@@ -39,7 +42,8 @@ import org.junit.jupiter.params.provider.MethodSource;
 import org.mockito.Mock;
 import org.mockito.junit.jupiter.MockitoExtension;
 
-import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.when;
 
@@ -60,9 +64,9 @@ class WarMainDependencyClassesProviderTest {
         Set<DependencyUsage> classes =
                 provider.getDependencyClasses(project, new 
ClassesPatterns(Collections.singleton(".*\\.Servlet$")));
 
-        assertThat(classes)
-                .map(DependencyUsage::getDependencyClass)
-                .containsExactlyInAnyOrder("org.example.test.Filter", 
"org.example.test.Listener");
+        assertEquals(
+                new HashSet<>(Arrays.asList("org.example.test.Filter", 
"org.example.test.Listener")),
+                
classes.stream().map(DependencyUsage::getDependencyClass).collect(Collectors.toSet()));
     }
 
     @Test
@@ -74,7 +78,7 @@ class WarMainDependencyClassesProviderTest {
 
         Set<DependencyUsage> classes = provider.getDependencyClasses(project, 
new ClassesPatterns());
 
-        assertThat(classes).isEmpty();
+        assertTrue(classes.isEmpty());
     }
 
     public static Stream<Arguments> examplesData() {
@@ -104,7 +108,9 @@ class WarMainDependencyClassesProviderTest {
 
         Set<DependencyUsage> classes = provider.getDependencyClasses(project, 
new ClassesPatterns());
 
-        
assertThat(classes).map(DependencyUsage::getDependencyClass).containsExactlyInAnyOrder(expectedClasses);
+        assertEquals(
+                new HashSet<>(Arrays.asList(expectedClasses)),
+                
classes.stream().map(DependencyUsage::getDependencyClass).collect(Collectors.toSet()));
     }
 
     private void setupProjectWithWebXml(String webXmlName) throws 
URISyntaxException {

Reply via email to