offset += 4;

        // Write context name
        System.arraycopy(CONTEXT_NAME_BYTES, 0, buffer, offset, 4);
        offset += 4;

        // Padding to align data to 8-byte boundary
        offset += 4;

        // Write standard lease data (32 bytes)
        leaseKey.encode(buffer, offset); // LeaseKey (16 bytes)
        offset += 16;

}

// getSHA256Hash returns SHA-256 sum of given data.
func getSHA256Sum(data []byte) []byte {
	hash := sha256.New()
	hash.Write(data)
	return hash.Sum(nil)
}

// getMD5Sum returns MD5 sum of given data.
func getMD5Sum(data []byte) []byte {
	hash := md5.New()
	hash.Write(data)
	return hash.Sum(nil)
}

// getMD5Hash returns MD5 hash in hex encoding of given data.
func getMD5Hash(data []byte) string {

}

// A DRWMutex is a distributed mutual exclusion lock.
type DRWMutex struct {
	Names                []string
	writeLocks           []string // Array of nodes that granted a write lock
	readLocks            []string // Array of array of nodes that granted reader locks
	rng                  *rand.Rand
	m                    sync.Mutex // Mutex to prevent multiple simultaneous locks from this node

                    @Throws(Exception::class)
                    override fun doExecute(s: String) {
                        bufferedWriter.write(s)
                        bufferedWriter.write('\n'.code)
                    }
                })
            }
        })
    }

        SMBUtil.writeInt4(STRUCTURE_SIZE, dst, dstIndex); // DataLength
        dstIndex += 4;

        // Write context name
        System.arraycopy(CONTEXT_NAME_BYTES, 0, dst, dstIndex, 4);
        dstIndex += 4;

        // Padding to align data to 8-byte boundary
        dstIndex += 4;

        // Write durable handle V2 request data (32 bytes total)
        // MS-SMB2 2.2.13.2.4 structure:

  @Throws(IOException::class)
  fun deflate(buffer: Buffer) {
    require(deflatedBytes.size == 0L)

    if (noContextTakeover) {
      deflater.reset()
    }

    deflaterSink.write(buffer, buffer.size)
    deflaterSink.flush()

    if (deflatedBytes.endsWith(EMPTY_DEFLATE_BLOCK)) {
      val newSize = deflatedBytes.size - LAST_OCTETS_COUNT_TO_REMOVE_AFTER_DEFLATION

    @Override
    public void write(Writer output, Map<String, Object> options, PersistedToolchains toolchains) throws IOException {
        Objects.requireNonNull(output, "output cannot be null");
        Objects.requireNonNull(toolchains, "toolchains cannot be null");

        try (Writer out = output) {
            new MavenToolchainsStaxWriter().write(out, toolchains.getDelegate());

 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */
package jcifs.internal.smb2.rdma;

/**
 * RDMA capability flags indicating what operations are supported

        SMBUtil.writeInt4(8, buffer, bufferIndex + 4);

        // Mock getHeaderStart
        response = spy(response);
        when(response.getHeaderStart()).thenReturn(0);

        // Write FileInternalInfo data at the buffer offset
        // FileInternalInfo expects 8 bytes (IndexNumber as int8)
        SMBUtil.writeInt8(0x123456789ABCDEFL, buffer, 50);

        String testContent = "Hello, World!";
        tempFile = File.createTempFile("test", ".tmp", Curl.tmpDir);

        // Write test content to file
        try (FileOutputStream fos = new FileOutputStream(tempFile)) {
            fos.write(testContent.getBytes("UTF-8"));
        }

        ContentCache cache = new ContentCache(tempFile);