*
 */
@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

  OPEN(false),
  CLOSED(true);

  final boolean inclusive;

  BoundType(boolean inclusive) {
    this.inclusive = inclusive;
  }

  /** Returns the bound type corresponding to a boolean value for inclusivity. */
  static BoundType forBoolean(boolean inclusive) {
    return inclusive ? CLOSED : OPEN;
  }

        }

        public boolean add(final E e) {
            return parent.add(e);
        }

        public boolean remove(final Object o) {
            return parent.remove(o);
        }

        public boolean containsAll(final Collection<?> c) {
            return parent.containsAll(c);
        }

        public boolean addAll(final Collection<? extends E> c) {

  override fun send(text: String): Boolean = send(text.encodeUtf8(), OPCODE_TEXT)

  override fun send(bytes: ByteString): Boolean = send(bytes, OPCODE_BINARY)

  @Synchronized private fun send(
    data: ByteString,
    formatOpcode: Int,
  ): Boolean {
    // Don't send new frames after we've failed or enqueued a close frame.

    public JulLoggerAdapter(final Class<?> clazz) {
        sourceClass = clazz.getName();
        logger = java.util.logging.Logger.getLogger(clazz.getName());
    }

    @Override
    public boolean isFatalEnabled() {
        return logger.isLoggable(Level.SEVERE);
    }

    @Override
    public void fatal(final String message) {
        logger.logp(Level.SEVERE, sourceClass, null, message);
    }

  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

    private int capability;
    private int linkSpeed; // In units of 1 Mbps
    private byte[] sockaddrStorage;
    private InetAddress address;
    private boolean ipv6;
    private boolean rssCapable; // Receive Side Scaling
    private boolean rdmaCapable;

    /**
     * Create network interface info
     *
     * @param address interface address
     * @param linkSpeed link speed in Mbps
     */

    )
  }

  class Builder {
    internal var tls: Boolean = false
    internal var cipherSuites: Array<String>? = null
    internal var tlsVersions: Array<String>? = null
    internal var supportsTlsExtensions: Boolean = false

    internal constructor(tls: Boolean) {
      this.tls = tls
    }

    constructor(connectionSpec: ConnectionSpec) {

        void testVerifyThreadSafety() throws InterruptedException {
            int threadCount = 10;
            Thread[] threads = new Thread[threadCount];
            boolean[] results = new boolean[threadCount];

            // Set signed flag
            SMBUtil.writeInt4(ServerMessageBlock2.SMB2_FLAGS_SIGNED, data, 16);

            for (int i = 0; i < threadCount; i++) {
                final int index = i;