private static ReleaseableLatch waitForLatch(EntityInternal entity, ConfigKey<Boolean> configKey) { Maybe<?> rawValue = entity.config().getRaw(configKey); if (rawValue.isAbsent()) { return ReleaseableLatch.NOP; } else { ValueResolverIterator<Boolean> iter = resolveLatchIterator(entity, rawValue.get(), configKey); // The iterator is used to prevent coercion; the value should always be the last one, but iter.last() will return a coerced Boolean Maybe<ReleaseableLatch> releasableLatchMaybe = iter.next(ReleaseableLatch.class); if (releasableLatchMaybe.isPresent()) { ReleaseableLatch latch = releasableLatchMaybe.get(); log.debug("{} finished waiting for {} (value {}); waiting to acquire the latch", new Object[] {entity, configKey, latch}); Tasks.setBlockingDetails("Acquiring " + configKey + " " + latch); try { latch.acquire(entity); } finally { Tasks.resetBlockingDetails(); } log.debug("{} Acquired latch {} (value {}); continuing...", new Object[] {entity, configKey, latch}); return latch; } else { // If iter.next() above returned absent due to a resolve error next line will throw with the cause Boolean val = iter.last().get(); if (rawValue != null) log.debug("{} finished waiting for {} (value {}); continuing...", new Object[] {entity, configKey, val}); return ReleaseableLatch.NOP; } } }
@Test(dataProvider="resolveTypes") public void testNextTypeFound(ResolveType resolveType) { FailingImmediateAndDeferredSupplier failingExpected = new FailingImmediateAndDeferredSupplier(); WrappingImmediateAndDeferredSupplier wrapperExpected = new WrappingImmediateAndDeferredSupplier(failingExpected); ValueResolver<Object> resolver = Tasks.resolving(wrapperExpected) .as(Object.class) .context(app) .immediately(resolveType.isImmediate()); ValueResolverIterator<Object> iter = resolver.iterator(); Maybe<FailingImmediateAndDeferredSupplier> actual = iter.next(FailingImmediateAndDeferredSupplier.class); assertTrue(actual.isPresent()); assertNotEquals(actual, iter.last()); }
@Test(dataProvider="resolveTypes") public void testNextOrLastFound(ResolveType resolveType) { FailingImmediateAndDeferredSupplier failingExpected = new FailingImmediateAndDeferredSupplier(); WrappingImmediateAndDeferredSupplier wrapperExpected = new WrappingImmediateAndDeferredSupplier(failingExpected); ValueResolver<Object> resolver = Tasks.resolving(wrapperExpected) .as(Object.class) .context(app) .immediately(resolveType.isImmediate()); ValueResolverIterator<Object> iter = resolver.iterator(); Maybe<Object> actual = iter.nextOrLast(FailingImmediateAndDeferredSupplier.class); assertTrue(actual.isPresent()); assertNotEquals(actual, iter.last()); }
@Test(dataProvider="resolveTypes") public void testNextOrLastNotFound(ResolveType resolveType) { FailingImmediateAndDeferredSupplier failingExpected = new FailingImmediateAndDeferredSupplier(); WrappingImmediateAndDeferredSupplier wrapperExpected = new WrappingImmediateAndDeferredSupplier(failingExpected); ValueResolver<Object> resolver = Tasks.resolving(wrapperExpected) .as(Object.class) .context(app) .immediately(resolveType.isImmediate()); ValueResolverIterator<Object> iter = resolver.iterator(); Maybe<Object> actual = iter.nextOrLast(Void.class); assertFalse(actual.isPresent()); assertEquals(actual, iter.last()); }
@Test(dataProvider="resolveTypes") public void testNextTypeNotFound(ResolveType resolveType) { FailingImmediateAndDeferredSupplier failingExpected = new FailingImmediateAndDeferredSupplier(); WrappingImmediateAndDeferredSupplier wrapperExpected = new WrappingImmediateAndDeferredSupplier(failingExpected); ValueResolver<Object> resolver = Tasks.resolving(wrapperExpected) .as(Object.class) .context(app) .immediately(resolveType.isImmediate()); ValueResolverIterator<Object> iter = resolver.iterator(); Maybe<Void> actual = iter.next(Void.class); assertFalse(actual.isPresent()); assertEquals(actual, iter.last()); } }
@Test(dataProvider="resolveTypes") public void testNull(ResolveType resolveType) { ValueResolver<Void> resolver = Tasks.resolving(null) .as(Void.class) .context(app) .immediately(resolveType.isImmediate()); assertNull(resolver.get()); ValueResolverIterator<Void> iter = resolver.iterator(); assertTrue(iter.hasNext()); assertNull(iter.next().get()); assertFalse(iter.hasNext()); Maybe<Object> voidOrLast = resolver.iterator().nextOrLast(Void.class); assertNull(voidOrLast.get()); Maybe<Void> voidItem = resolver.iterator().next(Void.class); assertTrue(voidItem.isAbsent()); Maybe<Void> lastItem = resolver.iterator().last(); assertNull(lastItem.get()); }