public class DeferredUtil {

    /**
     * Successively unpacks a deferred value until it is resolved to null or something other than Callable (including Groovy Closure) or Kotlin lambda
     * then unpacks the remaining Provider or Factory.
     *
     * Fails when the Provider is not present.
     */
    @Nullable
    public static Object unpack(@Nullable Object deferred) {

            }

            tasks.register("lambda", LambdaTask) {
                myActions = new ManyLambdas().createLotsOfLambdas()

                doFirst {
                    println("generated method count = \${getDeserializeMethodsCount(ManyLambdas)}")
                }
            }
        """)

        when:
        succeeds("lambda")

        then:

            val lambda = when (lambdas.size) {
                0 -> null
                1 -> lambdas.single()
                else -> {
                    errors += UnsupportedSyntax(UnsupportedSyntaxCause.ElementMultipleLambdas)
                    null
                }
            }
            val content = lambda?.block?.content.orEmpty().map { blockElementToNode(it) }

  TF_EXPECT_OK(ShapeAnnotationsMatch(*graph, shape_info, expected));
}

TEST(ShapeInferenceTest, WhileLoop) {
  // Graph:
  // x = array_ops.placeholder(dtypes.int32)
  // y = control_flow_ops.while_loop(lambda i: i < 10, lambda i: i + 1, [x])
  Graph graph(OpRegistry::Global());
  {
    Scope scope = Scope::NewRootScope().ExitOnError();

    auto dummy = ops::Placeholder(scope.WithOpName("Dummy"), DT_INT32,

          a: CONSTRUCTOR_CALL 'public constructor <init> () [primary] declared in p2.A' type=p2.A origin=null
          content: FUN_EXPR type=@[ExtensionFunctionType] kotlin.Function1<p3.RowScope, kotlin.Unit> origin=LAMBDA
            FUN LOCAL_FUNCTION_FOR_LAMBDA name:<anonymous> visibility:local modality:FINAL <> ($receiver:p3.RowScope) returnType:kotlin.Unit
              annotations:
                MyComposable

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

          CALL 'public final fun setContent (content: @[MyComposable] kotlin.Function0<kotlin.Unit>): kotlin.Int declared in p3' type=kotlin.Int origin=null
            content: FUN_EXPR type=kotlin.Function0<kotlin.Unit> origin=LAMBDA
              FUN LOCAL_FUNCTION_FOR_LAMBDA name:<anonymous> visibility:local modality:FINAL <> () returnType:kotlin.Unit
                annotations:
                  MyComposable
                BLOCK_BODY

import com.google.errorprone.annotations.DoNotMock;

/**
 * Any object which can accept registrations of {@link TearDown} instances.
 *
 * @author Kevin Bourrillion
 * @since 10.0
 */
@DoNotMock("Implement with a lambda")
@GwtCompatible
@ElementTypesAreNonnullByDefault
public interface TearDownAccepter {
  /**
   * Registers a TearDown implementor which will be run after the test proper.
   *

import com.google.errorprone.annotations.DoNotMock;

/**
 * Any object which can accept registrations of {@link TearDown} instances.
 *
 * @author Kevin Bourrillion
 * @since 10.0
 */
@DoNotMock("Implement with a lambda")
@GwtCompatible
@ElementTypesAreNonnullByDefault
public interface TearDownAccepter {
  /**
   * Registers a TearDown implementor which will be run after the test proper.
   *

        // 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());