* limitations under the License.
 */

package org.gradle.buildinit.plugins;

import org.gradle.api.Plugin;
import org.gradle.api.Project;
import org.gradle.api.internal.lambdas.SerializableLambdas;
import org.gradle.api.internal.project.ProjectInternal;
import org.gradle.api.plugins.jvm.internal.JvmPluginServices;
import org.gradle.api.provider.Provider;

def tfcond(_):
  p = array_ops.placeholder(dtypes.bool, name='p_hold')
  x = array_ops.placeholder(dtypes.int32, name='x_hold')
  y = array_ops.placeholder(dtypes.int32, name='y_hold')
  z = cond.cond(p, lambda: x, lambda: y)
  array_ops.identity(z, name='result')


def tfgather(_):
  params = array_ops.placeholder(dtypes.float32, name='params')
  indices = array_ops.placeholder(dtypes.int32, name='indices')

        // After validation, the current implementations and previous implementations can't be unknown.
        // Moreover, they need to come from an actual Class, not a lambda, since there isn't a way for a unit of work implementation to be a lambda.
        ClassImplementationSnapshot currentImplementation = Cast.uncheckedNonnullCast(thisExecution.getImplementation());

 * someGraphAlgorithm(startNode, MyNode::getParents);
 * }</pre>
 *
 * <p>If you have some other mechanism for returning the predecessors of a node, or one that doesn't
 * return a {@code Iterable<? extends N>}, then you can use a lambda to perform a more general
 * transformation:
 *
 * <pre>{@code
 * someGraphAlgorithm(startNode, node -> ImmutableList.of(node.mother(), node.father()));
 * }</pre>
 *

        '''
    }

    def configuredTaskRunsCorrectly() {
        run 'test'
        outputContains 'The parameter is `42`'
        true
    }

    def 'isolated beforeProject action given as Kotlin lambda can capture managed value'() {
        given:
        withSettingsPluginInBuildLogic()

        createDir('build-logic') {
            file('settings.gradle.kts') << ''
            file('build.gradle.kts') << """

@needs_pydanticv1
def test_pydanticv1():
    class ModelWithDatetimeField(BaseModel):
        dt_field: datetime

        class Config:
            json_encoders = {
                datetime: lambda dt: dt.replace(
                    microsecond=0, tzinfo=timezone.utc
                ).isoformat()
            }

    app = FastAPI()
    model = ModelWithDatetimeField(dt_field=datetime(2019, 1, 1, 8))

import org.gradle.api.provider.Provider;
import org.gradle.process.ExecOutput;
import org.gradle.process.ExecResult;

import java.nio.charset.Charset;

import static org.gradle.api.internal.lambdas.SerializableLambdas.transformer;

public class DefaultExecOutput implements ExecOutput {
    private final Provider<ExecOutputData> dataProvider;

    public DefaultExecOutput(Provider<ExecOutputData> dataProvider) {

        // We want to track the implementation of the Closure, since the class name and classloader of the proxy will not change.
        // Java and Kotlin Lambdas are coerced to SAM types at compile time, so no unpacking is necessary there.
        if (Proxy.isProxyClass(bean.getClass())) {
            InvocationHandler invocationHandler = Proxy.getInvocationHandler(bean);

\tat org.gradle.api.internal.tasks.execution.ExecuteActionsTaskExecuter$TaskExecution.execute(ExecuteActionsTaskExecuter.java:267)
\tat org.gradle.internal.execution.steps.ExecuteStep.lambda$execute$0(ExecuteStep.java:32)
\tat java.base/java.util.Optional.map(Optional.java:258)
\tat org.gradle.internal.execution.steps.ExecuteStep.execute(ExecuteStep.java:32)

                LAMBDA_EXPRESSION -> list.add(lambda(tree, it))
                ERROR_ELEMENT -> list.add(tree.parsingError(node, it, "Unparsable value argument: \"${node.asText}\""))
                else -> tree.parsingError(it, "Parsing failure, unexpected token type in value arguments: $tokenType")
            }
        }
        return list
    }

    private