this.dialectRevision = SMBUtil.readInt2(buffer, bufferIndex);
        final int negotiateContextCount = SMBUtil.readInt2(buffer, bufferIndex + 2);

        // Validate negotiate context count - prevent excessive memory allocation
        if (negotiateContextCount < 0 || negotiateContextCount > 100) {
            throw new SMBProtocolDecodingException("Invalid negotiate context count: " + negotiateContextCount + " (must be 0-100)");

            bufferedRequestBody.close()
          }
        } else {
          exchange.noRequestBody()
          if (!exchange.connection.isMultiplexed) {
            // If the "Expect: 100-continue" expectation wasn't met, prevent the HTTP/1 connection
            // from being reused. Otherwise we're still obligated to transmit the request body to
            // leave the connection in a consistent state.
            exchange.noNewExchangesOnConnection()

    do {
      val buffer = cursor.data
      var i = cursor.start
      val end = cursor.end
      if (buffer != null) {
        while (i < end) {
          keyIndex %= keyLength // Reassign to prevent overflow breaking counter.

          // Byte xor is experimental in Kotlin so we coerce bytes to int, xor them
          // and convert back to byte.
          val bufferInt: Int = buffer[i].toInt()

  }

  override fun flush() {
  }

  override fun close() {
  }
}

@SuppressSignatureCheck
object AndroidLog {
  private const val MAX_LOG_LENGTH = 4000

  // Keep references to loggers to prevent their configuration from being GC'd.
  private val configuredLoggers = CopyOnWriteArraySet<Logger>()

  private val knownLoggers =
    LinkedHashMap<String, String>()
      .apply {

        }
        // Clear system properties that might affect the test
        System.clearProperty("jcifs.properties");
        System.clearProperty("java.protocol.handler.pkgs");
        // Clear jcifs-specific properties to prevent test interference
        System.clearProperty("jcifs.smb.client.nativeOs");
        System.clearProperty("jcifs.smb.client.nativeLanMan");
    }

    @Test
    void testInitWithNullProperties() throws CIFSException {

 * text is performed automatically by the relevant parser.
 *
 * <p>For example, an XML escaper would convert the literal string {@code "Foo<Bar>"} into {@code
 * "Foo&lt;Bar&gt;"} to prevent {@code "<Bar>"} from being confused with an XML tag. When the
 * resulting XML document is parsed, the parser API will return this text as the original literal
 * string {@code "Foo<Bar>"}.
 *

import java.io.IOException;
import java.io.InputStream;

/**
 * A wrapper for an {@link InputStream} that ignores the {@link #close()} method call.
 * This can be useful when you want to prevent the underlying input stream from being closed.
 *
 * <p>All other methods delegate to the wrapped input stream.</p>
 *
 */
public class IgnoreCloseInputStream extends InputStream {

   * for an RPC may wait for a similar call that requests a long timeout, or a call by an
   * unprivileged user may return a resource accessible only to a privileged user making a similar
   * call. To prevent this problem, create a key object that includes all values that affect the
   * result of the query. Or use {@code LoadingCache.get(K)}, which lacks the ability to refer to
   * state other than that in the key.
   *

/**
 * Security-focused test cases for BufferCache to verify buffer overflow protection.
 */
public class BufferCacheSecurityTest {

    /**
     * Test that buffer allocation validates size to prevent overflow.
     */
    @Test
    public void testBufferSizeValidation() {
        // When - Get a buffer
        byte[] buffer = BufferCache.getBuffer();

        // Then - Buffer should have expected size

     *
     * <p>This method returns all duplicate host configurations in the system,
     * ordered by sort order, regular name, and duplicate hostname. The results
     * are limited by the configured maximum fetch size to prevent memory issues.</p>
     *
     * @return a list of all DuplicateHost entities
     */
    public List<DuplicateHost> getDuplicateHostList() {

        return duplicateHostBhv.selectList(cb -> {