*/
class DeferredSocketAdapter(
  private val socketAdapterFactory: Factory,
) : SocketAdapter {
  private var delegate: SocketAdapter? = null

  override fun isSupported(): Boolean = true

  override fun matchesSocket(sslSocket: SSLSocket): Boolean = socketAdapterFactory.matchesSocket(sslSocket)

  override fun configureTlsExtensions(
    sslSocket: SSLSocket,
    hostname: String?,
    protocols: List<Protocol>,
  ) {

    private int allRecordCount;

    /** Total number of pages */
    private int allPageCount;

    /** Whether a previous page exists */
    private boolean existPrePage;

    /** Whether a next page exists */
    private boolean existNextPage;

    /** List of page numbers for pagination display */
    private List<Integer> pageNumberList;

    /** Number of items per page */
    private int pageSize;

        return parent.size();
    }

    @Override
    public boolean isEmpty() {
        return parent.isEmpty();
    }

    @Override
    public boolean containsKey(final Object key) {
        if (parent.containsKey(key)) {
            return true;
        }
        return parent.containsKey(toCamelCase(key));
    }

    @Override
    public boolean containsValue(final Object value) {

    checkNotNull(comparator);

    boolean hasSameComparator = fromSortedSet || hasSameComparator(elements, comparator);
    if (hasSameComparator && (elements instanceof ImmutableSortedSet)) {
      @SuppressWarnings("unchecked")
      ImmutableSortedSet<E> result = (ImmutableSortedSet<E>) elements;
      boolean isSubset =

    public int security;
    /**
     * Whether the server requires encrypted passwords.
     */
    public boolean encryptedPasswords;
    /**
     * Whether message signing is enabled.
     */
    public boolean signaturesEnabled;
    /**
     * Whether message signing is required.
     */
    public boolean signaturesRequired;
    /**
     * Maximum number of virtual circuits.
     */
    public int maxNumberVcs;

import java.time.ZonedDateTime;

/**
 * Represents a storage item (file or directory).
 */
public class StorageItem {

    private final String name;
    private final String path;
    private final boolean directory;
    private final long size;
    private final ZonedDateTime lastModified;
    private final String encodedId;

    /**
     * Creates a new StorageItem instance.
     *

            when(mockResource.canWrite()).thenReturn(true);

            // When
            boolean exists = mockResource.exists();
            boolean isFile = mockResource.isFile();
            boolean canRead = mockResource.canRead();
            boolean canWrite = mockResource.canWrite();

            // Then
            assertTrue(exists, "Should support SMB existence checks");

    private final String className;
    private final ValueHolder holderHead = new ValueHolder();
    private ValueHolder holderTail = holderHead;
    private boolean omitNullValues = false;
    private boolean omitEmptyValues = false;

    /** Use {@link MoreObjects#toStringHelper(Object)} to create an instance. */
    private ToStringHelper(String className) {

  @SafeVarargs
  public static <T extends @Nullable Object> Stream<T> concat(Stream<? extends T>... streams) {
    // TODO(lowasser): consider an implementation that can support SUBSIZED
    boolean isParallel = false;
    int characteristics = Spliterator.ORDERED | Spliterator.SIZED | Spliterator.NONNULL;
    long estimatedSize = 0L;
    ImmutableList.Builder<Spliterator<? extends T>> splitrsBuilder =

    protected MimeTypes mimeTypes;

    /** Whether to use the filename for MIME type detection. */
    protected boolean useFilename = false;

    /** Whether to use the filename for MIME type detection when the stream is detected as octet-stream. */
    protected boolean useFilenameOnOctetStream = true;

    /**
     * Creates a new MimeTypeHelperImpl instance.