@Testcontainers
@Isolated
class BasicLoomTest {
  @JvmField
  @RegisterExtension
  val platform = PlatformRule()

  // Use mock server so we are strictly testing OkHttp client only in this test.
  // We should test MockWebServer later.
  @Container
  val mockServer: MockServerContainer = MockServerContainer(MOCKSERVER_IMAGE)

  val capturedOut = ByteArrayOutputStream()

  private lateinit var executor: ExecutorService

    @get:Input
    abstract val optionalProjects: ListProperty<String>

    @get:Internal
    abstract val projectDependencies: ConfigurableFileCollection

    @Input
    val runtime = externalDependencies.elements.map { it.map { it.asFile.name }.sorted() }

    @get:Internal
    abstract val externalDependencies: ConfigurableFileCollection

    @Input

 */
data class Case(
  val seqno: Int = 0,
  val wire: ByteString? = null,
  val headers: List<Map<String, String>>,
) : Cloneable {
  val headersList: List<Header>
    get() {
      val result = mutableListOf<Header>()
      for (inputHeader in headers) {
        val (key, value) = inputHeader.entries.iterator().next()
        result.add(Header(key, value))
      }

  override fun platformTrustManager(): X509TrustManager {
    val factory =
      TrustManagerFactory.getInstance(
        TrustManagerFactory.getDefaultAlgorithm(),
        provider,
      )
    factory.init(null as KeyStore?)
    val trustManagers = factory.trustManagers!!
    check(trustManagers.size == 1 && trustManagers[0] is X509TrustManager) {

    configurations[implementationConfigurationName].dependencies.add(
        dependencies.testFixtures(project)
    )
}

val testFixturesApi by configurations
val testFixturesImplementation by configurations
val testFixturesRuntimeOnly by configurations
val testFixturesRuntimeElements by configurations
val testFixturesApiElements by configurations

// Required due to: https://github.com/gradle/gradle/issues/13278

/**
 * 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(

                    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()
    }

    @VisibleForTesting
    data class AcceptedApiChange(
        val type: String?,
        val member: String?,
        val acceptation: String?,
        val changes: List<String>?
    ) {
        override fun toString(): String = "Type: '$type', Member: '$member'"
    }

    @VisibleForTesting
    data class AcceptedApiChanges(
        val acceptedApiChanges: List<AcceptedApiChange>?
    )

  private class TestStreams(
    private val taskFaker: TaskFaker,
    private val delegate: Socket,
    private val client: Boolean,
  ) : BufferedSocket {
    private val name = if (client) "client" else "server"
    val listener = WebSocketRecorder(name)
    var webSocket: RealWebSocket? = null
    var sourceClosed = false
    var sinkClosed = false
    val closed: Boolean
      get() = sourceClosed && sinkClosed