public void clear() {
    delegate().clear();
  }

  @Override
  public boolean containsEntry(@Nullable Object key, @Nullable Object value) {
    return delegate().containsEntry(key, value);
  }

  @Override
  public boolean containsKey(@Nullable Object key) {
    return delegate().containsKey(key);
  }

  @Override
  public boolean containsValue(@Nullable Object value) {
    return delegate().containsValue(value);
  }

  public void clear() {
    delegate().clear();
  }

  @Override
  public boolean containsEntry(@Nullable Object key, @Nullable Object value) {
    return delegate().containsEntry(key, value);
  }

  @Override
  public boolean containsKey(@Nullable Object key) {
    return delegate().containsKey(key);
  }

  @Override
  public boolean containsValue(@Nullable Object value) {
    return delegate().containsValue(value);
  }

    //                                                                         ===========
    @Override
    public boolean hasPrimaryKey() {
        return false;
    }

    @Override
    public boolean hasCompoundPrimaryKey() {
        return false;
    }

    @Override
    protected UniqueInfo cpui() {
        return null;
    }

    writeTimeoutMillis: Int = 10_000,
    socketConnectTimeoutMillis: Int = 10_000,
    socketReadTimeoutMillis: Int = 10_000,
    pingIntervalMillis: Int = 10_000,
    retryOnConnectionFailure: Boolean = true,
    fastFallback: Boolean = true,
    routeDatabase: RouteDatabase = RouteDatabase(),
  ) : this(
    RealConnectionPool(
      taskRunner = taskRunner,
      maxIdleConnections = maxIdleConnections,

 *
 */
@Deprecated
public final class MetadataBridge extends AbstractMetadata implements MergeableMetadata {

    private ArtifactMetadata metadata;

    private boolean merged;

    public MetadataBridge(ArtifactMetadata metadata) {
        this.metadata = metadata;
    }

    @Override
    public void merge(File current, File result) throws RepositoryException {
        try {

     * - parse: sets mechanismToken, throws on null
     * - toByteArray: returns mechanismToken or empty array if null
     */
    static class TestSpnegoToken extends SpnegoToken {
        private boolean parsed = false;

        @Override
        public byte[] toByteArray() {
            byte[] tok = getMechanismToken();
            return tok == null ? new byte[0] : tok;
        }

        @Override

    testThreshold(10, 100, false, false);
    testThreshold(100, 100, false, false);
    testThreshold(1000, 100, false, false);
  }

  private void testThreshold(
      int fileThreshold, int dataSize, boolean singleByte, boolean resetOnFinalize)
      throws IOException {
    byte[] data = newPreFilledByteArray(dataSize);
    FileBackedOutputStream out = new FileBackedOutputStream(fileThreshold, resetOnFinalize);

            }

            @Override
            public boolean isRequestedSessionIdValid() {
                return false;
            }

            @Override
            public boolean isRequestedSessionIdFromCookie() {
                return false;
            }

            @Override
            public boolean isRequestedSessionIdFromURL() {
                return false;
            }

                return Short.valueOf(new SimpleDateFormat(pattern).format(o));
            }
            return (short) ((java.util.Date) o).getTime();
        } else if (o instanceof Boolean) {
            return ((Boolean) o) ? (short) 1 : (short) 0;
        } else {
            return toShort(o.toString());
        }
    }

    private static Short toShort(final String s) {
        if (StringUtil.isEmpty(s)) {

  public boolean addAll(Collection<? extends E> c) {
    assertTrue(Thread.holdsLock(mutex));
    return super.addAll(c);
  }

  @Override
  public void clear() {
    assertTrue(Thread.holdsLock(mutex));
    super.clear();
  }

  @Override
  public boolean contains(@Nullable Object o) {
    assertTrue(Thread.holdsLock(mutex));
    return super.contains(o);
  }

  @Override