mockContext = mock(CIFSContext.class);
        when(mockContext.getConfig()).thenReturn(mockConfig);
        when(mockConfig.getMaximumBufferSize()).thenReturn(65536);
        when(mockConfig.getListSize()).thenReturn(65536);

        testFileId = new byte[16];
        for (int i = 0; i < 16; i++) {
            testFileId[i] = (byte) i;
        }
    }

    @Test

        response.setSelectedVersion(request.getMaxVersion());
        response.setCreditsGranted(request.getCreditsRequested());
        response.setMaxReceiveSize(Math.min(request.getMaxReceiveSize(), 65536));
        response.setMaxReadWriteSize(0); // No RDMA read/write support
        response.setMaxFragmentedSize(request.getMaxFragmentedSize());

        state = RdmaConnectionState.ESTABLISHED;

```

A response similar to this one should be displayed:

```
Generating RSA private key, 2048 bit long modulus
............................................+++
...........+++
e is 65537 (0x10001)
```

Alternatively, use the following command to generate a private RSA key protected by a password:

```sh
openssl genrsa -aes256 -passout pass:PASSWORD -out private.key 2048
```

### [Fast Fallback](https://square.github.io/okhttp/4.x/okhttp/okhttp3/-ok-http-client/-builder/fast-fallback/)

Since version 5.0, `OkHttpClient` supports fast fallback, which is our implementation of Happy Eyeballs [RFC 6555](https://datatracker.ietf.org/doc/html/rfc6555).

With fast fallback, OkHttp attempts to connect to multiple web servers concurrently. It keeps whichever route connects first and cancels all of the others. Its rules are:

            assertEquals(16, result3);
        }

        @Test
        @DisplayName("Should handle maximum name length")
        void testMaximumNameLength() {
            byte[] maxName = new byte[65536]; // 64KB
            Arrays.fill(maxName, (byte) 'M');
            TestCreateContextRequest request = new TestCreateContextRequest(maxName);

            assertArrayEquals(maxName, request.getName());

            byte[] salt = new byte[64];
            SecureRandom random = new SecureRandom();

            for (int i = 0; i < hashAlgos.length; i++) {
                hashAlgos[i] = random.nextInt(65536);
            }
            random.nextBytes(salt);

            PreauthIntegrityNegotiateContext original = new PreauthIntegrityNegotiateContext(mockConfig, hashAlgos, salt);

            // Encode

    class EdgeCaseTests {

        @Test
        @DisplayName("Should handle large buffer decoding")
        void testLargeBufferDecode() throws SMBProtocolDecodingException {
            byte[] largeBuffer = new byte[65536];
            Arrays.fill(largeBuffer, (byte) 0xFF);

            TestCreateContextResponse response = new TestCreateContextResponse("LARGE_BUFFER_TEST".getBytes(StandardCharsets.UTF_8));

secret key (apart from the KMS-generated ones) is 256 bits long. The KMS-generated keys may be 256 bits but this depends on the KMS capabilities and configuration.

The *Secure Channel* splits the object content into chunks of a fixed size of `65536` bytes. The last chunk may be smaller to avoid adding additional overhead and is treated specially to prevent truncation attacks. The nonce value is 96 bits long and generated randomly per object / multi-part part. The *Secure Channel* supports plaintexts...

  /**
   * The explicitly-specified port if one was provided, or the default port for this URL's scheme.
   * For example, this returns 8443 for `https://square.com:8443/` and 443 for
   * `https://square.com/`. The result is in `[1..65535]`.
   *
   * | URL                 | `port()` |
   * | :------------------ | :------- |
   * | `http://host/`      | `80`     |
   * | `http://host:8000/` | `8000`   |
   * | `https://host/`     | `443`    |

The predeclared architecture-independent numeric types are:
</p>

<pre class="grammar">
uint8       the set of all unsigned  8-bit integers (0 to 255)
uint16      the set of all unsigned 16-bit integers (0 to 65535)
uint32      the set of all unsigned 32-bit integers (0 to 4294967295)
uint64      the set of all unsigned 64-bit integers (0 to 18446744073709551615)

int8        the set of all signed  8-bit integers (-128 to 127)