if (LogStream.level >= 3) {
                log.println("TransCallNamedPipe data too long for buffer");
            }
            return 0;
        }
        System.arraycopy(pipeData, pipeDataOff, dst, dstIndex, pipeDataLen);
        return pipeDataLen;
    }

    @Override
    int readParametersWireFormat(final byte[] buffer, final int bufferIndex, final int len) {
        return 0;
    }

    @Override

            }
            // Simulate some encoding activity on the buffer
            dst.enc_ndr_long(123);
        }

        @Override
        public void decode(NdrBuffer src) throws NdrException {
            if (throwOnDecode) {
                throw new NdrException("Failed to decode");
            }
            // Simulate some decoding activity on the buffer
            src.dec_ndr_long();
        }

import assertk.assertions.isEqualTo
import assertk.assertions.isNull
import okio.Buffer
import org.junit.jupiter.api.Test

class ConfiguredPublicSuffixDatabaseTest {
  private val list = ConfiguredPublicSuffixList()
  private val publicSuffixDatabase = PublicSuffixDatabase(list)

  @Test fun longestMatchWins() {
    list.bytes =
      Buffer()
        .writeUtf8("com\n")
        .writeUtf8("my.square.com\n")

    @Override
    public int decode(byte[] buffer, int bufferIndex, int len) throws SMBProtocolDecodingException {
        int start = bufferIndex;

        if (len < 32) {
            throw new SMBProtocolDecodingException("Lease V1 context data too short: " + len);
        }

        // Read lease V1 data (32 bytes)
        byte[] keyBytes = new byte[16];
        System.arraycopy(buffer, bufferIndex, keyBytes, 0, 16);

    random.nextBytes(buf)
    assertRoundTrip(buf.toByteString())
  }

  private fun assertRoundTrip(data: ByteString) {
    val encodeBuffer = Buffer()
    encode(data, encodeBuffer)
    assertThat(encodedLength(data).toLong()).isEqualTo(encodeBuffer.size)
    val decodeBuffer = Buffer()
    decode(encodeBuffer, encodeBuffer.size, decodeBuffer)
    assertEquals(data, decodeBuffer.readByteString())
  }

    @Override
    int readParameterWordsWireFormat(final byte[] buffer, final int bufferIndex) {
        supportSearchBits = (buffer[bufferIndex] & SMB_SUPPORT_SEARCH_BITS) == SMB_SUPPORT_SEARCH_BITS;
        shareIsInDfs = (buffer[bufferIndex] & SMB_SHARE_IS_IN_DFS) == SMB_SHARE_IS_IN_DFS;
        return 2;
    }

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

     */
    public byte[] getKey() {
        return Arrays.copyOf(key, LEASE_KEY_SIZE);
    }

    /**
     * Write the lease key to a buffer
     *
     * @param dst destination buffer
     * @param dstIndex starting index in destination buffer
     */
    public void encode(byte[] dst, int dstIndex) {
        System.arraycopy(key, 0, dst, dstIndex, LEASE_KEY_SIZE);
    }

    /**

        this.currentLeaseState = SMBUtil.readInt4(buffer, bufferIndex);
        bufferIndex += 4;

        // NewLeaseState (4 bytes)
        this.newLeaseState = SMBUtil.readInt4(buffer, bufferIndex);
        bufferIndex += 4;

        // BreakReason (4 bytes)
        this.breakReason = SMBUtil.readInt4(buffer, bufferIndex);
        bufferIndex += 4;

        // AccessMaskHint (4 bytes)

        this.creationTime = SMBUtil.readTime(buffer, bufferIndex);
        bufferIndex += 8;
        this.lastAccessTime = SMBUtil.readTime(buffer, bufferIndex);
        bufferIndex += 8;
        this.lastWriteTime = SMBUtil.readTime(buffer, bufferIndex);
        bufferIndex += 8;
        this.changeTime = SMBUtil.readTime(buffer, bufferIndex);
        bufferIndex += 8;

    }

    /**
     * Runs the thread to continuously read lines from the input stream.
     * Each line is processed by the output callback (if provided) and added to the buffer.
     * The buffer is maintained as a circular buffer with the specified size.
     */
    @Override
    public void run() {
        boolean running = true;
        while (running) {
            try {