assertTrue(pool.contains(transport), "Transport should be in pool initially");

        // When: Remove the transport
        pool.removeTransport(transport);

        // Then: Transport should no longer be in pool
        assertFalse(pool.contains(transport), "Transport should be removed from pool");
    }

    @Test
    @DisplayName("Should close all connections and return in-use status")

import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicLong;

import javax.security.auth.Subject;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import jcifs.CIFSContext;
import jcifs.CIFSException;
import jcifs.Configuration;
import jcifs.DialectVersion;
import jcifs.RuntimeCIFSException;
import jcifs.SmbConstants;

	"github.com/minio/minio/internal/logger"
	"github.com/minio/pkg/v3/env"
	xnet "github.com/minio/pkg/v3/net"
	"github.com/rabbitmq/amqp091-go"
)

const (
	formatNamespace = "namespace"
)

const (
	logSubsys = "notify"
)

func logOnceIf(ctx context.Context, err error, id string, errKind ...any) {
	logger.LogOnceIf(ctx, logSubsys, err, id, errKind...)
}

	"github.com/minio/minio/internal/crypto"
	"github.com/minio/minio/internal/hash"
	xhttp "github.com/minio/minio/internal/http"
	xioutil "github.com/minio/minio/internal/ioutil"
	"github.com/minio/minio/internal/logger"
	"github.com/minio/pkg/v3/mimedb"
	"github.com/minio/pkg/v3/sync/errgroup"
	"github.com/minio/sio"
)

func (er erasureObjects) getUploadIDDir(bucket, object, uploadID string) string {
	uploadUUID := uploadID

        // Then
        assertNotNull(type3.getNTResponse());
        // NTLMv2 responses are typically longer than 24 bytes when target info is present
        assertTrue(type3.getNTResponse().length > 24);
    }

    @Test
    @DisplayName("Should include MIC when supported")
    void testMICInclusion() throws Exception {

        @SuppressWarnings("nullness") // safe because we pass sort() a range that contains real Ts
        T[] castBuffer = (T[]) buffer;
        // We've already taken O(k log k), let's make sure we don't take longer than O(k log k).
        sort(castBuffer, left, right + 1, comparator);
        break;
      }
    }
    bufferSize = k;

    threshold = uncheckedCastNullableTToT(buffer[minThresholdPosition]);

   *       {@code UncaughtExceptionHandler} for the thread. For example, if the callback passed to
   *       {@link Futures#addCallback} throws an exception, that exception will be typically be
   *       logged by the {@link ListenableFuture} implementation, even if the thread is configured
   *       to do something different. In other cases, no code will catch the exception, and it may

	// The above implementation would incorrectly consider
	// such an ETag (with a nonce value containing a '-')
	// as non-encrypted.

	return len(e) >= 32 // We consider all ETags longer than 32 bytes as encrypted
}

// IsMultipart reports whether the ETag belongs to an
// object that has been uploaded using the S3 multipart
// API.
// An S3 multipart ETag has a -<part-number> suffix.

    // Starting with an 8k buffer, double the size of each successive buffer. Smaller buffers
    // quadruple in size until they reach 8k, to minimize the number of small reads for longer
    // streams. Buffers are retained in a deque so that there's no copying between buffers while
    // reading and so all of the bytes in each new allocated buffer are available for reading from
    // the stream.

    static LogStream log = LogStream.getInstance();
    private static final Logger logger = LoggerFactory.getLogger(SmbFile.class);
    static long attrExpirationPeriod;
    static boolean ignoreCopyToException;

    static {

        try {
            Class.forName("jcifs.smb1.Config");
        } catch (final ClassNotFoundException cnfe) {
            logger.error("Failed to load jcifs.smb1.Config class", cnfe);
        }