this.service0 = this.service;
        this.connectionState = 0;
    }

    boolean matches(final String share, final String service) {
        return this.share.equalsIgnoreCase(share)
                && (service == null || service.startsWith("??") || this.service.equalsIgnoreCase(service));
    }

    @Override
    public boolean equals(final Object obj) {
        if (obj instanceof final SmbTree tree) {

   * address.
   */
  private fun routeMatchesAny(candidates: List<Route>): Boolean =
    candidates.any {
      it.proxy.type() == Proxy.Type.DIRECT &&
        route.proxy.type() == Proxy.Type.DIRECT &&
        route.socketAddress == it.socketAddress
    }

  private fun supportsUrl(url: HttpUrl): Boolean {
    assertLockHeld()

    val routeUrl = route.address.url

        .url("https://publicobject.com/helloworld.txt")
        .build();

    final ProgressListener progressListener = new ProgressListener() {
      boolean firstUpdate = true;

      @Override public void update(long bytesRead, long contentLength, boolean done) {
        if (done) {
          System.out.println("completed");
        } else {
          if (firstUpdate) {
            firstUpdate = false;

    }

    @Override
    public boolean removeAll(Collection<?> collection) {
      assertTrue(Thread.holdsLock(mutex));
      return delegate.removeAll(collection);
    }

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

    @Override
    public boolean contains(Object object) {

     *
     * @deprecated Use {@link ModelInterpolator#interpolate(Model, File, ProjectBuilderConfiguration, boolean)} instead.
     */
    @Deprecated
    @Override
    public Model interpolate(Model model, Map<String, ?> context, boolean strict) throws ModelInterpolationException {
        Properties props = new Properties();
        props.putAll(context);

    /**
     * Evaluates this guard's boolean condition. This method is always called with the associated
     * monitor already occupied. Implementations of this method must depend only on state protected
     * by the associated monitor, and must not modify that state.
     */
    public abstract boolean isSatisfied();
  }

  /** Whether this monitor is fair. */
  private final boolean fair;

     */
    protected boolean namespaceAware;

    /**
     * If true, the parser will convert CDATA nodes to Text nodes and append them to the adjacent Text node.
     */
    protected boolean coalescing;

    /**
     * If true, the parser will expand entity reference nodes.
     */
    protected boolean expandEntityRef = false;

    /**

  private val renameFaults: MutableSet<Path> = LinkedHashSet()

  fun setFaultyWrite(
    file: Path,
    faulty: Boolean,
  ) {
    if (faulty) {
      writeFaults.add(file)
    } else {
      writeFaults.remove(file)
    }
  }

  fun setFaultyDelete(
    file: Path,
    faulty: Boolean,
  ) {
    if (faulty) {
      deleteFaults.add(file)
    } else {
      deleteFaults.remove(file)
    }
  }

public class SmbFileOutputStream extends OutputStream {

    private static final Logger log = LoggerFactory.getLogger(SmbFileOutputStream.class);

    private final SmbFile file;
    private final boolean append;

    private boolean useNTSmbs;
    private int openFlags;

    private final int access;

    private int writeSize;

    private int writeSizeFile;
    private long fp;
    private byte[] tmp = new byte[1];

    /** Whether to use raw NTLM authentication without SPNEGO */
    protected boolean useRawNTLM = false;
    /** Whether to disable SPNEGO integrity checking */
    protected boolean disableSpnegoIntegrity = false;
    /** Whether to enforce SPNEGO integrity checking */
    protected boolean enforceSpnegoIntegrity = true;
    /** Whether plain text passwords are disabled */