Typo rename

Author: jakubmalek

build.gradle.kts

@@ -90,15 +90,16 @@ tasks {
     test {
         useJUnitPlatform()
         systemProperty("file.encoding", "UTF-8")
-        finalizedBy(jacocoTestReport)
         finalizedBy(junit4Test)
+        finalizedBy(jacocoTestReport)
         testLogging {
             events("passed", "skipped", "failed")
         }
     }
     // Jacoco tasks
     jacocoTestReport {
         dependsOn(test)
+        dependsOn(junit4Test)
         executionData(fileTree(project.buildDir).include("jacoco/*.exec"))
         finalizedBy(jacocoTestCoverageVerification)
         reports {

lombok.config

@@ -2,5 +2,5 @@ config.stopBubbling = true
 lombok.toString.doNotUseGetters = true
 lombok.equalsAndHashCode.doNotUseGetters = true
 lombok.log.fieldName = LOG
-lombok.singular.useGuava = true
+lombok.singular.useGuava = false
 lombok.builder.classname = Builder

src/junit4Test/java/com/webfleet/assertj/AsyncAssertionErrorCreatorJUnit4Test.java

@@ -14,7 +14,7 @@
  */
 public class AsyncAssertionErrorCreatorJUnit4Test
 {
-    private static final AsyncAssertAwaiConfig CONFIG = AsyncAssertAwaiConfig.withTimeout(Duration.ofSeconds(4));
+    private static final AsyncAssertAwaitConfig CONFIG = AsyncAssertAwaitConfig.withTimeout(Duration.ofSeconds(4));
 
     @Test
     public void shouldCreateAsyncAssertionErrorForSingleError()

src/main/java/com/webfleet/assertj/AsyncAssertAwaiConfig.java renamed to src/main/java/com/webfleet/assertj/AsyncAssertAwaitConfig.java

@@ -20,25 +20,25 @@
 @Getter
 @EqualsAndHashCode
 @ToString
-final class AsyncAssertAwaiConfig
+final class AsyncAssertAwaitConfig
 {
     private static final Duration DEFAULT_CHECK_INTERVAL = Duration.ofMillis(100L);
     private static final Duration DEFAULT_SHORT_CHECK_INTERVAL = Duration.ofMillis(50L);
 
     private final Duration timeout;
     private final Duration checkInterval;
 
-    static AsyncAssertAwaiConfig withTimeout(@NonNull final Duration timeout)
+    static AsyncAssertAwaitConfig withTimeout(@NonNull final Duration timeout)
     {
         if (timeout.compareTo(ZERO) <= 0)
         {
             throw new IllegalArgumentException("timeout must be greater than zero");
         }
         final var checkInterval = computeCheckInterval(timeout);
-        return new AsyncAssertAwaiConfig(timeout, checkInterval);
+        return new AsyncAssertAwaitConfig(timeout, checkInterval);
     }
 
-    AsyncAssertAwaiConfig withCheckInterval(@NonNull final Duration checkInterval)
+    AsyncAssertAwaitConfig withCheckInterval(@NonNull final Duration checkInterval)
     {
         if (checkInterval.compareTo(ZERO) <= 0)
         {
@@ -48,7 +48,7 @@ AsyncAssertAwaiConfig withCheckInterval(@NonNull final Duration checkInterval)
         {
             throw new IllegalArgumentException("checkInterval must be lower than or equal to timeout");
         }
-        return new AsyncAssertAwaiConfig(timeout, checkInterval);
+        return new AsyncAssertAwaitConfig(timeout, checkInterval);
     }
 
     Duration checkInterval(@NonNull final ElapsedTime elapsedTime)

src/main/java/com/webfleet/assertj/AsyncAssertImpl.java

@@ -14,10 +14,10 @@
 final class AsyncAssertImpl implements AsyncAssert
 {
     private final Time time;
-    private final AsyncAssertAwaiConfig config;
+    private final AsyncAssertAwaitConfig config;
     private final Object waitMutex;
 
-    AsyncAssertImpl(@NonNull final Time time, @NonNull final AsyncAssertAwaiConfig config)
+    AsyncAssertImpl(@NonNull final Time time, @NonNull final AsyncAssertAwaitConfig config)
     {
         this(time, config, new Object());
     }

src/main/java/com/webfleet/assertj/AsyncAssertResult.java

@@ -40,7 +40,7 @@ boolean hasFailed()
         return error != null;
     }
 
-    void throwOnFailure(@NonNull final AsyncAssertAwaiConfig config)
+    void throwOnFailure(@NonNull final AsyncAssertAwaitConfig config)
     {
         if (hasFailed())
         {

src/main/java/com/webfleet/assertj/AsyncAssertionErrorCreator.java

@@ -28,12 +28,12 @@ final class AsyncAssertionErrorCreator
      */
     private static final String ASYNC_ASSERTION_ERROR_CLASS = "com.webfleet.assertj.AsyncAssertionError";
 
-    private static final BiFunction<AsyncAssertAwaiConfig, AssertionError, AssertionError> CREATOR =
+    private static final BiFunction<AsyncAssertAwaitConfig, AssertionError, AssertionError> CREATOR =
         tryLoadAsyncAssertionErrorClass()
             .map(AsyncAssertionErrorCreator::asyncAssertionErrorCreator)
             .orElseGet(AsyncAssertionErrorCreator::fallbackCreator);
 
-    static AssertionError create(@NonNull final AsyncAssertAwaiConfig config, @NonNull final AssertionError error)
+    static AssertionError create(@NonNull final AsyncAssertAwaitConfig config, @NonNull final AssertionError error)
     {
         return CREATOR.apply(config, error);
     }
@@ -51,14 +51,14 @@ private static Optional<Class<?>> tryLoadAsyncAssertionErrorClass()
         }
     }
 
-    private static BiFunction<AsyncAssertAwaiConfig, AssertionError, AssertionError> asyncAssertionErrorCreator(final Class<?> asyncAssertionErrorClass)
+    private static BiFunction<AsyncAssertAwaitConfig, AssertionError, AssertionError> asyncAssertionErrorCreator(final Class<?> asyncAssertionErrorClass)
     {
         final var method = ReflectionCall.run(() -> asyncAssertionErrorClass
             .getDeclaredMethod("create", String.class, AssertionError.class));
         return (config, error) -> ReflectionCall.run(() -> (AssertionError) method.invoke(null, createHeading(config), error));
     }
 
-    private static BiFunction<AsyncAssertAwaiConfig, AssertionError, AssertionError> fallbackCreator()
+    private static BiFunction<AsyncAssertAwaitConfig, AssertionError, AssertionError> fallbackCreator()
     {
         return (config, error) -> {
             final var errors = aggregateErrors(error);
@@ -85,7 +85,7 @@ private static List<String> aggregateErrors(final AssertionError error)
         return singletonList(error.getMessage());
     }
 
-    private static String createHeading(final AsyncAssertAwaiConfig config)
+    private static String createHeading(final AsyncAssertAwaitConfig config)
     {
         return String.format("Async assertion failed after exceeding %sms timeout", config.timeout().toMillis());
     }

src/main/java/com/webfleet/assertj/AsyncAssertions.java

@@ -29,7 +29,7 @@ public final class AsyncAssertions
      */
     public static AsyncAssert awaitAtMost(@NonNull final Duration timeout)
     {
-        return new AsyncAssertImpl(SystemTime.UTC, AsyncAssertAwaiConfig.withTimeout(timeout));
+        return new AsyncAssertImpl(SystemTime.UTC, AsyncAssertAwaitConfig.withTimeout(timeout));
     }
 
     /**

src/test/java/com/webfleet/assertj/AsyncAssertAwaitConfigTest.java

@@ -22,7 +22,7 @@ class AsyncAssertAwaitConfigTest
     void shouldThrowExceptionOnCreationWithNullTimeout()
     {
         // when
-        final var caughtException = catchThrowable(() -> AsyncAssertAwaiConfig.withTimeout(null));
+        final var caughtException = catchThrowable(() -> AsyncAssertAwaitConfig.withTimeout(null));
 
         // then
         assertThat(caughtException)
@@ -35,7 +35,7 @@ void shouldThrowExceptionOnCreationWithNullTimeout()
     void shouldThrowExceptionOnCreationWithNegativeOrZeroTimeout(final Duration timeout)
     {
         // when
-        final var caughtException = catchThrowable(() -> AsyncAssertAwaiConfig.withTimeout(timeout));
+        final var caughtException = catchThrowable(() -> AsyncAssertAwaitConfig.withTimeout(timeout));
 
         // then
         assertThat(caughtException)
@@ -66,7 +66,7 @@ void shouldComputeInitialCheckIntervalBasedOnTimeout(final Duration timeout,
                                                          final SoftAssertions softly)
     {
         // when
-        final var tested = AsyncAssertAwaiConfig.withTimeout(timeout);
+        final var tested = AsyncAssertAwaitConfig.withTimeout(timeout);
 
         // then
         softly.assertThat(tested.checkInterval()).isEqualTo(expectedCheckInterval);
@@ -87,7 +87,7 @@ void shouldReturnAsyncAssertAwaitConfigWithChangedWaitInterval(final Duration ti
                                                                    final SoftAssertions softly)
     {
         // given
-        final var tested = AsyncAssertAwaiConfig.withTimeout(timeout);
+        final var tested = AsyncAssertAwaitConfig.withTimeout(timeout);
 
         // when
         final var withWaitInterval = tested.withCheckInterval(waitInterval);
@@ -122,7 +122,7 @@ void shouldShortenCheckIntervalWhenAddedToElapsedTimeExceedsTimeout(final Durati
                                                                         final Duration expectedCheckInterval)
     {
         // given
-        final var config = AsyncAssertAwaiConfig.withTimeout(timeout)
+        final var config = AsyncAssertAwaitConfig.withTimeout(timeout)
             .withCheckInterval(configuredCheckInterval);
         final ElapsedTime elapsedTime = () -> elapsedTimeDuration;
 
@@ -138,7 +138,7 @@ void shouldThrowExceptionWhenChangedCheckIntervalIsGreaterThanTimeout()
     {
         // given
         final var timeout = Duration.ofSeconds(5);
-        final var tested = AsyncAssertAwaiConfig.withTimeout(timeout);
+        final var tested = AsyncAssertAwaitConfig.withTimeout(timeout);
 
         // when
         final var caughtException = catchThrowable(() -> tested.withCheckInterval(timeout.plusMillis(1)));
@@ -154,7 +154,7 @@ void shouldThrowExceptionWhenChangedCheckIntervalIsGreaterThanTimeout()
     void shouldThrowExceptionWhenChangedCheckIntervalIsNegativeOrZero(final Duration checkInterval)
     {
         // given
-        final var tested = AsyncAssertAwaiConfig.withTimeout(Duration.ofSeconds(1L));
+        final var tested = AsyncAssertAwaitConfig.withTimeout(Duration.ofSeconds(1L));
 
         // when
         final var caughtException = catchThrowable(() -> tested.withCheckInterval(checkInterval));
@@ -169,7 +169,7 @@ void shouldThrowExceptionWhenChangedCheckIntervalIsNegativeOrZero(final Duration
     void shouldThrowExceptionWhenChangedCheckIntervalIsNull()
     {
         // given
-        final var tested = AsyncAssertAwaiConfig.withTimeout(Duration.ofSeconds(1L));
+        final var tested = AsyncAssertAwaitConfig.withTimeout(Duration.ofSeconds(1L));
 
         // when
         final var caughtException = catchThrowable(() -> tested.withCheckInterval(null));

src/test/java/com/webfleet/assertj/AsyncAssertTest.java

@@ -16,7 +16,7 @@
 @ExtendWith(SoftAssertionsExtension.class)
 class AsyncAssertTest
 {
-    private static final AsyncAssertAwaiConfig CONFIG = AsyncAssertAwaiConfig
+    private static final AsyncAssertAwaitConfig CONFIG = AsyncAssertAwaitConfig
         .withTimeout(Duration.ofSeconds(5))
         .withCheckInterval(Duration.ofSeconds(1));