}
}
// end::dependency-management[]

// tag::configure-target-machines[]
library {
    targetMachines = listOf(machines.linux.x86_64, machines.macOS.x86_64)
}
// end::configure-target-machines[]

// tag::configure-linkages[]
library {
    linkage = listOf(Linkage.STATIC, Linkage.SHARED)
}

            parser("foo bar"),
            listOf(Unit)
        )
        assertSuccess(
            parser("foo foo bar"),
            listOf(Unit, Unit)
        )
    }

    @Test
    fun `can fail many symbols`() {
        val parser = zeroOrMore(combinator.symbol("foo"))
        assertSuccess(
            parser("foofoo"),
            listOf()
        )
    }

    @Test

    testImplementation("junit:junit:4.13")
}

// tag::custom-source-locations[]
sourceSets {
    main {
        scala {
            setSrcDirs(listOf("src/scala"))
        }
    }
    test {
        scala {
            setSrcDirs(listOf("test/scala"))
        }
    }
}

        val silencer = ExperimentalCompilerWarningSilencer(listOf("SOME"))

        val message = "Hello, World!"
        val rewritten = silencer.rewrite(LogLevel.WARN, message)

        assertThat(rewritten, equalTo(message))
    }

    @Test
    fun `silences unsafe internal compiler arguments`() {
        val silencer = ExperimentalCompilerWarningSilencer(listOf("-XXLanguage:+DisableCompatibilityModeForNewInference"))

        null -> emptyList()
        else -> listOf(
            TypesafeProjectPropertyProducer(),
            ExtensionProperties(mapOf(ProjectTopLevelReceiver::class to listOf(projectAccessorsExtension)))
        )
    }

    override fun typeDiscovery(): List<TypeDiscovery> = when (projectAccessorsClass) {
        null -> emptyList()
        else -> listOf(

        assertThat(
            invalidationReasonForInitScriptsChange(
                from = listOf(
                    File("init.gradle.kts") to TestHashCodes.hashCodeFrom(1),
                    File("unchanged.gradle.kts") to TestHashCodes.hashCodeFrom(1)
                ),
                to = listOf(
                    File("init.gradle.kts") to TestHashCodes.hashCodeFrom(2),

}
// end::dependency-management[]

// tag::configure-target-machines[]
library {
    targetMachines = listOf(machines.linux.x86_64,
        machines.windows.x86, machines.windows.x86_64,
        machines.macOS.x86_64)
}
// end::configure-target-machines[]

// tag::configure-linkages[]
library {
    linkage = listOf(Linkage.STATIC, Linkage.SHARED)
}

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 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"

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