assertEquals(1.0, noRetryPolicy.getBackoffMultiplier());
        assertFalse(noRetryPolicy.isExponentialBackoff());
    }

    @Test
    @DisplayName("Should limit retry delay to maximum")
    void testMaxDelayLimit() {
        // Given
        SmbOperationException.RetryPolicy policy = new SmbOperationException.RetryPolicy(10, 1000, 5000, 2.0, true);

    // nothing really to assert?
    assertSame(CharStreams.nullWriter(), CharStreams.nullWriter());
  }

  /**
   * Returns a reader wrapping the given reader that only reads half of the maximum number of
   * characters that it could read in read(char[], int, int).
   */
  private static Reader newNonBufferFillingReader(Reader reader) {
    return new FilterReader(reader) {
      @Override

    // nothing really to assert?
    assertSame(CharStreams.nullWriter(), CharStreams.nullWriter());
  }

  /**
   * Returns a reader wrapping the given reader that only reads half of the maximum number of
   * characters that it could read in read(char[], int, int).
   */
  private static Reader newNonBufferFillingReader(Reader reader) {
    return new FilterReader(reader) {
      @Override

            return buffer;
        }
    }

    @Nested
    @DisplayName("Edge Case Tests")
    class EdgeCaseTests {

        @Test
        @DisplayName("Should handle maximum values")
        void testMaximumValues() throws SMBProtocolDecodingException {
            byte[] buffer = createValidCopyChunkResponse(Integer.MAX_VALUE, Integer.MAX_VALUE, Integer.MAX_VALUE);

        }
    }

    @Nested
    @DisplayName("Edge Cases and Error Conditions")
    class EdgeCasesTests {

        @Test
        @DisplayName("Should handle maximum size arrays")
        void testMaximumSizeArrays() {
            // Test with reasonably large arrays
            int[] largeCiphers = new int[100];
            for (int i = 0; i < 100; i++) {

  private const val PREFIX_6_BITS = 0x3f
  private const val PREFIX_7_BITS = 0x7f

  private const val SETTINGS_HEADER_TABLE_SIZE = 4_096

  /**
   * The decoder has ultimate control of the maximum size of the dynamic table but we can choose
   * to use less. We'll put a cap at 16K. This is arbitrary but should be enough for most purposes.
   */
  private const val SETTINGS_HEADER_TABLE_SIZE_LIMIT = 16_384

    }

    /**
     * Test edge cases for numeric fields
     */
    @Test
    @DisplayName("Test edge cases for numeric fields")
    public void testNumericFieldsEdgeCases() {
        // Test maximum values for int fields
        serverData.sflags2 = Integer.MAX_VALUE;
        serverData.smaxMpxCount = Integer.MAX_VALUE;
        serverData.maxBufferSize = Integer.MAX_VALUE;
        serverData.sessKey = Integer.MAX_VALUE;

 * to process and analyze the input data.</p>
 *
 * <p>It also handles the exclusion of search words based on certain criteria and manages the
 * maximum length of analyzed content.</p>
 *
 * <p>Methods in this class may throw SuggesterException in case of failures during the parsing process.</p>
 *
 * <p>Usage example:</p>
 * <pre>
 * {@code

    public void testBoundaryConditions() {
        // Given
        smbComTreeDisconnect = new SmbComTreeDisconnect(config);
        byte[] buffer = new byte[100];

        // When & Then - test with maximum valid index
        assertEquals(0, smbComTreeDisconnect.writeParameterWordsWireFormat(buffer, 99));
        assertEquals(0, smbComTreeDisconnect.writeBytesWireFormat(buffer, 99));

	"github.com/minio/minio-go/v7/pkg/credentials"
	xioutil "github.com/minio/minio/internal/ioutil"
	"github.com/minio/pkg/v3/mimedb"
	"github.com/pkg/sftp"
	"golang.org/x/crypto/ssh"
)

// Maximum write offset for incoming SFTP blocks.
// Set to 100MiB to prevent hostile DOS attacks.
const ftpMaxWriteOffset = 100 << 20

type sftpDriver struct {
	permissions *ssh.Permissions
	endpoint    string