/**
     * The pipe should be opened read-only.
     */

    int PIPE_TYPE_RDONLY = SmbConstants.O_RDONLY;

    /**
     * The pipe should be opened only for writing.
     */

    int PIPE_TYPE_WRONLY = SmbConstants.O_WRONLY;

    /**
     * The pipe should be opened for both reading and writing.
     */

    int PIPE_TYPE_RDWR = SmbConstants.O_RDWR;

    /**

    void testReadBytesWireFormatNoop() {
        byte[] buffer = new byte[10];
        int used = cmd.readBytesWireFormat(buffer, 0);
        assertEquals(0, used, "readBytesWireFormat is unimplemented and must return 0");
    }

    private static byte[] subArray(byte[] src, int offset, int length) {
        byte[] dst = new byte[length];
        System.arraycopy(src, offset, dst, 0, length);

    }

    /**
     * Constant-time array copy to prevent timing attacks
     */
    private void constantTimeCopy(byte[] src, int srcPos, byte[] dest, int destPos, int length) {
        // Simple constant-time copy - always process all bytes
        for (int i = 0; i < length; i++) {
            dest[destPos + i] = src[srcPos + i];
        }
    }

    /**
     * Decrypt an SMB2 message
     *

        FileEndOfFileInformation spy = Mockito.spy(realObject);

        // Call methods
        byte level = spy.getFileInformationLevel();
        int size = spy.size();
        byte[] buffer = new byte[8];
        int encoded = spy.encode(buffer, 0);
        int decoded = spy.decode(buffer, 0, 8);
        String str = spy.toString();

        // Verify all methods were called except toString (Mockito limitation)

pkg net, method (*UDPConn) ReadFromUDPAddrPort([]uint8) (int, netip.AddrPort, error)
pkg net, method (*UDPConn) ReadMsgUDPAddrPort([]uint8, []uint8) (int, int, int, netip.AddrPort, error)
pkg net, method (*UDPConn) WriteMsgUDPAddrPort([]uint8, []uint8, netip.AddrPort) (int, int, error)
pkg net, method (*UDPConn) WriteToUDPAddrPort([]uint8, netip.AddrPort) (int, error)
pkg net, type Error interface, Temporary //deprecated

        return this.resumeKey;
    }

    /**
     * {@inheritDoc}
     *
     * @see jcifs.Decodable#decode(byte[], int, int)
     */
    @Override
    public int decode(final byte[] buffer, int bufferIndex, final int len) throws SMBProtocolDecodingException {
        final int start = bufferIndex;
        if (len < 24) {
            throw new SMBProtocolDecodingException("Invalid resume key");
        }

        }

        return this;
    }

    private String formatLocation(int columnNumber, int lineNumber) {
        return String.format("line %d, column %d", lineNumber, columnNumber);
    }

    // Helper method for backward compatibility
    static ProjectBuildingResultWithLocationAssert projectBuildingResultWithLocation(int columnNumber, int lineNumber) {

  }

  /** Returns a -1 if unable to parse */
  private static int tryParseDecimal(String string, int start, int end) {
    int decimal = 0;
    int max = Integer.MAX_VALUE / 10; // for int overflow detection
    for (int i = start; i < end; i++) {
      if (decimal > max) {
        return -1;
      }
      decimal *= 10;
      int digit = Character.digit(string.charAt(i), 10);
      if (digit < 0) {

        
        // Data (16 bytes of reserved)
        int dataOffset = offset + 16 + nameLen;
        dataOffset = (dataOffset + 7) & ~7;  // 8-byte alignment
        
        for (int i = 0; i < 16; i++) {
            buffer[dataOffset + i] = 0;
        }
    }
    
    @Override
    public int size() {
        int nameLen = getName().length();

  }

  private static final ImmutableList<Range<Integer>> RANGES;
  private static final int MIN_BOUND = -1;
  private static final int MAX_BOUND = 1;

  static {
    ImmutableList.Builder<Range<Integer>> builder = ImmutableList.builder();

    builder.add(Range.<Integer>all());

    // Add one-ended ranges
    for (int i = MIN_BOUND; i <= MAX_BOUND; i++) {
      for (BoundType type : BoundType.values()) {