private void tryInitialize() { long latestTimestamp = store.getUpperLimit(); PersistentUpperLimit upperLimit = new PersistentUpperLimit(store); timestamp = new PersistentTimestamp(upperLimit, latestTimestamp); }
@Test public void shouldIncreaseTheUpperLimitIfTheNewLimitIsBigger() { upperLimit.increaseToAtLeast(TIMESTAMP); long biggerLimit = upperLimit.get() + 1000; upperLimit.increaseToAtLeast(biggerLimit); assertThat(upperLimit.get(), is(biggerLimit + BUFFER)); }
private synchronized void updateLimit(long newLimit) { if (currentLimit >= newLimit) { return; } long newLimitWithBuffer = Math.addExact(newLimit, BUFFER); storeUpperLimit(newLimitWithBuffer); currentLimit = newLimitWithBuffer; }
@Test public void shouldStartWithTheCurrentStoredLimit() { when(boundStore.getUpperLimit()).thenReturn(TIMESTAMP); PersistentUpperLimit brandNewUpperLimit = new PersistentUpperLimit(boundStore); assertThat(brandNewUpperLimit.get(), is(TIMESTAMP)); }
public void increaseTo(long newTimestamp) { timestamp.increaseTo(newTimestamp); upperLimit.increaseToAtLeast(newTimestamp); }
public long getUpperLimitTimestampToHandOutInclusive() { return upperLimit.get(); } }
public void increaseToAtLeast(long newLimit) { if (newLimit > currentLimit) { updateLimit(newLimit); } }
public TimestampRange incrementBy(long delta) { TimestampRange range = timestamp.incrementBy(delta); upperLimit.increaseToAtLeast(range.getUpperBound()); return range; }
public void increaseToAtLeast(long newLimit) { if (newLimit > currentLimit) { updateLimit(newLimit); } }
@Test public void shouldNotIncreaseTheUpperLimitWithBufferIfTheNewLimitIsEqual() { upperLimit.increaseToAtLeast(TIMESTAMP); upperLimit.increaseToAtLeast(upperLimit.get()); assertThat(upperLimit.get(), is(TIMESTAMP + BUFFER)); }
@Test public void shouldIncreaseUpperLimitWhenHandingOutNewTimestamps() { assertThat( timestamp.incrementBy(INITIAL_REMAINING_TIMESTAMPS + 10).getUpperBound(), is(UPPER_LIMIT + 10)); verify(upperLimit).increaseToAtLeast(UPPER_LIMIT + 10); }
@Before public void before() { when(upperLimit.get()).thenReturn(5L); timestamp = new PersistentTimestamp(upperLimit, INITIAL_TIMESTAMP); }
@Before public void setup() { boundStore = mock(TimestampBoundStore.class); when(boundStore.getUpperLimit()).thenReturn(INITIAL_UPPER_LIMIT); upperLimit = new PersistentUpperLimit(boundStore); }
private synchronized void updateLimit(long newLimit) { if (currentLimit >= newLimit) { return; } long newLimitWithBuffer = Math.addExact(newLimit, BUFFER); storeUpperLimit(newLimitWithBuffer); currentLimit = newLimitWithBuffer; }
@Test public void shouldNotIncreaseTheUpperLimitIfTheNewLimitIsSmaller() { upperLimit.increaseToAtLeast(TIMESTAMP); upperLimit.increaseToAtLeast(TIMESTAMP - 1000); assertThat(upperLimit.get(), is(TIMESTAMP + BUFFER)); }
@Test public void canFastForwardToANewMinimumTimestamp() { long newMinimum = 2 * UPPER_LIMIT; timestamp.increaseTo(newMinimum); assertThat(timestamp.incrementBy(1).getLowerBound(), is(newMinimum + 1L)); verify(upperLimit).increaseToAtLeast(longThat(is(greaterThan(newMinimum)))); }
public long getUpperLimitTimestampToHandOutInclusive() { return upperLimit.get(); } }
private void tryInitialize() { long latestTimestamp = store.getUpperLimit(); PersistentUpperLimit upperLimit = new PersistentUpperLimit(store); timestamp = new PersistentTimestamp(upperLimit, latestTimestamp); }
@Test public void shouldPersistAnIncreasedTimestamp() { upperLimit.increaseToAtLeast(TIMESTAMP); long biggerLimit = upperLimit.get() + 1000; upperLimit.increaseToAtLeast(biggerLimit); verify(boundStore).storeUpperLimit(biggerLimit + BUFFER); }