void testLargeBufferEncode() {
            byte[] largeName = new byte[1024];
            Arrays.fill(largeName, (byte) 'X');
            byte[] largeData = new byte[2048];
            Arrays.fill(largeData, (byte) 'Y');

            TestCreateContextRequest request = new TestCreateContextRequest(largeName, largeData);

            byte[] buffer = new byte[8192];

        }
    }

    @Test
    @DisplayName("Should create transform header with constructor")
    void testConstructorWithParameters() {
        // Given
        int messageSize = 2048;
        int flags = 0x0002;

        // When
        Smb2TransformHeader header = new Smb2TransformHeader(testNonce, messageSize, flags, testSessionId);

        // Then

        assertTrue(result.contains("lastWriteTime="));
        assertTrue(result.contains("changeTime="));
        assertTrue(result.contains("endOfFile=1024"));
        assertTrue(result.contains("allocationSize=2048"));
        assertTrue(result.contains("extFileAttributes=32"));
        assertTrue(result.contains("eaSize=512"));
        assertTrue(result.contains("shortName=TOSTRI~1.TXT"));

        String longDomain = "A".repeat(256); // Very long domain name
        netServerEnum2 = new NetServerEnum2(realConfig, longDomain, NetServerEnum2.SV_TYPE_ALL);

        byte[] dst = new byte[2048];
        int bytesWritten = netServerEnum2.writeParametersWireFormat(dst, 0);

        assertTrue(bytesWritten > 0);

        // Verify domain is written (uppercase)

      (long) Math.pow(EXPECTED_ONE_BYTE_ROUNDTRIPPABLE_COUNT, 2)
          +
          // The possible number of two byte characters
          TWO_BYTE_ROUNDTRIPPABLE_CHARACTERS;

  // 2048
  private static final long THREE_BYTE_SURROGATES = 2 * 1024;

  // 61,440 [chars 0x0800 to 0xFFFF, minus surrogates]
  private static final long THREE_BYTE_ROUNDTRIPPABLE_CHARACTERS =

            validator.validateBuffer(buffer, 100, 1024);
        });
    }

    @Test
    public void testBufferTooLarge() throws Exception {
        byte[] buffer = new byte[2048];
        assertThrows(SmbException.class, () -> {
            validator.validateBuffer(buffer, 100, 1024);
        });
    }

    @Test
    public void testValidBufferAccess() throws Exception {

        Smb2SessionSetupRequest req =
                new Smb2SessionSetupRequest(mockContext, TEST_SECURITY_MODE, TEST_CAPABILITIES, TEST_PREVIOUS_SESSION_ID, token);
        byte[] buffer = new byte[2048];

        // When
        req.encode(buffer, 0);

        // Then
        int bodyOffset = Smb2Constants.SMB2_HEADER_LENGTH;

        // Verify token length

            }

            Smb2LockRequest req = new Smb2LockRequest(mockConfig, testFileId, locks);
            byte[] buffer = new byte[2048];

            int bytesWritten = req.writeBytesWireFormat(buffer, 0);

            assertEquals(48, SMBUtil.readInt2(buffer, 0));
            assertEquals(lockCount, SMBUtil.readInt2(buffer, 2));

      const val LOOM_PROPERTY = "loom"

      /**
       * For whatever reason our BouncyCastle provider doesn't work with ECDSA keys. Just configure it
       * to use RSA-2048 instead.
       *
       * (We otherwise prefer ECDSA because it's faster.)
       */
      private val localhostHandshakeCertificatesWithRsa2048: HandshakeCertificates by lazy {
        val heldCertificate =

            buffer.putLong(2000L);
            buffer.putInt(4);
            buffer.putInt(2048);

            // When
            allocInfo.decode(buffer.array(), 0, 24);

            // Then
            assertEquals(5000L * 4 * 2048, allocInfo.getCapacity());
            assertEquals(2000L * 4 * 2048, allocInfo.getFree());