Reviewed changes and code tidy

Author: peter-lawrey

src/main/java/net/openhft/chronicle/testframework/CloseableUtil.java

@@ -23,7 +23,7 @@ public enum CloseableUtil {
     public static void closeQuietly(AutoCloseable closeable) {
         try {
             if (closeable != null) { // Ensuring the closeable is not null to avoid NullPointerException
-            closeable.close();
+                closeable.close();
             }
         } catch (Exception e) {
             LOGGER.warn("Error closing", e); // Logging any exceptions that occur during closing

src/main/java/net/openhft/chronicle/testframework/Combination.java

@@ -36,14 +36,15 @@
 public final class Combination {
 
     // Suppresses default constructor, ensuring non-instantiability.
-    private Combination() {}
+    private Combination() {
+    }
 
     /**
      * Creates and returns a stream of all possible combinations of the given elements.
      * <p>
      * The order of the combinations in the stream is unspecified.
      *
-     * @param <T> element type
+     * @param <T>   element type
      * @param items the array of items to combine
      * @return a stream of sets containing all possible combinations of the given elements
      * @throws NullPointerException if the provided {@code items} array is {@code null}.
@@ -60,7 +61,7 @@ public static <T> Stream<Set<T>> of(@NotNull final T... items) {
      * <p>
      * The order of the combinations in the stream is unspecified.
      *
-     * @param <T> element type
+     * @param <T>   element type
      * @param items a collection of items to combine
      * @return a stream of sets containing all possible combinations of the given elements
      * @throws NullPointerException if the provided {@code items} collection is {@code null}.
@@ -78,7 +79,7 @@ public static <T> Stream<Set<T>> of(@NotNull final Collection<T> items) {
      * It is unspecified if the method lazily consumes the provided stream before providing
      * the result or not.
      *
-     * @param <T> element type
+     * @param <T>   element type
      * @param items a stream of items to combine
      * @return a stream of sets containing all possible combinations of the given elements
      * @throws NullPointerException if the provided {@code items} stream is {@code null}.
@@ -88,4 +89,3 @@ public static <T> Stream<Set<T>> of(@NotNull final Stream<T> items) {
         return CombinationUtil.of(items);
     }
 }
-

src/main/java/net/openhft/chronicle/testframework/FlakyTestRunner.java

@@ -92,6 +92,7 @@ public static Builder<RuntimeException> builderUnchecked(@NotNull final Runnable
     private static RunnableThrows<RuntimeException> asRunnableThrows(Runnable runnable) {
         return runnable::run;
     }
+
     /**
      * Defines the interface for constructing and configuring a flaky test runner.
      * <p>
@@ -112,7 +113,6 @@ private static RunnableThrows<RuntimeException> asRunnableThrows(Runnable runnab
      * </pre>
      *
      * @param <X> Type of exception that can be thrown by the runnable object
-     *
      * @see FlakyTestRunner
      * @see FlakyTestRunner.RunnableThrows
      */

src/main/java/net/openhft/chronicle/testframework/Product.java

@@ -281,63 +281,80 @@ public interface TriFunction<T, U, V, R> {
     }
 
 
+    /**
+     * An interface representing an object that has a first component.
+     * This can be used to add functionality to objects that are made up of multiple components.
+     *
+     * @param <T> The type of the first component.
+     */
     public interface HasFirst<T> {
+
         /**
-         * Returns the first component.
+         * Returns the first component of the object.
+         * This method should be implemented to return the first component of the multi-component object.
          *
-         * @return the first component
+         * @return The first component of the object.
          */
         T first();
     }
 
     /**
-     * Interface representing an object that has a second component of type {@code U}.
+     * An interface representing an object that has a second component.
+     * This can be used to add functionality to objects that are made up of multiple components.
      *
-     * @param <U> Type of the second component
+     * @param <U> The type of the second component.
      */
     public interface HasSecond<U> {
+
         /**
-         * Returns the second component.
+         * Returns the second component of the object.
+         * This method should be implemented to return the second component of the multi-component object.
          *
-         * @return the second component
+         * @return The second component of the object.
          */
         U second();
     }
-
     /**
      * Interface representing an object that has a third component of type {@code V}.
+     * This can be used to add functionality to objects that are made up of three components.
      *
      * @param <V> Type of the third component
      */
     public interface HasThird<V> {
+
         /**
-         * Returns the third component.
+         * Returns the third component of the object.
+         * This method should be implemented to return the third component of the multi-component object.
          *
-         * @return the third component
+         * @return The third component of the object.
          */
         V third();
     }
 
     /**
      * A Product2 is a composite object comprising two components.
-     * It's a part of a tuple-like structure with two elements.
+     * It's a part of a tuple-like structure with two elements, extending the HasFirst and HasSecond interfaces.
+     * This provides a way to group two related objects together into a single unit.
      *
      * @param <T> Type of the first component
      * @param <U> Type of the second component
      */
     public interface Product2<T, U> extends HasFirst<T>, HasSecond<U> {
 
+        // Interface doesn't have any additional methods or fields, but inherits those from HasFirst and HasSecond.
     }
 
     /**
      * A Product3 is a composite object comprising three components.
-     * It's a part of a tuple-like structure with three elements.
+     * It's a part of a tuple-like structure with three elements, extending the HasFirst, HasSecond, and HasThird interfaces.
+     * This provides a way to group three related objects together into a single unit.
      *
      * @param <T> Type of the first component
      * @param <U> Type of the second component
      * @param <V> Type of the third component
      */
     public interface Product3<T, U, V> extends HasFirst<T>, HasSecond<U>, HasThird<V> {
-    }
 
+        // Interface doesn't have any additional methods or fields, but inherits those from HasFirst, HasSecond, and HasThird.
+    }
 }

src/main/java/net/openhft/chronicle/testframework/Waiters.java

@@ -6,6 +6,14 @@
 
 import static net.openhft.chronicle.testframework.ThreadUtil.pause;
 
+/**
+ * A utility class providing methods to create wait conditions. These conditions pause the execution of the
+ * program until certain criteria are met or until a specified amount of time has elapsed.
+ * <p>
+ * The class provides functionality for boolean as well as generic conditions and uses a builder pattern
+ * for customization of the waiting behavior, such as the maximum time to wait and the interval to check
+ * the condition.
+ */
 public class Waiters {
 
     // Default maximum time to wait for a condition in milliseconds
@@ -24,10 +32,10 @@ public class Waiters {
      * <p>
      * This method is useful for synchronizing activities in concurrent programming, such as waiting for a connection to close.
      *
-     * @param message         The message to include in the exception if the condition is not met
-     * @param condition       A supplier of the condition being tested, which returns true when the condition is met
-     * @param maxTimeToWaitMs The maximum amount of time to wait for the condition, in milliseconds
-     * @throws ConditionNotMetException If the condition is not met within the specified time
+     * @param message         The message to include in the exception if the condition is not met.
+     * @param condition       A supplier of the condition being tested, which returns true when the condition is met.
+     * @param maxTimeToWaitMs The maximum amount of time to wait for the condition, in milliseconds.
+     * @throws ConditionNotMetException If the condition is not met within the specified time.
      */
     public static void waitForCondition(String message, Supplier<Boolean> condition, long maxTimeToWaitMs) {
         builder(condition)
@@ -41,8 +49,8 @@ public static void waitForCondition(String message, Supplier<Boolean> condition,
      * <p>
      * This method simplifies the creation of waiters for boolean conditions.
      *
-     * @param condition the condition, when it returns true the waiter will complete
-     * @return the {@link WaiterBuilder} for further configuration
+     * @param condition the condition, when it returns true the waiter will complete.
+     * @return the {@link WaiterBuilder} for further configuration.
      */
     public static WaiterBuilder<Boolean> builder(Supplier<Boolean> condition) {
         return builder(condition, IDENTITY).message(DEFAULT_BOOLEAN_MESSAGE);
@@ -53,100 +61,100 @@ public static WaiterBuilder<Boolean> builder(Supplier<Boolean> condition) {
      * <p>
      * This method provides more flexibility for defining complex waiting conditions.
      *
-     * @param valueSupplier   The supplier of the value being tested, which will be regularly evaluated
-     * @param conditionTester A predicate that determines if the condition has been met based on the supplied value
-     * @param <T>             The type of the value being tested
-     * @return the {@link WaiterBuilder} for further configuration
+     * @param valueSupplier   The supplier of the value being tested, which will be regularly evaluated.
+     * @param conditionTester A predicate that determines if the condition has been met based on the supplied value.
+     * @param <T>             The type of the value being tested.
+     * @return the {@link WaiterBuilder} for further configuration.
      */
     public static <T> WaiterBuilder<T> builder(Supplier<T> valueSupplier, Predicate<T> conditionTester) {
         return new WaiterBuilder<>(valueSupplier, conditionTester);
     }
 
     public static class WaiterBuilder<T> implements Runnable {
-    // Supplier that provides a value
+        // Supplier that provides a value
         private final Supplier<T> valueSupplier;
 
-    // Predicate to test the provided value
+        // Predicate to test the provided value
         private final Predicate<T> conditionTester;
 
-    // Maximum time to wait for a condition in milliseconds
+        // Maximum time to wait for a condition in milliseconds
         private long maxTimeToWaitMs = DEFAULT_MAX_WAIT_TIME_MS;
 
-    // Time interval to check the condition in milliseconds
+        // Time interval to check the condition in milliseconds
         private long checkIntervalMs = DEFAULT_CHECK_INTERVAL_MS;
 
-    // Function to generate a message in case the condition isn't met
+        // Function to generate a message in case the condition isn't met
         private Function<T, String> messageGenerator = lastValue -> String.format(DEFAULT_GENERIC_MESSAGE, lastValue);
 
-    // Constructor
+        // Constructor
         private WaiterBuilder(Supplier<T> valueSupplier, Predicate<T> conditionTester) {
             this.valueSupplier = valueSupplier;
             this.conditionTester = conditionTester;
         }
 
         /**
-     * Wait for the condition to be true, throw an {@link ConditionNotMetException}
-     * if the condition is not met in time.
-     *
-     * This method is overridden from the Runnable interface, allowing the WaiterBuilder
-     * to be run as a separate thread.
+         * Wait for the condition to be true, throw an {@link ConditionNotMetException}
+         * if the condition is not met in time.
+         * <p>
+         * This method is overridden from the Runnable interface, allowing the WaiterBuilder
+         * to be run as a separate thread.
          */
         @Override
         public void run() {
             long endTime = System.currentTimeMillis() + maxTimeToWaitMs;
             while (true) {
                 final T value = valueSupplier.get();
                 if (conditionTester.test(value)) {
-                break; // Condition met, break the loop
+                    break; // Condition met, break the loop
                 }
                 if (System.currentTimeMillis() > endTime) {
-                // Condition wasn't met in the allowed time, throw an exception
+                    // Condition wasn't met in the allowed time, throw an exception
                     throw new ConditionNotMetException(value, messageGenerator.apply(value));
                 }
-            // Condition wasn't met yet, pause before checking again
+                // Condition wasn't met yet, pause before checking again
                 pause(checkIntervalMs);
             }
         }
 
         /**
-     * Specifies a static message for the exception in case the condition isn't met.
+         * Specifies a static message for the exception in case the condition isn't met.
          *
-     * @param message the message to be displayed when an exception is thrown
-     * @return the WaiterBuilder instance to allow for method chaining
+         * @param message the message to be displayed when an exception is thrown.
+         * @return the WaiterBuilder instance to allow for method chaining.
          */
         public WaiterBuilder<T> message(String message) {
-        // Override the default message generator with a function that returns the provided message
+            // Override the default message generator with a function that returns the provided message
             this.messageGenerator = lastValue -> message;
-        return this; // Return the instance for method chaining
+            return this; // Return the instance for method chaining
         }
 
         /**
-     * Supply a function for generating the exception message in case the condition isn't met.
+         * Supply a function for generating the exception message in case the condition isn't met.
          *
-     * @param messageGenerator a function that takes the last value as a parameter to create a message
-     * @return this WaiterBuilder instance to allow method chaining
+         * @param messageGenerator a function that takes the last value as a parameter to create a message.
+         * @return this WaiterBuilder instance to allow method chaining.
          */
         public WaiterBuilder<T> messageGenerator(Function<T, String> messageGenerator) {
             this.messageGenerator = messageGenerator;
             return this;
         }
 
         /**
-     * Specify the maximum amount of time to wait for the condition to be met.
+         * Specify the maximum amount of time to wait for the condition to be met.
          *
-     * @param maxTimeToWaitMs the maximum time in milliseconds to wait for the condition
-     * @return this WaiterBuilder instance to allow method chaining
+         * @param maxTimeToWaitMs the maximum time in milliseconds to wait for the condition.
+         * @return this WaiterBuilder instance to allow method chaining.
          */
         public WaiterBuilder<T> maxTimeToWaitMs(long maxTimeToWaitMs) {
             this.maxTimeToWaitMs = maxTimeToWaitMs;
             return this;
         }
 
         /**
-     * Specify the interval between checks of the condition. This determines how often the condition is evaluated.
+         * Specify the interval between checks of the condition. This determines how often the condition is evaluated.
          *
-         * @param checkIntervalMs the interval between checks in milliseconds
-     * @return this WaiterBuilder instance to allow method chaining
+         * @param checkIntervalMs the interval between checks in milliseconds.
+         * @return this WaiterBuilder instance to allow method chaining.
          */
         public WaiterBuilder<T> checkIntervalMs(long checkIntervalMs) {
             this.checkIntervalMs = checkIntervalMs;
@@ -182,4 +190,3 @@ public Object lastValue() {
         }
     }
 }
-