// e.g. build/test-results/embeddedIntegTest/trace.json
        return listOf(project.layout.buildDirectory.file("test-results/$name/trace.json").get().asFile)
    }

    private
    fun Task.genericHtmlReports() = when (this) {
        is Reporting<*> -> listOf(this.reports["html"].outputLocation.get().asFile)
        else -> emptyList()
    }

                    "input": "XL",
                }
            ],
            "body": {"title": "towel", "size": "XL"},
        }
    ) | IsDict(
        # TODO: remove when deprecating Pydantic v1
        {
            "detail": [
                {
                    "loc": ["body", "size"],
                    "msg": "value is not a valid integer",

                    "msg": "Input should be a valid integer, unable to parse string as an integer",
                    "input": "foo",
                }
            ]
        }
    ) | IsDict(
        # TODO: remove when deprecating Pydantic v1
        {
            "detail": [
                {
                    "loc": ["path", "item_id"],
                    "msg": "value is not a valid integer",

                                    ],
                                }
                            )
                            | IsDict(
                                # TODO: remove when deprecating Pydantic v1
                                {
                                    "title": "X-Token",
                                    "type": "array",

 *
 * This implementation uses an array for the dynamic table and a list for indexed entries. Dynamic
 * entries are added to the array, starting in the last position moving forward. When the array
 * fills, it is doubled.
 */
@Suppress("NAME_SHADOWING")
object Hpack {
  private const val PREFIX_4_BITS = 0x0f
  private const val PREFIX_5_BITS = 0x1f
  private const val PREFIX_6_BITS = 0x3f

     * Get the next set of changes
     * 
     * Will block until the server returns a set of changes that match the given filter. The file will be automatically
     * opened if it is not and should be closed with {@link #close()} when no longer
     * needed.
     * 
     * Closing the context should cancel a pending notify request, but that does not seem to work reliable in all
     * implementations.
     * 

import org.apache.maven.api.model.Model;

/**
 * Describes a tag used by the model builder to access a {@link ModelCache}. This interface basically aggregates a name
 * and a class to provide some type safety when working with the otherwise untyped cache.
 *
 * @param <T> The type of data associated with the tag.
 * @deprecated use {@link org.apache.maven.api.services.ModelBuilder} instead
 */
@Deprecated(since = "4.0.0")

     */
    public ClingSupport() {
        this(new ClassWorld(CORE_CLASS_REALM_ID, Thread.currentThread().getContextClassLoader()), true);
    }

    /**
     * Ctor to be used when running in ClassWorlds Launcher.
     */
    public ClingSupport(ClassWorld classWorld) {
        this(classWorld, false);
    }

    private ClingSupport(ClassWorld classWorld, boolean classWorldManaged) {

# Blocking vs Non-blocking

The default behavior of the ring buffer is non-blocking, 
meaning that reads and writes will return immediately with an error if the operation cannot be completed.
If you want to block when reading or writing, you must enable it:

```go
	rb := ringbuffer.New(1024).SetBlocking(true)
```

Enabling blocking will cause the ring buffer to behave like a buffered [io.Pipe](https://pkg.go.dev/io#Pipe).

 *
 * The returned string attempts to be column-aligned to 6 characters. For negative and large values
 * the returned string may be longer.
 */
fun formatDuration(ns: Long): String {
  val s =
    when {
      ns <= -999_500_000 -> "${(ns - 500_000_000) / 1_000_000_000} s "
      ns <= -999_500 -> "${(ns - 500_000) / 1_000_000} ms"
      ns <= 0 -> "${(ns - 500) / 1_000} µs"
      ns < 999_500 -> "${(ns + 500) / 1_000} µs"