[2020-01-01 00:00:00] Q10003 scheduled after   0 µs: OkHttp squareup.com onSettings
[2020-01-01 00:00:00] Q10003 starting              : OkHttp squareup.com onSettings
[2020-01-01 00:00:00] Q10001 finished run in   3 ms: OkHttp squareup.com applyAndAckSettings
[2020-01-01 00:00:00] Q10003 finished run in 528 µs: OkHttp squareup.com onSettings
[2020-01-01 00:00:00] Q10000 scheduled after   0 µs: OkHttp ConnectionPool

      "FINE: Q10000 starting              : task",
      "FINE: Q10000 finished run in   0 µs: task",
      "FINE: Q10000 run again after  50 µs: task",
      "FINE: Q10000 starting              : task",
      "FINE: Q10000 finished run in   0 µs: task",
      "FINE: Q10000 run again after 150 µs: task",
      "FINE: Q10000 starting              : task",
      "FINE: Q10000 finished run in   0 µs: task",
    )
  }

    assert state["context_b"] == "finished b with a: started a"
    assert state["context_a"] == "finished a"


def test_context_b_raise():
    with pytest.raises(OtherDependencyError):
        client.get("/context_b_raise")
    assert state["context_b"] == "finished b with a: started a"
    assert state["context_a"] == "finished a"


def test_background_tasks():

      byteCount: Long,
    ) {
      assertLockNotHeld()

      var remainingByteCount = byteCount

      while (remainingByteCount > 0L) {
        val finished: Boolean
        val flowControlError: Boolean
        withLock {
          finished = this.finished
          flowControlError = remainingByteCount + readBuffer.size > maxByteCount
        }

	"github.com/minio/minio/internal/logger"
)

func shutdownHealMRFWithTimeout() {
	const shutdownTimeout = time.Minute

	finished := make(chan struct{})
	go func() {
		globalMRFState.shutdown()
		close(finished)
	}()
	select {
	case <-time.After(shutdownTimeout):
	case <-finished:
	}
}

func handleSignals() {
	// Custom exit function
	exit := func(success bool) {
		if globalLoggerOutput != nil {

                }
            }
        }

        /**
         * Sets the finished flag to indicate whether the process has completed.
         * @param finished True if the process has finished, false otherwise.
         */
        public void setFinished(final boolean finished) {
            this.finished = finished;
        }

        /**
         * Checks if the process has been terminated due to timeout.

  private val readyAsyncCalls = ArrayDeque<AsyncCall>()

  /** Running asynchronous calls. Includes canceled calls that haven't finished yet. */
  private val runningAsyncCalls = ArrayDeque<AsyncCall>()

  /** Running synchronous calls. Includes canceled calls that haven't finished yet. */
  private val runningSyncCalls = ArrayDeque<RealCall>()

  constructor(executorService: ExecutorService?) : this() {

     * @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

        /** Initialization parameters for the data store */
        private final DataStoreParams initParamMap;

        /** Flag indicating whether the crawling thread has finished execution */
        protected boolean finished = false;

        /** Flag indicating whether the crawling thread is currently running */
        protected boolean running = false;

  PYTHON_BIN_PATH=$(which python3 || which python || true)
fi

# Set all env variables
CONFIGURE_DIR=$(dirname "$0")
"$PYTHON_BIN_PATH" "${CONFIGURE_DIR}/configure.py" "$@"