public Predicate<? super Entry<K, V>> entryPredicate() {
    return Maps.keyPredicateOnEntries(keyPredicate);
  }

  @Override
  public int size() {
    int size = 0;
    for (Collection<V> collection : asMap().values()) {
      size += collection.size();
    }
    return size;
  }

  @Override
  public boolean containsKey(@CheckForNull Object key) {
    if (unfiltered.containsKey(key)) {

  public Predicate<? super Entry<K, V>> entryPredicate() {
    return Maps.keyPredicateOnEntries(keyPredicate);
  }

  @Override
  public int size() {
    int size = 0;
    for (Collection<V> collection : asMap().values()) {
      size += collection.size();
    }
    return size;
  }

  @Override
  public boolean containsKey(@CheckForNull Object key) {
    if (unfiltered.containsKey(key)) {

        when:
        def visitor = new CollectingValueVisitor()
        hierarchy.visitValues(location, visitor)
        then:
        visitor.ancestorValues.asMap() == values

        where:
        location                                        | values
        ""                                              | [:]
        "some"                                          | [:]

   *
   * <p>Caches loaded by a {@link CacheLoader} will call {@link CacheLoader#load} to load new values
   * into the cache. Newly loaded values are added to the cache using {@code
   * Cache.asMap().putIfAbsent} after loading has completed; if another value was associated with
   * {@code key} while the new value was loading then a removal notification will be sent for the
   * new value.
   *

        list.index.asMap().size() == 2
        list.index.pendingAsMap.size() == 2

        when: "filter the list via the `named` method"
        def filtered = list.named { it.contains("2") }

        then: "unrealized elements remain as such"
        list.index.asMap().size() == 2
        list.index.pendingAsMap.size() == 2

        filtered.index.asMap().size() == 1

   *
   * <p>Caches loaded by a {@link CacheLoader} will call {@link CacheLoader#load} to load new values
   * into the cache. Newly loaded values are added to the cache using {@code
   * Cache.asMap().putIfAbsent} after loading has completed; if another value was associated with
   * {@code key} while the new value was loading then a removal notification will be sent for the
   * new value.
   *

  public long size() {
    return delegate().size();
  }

  @Override
  public CacheStats stats() {
    return delegate().stats();
  }

  @Override
  public ConcurrentMap<K, V> asMap() {
    return delegate().asMap();
  }

  @Override
  public void cleanUp() {
    delegate().cleanUp();
  }

  /**
   * A simplified version of {@link ForwardingCache} where subclasses can pass in an already

        def map = [(new NamespaceId('http://my.extra.info', 'some')): 'value']
        def ivyModuleDescriptor = new DefaultIvyModuleDescriptor(map, null, null)

        when:
        ivyModuleDescriptor.getExtraInfo().asMap().put(new QName('namespace', 'new'), 'value')

        then:
        thrown(UnsupportedOperationException)
    }

    def "getBranch returns branch" () {
        given:

        return producer.create(key, coordinationService, owner);
    }

    public Iterable<T> values() {
        return resourceLocks.asMap().values();
    }

    def "getExtraInfo returns IvyExtraInfo with immutable map" () {
        when:
        spec.getExtraInfo().asMap().put(new QName('http://some.namespace', 'foo'), 'fooValue')

        then:
        thrown(UnsupportedOperationException)
    }

    def "can add extra info elements" () {
        when: