import org.junit.jupiter.api.extension.RegisterExtension

class CompressionInterceptorTest {
  @RegisterExtension
  val clientTestRule = OkHttpClientTestRule()

  val source =
    Buffer().apply {
      write("Hello World".encodeUtf8())
    } as Source

  @Test
  fun emptyDoesntChangeRequestOrResponse() {
    val empty = CompressionInterceptor()
    val client =
      clientTestRule
        .newClientBuilder()

      println()
    }

    // Stream the response to the System.out as it is returned from the server.
    val out = System.out.sink()
    val source = response.body.source()
    while (!source.exhausted()) {
      out.write(source.buffer, source.buffer.size)
      out.flush()
    }

    response.body.close()
  } catch (e: IOException) {
    e.printStackTrace()
  } finally {
    close()
  }

- To run `make test` and `make build` completes.

### Commit changes

After verification, commit your changes. This is a [great post](https://chris.beams.io/posts/git-commit/) on how to write useful commit messages

```
git commit -am 'Add some feature'
```

### Push to the branch

Push your locally committed changes to the remote origin (your fork)

```
git push origin my-new-feature

  RecordedRequest(
    requestLine = requestLine,
    headers = headers,
    chunkSizes = chunkSizes ?: listOf(),
    bodySize = bodySize,
    body = Buffer().write(body ?: ByteString.EMPTY),
    sequenceNumber = exchangeIndex,
    failure = failure,
    method = method,
    path = target,
    handshake = handshake,
    requestUrl = url,

    runs-on: ubuntu-latest
    strategy:
      matrix:
        lang: ${{ fromJson(needs.langs.outputs.langs) }}
        command: ${{ fromJson(needs.langs.outputs.commands) }}
    permissions:
      contents: write
    steps:
      - name: Dump GitHub context
        env:
          GITHUB_CONTEXT: ${{ toJson(github) }}
        run: echo "$GITHUB_CONTEXT"
      - uses: actions/checkout@v6
        with:
          fetch-depth: 0

             OutputStreamWriter outputStream = new OutputStreamWriter(new FileOutputStream(destination), outputEncoding)) {
            String html = renderer.render(parser.parseReader(inputStream));
            outputStream.write(html);
        } catch (IOException e) {
            throw UncheckedException.throwAsUncheckedException(e);
        }
    }

```mermaid
graph TB

common_parameters(["common_parameters"])
read_items["/items/"]
read_users["/users/"]

common_parameters --> read_items
common_parameters --> read_users
```

This way you write shared code once and **FastAPI** takes care of calling it for your *path operations*.

/// check

Notice that you don't have to create a special class and pass it somewhere to **FastAPI** to "register" it or anything similar.

///

## Write the callback documentation code { #write-the-callback-documentation-code }

This code won't be executed in your app, we only need it to *document* how that *external API* should look like.

	cmd := exec.Command(
		"xcrun", "simctl", "install",
		"booted", // Install to the booted simulator.
		appdir,
	)
	if out, err := cmd.CombinedOutput(); err != nil {
		os.Stderr.Write(out)
		return fmt.Errorf("xcrun simctl install booted %q: %v", appdir, err)
	}
	return nil
}

func runSimulator(appdir, bundleID string, args []string) error {
	xcrunArgs := []string{"simctl", "spawn",

    testsuite.attrib = suite_attrib
    indent_xml(testsuites)

  tree = ElemTree.ElementTree(testsuites)
  file_path = os.path.join(output_path)
  with open(file_path, 'wb') as f:
    f.write(b'<?xml version="1.0"?>\n')
    tree.write(f)
    if verbose:
      print(f'\nWrote XML with Bazel invocation results to {file_path}')


def print_invocation_results(result_store_dict: ResultDictType):