}

    @Test
    fun `package list excludes default package`() {
        assertEquals(listOf<String>(), getRelocatedPackages(someClassesInDefaultPackage()))
        assertEquals(EXPECTED_PACKAGE_LIST, getRelocatedPackages(someClasses() + someClassesInDefaultPackage()))
    }

    @Test
    fun `package list excludes default package (in jar)`() {

abstract class JaxenDependenciesRule: ComponentMetadataRule {
    override fun execute(context: ComponentMetadataContext) {
        context.details.allVariants {
            withDependencies {
                removeAll { it.group in listOf("dom4j", "jdom", "xerces",  "maven-plugins", "xml-apis", "xom") }
            }
        }
    }
}
// end::jaxen-rule-1[]

// tag::jaxen-rule-2[]
@CacheableRule

  private lateinit var server: MockWebServer
  private lateinit var dns: Dns
  private val cacheFs = FakeFileSystem()
  private val bootstrapClient =
    OkHttpClient.Builder()
      .protocols(listOf(Protocol.HTTP_2, Protocol.HTTP_1_1))
      .build()

  @BeforeEach
  fun setUp(server: MockWebServer) {
    this.server = server
    server.protocols = bootstrapClient.protocols

                setInput = null
                setInput = listOf("a")
                setInput = provider { null }
                setInput = provider { listOf("a") }
                listInput = null
                listInput = listOf("a")
                listInput = provider { null }
                listInput = provider { listOf("a") }
                dirInput = null as File?

 * limitations under the License.
 */
package gradlebuild.basics


object PublicKotlinDslApi {

    val includes = listOf(
        "org/gradle/kotlin/dsl/*",
        "org/gradle/kotlin/dsl/precompile/*",
    )

    val excludes = listOf(
        // Kotlin inlined functions classes
        "**/*${'$'}inlined${'$'}*"
    )

                    "methodMan",
                    listOf("java.lang.String"),
                    true
                )
            )
        )
    }

    @Test
    fun `can extract JavaFunction from multiple parameters signature string`() {
        assertThat(
            javaFunctionOf("org.gradle.SomeType.methodMan(java.lang.String, java.util.List)"),
            equalTo(
                JavaFunction(

package okhttp3

import java.io.IOException
import java.security.Security
import okhttp3.internal.platform.Platform
import org.conscrypt.Conscrypt

// TLS 1.3
private val TLS13_CIPHER_SUITES =
  listOf(
    CipherSuite.TLS_AES_128_GCM_SHA256,
    CipherSuite.TLS_AES_256_GCM_SHA384,
    CipherSuite.TLS_CHACHA20_POLY1305_SHA256,
    CipherSuite.TLS_AES_128_CCM_SHA256,
    CipherSuite.TLS_AES_128_CCM_8_SHA256,
  )

/**

package gradlebuild.basics.testing

import org.gradle.api.tasks.testing.Test


enum class TestType(val prefix: String, val executers: List<String>) {
    INTEGRATION("integ", listOf("embedded", "forking", "noDaemon", "parallel", "configCache", "isolatedProjects")),
    CROSSVERSION("crossVersion", listOf("embedded", "forking"))
}


fun Test.includeSpockAnnotation(fqcn: String) {

 * limitations under the License.
 */
package okhttp3.survey.types

data class Client(
  val userAgent: String,
  val version: String,
  val platform: String? = null,
  val enabled: List<SuiteId> = listOf(),
  val supported: List<SuiteId> = listOf(),
) {
  val nameAndVersion: String
    get() = "$userAgent/$version"

        assertNull(resolver.trace.assignmentResolution(failedLhs).result)
        assertEquals(listOf(ErrorReason.UnresolvedAssignmentLhs::class), resolver.trace.assignmentResolution(failedLhs).errors?.map { it.errorReason::class })

        assertNull(resolver.trace.expressionResolution(failedLhs.lhs).result)