// or throw SMBProtocolDecodingException
            try {
                int result = response.readBytesWireFormat(buffer, 0);
                assertEquals(4, result); // If it succeeds, it must return 4
            } catch (SMBProtocolDecodingException e) {
                assertEquals("Expected structureSize = 4", e.getMessage());
            }
        }
    }

    return new ClosingFuture<>(future);
  }

  /**
   * Starts a {@link ClosingFuture} pipeline with a {@link ListenableFuture}.
   *
   * <p>If {@code future} succeeds, its value will be closed (using {@code closingExecutor)}) when
   * the pipeline is done, even if the pipeline is canceled or fails.
   *

              byteBuffer.clear()
              request.read(byteBuffer)
            }

            override fun onSucceeded(
              request: UrlRequest,
              info: UrlResponseInfo,
            ) {
              println("onSucceeded ${info.headers.asMap}")
              completableFuture.complete(Response(info.httpStatusCode, info.negotiatedProtocol, buffer.readUtf8()))
            }

            // Verify that no renewal happened
            assertFalse(renewed, "renewCredentials should return false if no renewal mechanism succeeds");
            assertEquals(mockCredentials, wrapper.getCredentials(), "Credentials should remain unchanged if no renewal mechanism succeeds");
            // Note: Credentials interface does not have renew() method
        }
    }

- Setting a mirror pod's phase to Succeeded or Failed can prevent the corresponding static pod from restarting due mutation of a Kubelet cache. ([#116482](https://github.com/kubernetes/kubernetes/pull/116482), [@smarterclayton](https://github.com/smarterclayton)) [SIG Node]

```sh
# 1. Create a bucket and a user, and upload a file. These operations will succeed.
mc mb myminio/test
mc admin user add myminio foo foobar123
mc cp /etc/issue myminio/test/

# 2. Now access the server as user `foo`. These operations will also succeed.
export MC_HOST_foo=http://foo:foobar123@localhost:9000
mc ls foo/test
mc cat foo/test/issue

 *  * Preemptive proxy authentication failed.
 *
 * Planning failures are not necessarily fatal. For example, even if we can't DNS lookup the first
 * proxy in a list, looking up a subsequent one may succeed.
 */
internal class FailedPlan(
  e: Throwable,
) : RoutePlanner.Plan {
  val result = RoutePlanner.ConnectResult(plan = this, throwable = e)

  override val isReady = false

   */
  fun cancel()

  fun interface Factory {
    /**
     * Creates a new event source and immediately returns it. Creating an event source initiates an
     * asynchronous process to connect the socket. Once that succeeds or fails, `listener` will be
     * notified. The caller must cancel the returned event source when it is no longer in use.
     */
    fun newEventSource(
      request: Request,
      listener: EventSourceListener,

    }

    @Test
    void testTreeConnectAndDisconnect() throws Exception {
        SmbTree tree = new SmbTree(session, "testShare", "testService");

        // Mock transport.connect() to succeed
        doNothing().when(transport).connect();

        // Setup response for tree connect
        doAnswer(invocation -> {
            ServerMessageBlock request = invocation.getArgument(0);

      } else {
        succ.predecessorInMultimap = pred;
      }
    }

    void delete(ValueEntry<K, V> entry) {
      succeeds(entry.predecessorInMultimap, entry.successorInMultimap);
    }

    void append(ValueEntry<K, V> newEntry) {
      succeeds(lastEntry, newEntry);
      lastEntry = newEntry;
    }
  }

  @GwtIncompatible @J2ktIncompatible private static final long serialVersionUID = 1;