import java.io.File


class BinaryCompatibilityRepositorySetupRule(private val params: Map<String, Any>) : SetupRule {

    companion object {
        const val REPOSITORY_CONTEXT_KEY = "binaryCompatibilityRepository"
    }

    /**
     * Each param is a `Set<String>`.
     */
    object Params {
        const val sourceRoots = "sourceRoots"
        const val sourceCompilationClasspath = "sourceCompilationClasspath"
    }

/**
 * Tests Hpack implementation using https://github.com/http2jp/hpack-test-case/
 */
open class HpackDecodeTestBase {
  private val bytesIn = Buffer()
  private val hpackReader = Hpack.Reader(bytesIn, 4096)

  protected fun testDecoder(story: Story) {
    for (testCase in story.cases) {
      val encoded = testCase.wire ?: continue
      bytesIn.write(encoded)
      hpackReader.readHeaders()
      assertSetEquals(

  duration: Int,
  timeUnit: TimeUnit,
): Boolean {
  val nowNs = System.nanoTime()
  val originalDurationNs =
    if (timeout().hasDeadline()) {
      timeout().deadlineNanoTime() - nowNs
    } else {
      Long.MAX_VALUE
    }
  timeout().deadlineNanoTime(nowNs + minOf(originalDurationNs, timeUnit.toNanos(duration.toLong())))
  return try {
    val skipBuffer = Buffer()
    while (read(skipBuffer, 8192) != -1L) {

                    license.setName(val);
                }
                // Url
                org = license.getUrl();
                val = interpolate(org);
                if (org != val) {
                    license.setUrl(val);
                }
                // Distribution
                org = license.getDistribution();
                val = interpolate(org);
                if (org != val) {

    assertThat(entry.hpackSize).isEqualTo(size)
  }

  private fun assertBytes(vararg bytes: Int) {
    val expected = intArrayToByteArray(bytes)
    val actual = bytesOut.readByteString()
    assertThat(actual).isEqualTo(expected)
  }

  private fun intArrayToByteArray(bytes: IntArray): ByteString {
    val data = ByteArray(bytes.size)
    for (i in bytes.indices) {
      data[i] = bytes[i].toByte()
    }

import org.gradle.workers.WorkParameters


interface IncubatingApiReportParameter : WorkParameters {
    val repositoryRoot: DirectoryProperty
    val srcDirs: ConfigurableFileCollection
    val htmlReportFile: RegularFileProperty
    val textReportFile: RegularFileProperty
    val title: Property<String>
    val releasedVersionsFile: RegularFileProperty

const val HTTP_CONTINUE = 100

/** `101 Switching Protocols` (HTTP/1.1 - RFC 9110)  */
const val HTTP_SWITCHING_PROTOCOLS = 101

/** `102 Processing` (WebDAV - RFC 2518)  */
const val HTTP_PROCESSING = 102

/** `103 Early Hints (Early Hints - RFC 8297)` */
const val HTTP_EARLY_HINTS = 103

/** `307 Temporary Redirect` (HTTP/1.1 - RFC 7231)  */
const val HTTP_TEMP_REDIRECT = 307

  // Make a defensive copy and clean it up.
  val namesAndValues: Array<String> = arrayOf(*inputNamesAndValues)
  for (i in namesAndValues.indices) {
    require(namesAndValues[i] != null) { "Headers cannot be null" }
    namesAndValues[i] = inputNamesAndValues[i].trim()
  }

  // Check for malformed headers.
  for (i in namesAndValues.indices step 2) {
    val name = namesAndValues[i]
    val value = namesAndValues[i + 1]

 * limitations under the License.
 */

package gradlebuild.buildutils.model

## Listen als Felder { #list-fields }

Sie können ein Attribut als Kindtyp definieren, zum Beispiel eine Python-`list`.

{* ../../docs_src/body_nested_models/tutorial001_py310.py hl[12] *}

Das bewirkt, dass `tags` eine Liste ist, wenngleich es nichts über den Typ der Elemente der Liste aussagt.

## Listen mit Typ-Parametern als Felder { #list-fields-with-type-parameter }