})
        .start();

    Uninterruptibles.awaitUninterruptibly(latch);

    // See Dispatcher.LegacyAsyncDispatcher for an explanation of why there aren't really any
    // useful testable guarantees about the behavior of that dispatcher in a multithreaded
    // environment. Here we simply test that all the expected dispatches happened in some order.

	return &Cache[T]{
		ttl:      ttl,
		updateFn: update,
		opts:     opts,
	}
}

// InitOnce initializes the cache with a TTL and an update function. It is
// guaranteed to be called only once.
func (t *Cache[T]) InitOnce(ttl time.Duration, opts Opts, update func(ctx context.Context) (T, error)) {
	t.Once.Do(func() {
		t.ttl = ttl
		t.updateFn = update
		t.opts = opts
	})
}

   on plugin goals execution order:

   * <<in a given phase, goals order is not expected to be guaranteed nor finely tuned>>:
     it is just a consequence of the order obtained during {{{../maven-model-builder/}effective model building}},
     which combines profile activation+injection and inheritance assembly from parents,

   * interface.
   */
  @Override
  Set<Entry<K, V>> entries();

  /**
   * {@inheritDoc}
   *
   * <p><b>Note:</b> The returned map's values are guaranteed to be of type {@link Set}. To obtain
   * this map with the more specific generic type {@code Map<K, Set<V>>}, call {@link
   * Multimaps#asMap(SetMultimap)} instead.
   */
  @Override
  Map<K, Collection<V>> asMap();

   * associated key. The two bimaps are backed by the same data; any changes to one will appear in
   * the other.
   *
   * <p><b>Note:</b> There is no guaranteed correspondence between the iteration order of a bimap
   * and that of its inverse.
   *
   * @return the inverse view of this bimap
   */
  BiMap<V, K> inverse();

   * interface.
   */
  @Override
  Set<Entry<K, V>> entries();

  /**
   * {@inheritDoc}
   *
   * <p><b>Note:</b> The returned map's values are guaranteed to be of type {@link Set}. To obtain
   * this map with the more specific generic type {@code Map<K, Set<V>>}, call {@link
   * Multimaps#asMap(SetMultimap)} instead.
   */
  @Override
  Map<K, Collection<V>> asMap();

   * example during quiescent points between multithreaded computations. If there are updates
   * concurrent with this method, the returned value is not guaranteed to be the final
   * value occurring before the reset.
   *
   * @return the sum
   */
  public long sumThenReset() {
    long sum = base;
    Cell[] as = cells;
    base = 0L;
    if (as != null) {

        assertNotNull(compressed);
        assertTrue(compressed.length > 0);
        // Compressed size should typically be smaller (though not guaranteed for all data)

        byte[] decompressed = compressionService.decompress(compressed, CompressionService.COMPRESSION_LZ77);
        assertArrayEquals(testData, decompressed);
    }

    @Test

 * equality for both keys and values, unlike {@code ForwardingMap}.
 *
 * <p>The {@code standard} methods and the collection views they return are not guaranteed to be
 * thread-safe, even when all of the methods that they depend on are thread-safe.
 *
 * @author Mike Bostock
 * @author Louis Wasserman
 * @since 2.0
 */
@GwtCompatible
/*

        if (sneaky == null) {
          return sample;
        } else {
          /* Someone beat us to it! Trying again...
           *
           * Technically this loop not guaranteed to terminate, so theoretically (extremely
           * unlikely) this thread might starve, but even then, there is always going to be another
           * thread doing progress here.
           */
        }
      }