private VersionedType<T> recalculate() { version++; return VersionedType.of(aggregator.apply(latestValues.values()), version); }
private VersionedType<Long> constantNumber() { return VersionedType.of(1L, 0); } }
private synchronized VersionedType<Long> increasingNumber() { supplierCounter++; return VersionedType.of(supplierCounter, supplierCounter / 100); }
@Test public void appliesFunctionOnlyOnceWhenUnderlyingSupplierIsConstant() { when(mockVersionedSupplier.get()).thenReturn(VersionedType.of(3L, 0)); assertThat(counter).isEqualTo(0); assertThat(testSupplier.get()).isEqualTo(6); assertThat(testSupplier.get()).isEqualTo(6); assertThat(testSupplier.get()).isEqualTo(6); assertThat(counter).isEqualTo(1); }
@Test public void appliesFunctionToNullValue() { when(mockVersionedSupplier.get()).thenReturn(VersionedType.of(null, 0)); assertThat(counter).isEqualTo(0); assertThat(testSupplier.get()).isNull(); assertThat(counter).isEqualTo(1); }
@Test public void doesNotApplyFunctionIfGetIsInvokedAndSuppliedVersionConstant() { when(mockVersionedSupplier.get()).thenReturn(VersionedType.of(null, 0)); assertThat(testSupplier.get()).isNull(); assertThat(counter).isEqualTo(1); when(mockVersionedSupplier.get()).thenReturn(VersionedType.of(3L, 0)); assertThat(testSupplier.get()).isNull(); assertThat(counter).isEqualTo(1); when(mockVersionedSupplier.get()).thenReturn(VersionedType.of(8L, 0)); assertThat(testSupplier.get()).isNull(); assertThat(counter).isEqualTo(1); when(mockVersionedSupplier.get()).thenReturn(VersionedType.of(3L, 1)); assertThat(testSupplier.get()).isEqualTo(6); assertThat(counter).isEqualTo(2); }
@Test public void appliesFunctionEachTimeGetIsInvokedAndSuppliedVersionChanged() { when(mockVersionedSupplier.get()).thenReturn(VersionedType.of(null, 0)); assertThat(testSupplier.get()).isNull(); assertThat(counter).isEqualTo(1); when(mockVersionedSupplier.get()).thenReturn(VersionedType.of(3L, 1)); assertThat(testSupplier.get()).isEqualTo(6); assertThat(counter).isEqualTo(2); when(mockVersionedSupplier.get()).thenReturn(VersionedType.of(3L, 2)); assertThat(testSupplier.get()).isEqualTo(6); assertThat(testSupplier.get()).isEqualTo(6); assertThat(counter).isEqualTo(3); when(mockVersionedSupplier.get()).thenReturn(VersionedType.of(8L, 3)); assertThat(testSupplier.get()).isEqualTo(16); assertThat(counter).isEqualTo(4); }
@Test public void versionUpdatesForGetAfterRefreshMillis() throws InterruptedException { assertThat(supplier.get()).isEqualTo(VersionedType.of(0L, UNINITIALIZED_VERSION + 1L)); waitForUpdate(); assertThat(supplier.get()).isEqualTo(VersionedType.of(0L, UNINITIALIZED_VERSION + 2L)); waitForUpdate(); assertThat(supplier.get()).isEqualTo(VersionedType.of(0L, UNINITIALIZED_VERSION + 3L)); }
@Test public void canUpdateForNewKeys() throws InterruptedException { assertThat(supplier.get()).isEqualTo(VersionedType.of(0L, UNINITIALIZED_VERSION + 1L)); supplier.update(1, 1L); waitForUpdate(); assertThat(supplier.get()).isEqualTo(VersionedType.of(1L, UNINITIALIZED_VERSION + 2L)); supplier.update(2, 100L); waitForUpdate(); assertThat(supplier.get()).isEqualTo(VersionedType.of(100L, UNINITIALIZED_VERSION + 3L)); }
@Test public void canUpdateForExistingKeys() throws InterruptedException { assertThat(supplier.get()).isEqualTo(VersionedType.of(0L, UNINITIALIZED_VERSION + 1L)); supplier.update(2, 100L); waitForUpdate(); assertThat(supplier.get()).isEqualTo(VersionedType.of(100L, UNINITIALIZED_VERSION + 2L)); supplier.update(2, 10L); waitForUpdate(); assertThat(supplier.get()).isEqualTo(VersionedType.of(10L, UNINITIALIZED_VERSION + 3L)); }
@Test public void versionDoesNotUpdateUntilGetIsCalled() throws InterruptedException { assertThat(supplier.get()).isEqualTo(VersionedType.of(0L, UNINITIALIZED_VERSION + 1L)); waitForUpdate(); waitForUpdate(); waitForUpdate(); assertThat(supplier.get()).isEqualTo(VersionedType.of(0L, UNINITIALIZED_VERSION + 2L)); }
private VersionedType<T> recalculate() { version++; return VersionedType.of(aggregator.apply(latestValues.values()), version); }