* @param fileId
     *            the file ID to read from
     * @param outputBuffer
     *            the buffer to read data into
     * @param outputBufferOffset
     *            the offset in the output buffer to start writing data
     */
    public Smb2ReadRequest(final Configuration config, final byte[] fileId, final byte[] outputBuffer, final int outputBufferOffset) {
        super(config, SMB2_READ);
        this.fileId = fileId;

    Range<Integer> closedRange = Range.closed(4, 8);

    // first range open end, second range open start
    assertEquals(Range.closed(2, 4), Range.lessThan(2).gap(openRange));
    assertEquals(Range.closed(2, 4), openRange.gap(Range.lessThan(2)));

    // first range closed end, second range open start
    assertEquals(Range.openClosed(2, 4), Range.atMost(2).gap(openRange));

            handlers.setHandlers(new Handler[] { request_handler, new DefaultHandler() });
            server.setHandler(handlers);
        }

        public void start() {
            try {
                server.start();
            } catch (final Exception e) {
                throw new CrawlerSystemException(e);
            }
        }

        public void stop() {
            try {

     *
     * @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;
        this.alloc = SMBUtil.readInt8(buffer, bufferIndex);
        bufferIndex += 8;

        this.free = SMBUtil.readInt8(buffer, bufferIndex);
        bufferIndex += 8;

#          $$foreignAlias$$.VALID_BEGIN_DATE <= /*targetDate(Date)*/null
#      and $$foreignAlias$$.VALID_END_DATE >= /*targetDate(Date)*/null 
#         ; fixedSuffix = AsValid
#     }
# }
#
# *The line that starts with '#' means comment-out.
#
map:{
    #; FK_MEMBER_MEMBER_STATUS_CODE = map:{
    #    ; localTableName  = MEMBER             ; foreignTableName  = MEMBER_STATUS

            dst[dstIndex++] = (byte) 0x00; // Reserved3
            dstIndex += writeSetupWireFormat(dst, dstIndex);
        }

        return dstIndex - start;
    }

    @Override
    int writeBytesWireFormat(final byte[] dst, int dstIndex) {
        final int start = dstIndex;
        int p = pad;

        if (command == SMB_COM_TRANSACTION && !isResponse()) {
            dstIndex += writeString(name, dst, dstIndex);

 * Any IO - writing to files or network should be done asynchronously.
 */
internal abstract class ConnectionListener {
  /**
   * Invoked as soon as a call causes a connection to be started.
   */
  open fun connectStart(
    route: Route,
    call: Call,
  ) {}

  /**
   * Invoked when a connection fails to be established.
   */
  open fun connectFailed(
    route: Route,

    @Override
    protected int readParameterWordsWireFormat(final byte[] buffer, int bufferIndex) {
        final int start = bufferIndex;

        this.dialectIndex = SMBUtil.readInt2(buffer, bufferIndex);
        bufferIndex += 2;
        if (this.dialectIndex > 10) {
            return bufferIndex - start;
        }
        this.server.securityMode = buffer[bufferIndex] & 0xFF;
        bufferIndex++;

            }
            n = response.dataLength;
            if (n <= 0) {
                return (int) (fp - start > 0L ? fp - start : -1);
            }
            fp += n;
            len -= n;
            response.off += n;
        } while (len > 0 && n == r);

        return (int) (fp - start);
    }

    /**
     * This stream class is unbuffered. Therefore this method will always

        }
    }

    /**
     *  Use an XPath string to select a nodelist.
     *  XPath namespace prefixes are resolved from the contextNode.
     *
     *  @param contextNode The node to start searching from.
     *  @param expression A valid XPath string.
     *  @return A XPathNodes, should never be null.
     *
     * @throws XPathExpressionException if an XPath expression error occurs.
     */