return LockContext{ctx: newCtx, cancel: cancel}, nil
}

// Unlock - block until write lock is released.
func (di *distLockInstance) Unlock(lc LockContext) {
	if lc.cancel != nil {
		lc.cancel()
	}
	di.rwMutex.Unlock(context.Background())
}

// RLock - block until read lock is taken or timeout has occurred.

	var totalWritten int64

	// Write all data blocks to dst.
	for _, block := range enBlocks[:dataBlocks] {
		// Skip blocks until we have reached our offset.
		if offset >= int64(len(block)) {
			// Decrement offset.
			offset -= int64(len(block))
			continue
		}

		// Skip until offset.
		block = block[offset:]

		// Reset the offset for next iteration to read everything
		// from subsequent blocks.

        DummyAndXBlock block = new DummyAndXBlock(next);

        assertNotNull(block);
        assertSame(next, block.andx, "andx should reference provided SMB");
    }

    @Test
    @DisplayName("getBatchLimit defaults to 0")
    void testGetBatchLimitDefault() {
        DummyAndXBlock block = new DummyAndXBlock();
        assertEquals(0, block.getBatchLimit((byte) 0x25));
    }

    @Test

	var bytesWritten int64
	var bufs [][]byte
	for block := startBlock; block <= endBlock; block++ {
		var blockOffset, blockLength int64
		switch {
		case startBlock == endBlock:
			blockOffset = offset % e.blockSize
			blockLength = length
		case block == startBlock:
			blockOffset = offset % e.blockSize
			blockLength = e.blockSize - blockOffset
		case block == endBlock:
			blockOffset = 0

        length -= remainder;
        int block;
        int i = 0;
        while (i < length) {
            block = (bytes[i++] & 0xff) << 16 | (bytes[i++] & 0xff) << 8 | bytes[i++] & 0xff;
            buffer.append(ALPHABET.charAt(block >>> 18));
            buffer.append(ALPHABET.charAt(block >>> 12 & 0x3f));
            buffer.append(ALPHABET.charAt(block >>> 6 & 0x3f));
            buffer.append(ALPHABET.charAt(block & 0x3f));

     *    <p>
     *    Transforms context based on 512 bits from input block starting
     *    from the offset'th byte.
     *
     *    @param    block    input sub-array.
     *    @param    offset    starting position of sub-array.
     */
    private void transform(final byte[] block, int offset) {

        // encodes 64 bytes from input block into an array of 16 32-bit
        // entities. Use A as a temp var.

        <span class="sponsor-badge">sponsor</span>
        <img class="sponsor-image" src="/img/sponsors/blockbee-banner.png" />
      </a>
    </div>
    <div class="item">

    }

    /// Encrypt a block of bytes.
    /**
     * Encrypts an 8-byte block using DES
     * @param clearText the 8-byte plaintext block
     * @param cipherText the output 8-byte ciphertext block
     */
    public void encrypt(final byte[] clearText, final byte[] cipherText) {
        encrypt(clearText, 0, cipherText, 0);
    }

    /// Decrypt a block of bytes.
    /**

  fun write(
    name: String,
    tagClass: Int,
    tag: Long,
    block: (BufferedSink) -> Unit,
  ) {
    val constructedBit: Int
    val content = Buffer()

    stack.add(content)
    constructed = false // The enclosed object written in block() is not constructed.
    path += name
    try {
      block(content)
      constructedBit = if (constructed) 0b0010_0000 else 0

 *   <li>If a {@code Throwable} is thrown in the try block, no exceptions that occur when attempting
 *       to close resources will be thrown from the finally block. The throwable from the try block
 *       will be thrown.
 *   <li>If no exceptions or errors were thrown in the try block, the <i>first</i> exception thrown
 *       by an attempt to close a resource will be thrown.