import org.junit.rules.TestRule
import org.junit.runner.Description
import org.junit.runners.model.Statement

/**
 * A log handler that records which log messages were published so that a calling test can make
 * assertions about them.
 */
class TestLogHandler(
  private val logger: Logger,
) : TestRule,
  BeforeEachCallback,
  AfterEachCallback {

    * Tell me how you use FastAPI (I love to hear that).
    * Hear when I make announcements or release new tools.
    * You can also [follow @fastapi on X (Twitter)](https://x.com/fastapi) (a separate account).
* [Follow me on **LinkedIn**](https://www.linkedin.com/in/tiangolo/).
    * Hear when I make announcements or release new tools (although I use X (Twitter) more often 🤷‍♂).

This can be quite noticeable when using `docker compose`. See this Docker Compose FAQ section for more technical details: [Why do my services take 10 seconds to recreate or stop?](https://docs.docker.com/compose/faq/#why-do-my-services-take-10-seconds-to-recreate-or-stop).

#### Directory Structure { #directory-structure }

You should now have a directory structure like:

```
.
├── app

func (e *Erasure) Encode(ctx context.Context, src io.Reader, writers []io.Writer, buf []byte, quorum int) (total int64, err error) {
	writer := &multiWriter{
		writers:     writers,
		writeQuorum: quorum,
		errs:        make([]error, len(writers)),
	}

	for {
		var blocks [][]byte
		n, err := io.ReadFull(src, buf)
		if err != nil {
			if !IsErrIgnored(err, []error{
				io.EOF,
				io.ErrUnexpectedEOF,
			}...) {

on 2020-08-01:

```
wget https://github.com/swojtasiak/fcml-lib/releases/download/v1.2.2/fcml-1.2.2.tar.gz
tar xf fcml*
cd fcml*
./configure
make
cd example/hsdis
make
sudo cp .libs/libhsdis.so.0.0.0 /usr/lib/jvm/java-14-adoptopenjdk/lib/hsdis-amd64.so
```

If you want to disassemble a single method do something like this:

```

     * Given that we declare this method as accepting and returning non-nullable values (because we
     * implement Function<A, B>, as discussed in a class-level comment), it would make some sense to
     * perform runtime null checks on the input and output. (That would also make NullPointerTester
     * happy!) However, since we didn't do that for many years, we're not about to start now.

3. **Testing**:
   - Include unit tests for new functionality or bug fixes.
   - Ensure existing tests pass (`make test`).
   - Document testing steps in the PR summary if manual testing was performed.

4. **Before Submitting**:
   - Run `make verify` to check formatting, linting, and tests.
   - Reference related issues (e.g., “Closes #1234”).

	})
	return list
}

// NewTargetList - creates TargetList.
func NewTargetList(ctx context.Context) *TargetList {
	list := &TargetList{
		targets:     make(map[TargetID]Target),
		queue:       make(chan asyncEvent, maxConcurrentAsyncSend),
		targetStats: make(map[TargetID]targetStat),
		ctx:         ctx,
	}
	return list

Concurrency
===========

This document describes the concurrency considerations for http/2 connections and the connection pool within OkHttp.

## HTTP/2 Connections

The HttpURLConnection API is a blocking API. You make a blocking write to send a request, and a blocking read to receive the response.

#### Blocking APIs

        taskRunner.kickCoordinator(this)
      }
    }
  }

  /**
   * Overload of [schedule] that uses a lambda for a repeating task.
   *
   * TODO: make this inline once this is fixed: https://github.com/oracle/graal/issues/3466
   */
  fun schedule(
    name: String,
    delayNanos: Long = 0L,
    block: () -> Long,
  ) {
    schedule(
      object : Task(name) {