public void testCreateWarmupParameterValidation() { RateLimiter unused; unused = RateLimiter.create(1.0, 1, NANOSECONDS); unused = RateLimiter.create(1.0, 0, NANOSECONDS); try { RateLimiter.create(0.0, 1, NANOSECONDS); fail(); } catch (IllegalArgumentException expected) { } try { RateLimiter.create(1.0, -1, NANOSECONDS); fail(); } catch (IllegalArgumentException expected) { } }
public void testInfinity_WarmUpTimeElapsed() { RateLimiter limiter = RateLimiter.create(Double.POSITIVE_INFINITY, 10, SECONDS, 3.0, stopwatch); stopwatch.instant += 1000000; limiter.setRate(1.0); for (int i = 0; i < 5; i++) { limiter.acquire(); } assertEvents("R0.00", "R1.00", "R1.00", "R1.00", "R1.00"); }
/** https://code.google.com/p/guava-libraries/issues/detail?id=1791 */ public void testInfinity_BustyTimeElapsed() { RateLimiter limiter = RateLimiter.create(Double.POSITIVE_INFINITY, stopwatch); stopwatch.instant += 1000000; limiter.setRate(2.0); for (int i = 0; i < 5; i++) { limiter.acquire(); } assertEvents( "R0.00", // First comes the saved-up burst, which defaults to a 1-second burst (2 requests). "R0.00", "R0.00", // Now comes the free request. "R0.50", // Now it's 0.5 seconds per request. "R0.50"); }
public void testSimple() { RateLimiter limiter = RateLimiter.create(5.0, stopwatch); limiter.acquire(); // R0.00, since it's the first request limiter.acquire(); // R0.20 limiter.acquire(); // R0.20 assertEvents("R0.00", "R0.20", "R0.20"); }
public void testImmediateTryAcquire() { RateLimiter r = RateLimiter.create(1); assertTrue("Unable to acquire initial permit", r.tryAcquire()); assertFalse("Capable of acquiring secondary permit", r.tryAcquire()); }
public void testWarmUpWithColdFactor1() { RateLimiter limiter = RateLimiter.create(5.0, 4000, MILLISECONDS, 1.0, stopwatch); for (int i = 0; i < 8; i++) { limiter.acquire(); // #1 } stopwatch.sleepMillis(340); // #2 for (int i = 0; i < 8; i++) { limiter.acquire(); // #3 } assertEvents( "R0.00, R0.20, R0.20, R0.20, R0.20, R0.20, R0.20, R0.20", // #1 "U0.34", // #2 "R0.00, R0.20, R0.20, R0.20, R0.20, R0.20, R0.20, R0.20"); // #3 }
public void testTryAcquire_overflow() { RateLimiter limiter = RateLimiter.create(5.0, stopwatch); assertTrue(limiter.tryAcquire(0, MICROSECONDS)); stopwatch.sleepMillis(100); assertTrue(limiter.tryAcquire(Long.MAX_VALUE, MICROSECONDS)); }
public void testExecutors_nullCheck() throws Exception { new ClassSanityTester() .setDefault(RateLimiter.class, RateLimiter.create(1.0)) .forAllPublicStaticMethods(MoreExecutors.class) .thatReturn(Executor.class) .testNulls(); }
public void testSimpleWithWait() { RateLimiter limiter = RateLimiter.create(5.0, stopwatch); limiter.acquire(); // R0.00 stopwatch.sleepMillis(200); // U0.20, we are ready for the next request... limiter.acquire(); // R0.00, ...which is granted immediately limiter.acquire(); // R0.20 assertEvents("R0.00", "U0.20", "R0.00", "R0.20"); }
public void testNulls() { NullPointerTester tester = new NullPointerTester() .setDefault(SleepingStopwatch.class, stopwatch) .setDefault(int.class, 1) .setDefault(double.class, 1.0d); tester.testStaticMethods(RateLimiter.class, Visibility.PACKAGE); tester.testInstanceMethods(RateLimiter.create(5.0, stopwatch), Visibility.PACKAGE); }
public void testVerySmallDoubleValues() throws Exception { RateLimiter rateLimiter = RateLimiter.create(Double.MIN_VALUE, stopwatch); assertTrue("Should acquire initial permit", rateLimiter.tryAcquire()); assertFalse("Should not acquire additional permit", rateLimiter.tryAcquire()); stopwatch.sleepMillis(5000); assertFalse( "Should not acquire additional permit even after sleeping", rateLimiter.tryAcquire()); }
public void testDoubleMinValueCanAcquireExactlyOnce() { RateLimiter r = RateLimiter.create(Double.MIN_VALUE, stopwatch); assertTrue("Unable to acquire initial permit", r.tryAcquire()); assertFalse("Capable of acquiring an additional permit", r.tryAcquire()); stopwatch.sleepMillis(Integer.MAX_VALUE); assertFalse("Capable of acquiring an additional permit after sleeping", r.tryAcquire()); }
public void testSimpleWeights() { RateLimiter rateLimiter = RateLimiter.create(1.0, stopwatch); rateLimiter.acquire(1); // no wait rateLimiter.acquire(1); // R1.00, to repay previous rateLimiter.acquire(2); // R1.00, to repay previous rateLimiter.acquire(4); // R2.00, to repay previous rateLimiter.acquire(8); // R4.00, to repay previous rateLimiter.acquire(1); // R8.00, to repay previous assertEvents("R0.00", "R1.00", "R1.00", "R2.00", "R4.00", "R8.00"); }
public void testBurstyAndUpdate() { RateLimiter rateLimiter = RateLimiter.create(1.0, stopwatch); rateLimiter.acquire(1); // no wait rateLimiter.acquire(1); // R1.00, to repay previous rateLimiter.setRate(2.0); // update the rate! rateLimiter.acquire(1); // R1.00, to repay previous (the previous was under the old rate!) rateLimiter.acquire(2); // R0.50, to repay previous (now the rate takes effect) rateLimiter.acquire(4); // R1.00, to repay previous rateLimiter.acquire(1); // R2.00, to repay previous assertEvents("R0.00", "R1.00", "R1.00", "R0.50", "R1.00", "R2.00"); }
public void testTryAcquire_negative() { RateLimiter limiter = RateLimiter.create(5.0, stopwatch); assertTrue(limiter.tryAcquire(5, 0, SECONDS)); stopwatch.sleepMillis(900); assertFalse(limiter.tryAcquire(1, Long.MIN_VALUE, SECONDS)); stopwatch.sleepMillis(100); assertTrue(limiter.tryAcquire(1, -1, SECONDS)); }
public void testSimpleAcquireReturnValues() { RateLimiter limiter = RateLimiter.create(5.0, stopwatch); assertEquals(0.0, limiter.acquire(), EPSILON); // R0.00 stopwatch.sleepMillis(200); // U0.20, we are ready for the next request... assertEquals(0.0, limiter.acquire(), EPSILON); // R0.00, ...which is granted immediately assertEquals(0.2, limiter.acquire(), EPSILON); // R0.20 assertEvents("R0.00", "U0.20", "R0.00", "R0.20"); }
public void testOneSecondBurst() { RateLimiter limiter = RateLimiter.create(5.0, stopwatch); stopwatch.sleepMillis(1000); // max capacity reached stopwatch.sleepMillis(1000); // this makes no difference limiter.acquire(1); // R0.00, since it's the first request limiter.acquire(1); // R0.00, from capacity limiter.acquire(3); // R0.00, from capacity limiter.acquire(1); // R0.00, concluding a burst of 5 permits limiter.acquire(); // R0.20, capacity exhausted assertEvents( "U1.00", "U1.00", "R0.00", "R0.00", "R0.00", "R0.00", // first request and burst "R0.20"); }
public void testSimpleAcquireEarliestAvailableIsInPast() { RateLimiter limiter = RateLimiter.create(5.0, stopwatch); assertEquals(0.0, limiter.acquire(), EPSILON); stopwatch.sleepMillis(400); assertEquals(0.0, limiter.acquire(), EPSILON); assertEquals(0.0, limiter.acquire(), EPSILON); assertEquals(0.2, limiter.acquire(), EPSILON); }
public void testTryAcquire_noWaitAllowed() { RateLimiter limiter = RateLimiter.create(5.0, stopwatch); assertTrue(limiter.tryAcquire(0, SECONDS)); assertFalse(limiter.tryAcquire(0, SECONDS)); assertFalse(limiter.tryAcquire(0, SECONDS)); stopwatch.sleepMillis(100); assertFalse(limiter.tryAcquire(0, SECONDS)); }
public void testTryAcquire_someWaitAllowed() { RateLimiter limiter = RateLimiter.create(5.0, stopwatch); assertTrue(limiter.tryAcquire(0, SECONDS)); assertTrue(limiter.tryAcquire(200, MILLISECONDS)); assertFalse(limiter.tryAcquire(100, MILLISECONDS)); stopwatch.sleepMillis(100); assertTrue(limiter.tryAcquire(100, MILLISECONDS)); }