*
     * @return whether the FD is open and valid
     */
    boolean isOpen();

    /**
     * Tests whether this file descriptor was previously open but has become invalid.
     *
     * @return whether the FD was previously open but became invalid
     */
    boolean isStale();

    /**
     * Unwraps this handle to the specified type.
     *
     * @param <T> the type to unwrap to

 */

package jcifs.internal.smb1.trans;

import jcifs.Configuration;

/**
 * Response for SMB1 TRANS_WAIT_NAMED_PIPE transaction.
 *
 * This response is received after waiting for a named pipe to become available
 * for connection when the pipe server was busy.
 */
public class TransWaitNamedPipeResponse extends SmbComTransactionResponse {

    /**
     * Constructs a response for a wait named pipe request.
     *

package jcifs.internal.smb1.trans;

import jcifs.Configuration;

/**
 * SMB1 Transaction Wait Named Pipe request implementation.
 * Implements the TRANS_WAIT_NAMED_PIPE transaction to wait for a named pipe
 * to become available when the pipe server is busy or temporarily unavailable.
 *
 * @author mbechler
 */
public class TransWaitNamedPipe extends SmbComTransaction {

    /**
     * Constructs a wait request for a named pipe.

import jcifs.Encodable;
import jcifs.internal.util.SMBUtil;

/**
 * File System Control Code (FSCC) request for pipe wait operations.
 * Implements the FSCTL_PIPE_WAIT control code used to wait for a named pipe
 * to become available when attempting to connect to a busy pipe.
 *
 * @author mbechler
 */
public class FsctlPipeWaitRequest implements Encodable {

    private final byte[] nameBytes;
    private final long timeout;

that STS tokens signed previously by root credentials will no longer be valid upon upgrading to the latest version with this change. Please re-generate them as you usually do. Additionally, if site replication is ever removed - the STS tokens will become invalid, regenerate them as you usually do....

  public void testIterator_removeAffectsBackingCollection() {
    int originalSize = collection.size();
    Iterator<E> iterator = collection.iterator();
    Object element = iterator.next();
    // If it's an Entry, it may become invalid once it's removed from the Map. Copy it.
    if (element instanceof Entry) {
      Entry<?, ?> entry = (Entry<?, ?>) element;
      element = mapEntry(entry.getKey(), entry.getValue());
    }

    val responseA = client.newCall(requestA).execute()

    assertThat(responseA.body.string()).isEqualTo("a")
    assertThat(server.takeRequest().exchangeIndex).isEqualTo(0)

    // Give the socket a chance to become stale.
    connection!!.idleAtNs -= IDLE_CONNECTION_HEALTHY_NS
    Thread.sleep(250)

    val requestB =
      Request(
        url = server.url("/"),

e.g, To remove noncurrent versions of all objects keeping the most recent 5 noncurrent versions under the prefix `user-uploads/` 30 days after they become noncurrent ,

```
{
    "Rules": [
        {
            "ID": "Keep only most recent 5 noncurrent versions",
            "Status": "Enabled",
            "Filter": {

        SmbTreeConnectionTrace trace = Mockito.spy(new SmbTreeConnectionTrace(ctx));
        doThrow(thrown).when(trace).connect(loc);

        // Act & Assert: both UnknownHostException and IOException should become CIFSException (SmbException)
        CIFSException ex = assertThrows(CIFSException.class, () -> trace.connectWrapException(loc));
        assertTrue(ex.getMessage() != null && ex.getMessage().contains("Failed to connect to server"));

          if (minDelayNanos < coordinatorWakeUpAt - now) {
            backend.coordinatorNotify(this@TaskRunner)
          }
          return null
        }

        // No other thread is coordinating. Become the coordinator!
        else -> {
          coordinatorWaiting = true
          coordinatorWakeUpAt = now + minDelayNanos
          try {
            backend.coordinatorWait(this@TaskRunner, minDelayNanos)