int index = nextEscapeIndex(string, 0, end);
    return index == end ? string : escapeSlow(string, index);
  }

  /**
   * Scans a sub-sequence of characters from a given {@link CharSequence}, returning the index of
   * the next character that requires escaping.
   *
   * <p><b>Note:</b> When implementing an escaper, it is a good idea to override this method for

    int index = nextEscapeIndex(string, 0, end);
    return index == end ? string : escapeSlow(string, index);
  }

  /**
   * Scans a sub-sequence of characters from a given {@link CharSequence}, returning the index of
   * the next character that requires escaping.
   *
   * <p><b>Note:</b> When implementing an escaper, it is a good idea to override this method for

   * loaded) value, or null. Multiple concurrent calls to {@link Cache} lookup methods on an absent
   * value can result in multiple misses, all returning the results of a single cache load
   * operation.
   */
  public long missCount() {
    return missCount;
  }

  /**

        }

        private String nodeValue;

        @Override
        public String getNodeValue() {
            return nodeValue;
        }

        // Other Node methods (not needed for testing, returning defaults)

        @Override
        public Node getParentNode() {
            return null;
        }

        @Override
        public org.w3c.dom.NodeList getChildNodes() {
            return null;

   * true when removing a connection from the pool; otherwise a racing caller might get it from the
   * pool when it shouldn't. Symmetrically, this must always be checked before returning a
   * connection from the pool.
   *
   * Once true this is always true. Guarded by this.
   */
  var noNewExchanges = false

  /**

    void testReadMethodsWithNullBuffer() {
        trans2QueryFSInfo = new Trans2QueryFSInformation(config, FileSystemInformation.SMB_INFO_ALLOCATION);

        // All read methods should handle null buffer gracefully by returning 0
        assertEquals(0, trans2QueryFSInfo.readSetupWireFormat(null, 0, 0));
        assertEquals(0, trans2QueryFSInfo.readParametersWireFormat(null, 0, 0));

        // Configuration is accessed during initialization
        // Verify at least that getPid() and getTransactionBufferSize() were called
    }

    @DisplayName("Test FileInformation encode returning different sizes")
    @ParameterizedTest
    @ValueSource(ints = { 0, 1, 10, 100, 1000 })
    void testFileInformationEncodeDifferentSizes(int encodeSize) {

    return derive(future.transformAsync(applyFunction, executor));
  }

  /**
   * Returns an {@link AsyncClosingFunction} that applies an {@link AsyncFunction} to an input,
   * ignoring the DeferredCloser and returning a {@code ClosingFuture} derived from the returned
   * {@link ListenableFuture}.
   *
   * <p>Use this method to pass a transformation to {@link #transformAsync(AsyncClosingFunction,

        HashFunction hashFunction1b = (HashFunction) method.invoke(clazz);

        new EqualsTester().addEqualityGroup(hashFunction1a, hashFunction1b).testEquals();

        // Make sure we're returning not only equal instances, but constants.
        assertSame(hashFunction1a, hashFunction1b);

        assertEquals(hashFunction1a.toString(), hashFunction1b.toString());
      }
    }
  }

      debugData = source.readByteString(opaqueDataLength.toLong())
    }
    handler.goAway(lastStreamId, errorCode, debugData)
  }

  /** Unlike other `readXxx()` functions, this one must log the frame before returning. */
  @Throws(IOException::class)
  private fun readWindowUpdate(
    handler: Handler,
    length: Int,
    flags: Int,
    streamId: Int,
  ) {
    val increment: Long
    try {