then:
        configurationCache.assertStateLoaded()

        where:
        encryptionTransformation | source
        "AES/ECB/PKCS5PADDING"   | EncryptionKind.KEYSTORE
        "AES/CBC/PKCS5PADDING"   | EncryptionKind.KEYSTORE
        "AES/ECB/PKCS5PADDING"   | EncryptionKind.ENV_VAR
        "AES/CBC/PKCS5PADDING"   | EncryptionKind.ENV_VAR
    }

) : SecretKeySource {

    private
    val keyProtection = KeyStore.PasswordProtection(CharArray(0))

    private
    val keyStore by lazy {
        KeyStore.getInstance(KEYSTORE_TYPE)
    }

    override val sourceDescription: String
        get() = customKeyStoreDir?.let { "custom Java keystore at $it" }
            ?: "default Gradle configuration cache keystore"

    private

    TestKeyStore keyStore

    def setup() {
        keyStore = TestKeyStore.init(resources.dir)
        // We need to set the SSL properties as arguments here even for non-embedded test mode
        // because we want them to be set on the wrapper client JVM, not the daemon one
        wrapperExecuter.withArguments(keyStore.getTrustStoreArguments())
        server.configure(keyStore)

    void prepareWrapper(URI distributionUri = distribution.binDistribution.toURI(), TestKeyStore keyStore) {
        def executer = new InProcessGradleExecuter(distribution, temporaryFolder)
        executer.withArguments(
            "wrapper",
            "--gradle-distribution-url",
            distributionUri.toString(),
        )
        keyStore.trustStoreArguments.each {
            executer.withArgument(it)
        }

 * limitations under the License.
 */

package org.gradle.internal.cc.impl

class ConfigurationCacheJavaSerializationIntegrationTest extends AbstractConfigurationCacheIntegrationTest {

    def "restores task fields whose value is Serializable and has writeReplace method"() {
        buildFile << """
            class Placeholder implements Serializable {
                String value

import javax.inject.Inject
import java.nio.charset.Charset
import java.util.logging.Level

class ConfigurationCacheSupportedTypesIntegrationTest extends AbstractConfigurationCacheIntegrationTest {

    def "restores task fields whose value is instance of #type"() {
        buildFile << """
            import java.util.concurrent.*

            class SomeBean {
                ${type} value
            }

class ConfigurationCacheLambdaIntegrationTest extends AbstractConfigurationCacheIntegrationTest {

    def fixture = new ConfigurationCacheFixture(this)

    def "restores task fields whose value is a #kind Java lambda"() {
        given:
        file("buildSrc/src/main/java/my/LambdaTask.java").tap {
            parentFile.mkdirs()
            text = """
                package my;

        expect: 'convention mapping is ignored'
        configurationCacheRun 'myTask'

        and: 'convention mapping is ignored just the same'
        configurationCacheRun 'myTask'
    }

    def "restores convention mapped task input property explicitly set to null"() {
        given:
        withConventionMappingForPropertyOfType String, '"42"'
        buildFile << '''
            tasks.named("ok") {

            totalProblemsCount = 1
            problemsWithStackTraceCount = 0
        }
    }

    def "restores task fields whose value is an object graph with cycles"() {
        buildFile << """
            class SomeBean {
                String value
                SomeBean parent
                SomeBean child

     * {@link #redirectStandardErrorTo(OutputListener)} and
     * {@link #redirectStandardOutputTo(OutputListener)
     */
    void start();

    /**
     * Restores System.out and System.err to the values they had before {@link #start()} has been called.
     */
    void stop();

    void redirectStandardOutputTo(OutputListener stdOutDestination);