return nil
		}
		return apiErr
	}
	return nil
}

// GetObjectLamdbaHandler - GET Object with transformed data via lambda functions
// ----------
// This implementation of the GET operation applies lambda functions and returns the
// response generated via the lambda functions. To use this API, you must have READ access
// to the object.

    }

    @Test
    fun `if a lambda is optional, a lambda is accepted`() {
        schema.resolve("lambdaOptional(0) { }").isSuccessful()
    }

    @Test
    fun `if a lambda is not allowed, missing lambda is ok`() {
        schema.resolve("lambdaNotAllowed(0)").isSuccessful()
    }

    @Test
    fun `if a lambda is not allowed, a lambda is reported as an error`() {

    }

    public static Optional<SerializedLambda> serializedLambdaFor(@Nullable Object lambda) {
        if (!(lambda instanceof Serializable)) {
            return Optional.empty();
        }
        for (Class<?> lambdaClass = lambda.getClass(); lambdaClass != null; lambdaClass = lambdaClass.getSuperclass()) {
            try {

            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)) {

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].

    override fun produceValueCaptor(lambdaType: KType): ConfigureLambdaHandler.ValueCaptor {
        lateinit var value: Any
        val lambda: Function1<Any, Unit> = { value = it }
        return ConfigureLambdaHandler.ValueCaptor(lambda, lazy { value })
    }

    private
    fun isConfigureLambdaType(maybeLambdaType: KType) = maybeLambdaType.isSubtypeOf(typeOf<Function1<*, Unit>>())

    private

    fun `adding function may have a configuring lambda if it returns the added value`() {
        val schema = schemaFromTypes(ReceiverOne::class, listOf(ReceiverOne::class))
        val function = schema.dataClassesByFqName.values.single().memberFunctions.single()
        assertIs<FunctionSemantics.AddAndConfigure>(function.semantics)
    }

    @Test
    fun `adding function may not have a configuring lambda if it returns Unit`() {

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;

                import org.gradle.api.*;