Migrate JUnit asserts to AssertJ - migration

api/maven-api-core/src/test/java/org/apache/maven/api/MonotonicClockTest.java

@@ -28,69 +28,76 @@
 import org.junit.jupiter.api.Nested;
 import org.junit.jupiter.api.Test;
 
-import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.junit.jupiter.api.Assertions.assertNotNull;
-import static org.junit.jupiter.api.Assertions.assertSame;
-import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.assertj.core.api.Assertions.assertThat;
 
 class MonotonicClockTest {
 
     @Test
     @DisplayName("MonotonicClock singleton instance should always return the same instance")
-    void testSingletonInstance() {
+    void singletonInstance() {
         MonotonicClock clock1 = MonotonicClock.get();
         MonotonicClock clock2 = MonotonicClock.get();
 
-        assertSame(clock1, clock2, "Multiple calls to get() should return the same instance");
+        assertThat(clock2)
+                .as("Multiple calls to get() should return the same instance")
+                .isSameAs(clock1);
     }
 
     @Test
     @DisplayName("MonotonicClock should always use UTC timezone")
-    void testClockTimezone() {
+    void clockTimezone() {
         MonotonicClock clock = MonotonicClock.get();
 
-        assertEquals(ZoneOffset.UTC, clock.getZone(), "Clock should use UTC timezone");
+        assertThat(clock.getZone()).as("Clock should use UTC timezone").isEqualTo(ZoneOffset.UTC);
 
         // Verify that attempting to change timezone returns the same instance
         Clock newClock = clock.withZone(ZoneId.systemDefault());
-        assertSame(clock, newClock, "withZone() should return the same clock instance");
+        assertThat(newClock)
+                .as("withZone() should return the same clock instance")
+                .isSameAs(clock);
     }
 
     @Test
     @DisplayName("MonotonicClock should maintain monotonic time progression")
-    void testMonotonicBehavior() throws InterruptedException {
+    void monotonicBehavior() throws InterruptedException {
         Instant first = MonotonicClock.now();
         Thread.sleep(10); // Small delay
         Instant second = MonotonicClock.now();
         Thread.sleep(10); // Small delay
         Instant third = MonotonicClock.now();
 
-        assertTrue(first.isBefore(second), "Time should progress forward between measurements");
-        assertTrue(second.isBefore(third), "Time should progress forward between measurements");
+        assertThat(first.isBefore(second))
+                .as("Time should progress forward between measurements")
+                .isTrue();
+        assertThat(second.isBefore(third))
+                .as("Time should progress forward between measurements")
+                .isTrue();
     }
 
     @Test
     @DisplayName("MonotonicClock elapsed time should increase")
-    void testElapsedTime() throws InterruptedException {
+    void elapsedTime() throws InterruptedException {
         Duration initial = MonotonicClock.elapsed();
         Thread.sleep(50); // Longer delay for more reliable measurement
         Duration later = MonotonicClock.elapsed();
 
-        assertTrue(later.compareTo(initial) > 0, "Elapsed time should increase");
-        assertTrue(
-                later.minus(initial).toMillis() >= 45,
-                "Elapsed time difference should be at least 45ms (accounting for some timing variance)");
+        assertThat(later.compareTo(initial) > 0)
+                .as("Elapsed time should increase")
+                .isTrue();
+        assertThat(later.minus(initial).toMillis() >= 45)
+                .as("Elapsed time difference should be at least 45ms (accounting for some timing variance)")
+                .isTrue();
     }
 
     @Test
     @DisplayName("MonotonicClock start time should remain constant")
-    void testStartTime() throws InterruptedException {
+    void startTime() throws InterruptedException {
         Instant start1 = MonotonicClock.start();
         Thread.sleep(10);
         Instant start2 = MonotonicClock.start();
 
-        assertEquals(start1, start2, "Start time should remain constant");
-        assertNotNull(start1, "Start time should not be null");
+        assertThat(start2).as("Start time should remain constant").isEqualTo(start1);
+        assertThat(start1).as("Start time should not be null").isNotNull();
     }
 
     @Nested
@@ -99,52 +106,56 @@ class TimeConsistencyTests {
 
         @Test
         @DisplayName("Current time should be after start time")
-        void testCurrentTimeAfterStart() {
+        void currentTimeAfterStart() {
             Instant now = MonotonicClock.now();
             Instant start = MonotonicClock.start();
 
-            assertTrue(now.isAfter(start), "Current time should be after start time");
+            assertThat(now.isAfter(start))
+                    .as("Current time should be after start time")
+                    .isTrue();
         }
 
         @Test
         @DisplayName("Elapsed time should match time difference")
-        void testElapsedTimeConsistency() {
+        void elapsedTimeConsistency() {
             MonotonicClock clock = MonotonicClock.get();
             Instant now = clock.instant();
             Duration elapsed = clock.elapsedTime();
             Duration calculated = Duration.between(clock.startInstant(), now);
 
             // Allow for small timing differences (1ms) due to execution time between measurements
-            assertTrue(
-                    Math.abs(elapsed.toMillis() - calculated.toMillis()) <= 1,
-                    "Elapsed time should match calculated duration between start and now");
+            assertThat(Math.abs(elapsed.toMillis() - calculated.toMillis()) <= 1)
+                    .as("Elapsed time should match calculated duration between start and now")
+                    .isTrue();
         }
     }
 
     @Test
     @DisplayName("MonotonicClock should handle rapid successive calls")
-    void testRapidCalls() {
+    void rapidCalls() {
         Instant[] instants = new Instant[1000];
         for (int i = 0; i < instants.length; i++) {
             instants[i] = MonotonicClock.now();
         }
 
         // Verify monotonic behavior across all measurements
         for (int i = 1; i < instants.length; i++) {
-            assertTrue(
-                    instants[i].compareTo(instants[i - 1]) >= 0,
-                    "Time should never go backwards even with rapid successive calls");
+            assertThat(instants[i].compareTo(instants[i - 1]) >= 0)
+                    .as("Time should never go backwards even with rapid successive calls")
+                    .isTrue();
         }
     }
 
     @Test
     @DisplayName("MonotonicClock should maintain reasonable alignment with system time")
-    void testSystemTimeAlignment() {
+    void systemTimeAlignment() {
         Instant monotonic = MonotonicClock.now();
         Instant system = Instant.now();
 
         // The difference should be relatively small (allow for 1 second max)
         Duration difference = Duration.between(monotonic, system).abs();
-        assertTrue(difference.getSeconds() <= 1, "Monotonic time should be reasonably aligned with system time");
+        assertThat(difference.getSeconds() <= 1)
+                .as("Monotonic time should be reasonably aligned with system time")
+                .isTrue();
     }
 }

api/maven-api-core/src/test/java/org/apache/maven/api/services/RequestImplementationTest.java

@@ -27,15 +27,13 @@
 import org.apache.maven.api.Session;
 import org.junit.jupiter.api.Test;
 
-import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.junit.jupiter.api.Assertions.assertNotEquals;
-import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.assertj.core.api.Assertions.assertThat;
 import static org.mockito.Mockito.mock;
 
 class RequestImplementationTest {
 
     @Test
-    void testArtifactResolverRequestEquality() {
+    void artifactResolverRequestEquality() {
         Session session = mock(Session.class);
         ArtifactCoordinates coords1 = mock(ArtifactCoordinates.class);
         ArtifactCoordinates coords2 = mock(ArtifactCoordinates.class);
@@ -63,30 +61,30 @@ void testArtifactResolverRequestEquality() {
                 .build();
 
         // Test equals and hashCode
-        assertEquals(request1, request2);
-        assertEquals(request1.hashCode(), request2.hashCode());
-        assertNotEquals(request1, request3);
+        assertThat(request2).isEqualTo(request1);
+        assertThat(request2.hashCode()).isEqualTo(request1.hashCode());
+        assertThat(request3).isNotEqualTo(request1);
 
         // Test toString
         String toString = request1.toString();
-        assertTrue(toString.contains("coordinates="));
-        assertTrue(toString.contains("repositories="));
+        assertThat(toString.contains("coordinates=")).isTrue();
+        assertThat(toString.contains("repositories=")).isTrue();
     }
 
     @Test
-    void testRequestTraceIntegration() {
+    void requestTraceIntegration() {
         Session session = mock(Session.class);
         RequestTrace trace = new RequestTrace("test-context", null, "test-data");
 
         ArtifactInstallerRequest request =
                 ArtifactInstallerRequest.builder().session(session).trace(trace).build();
 
-        assertEquals(trace, request.getTrace());
-        assertEquals(session, request.getSession());
+        assertThat(request.getTrace()).isEqualTo(trace);
+        assertThat(request.getSession()).isEqualTo(session);
     }
 
     @Test
-    void testDependencyResolverRequestEquality() {
+    void dependencyResolverRequestEquality() {
         Session session = mock(Session.class);
 
         DependencyResolverRequest.DependencyResolverRequestBuilder builder = DependencyResolverRequest.builder();
@@ -105,12 +103,12 @@ void testDependencyResolverRequestEquality() {
                 .pathScope(PathScope.MAIN_COMPILE)
                 .build();
 
-        assertEquals(request1, request2);
-        assertEquals(request1.hashCode(), request2.hashCode());
-        assertNotEquals(request1, request3);
+        assertThat(request2).isEqualTo(request1);
+        assertThat(request2.hashCode()).isEqualTo(request1.hashCode());
+        assertThat(request3).isNotEqualTo(request1);
 
         String toString = request1.toString();
-        assertTrue(toString.contains("requestType="));
-        assertTrue(toString.contains("pathScope="));
+        assertThat(toString.contains("requestType=")).isTrue();
+        assertThat(toString.contains("pathScope=")).isTrue();
     }
 }

api/maven-api-core/src/test/java/org/apache/maven/api/services/RequestTraceTest.java

@@ -20,68 +20,66 @@
 
 import org.junit.jupiter.api.Test;
 
-import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.junit.jupiter.api.Assertions.assertNull;
-import static org.junit.jupiter.api.Assertions.assertSame;
+import static org.assertj.core.api.Assertions.assertThat;
 
 class RequestTraceTest {
 
     @Test
-    void testRequestTraceCreation() {
+    void requestTraceCreation() {
         RequestTrace parentTrace = new RequestTrace("parent-context", null, "parent-data");
         RequestTrace childTrace = new RequestTrace("child-context", parentTrace, "child-data");
 
-        assertEquals("parent-context", parentTrace.context());
-        assertNull(parentTrace.parent());
-        assertEquals("parent-data", parentTrace.data());
+        assertThat(parentTrace.context()).isEqualTo("parent-context");
+        assertThat(parentTrace.parent()).isNull();
+        assertThat(parentTrace.data()).isEqualTo("parent-data");
 
-        assertEquals("child-context", childTrace.context());
-        assertSame(parentTrace, childTrace.parent());
-        assertEquals("child-data", childTrace.data());
+        assertThat(childTrace.context()).isEqualTo("child-context");
+        assertThat(childTrace.parent()).isSameAs(parentTrace);
+        assertThat(childTrace.data()).isEqualTo("child-data");
     }
 
     @Test
-    void testRequestTraceWithParentContextInheritance() {
+    void requestTraceWithParentContextInheritance() {
         RequestTrace parentTrace = new RequestTrace("parent-context", null, "parent-data");
         RequestTrace childTrace = new RequestTrace(parentTrace, "child-data");
 
-        assertEquals("parent-context", parentTrace.context());
-        assertEquals("parent-context", childTrace.context());
-        assertEquals("child-data", childTrace.data());
+        assertThat(parentTrace.context()).isEqualTo("parent-context");
+        assertThat(childTrace.context()).isEqualTo("parent-context");
+        assertThat(childTrace.data()).isEqualTo("child-data");
     }
 
     @Test
-    void testPredefinedContexts() {
-        assertEquals("plugin", RequestTrace.CONTEXT_PLUGIN);
-        assertEquals("project", RequestTrace.CONTEXT_PROJECT);
-        assertEquals("bootstrap", RequestTrace.CONTEXT_BOOTSTRAP);
+    void predefinedContexts() {
+        assertThat(RequestTrace.CONTEXT_PLUGIN).isEqualTo("plugin");
+        assertThat(RequestTrace.CONTEXT_PROJECT).isEqualTo("project");
+        assertThat(RequestTrace.CONTEXT_BOOTSTRAP).isEqualTo("bootstrap");
     }
 
     @Test
-    void testNullValues() {
+    void nullValues() {
         RequestTrace trace = new RequestTrace(null, null, null);
-        assertNull(trace.context());
-        assertNull(trace.parent());
-        assertNull(trace.data());
+        assertThat(trace.context()).isNull();
+        assertThat(trace.parent()).isNull();
+        assertThat(trace.data()).isNull();
     }
 
     @Test
-    void testChainedTraces() {
+    void chainedTraces() {
         RequestTrace root = new RequestTrace("root", null, "root-data");
         RequestTrace level1 = new RequestTrace("level1", root, "level1-data");
         RequestTrace level2 = new RequestTrace("level2", level1, "level2-data");
         RequestTrace level3 = new RequestTrace(level2, "level3-data");
 
         // Verify the chain
-        assertNull(root.parent());
-        assertEquals(root, level1.parent());
-        assertEquals(level1, level2.parent());
-        assertEquals(level2, level3.parent());
+        assertThat(root.parent()).isNull();
+        assertThat(level1.parent()).isEqualTo(root);
+        assertThat(level2.parent()).isEqualTo(level1);
+        assertThat(level3.parent()).isEqualTo(level2);
 
         // Verify context inheritance
-        assertEquals("root", root.context());
-        assertEquals("level1", level1.context());
-        assertEquals("level2", level2.context());
-        assertEquals("level2", level3.context()); // Inherited from parent
+        assertThat(root.context()).isEqualTo("root");
+        assertThat(level1.context()).isEqualTo("level1");
+        assertThat(level2.context()).isEqualTo("level2");
+        assertThat(level3.context()).isEqualTo("level2"); // Inherited from parent
     }
 }