import org.jspecify.annotations.NullUnmarked;

/** Measures the size of AbstractFuture implementations. */
@NullUnmarked
public class AbstractFutureFootprintBenchmark {

  enum State {
    NOT_DONE,
    FINISHED,
    CANCELLED,
    FAILED
  }

  @Param State state;
  @Param Impl impl;

  @Param({"0", "1", "5", "10"})
  int numListeners;

  @Param({"0", "1", "5", "10"})
  int numThreads;

     * @return output stream, needs to be closed when finished
     * @throws CIFSException if an error occurs accessing the resource
     */
    OutputStream openOutputStream(boolean append) throws CIFSException;

    /**
     * Opens an output stream writing to the file (truncating, write only, sharable)
     *
     * @return output stream, needs to be closed when finished

                if (scheduledJob.isLoggingEnabled() && logger.isInfoEnabled()) {
                    logger.info("Finished job: id={}", id);
                }
            } else {
                if (scheduledJob.isLoggingEnabled() && logger.isInfoEnabled()) {
                    logger.info("Finished job: id={}, returnValue:\n{}", id, ret);
                }
                jobLog.setScriptResult(ret.toString());
            }

      jarTask,
    )
  bundleExtension.run {
    setClasspath(osgi.compileClasspath + sourceSets["main"].compileClasspath)
    bnd(*bndProperties)
  }
  // Call the convention when the task has finished, to modify the jar to contain OSGi metadata.
  jarTask.doLast {
    bundleExtension.buildAction().execute(this)
  }
}

fun Project.applyOsgiMultiplatform(vararg bndProperties: String) {

    protected void processRemaining(ByteBuffer bb) {
      if (finished) {
        return;
      }
      crc0 = combine(0, crc0);
      crc0 = combine(crc0, crc1);
      crc0 = combine(crc0, crc2);
      crc0 = combine(crc0, crc3);
      while (bb.hasRemaining()) {
        crc0 = (crc0 >>> 8) ^ byteTable[(bb.get() ^ crc0) & 0xFF];
      }
      finished = true;
    }

    @Override

  get() = this.exchange

internal val Exchange.connectionAccessor: RealConnection
  get() = this.connection

   *
   * <p>This method waits 120 seconds before continuing with JVM termination, even if the executor
   * has not finished its work.
   *
   * <p>This is mainly for fixed thread pools. See {@link Executors#newFixedThreadPool(int)}.
   *
   * @param executor the executor to modify to make sure it exits when the application is finished
   * @return an unmodifiable version of the input which will not hang the JVM
   */
  @J2ktIncompatible

     * Gets the type of this pipe.
     *
     * @return the type of the pipe
     */
    int getPipeType();

    /**
     * Create a pipe handle
     *
     * @return pipe handle, needs to be closed when finished
     */
    SmbPipeHandle openPipe();

    // Instead, we ensure that all bytes from source have been processed by inflater.
    do {
      inflaterSource.readOrInflate(buffer, Long.MAX_VALUE)
    } while (inflater.bytesRead < totalBytesToRead && !inflater.finished())

    // The inflater data was self-terminated and there's unexpected trailing data. Tear it all down
    // so we don't leak that data into the input of the next message.
    if (inflater.bytesRead < totalBytesToRead) {

In version 0.121.0, FastAPI added support for `Depends(scope="function")` for dependencies with `yield`.

Using `Depends(scope="function")`, the exit code after `yield` is executed right after the *path operation function* is finished, before the response is sent back to the client.

And when using `Depends(scope="request")` (the default), the exit code after `yield` is executed after the response is sent.