def output = file("build/task-a/output.txt")
                inputs.file input
                outputs.file output
                outputs.cacheIf { true }
                doFirst action
            }

            task taskB {
                def output = file("build/task-b/output.txt")
                inputs.file input
                outputs.file output
                outputs.cacheIf { true }

)

func TestMapToLabelSelectorRoundTrip(t *testing.T) {
	// We should be able to round-trip a map-only selector through LabelSelector.
	inputs := []map[string]string{
		nil,
		{},
		{"one": "foo"},
		{"one": "foo", "two": "bar"},
	}
	for _, in := range inputs {
		ls := &v1.LabelSelector{}
		if err := v1.Convert_Map_string_To_string_To_v1_LabelSelector(&in, ls, nil); err != nil {

// CHECK-EMPTY:
// CHECK-NEXT:         },
// CHECK-NEXT:         has_rank: true
// CHECK-NEXT:       } ],
// CHECK-NEXT:       inputs: [ 0, 1, 2, 3 ],
// CHECK-NEXT:       outputs: [ 5 ],
// CHECK-NEXT:       operators: [ {
// CHECK-NEXT:         inputs: [ 0, 1, 2, 3, 4 ],
// CHECK-NEXT:         outputs: [ 5 ],
// CHECK-NEXT:         builtin_options_type: SVDFOptions,
// CHECK-NEXT:         builtin_options: {

// CHECK-EMPTY:
// CHECK-NEXT:         },
// CHECK-NEXT:         has_rank: true
// CHECK-NEXT:       } ],
// CHECK-NEXT:       inputs: [ 0, 1, 2, 3 ],
// CHECK-NEXT:       outputs: [ 5 ],
// CHECK-NEXT:       operators: [ {
// CHECK-NEXT:         inputs: [ 0, 1, 2, 3, 4 ],
// CHECK-NEXT:         outputs: [ 5 ],
// CHECK-NEXT:         builtin_options_type: SequenceRNNOptions,
// CHECK-NEXT:         builtin_options: {

Status Reset(AbstractOperation*, const char* op, const char* raw_device_name,
             ForwardOperation*);

// Records the inputs in the `ForwardOperation`.
Status AddInput(AbstractOperation*, AbstractTensorHandle*, ForwardOperation*);
Status AddInputList(AbstractOperation*,
                    absl::Span<AbstractTensorHandle* const> inputs,
                    ForwardOperation*);

// Sets the attrs in the `ForwardOperation`.

    private final boolean allMustSucceed;
    protected final ImmutableList<ClosingFuture<?>> inputs;

    private Combiner(boolean allMustSucceed, Iterable<? extends ClosingFuture<?>> inputs) {
      this.allMustSucceed = allMustSucceed;
      this.inputs = ImmutableList.copyOf(inputs);
      for (ClosingFuture<?> input : inputs) {
        input.becomeSubsumedInto(closeables);
      }
    }

    /**

    $equation, $args, $einsum),
  [(IsInt32ElementType $einsum),
   // Constraint to check:
   // 1. The einsum has two inputs and one output.
   // 2. The einsum is not created by the convert function itself.
   // 3. Both inputs are int32 tensor.
   // 4. Both inputs have the graph ancestor of either const-(sub), or cast-sub.
   // 5. The type of the const tensor (or input of the cast operation) is int8.

                                             const char* prefix2 = nullptr) {
    TF_Output inputs[2];
    TF_Output outputs[1];
    TF_Output grad_outputs[2];

    BuildSuccessGraph(inputs, outputs);

    AddGradients(false, prefix1, inputs, 2, outputs, 1, grad_outputs);
    if (prefix2 != nullptr) {
      AddGradients(false, prefix2, inputs, 2, outputs, 1, grad_outputs);
    }
  }

  TF_Status* s_;

            disableDependencyVerification()
        }
    }
}
// end::disabling-one-configuration[]

tasks.register("checkDependencies") {
    FileCollection classpath = configurations.myPluginClasspath
    inputs.files(classpath)
    doLast {
        println(classpath.files)
    }
}

// tag::disabling-detached-configuration[]
tasks.register("checkDetachedDependencies") {

    return errors::Internal("Invalid input index");
  }
  std::vector<Output> inputs;
  inputs.reserve(end_value_index - start_value_index);
  for (int i = start_value_index; i < end_value_index; ++i) {
    inputs.push_back(op.input(i));
  }

  auto shapes = ShapeN(scope, inputs);
  const auto unique_name = scope.GetUniqueNameForOp("ConcatOffset");
  auto builder =