Change timeout & invocations params type from int to long

docs/index.md

@@ -93,7 +93,7 @@ See [LICENSE](LICENSE).
 	* discuss with the authors on an issue ticket prior to doing anything big
 	* follow the style, naming and structure conventions of the rest of the project
 	* make commits atomic and easy to merge
-	* verify all tests are passing. Build the project with `mvn clean install` to do this.
+	* verify all tests are passing. Build the project with `./mvnw clean install` to do this.
 
 ## Copyright
 

src/main/java/org/rnorth/ducttape/ratelimits/ConstantThroughputRateLimiter.java

@@ -11,7 +11,7 @@ class ConstantThroughputRateLimiter extends RateLimiter {
 
     private final long timeBetweenInvocations;
 
-    ConstantThroughputRateLimiter(@NotNull Integer rate, @NotNull TimeUnit perTimeUnit) {
+    ConstantThroughputRateLimiter(@NotNull Long rate, @NotNull TimeUnit perTimeUnit) {
         this.timeBetweenInvocations = perTimeUnit.toMillis(1) / rate;
     }
 

src/main/java/org/rnorth/ducttape/ratelimits/RateLimiterBuilder.java

@@ -9,7 +9,7 @@
  */
 public class RateLimiterBuilder {
 
-    private Integer invocations;
+    private Long invocations;
     private TimeUnit perTimeUnit;
     private RateLimiterStrategy strategy;
 
@@ -30,7 +30,7 @@ public static RateLimiterBuilder newBuilder() {
      * @param perTimeUnit   the time period in which this number of invocations are allowed
      * @return the builder
      */
-    public RateLimiterBuilder withRate(final int invocations, final TimeUnit perTimeUnit) {
+    public RateLimiterBuilder withRate(final long invocations, final TimeUnit perTimeUnit) {
         this.invocations = invocations;
         this.perTimeUnit = perTimeUnit;
         return this;

src/main/java/org/rnorth/ducttape/timeouts/Timeouts.java

@@ -2,7 +2,15 @@
 
 import org.jetbrains.annotations.NotNull;
 
-import java.util.concurrent.*;
+import java.time.Duration;
+import java.util.concurrent.Callable;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.Future;
+import java.util.concurrent.ThreadFactory;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
 import java.util.concurrent.atomic.AtomicInteger;
 
 import static org.rnorth.ducttape.Preconditions.check;
@@ -35,7 +43,7 @@ public Thread newThread(@NotNull Runnable r) {
      * @param <T>      return type of the lambda
      * @return the result of the successful lambda expression call
      */
-    public static <T> T getWithTimeout(final int timeout, final TimeUnit timeUnit, @NotNull final Callable<T> lambda) {
+    public static <T> T getWithTimeout(final long timeout, final TimeUnit timeUnit, @NotNull final Callable<T> lambda) {
 
         check("timeout must be greater than zero", timeout > 0);
 
@@ -52,15 +60,15 @@ public static <T> T getWithTimeout(final int timeout, final TimeUnit timeUnit, @
      * @param timeUnit time unit for time interval
      * @param lambda   supplier lambda expression (may throw checked exceptions)
      */
-    public static void doWithTimeout(final int timeout, @NotNull final TimeUnit timeUnit, @NotNull final Runnable lambda) {
+    public static void doWithTimeout(final long timeout, @NotNull final TimeUnit timeUnit, @NotNull final Runnable lambda) {
 
         check("timeout must be greater than zero", timeout > 0);
 
         Future<?> future = EXECUTOR_SERVICE.submit(lambda);
         callFuture(timeout, timeUnit, future);
     }
 
-    private static <T> T callFuture(final int timeout, @NotNull final TimeUnit timeUnit, @NotNull final Future<T> future) {
+    private static <T> T callFuture(final long timeout, @NotNull final TimeUnit timeUnit, @NotNull final Future<T> future) {
         try {
             return future.get(timeout, timeUnit);
         } catch (ExecutionException e) {

src/main/java/org/rnorth/ducttape/unreliables/Unreliables.java

@@ -5,6 +5,7 @@
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
+import java.time.Duration;
 import java.util.concurrent.Callable;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicBoolean;
@@ -28,7 +29,7 @@ public abstract class Unreliables {
      * @param <T>      return type of the supplier
      * @return the result of the successful lambda expression call
      */
-    public static <T> T retryUntilSuccess(final int timeout, @NotNull final TimeUnit timeUnit, @NotNull final Callable<T> lambda) {
+    public static <T> T retryUntilSuccess(final long timeout, @NotNull final TimeUnit timeUnit, @NotNull final Callable<T> lambda) {
 
         check("timeout must be greater than zero", timeout > 0);
 
@@ -96,7 +97,7 @@ public static <T> T retryUntilSuccess(final int tryLimit, @NotNull final Callabl
      * @param timeUnit time unit for time interval
      * @param lambda   supplier lambda expression
      */
-    public static void retryUntilTrue(final int timeout, @NotNull final TimeUnit timeUnit, @NotNull final Callable<Boolean> lambda) {
+    public static void retryUntilTrue(final long timeout, @NotNull final TimeUnit timeUnit, @NotNull final Callable<Boolean> lambda) {
         retryUntilSuccess(timeout, timeUnit, () -> {
             if (!lambda.call()) {
                 throw new RuntimeException("Not ready yet");