"serialize",
            // TODO: maybe introduce a separate section for the lambda serialization contract
            DocumentationSection.RequirementsDisallowedTypes
        ) {
            text(" a lambda that captures or accepts a parameter of type ")
            reference(baseType)
        }
    }

    private
    val unsupportedTypes: Map<Type, KClass<*>> =

    [SingleBlockImplicitTerminator<"ReturnOp">]> {
  let summary = [{
The `tf_device.launch` op launches containing operations on target device.
  }];

  let description = [{
This op captures all needed live-in values.
  }];

  let arguments = (ins
    StrAttr:$device
  );

  let results = (outs
    Variadic<AnyType>:$results
  );

  let regions = (region SizedRegion<1>:$body);

  build-tags:
  - integ
  - integfuzz
linters:
  disable-all: true
  enable:
  - goimports
  - gofumpt
  - gci
  fast: false
linters-settings:
  gci:
    sections:
      - standard # Captures all standard packages if they do not match another section.
      - default # Contains all imports that could not be matched to another section type.
      - prefix(istio.io/) # Groups all imports with the specified Prefix.

package cmd

import (
	"sync"

	"github.com/dustin/go-humanize"
)

const (
	// Block size used for all internal operations version 1.

	// TLDR..
	// Not used anymore xl.meta captures the right blockSize
	// so blockSizeV2 should be used for all future purposes.
	// this value is kept here to calculate the max API
	// requests based on RAM size for existing content.
	blockSizeV1 = 10 * humanize.MiByte

    BuildOperationsFixture operations = new BuildOperationsFixture(executer, temporaryFolder)

    @Requires(IntegTestPreconditions.NotEmbeddedExecutor)
    @UnsupportedWithConfigurationCache(because = "captures worker threads in shared state")
    def "task operations are closed even when interrupting the execution workers"() {
        server.start()
        executer.withStackTraceChecksDisabled()
        def parallelTaskCount = 5

import org.gradle.internal.operations.BuildOperationType
import org.gradle.internal.operations.trace.BuildOperationRecord
import org.gradle.jvm.toolchain.internal.operations.JavaToolchainUsageProgressDetails

/**
 * Captures build operations and allows to make assertions about events related to Java Toolchains.
 * <p>
 * When using this fixture make sure to first call {@link JavaToolchainBuildOperationsFixture#captureBuildOperations captureBuildOperations}

	globalBrowserConfig browser.Config

	// This flag is set to 'true' when MINIO_UPDATE env is set to 'off'. Default is false.
	globalInplaceUpdateDisabled = false

	// Captures site name and region
	globalSite config.Site

	// MinIO local server address (in `host:port` format)
	globalMinioAddr = ""

	// MinIO default port, can be changed through command line.

  llvm::ArrayRef<llvm::StringRef> output_names;
  llvm::ArrayRef<
      std::pair<tensorflow::DataType, tensorflow::PartialTensorShape>>
      output_specs;

  // The following are metadata for bound_inputs, ie. captures.
  llvm::ArrayRef<mlir::Operation*> bound_inputs;
};

// Apply `map_fn` on every exported function in the module with the
// corresponding signature metadata populated in TFRTSavedModelSignatureInfo for
// the function.

  RevivedObjects revived_objects;
  TF_RETURN_IF_ERROR(partially_revived_objects.Build(
      context, bundle.saved_object_graph(), &revived_objects));

  // Revive function library functions as concrete functions without captures.
  // This is necessary because object graph functions may refer to functions
  // _not_ in the object graph: A while loop, for example, will create two

     *
     * @param type the {@literal Class}
     * @param <T> the parameterized type of the given {@literal Class}
     * @return the {@literal TypeOf} that captures the generic type of the given {@literal Class}
     */
    public static <T> TypeOf<T> typeOf(Class<T> type) {
        return new TypeOf<T>(
            ModelType.of(typeWhichCannotBeNull(type))) {
        };
    }