}

    @Override
    public Set<K> createKeySet() {
      return removeOnlySet(backingSet());
    }

    @Override
    Collection<V> createValues() {
      return Collections2.transform(set, function);
    }

    @Override
    public int size() {
      return backingSet().size();
    }

    @Override
    public boolean containsKey(@Nullable Object key) {

                  @Override
                  public String[] createKeyArray(int length) {
                    return new String[length];
                  }

                  @Override
                  public Integer[] createValueArray(int length) {
                    return new Integer[length];
                  }

                  @Override

     * @see jcifs.util.transport.Request#getCreditCost()
     */
    @Override
    public int getCreditCost() {
        return 1;
    }

    /**
     * {@inheritDoc}
     *
     * @see jcifs.internal.CommonServerMessageBlockRequest#isResponseAsync()
     */
    @Override
    public boolean isResponseAsync() {
        return false;
    }

    @Override
    public ServerMessageBlock2Request<?> getNext() {

    @Override
    public String getProjectName() {
        return null;
    }

    @Override
    public String getProjectPrefix() {
        return null;
    }

    @Override
    public String getGenerationGapBasePrefix() {
        return null;
    }

    @Override
    public DBDef getCurrentDBDef() {
        return null;
    }

    }

    @Override
    public void artifactDeployed(RepositoryEvent event) {
        println("artifactDeployed", event.getArtifact() + " to " + event.getRepository());
    }

    @Override
    public void artifactDeploying(RepositoryEvent event) {
        println("artifactDeploying", event.getArtifact() + " to " + event.getRepository());
    }

    @Override

    @Override
    protected Map<String, String> create(Entry<String, String>[] entries) {
      return ImmutableMap.copyOf(asList(entries));
    }
  }

  public static class ImmutableMapUnhashableValuesGenerator
      extends TestUnhashableCollectionGenerator<Collection<UnhashableObject>> {

    @Override

      this.mutex = mutex;
    }

    @Override
    protected Map<K, V> delegate() {
      return delegate;
    }

    @Override
    public int size() {
      assertTrue(Thread.holdsLock(mutex));
      return super.size();
    }

    @Override
    public boolean isEmpty() {
      assertTrue(Thread.holdsLock(mutex));
      return super.isEmpty();
    }

    @Override
    public @Nullable V remove(Object object) {

        return null;
    }

    @Override
    public void injectAuthentication(List<ArtifactRepository> repositories, List<Server> servers) {}

    @Override
    public void injectMirror(List<ArtifactRepository> repositories, List<Mirror> mirrors) {}

    @Override
    public void injectProxy(List<ArtifactRepository> repositories, List<Proxy> proxies) {}

    @Override
    public void publish(

      this.delegate = delegate;
    }

    @Override
    protected Map<K, V> delegate() {
      return delegate;
    }

    @Override
    public Set<K> keySet() {
      return new ForwardingSet<K>() {
        @Override
        protected Set<K> delegate() {
          return delegate.keySet();
        }

        @Override
        public Iterator<K> iterator() {

    super(delegate);
  }

  @Override
  protected SortedMultiset<E> delegate() {
    return (SortedMultiset<E>) super.delegate();
  }

  @Override
  public Comparator<? super E> comparator() {
    return delegate().comparator();
  }

  @Override
  NavigableSet<E> createElementSet() {
    return unmodifiableNavigableSet(delegate().elementSet());
  }

  @Override
  public NavigableSet<E> elementSet() {