loaded.get(),
            equalTo("42")
        )
    }

    @Test
    fun `can serialize Java lambda with Property`() {
        assertProviderRoundtrip(
            propertyOf("42"),
            "42"
        )
    }

    @Test
    fun `can serialize Java lambda with ListProperty`() {
        assertProviderRoundtrip(
            listPropertyOf(1, 2, 3),
            listOf(1, 2, 3)
        )

                public void apply(Project project) {
                    // Inside a lambda body
                    lambda("apply").run();

                    project.getTasks().register("thing", t -> {
                        t.doLast(new Action<Task>() {
                            public void execute(Task t) {
                                lambda("task").run();
                            }
                        });

        }

        val lambda = call.args.filterIsInstance<FunctionArgument.Lambda>().singleOrNull()
        val (expectsConfigureLambda, requiresConfigureLambda) = semantics.configureBlockRequirement.run { allows to requires }
        if (expectsConfigureLambda) {
            if (lambda != null) {
                withScope(AnalysisScope(currentScopes.last(), configureReceiver, lambda)) {

  // CHECK: "tf.MapAndBatchDataset"(%[[TSLICE]], %[[BSIZE:.*]], %[[NPC]]
  // CHECK-SAME: f = @"__inference_Dataset_map_<lambda>_80",
  %4 = "tf.MapDataset"(%3) {device = "",
           f = @"__inference_Dataset_map_<lambda>_80",
           output_shapes = [#tf_type.shape<>], output_types = [i32],
           preserve_cardinality = false, sloppy = false,
           use_inter_op_parallelism = true,

    public LambdaImplementationSnapshot(HashCode classLoaderHash, SerializedLambda lambda) {
        this(
            lambda.getCapturingClass(),
            classLoaderHash,
            lambda.getFunctionalInterfaceClass(),
            lambda.getImplClass(),
            lambda.getImplMethodName(),
            lambda.getImplMethodSignature(),
            lambda.getImplMethodKind()
        );
    }

import java.lang.invoke.SerializedLambda
import kotlin.reflect.KClass


/**
 * In encoding a [SerializedLambda], this codec checks if the lambda parameter types are allowed in the configuration cache.
 * If some of them are not, it logs a problem.
 *
 * The lambda is encoded straightforwardly as a bean, and, upon decoding, the bean is expected to be the [SerializedLambda].

fun foo(lambda: (String) -> Int): Int = lambda("jello!")

fun test() {
    foo <expr>@Deprecated("") {
        it.length
    }</expr>

            public class MyPlugin implements Plugin<Project> {
                public void apply(Project project) {
                    Function<String, String> lambda = s -> s.toUpperCase();
                    project.getExtensions().add("lambdaExtension", lambda);
                }
            }
            """
        )

        withBuildScript(
            """
            import java.util.function.Function

    }

    def "can change nested property from an Action Java lambda to anonymous inner class and back"() {
        setupTaskClassWithActionProperty()
        def lambdaClassName = "LambdaAction"
        def anonymousClassName = "AnonymousAction"
        file("buildSrc/src/main/java/${lambdaClassName}.java") << javaClass(lambdaClassName, actionLambdaWritingFile("ACTION", "lambda"))

  // CHECK: "tf.MapAndBatchDataset"(%[[TSLICE]],
  // CHECK-SAME: f = @"__inference_Dataset_map_<lambda>_80",
  %5 = "tf.ParallelMapDataset"(%4, %3) {device = "",
           f = @"__inference_Dataset_map_<lambda>_80",
           output_shapes = [#tf_type.shape<>], output_types = [i32],
           preserve_cardinality = false, sloppy = false,
           use_inter_op_parallelism = true,