domainObject,
                typeOf<NamedDomainObjectProvider<DomainObject>>()
            )
        }
    }

    @Test
    fun `val domainObject by registering(type)`() {

        val domainObjectProvider = mockDomainObjectProviderFor(DomainObject())
        val container = mock<PolymorphicDomainObjectContainer<Any>> {

            )
        }
        if (kClass.isSubclassOf(Map::class)) {
            val keyType = type.arguments.getOrNull(0)?.type
            val valueType = type.arguments.getOrNull(1)?.type

            val keyConversion = keyType?.let { createConversion(it) } ?: HLIdParameterConversion
            val valueConversion = valueType?.let { createConversion(it) } ?: HLIdParameterConversion

            accessibleConventionsSchema(plugins).forEach { (name, type) ->
                conventions.add(ProjectSchemaEntry(targetType, name, type))
                val plugin = DeprecationLogger.whileDisabled(Factory { plugins[name] })!!
                collectSchemaOf(plugin, type)
            }
            accessibleContainerSchema(target.tasks.collectionSchema).forEach { schema ->

    ): FunctionSemantics {
        val lastParam = function.parameters[function.parameters.lastIndex]
        val configuredType = configureLambdas.getTypeConfiguredByLambda(function.parameters.last().type)
        val blockRequirement = when {
            configuredType == null -> FunctionSemanticsInternal.DefaultConfigureBlockRequirement.DefaultNotAllowed

    val keyPair: KeyPair = heldCertificate.keyPair()
  }

  @Test @Disabled
  fun mediaType() {
    val mediaType: MediaType = MediaType.get("")
    val type: String = mediaType.type()
    val subtype: String = mediaType.subtype()
    val parse: MediaType? = MediaType.parse("")
  }

  @Test @Disabled
  fun mockResponse() {
    val mockResponse = MockResponse()

    hostname: String,
    networkRequests: MutableList<Call>,
    results: MutableList<InetAddress>,
    failures: MutableList<Exception>,
    type: Int,
  ) {
    val request = buildRequest(hostname, type)
    val response = getCacheOnlyResponse(request)

    response?.let { processResponse(it, hostname, results, failures) } ?: networkRequests.add(
      client.newCall(request),
    )
  }

          ) {
            cacheRequestClosed = true
            cacheRequest.abort()
          }
          source.close()
        }
      }

    val contentType = response.header("Content-Type")
    val contentLength = response.body.contentLength()
    return response.newBuilder()
      .body(RealResponseBody(contentType, contentLength, cacheWritingSource.buffer()))
      .build()
  }

  companion object {

        get() = analysisSession.token

    override fun getKtExpressionType(expression: KtExpression): KaType? {
        // Not sure if it's safe enough. In theory, some annotations on expressions might change its type
        val unwrapped = expression.unwrapParenthesesLabelsAndAnnotations() as? KtExpression ?: return null
        if (unwrapped.getParentOfTypes(false, *NON_EXPRESSION_CONTAINERS) != null) {
            return null
        }

        // given: different classpath
        withClassJar("left/fixture.jar")
        withClassJar("right/fixture.jar", DeepThought::class.java)

        // and: same script & target type
        val sameContent = """
            buildscript {
                dependencies { classpath(files("fixture.jar")) }
            }
            println("Same content, different classpath on ${'$'}this")
        """

    override fun createPerformanceTestsFor(stage: Stage, performanceTestCoverage: PerformanceTestCoverage): List<PerformanceTest> {
        val performanceTestType = performanceTestCoverage.type
        val performanceTestSpec = PerformanceTestSpec(performanceTestType, performanceTestCoverage.os)
        val scenarios = determineScenariosFor(performanceTestSpec, performanceTestConfigurations)