TF_RETURN_IF_ERROR((*out)->AddInputList(inputs));

  absl::Span<AbstractTensorHandle* const> captures(
      reinterpret_cast<AbstractTensorHandle* const*>(captures_.data()),
      captures_.size());

  // Adding the captures of the function.
  TF_RETURN_IF_ERROR((*out)->AddInputList(captures));
  return Status();
}

  // Capture is at index "10"
  saved.add_bound_inputs(10);

  // `func` has 4 inputs
  FunctionDef func = FuncDefWithNumInputsOutputs(4, 0);

  // `captures` only has a capture for index 5
  std::unordered_map<int, std::unique_ptr<TensorHandleConvertible>> captures;
  captures[5] = std::make_unique<DummyCapture>(context(), 10);

  std::unique_ptr<TFConcreteFunction> result;

// taking + returning flat lists of tensors, including any captures.
// Effectively, it is a thin wrapper around a FunctionDef owned by the
// EagerContext, and any TensorHandle captures associated with the function. The
// MakeCallOp method handles the logic of marshaling captures after the user
// provided inputs automatically.
// Note(bmzhao): This class is mainly intended to house low-level reusable

}

// Stat captures time taken to call os.Stat
func Stat(name string) (info os.FileInfo, err error) {
	defer updateOSMetrics(osMetricStat, name)(err)
	return os.Stat(name)
}

// Create captures time taken to call os.Create
func Create(name string) (f *os.File, err error) {
	defer updateOSMetrics(osMetricCreate, name)(err)
	return os.Create(name)
}

// Fdatasync captures time taken to call Fdatasync

            ${mavenCentralRepository()}
            dependencies {
                ${testFrameworkDependencies}
            }
            test.${configureTestFramework}
        """
    }

    def "captures test progress logging events" () {
        withGoodTestClasses(10)

        when:
        succeeds("test")

        then:
        events.statusLogged("0 tests completed")

// inaccuracies.
type Stats struct {
	// Writes captures the number of times state in the cache was added or updated.
	Writes uint64

	// Hits captures the number of times a Get operation succeeded to find an entry in the cache.
	Hits uint64

	// Misses captures the number of times a Get operation failed to find an entry in the cache.
	Misses uint64

	// Evictions captures the number of entries that have been evicted from the cache

  std::vector<ImmediateExecutionTensorHandle*> captures;
  captures.reserve(capture_node_ids.size());
  for (int capture_node_id : capture_node_ids) {
    ImmediateExecutionTensorHandle* capture_handle;
    TF_RETURN_IF_ERROR(TensorHandleFromNode(capture_node_id, obj_graph, objects,
                                            &capture_handle));
    captures.push_back(capture_handle);
  }

class ApplyScriptPluginBuildOperationIntegrationTest extends AbstractIntegrationSpec {

    def operations = new BuildOperationsFixture(executer, temporaryFolder)

    def "captures gradle script events"() {
        given:
        def otherScript2 = file("script2.gradle") << ""
        def otherScript1 = file("script1.gradle") << """

  const SavedConcreteFunction* saved_concrete_func = nullptr;

  // The name of the SignatureDef key.
  std::string signature_key;

  // TensorHandle captures for this funtion
  std::vector<ImmediateExecutionTensorHandle*> captures;
};

}  // namespace tensorflow

    final static String CLASSPATH = "CLASSPATH"
    final static String BODY = "BODY"

    def setup() {
        executer.requireOwnGradleUserHomeDir()
    }

    def "captures script compilation build operations"() {
        given:
        settingsFile << "println 'settings.gradle'"
        buildFile << """
            apply from: 'script.gradle'
            println 'build.gradle'
        """