isReadLock := false
	return dm.lockBlocking(ctx, cancel, id, source, isReadLock, opts)
}

// RLock holds a read lock on dm.
//
// If one or more read locks are already in use, it will grant another lock.
// Otherwise the calling go routine blocks until the mutex is available.
func (dm *DRWMutex) RLock(id, source string) {
	isReadLock := true

            SMBUtil.writeInt2(4, buffer, start);
            Smb2LogoffResponse resp = newResponse();

            // Act
            int read = resp.readBytesWireFormat(buffer, start);

            // Assert
            assertEquals(4, read, "Should return the fixed structure size (4)");
        }

        @ParameterizedTest
        @ValueSource(ints = { 0, 1, 7 })

import org.apache.maven.api.model.Model;
import org.apache.maven.api.services.Source;

/**
 * The {@code ModelParser} interface is used to locate and read {@link Model}s from the file system.
 * This allows plugging in additional syntaxes for the main model read by Maven when building a project.
 *
 * @since 4.0.0
 */
@Experimental
@Consumer
@Named
public interface ModelParser extends SpiService {

    /**

    require(length < bytesOut.size - lastFrame.start)

    // Move everything from bytesOut into a new buffer.
    val fullBuffer = Buffer()
    bytesOut.read(fullBuffer, bytesOut.size)

    // Copy back all but what we're truncating.
    fullBuffer.read(bytesOut, lastFrame.start + length)
    outFrames.add(OutFrame(lastFrame.sequence, lastFrame.start, true))
    return writer
  }

        final int start = bufferIndex;

        final SmbInfoAllocation info = new SmbInfoAllocation();

        // Read total allocation units.
        info.alloc = readInt8(buffer, bufferIndex);
        bufferIndex += 8;

        // read caller available allocation units
        info.free = readInt8(buffer, bufferIndex);
        bufferIndex += 8;

        // skip actual free units

        // Fill with pattern to verify we read correct bytes
        for (int i = 0; i < buffer.length; i++) {
            buffer[i] = (byte) (i + 1);
        }

        // Decode
        int bytesDecoded = smbInfoAllocation.decode(buffer, 0, buffer.length);

        // Verify we read exactly 20 bytes (4 + 4 + 4 + 4 + 4)
        // Note: bytesPerSect is read as Int2 but 4 bytes are consumed (padding)

            off = in.read(buf, 0, 1024);
        } else {
            off = in.readDirect(buf, 0, buf.length);
        }

        if (buf[0] != 5 && buf[1] != 0) {
            throw new IOException("Unexpected DCERPC PDU header");
        }

        flags = buf[3] & 0xFF;
        // next read is start of new frag

name: Shell formatting checks

on:
  pull_request:
    branches:
      - master

permissions:
  contents: read
    
jobs:
  build:
    name: runner / shfmt
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: luizm/action-sh-checker@master
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
          SHFMT_OPTS: "-s"
        with:

func ChecksumFromBytes(b []byte) *Checksum {
	if len(b) == 0 {
		return nil
	}

	// Read checksum type
	t, n := binary.Uvarint(b)
	if n <= 0 {
		return nil
	}
	b = b[n:]

	typ := ChecksumType(t)
	length := typ.RawByteLen()
	if length == 0 || len(b) < length {
		return nil
	}

	// Read raw checksum bytes
	raw := make([]byte, length)
	copy(raw, b[:length])
	b = b[length:]

                        expressionDocumentation.putAll(doco);
                    }
                } catch (IOException e) {
                    throw new ExpressionDocumentationException(
                            "Failed to read documentation for expression root: " + root, e);
                } catch (XmlPullParserException e) {
                    throw new ExpressionDocumentationException(