inline impl::NodeMatcherProperties Attr(const string& name) {
  return impl::Attr(name);
}

// Matches a node with inputs `inputs`.
//
// `inputs` are ordered; `inputs`[i] must match input i.
template <typename... Ts>
impl::NodeMatcherProperties Inputs(Ts... inputs) {
  return impl::Inputs({inputs...});
}

// Matches the `idx`'th output of a node that matches `node`.
::testing::Matcher<impl::OutEdge> Out(int oidx,

    }

    public Object get(String path) {
        PotentialInput potentialInput = inputs.get(path);
        if (potentialInput == null) {
            throw new IllegalStateException("no input for " + path);
        }
        return potentialInput.get(modelViews);
    }

	col3 := newSchema("col3")
	col4 := newSchema("col4")

	a1 := &analyzer{name: "a1", inputs: []config.GroupVersionKind{col1.GroupVersionKind()}}
	a2 := &analyzer{name: "a2", inputs: []config.GroupVersionKind{col2.GroupVersionKind()}}
	a3 := &analyzer{name: "a3", inputs: []config.GroupVersionKind{col3.GroupVersionKind()}}
	a4 := &analyzer{name: "a4", inputs: []config.GroupVersionKind{col4.GroupVersionKind()}}

	a := Combine("combined", a1, a2, a3, a4)

              dependsOn "a"
              inputs.dir "b"
              outputs.file "build/b"
              doLast {}
            }
            task c {
              dependsOn "b"
              inputs.dir "c"
              outputs.file "build/c"
              doLast {}
            }
            task d {
              dependsOn "c"
              inputs.dir "d"
              outputs.file "build/d"

                  const std::vector<Output>& inputs,
                  std::vector<Output>* outputs) {
  DCHECK(outputs != nullptr);
  DCHECK(outputs->empty());

  // The control dependency is analogous to that in CreateCond().
  Scope body_scope =
      scope.NewSubScope("body").WithControlDependencies(inputs[0]);
  TF_RETURN_IF_ERROR(body(body_scope, inputs, outputs));

  const size_t num_loop_vars = inputs.size();

  bool UseFunction() const { return std::get<2>(GetParam()); }
};

// Checks that inputs[0] is a scalar.
Status TestScalarShape(AbstractContext* ctx,
                       absl::Span<AbstractTensorHandle* const> inputs,
                       absl::Span<AbstractTensorHandle*> outputs) {
  PartialTensorShape shape;
  TF_RETURN_IF_ERROR(inputs[0]->Shape(&shape));
  if (shape.dims() != 0) {
    return errors::InvalidArgument(

  if (ops.empty()) {
    return;
  }

  std::vector<Value> inputs;
  std::vector<Value> outputs;
  computeInputsOutputs(ops, &inputs, &outputs);

  std::vector<Type> input_types;
  std::vector<Type> output_types;

  input_types.reserve(inputs.size());
  for (Value v : inputs) {
    input_types.push_back(v.getType());
  }
  output_types.reserve(outputs.size());

// CHECK: func @add(
// CHECK-SAME: {tf_saved_model.index_path = ["input1"]}
// CHECK-SAME: {tf_saved_model.index_path = ["input2"]}
// CHECK-SAME: {tf_saved_model.index_path = ["result"]}
// CHECK-SAME: tf.entry_function = {inputs = "input1:0,input2:0", outputs = "result:0"}
// CHECK-SAME: tf_saved_model.exported_names = ["add"]

// CHECK: func @sub(
// CHECK-SAME: {tf_saved_model.index_path = ["input2"]}
// CHECK-SAME: {tf_saved_model.index_path = ["input1"]}

        inputsDir.file('4.txt').asFile.text = 'Content for new file 4.'
    }
}
// end::updated-inputs[]

// tag::removed-input[]
tasks.register('removeInput', Delete) {
    delete 'inputs/3.txt'
}
// end::removed-input[]

// tag::removed-output[]
tasks.register('removeOutput', Delete) {
    delete layout.buildDirectory.file("outputs/1.txt")
}
// end::removed-output[]

          A result(Collector<T, A, R> collector, Iterable<T> inputs) {
        List<A> stack = new ArrayList<>();
        for (T input : inputs) {
          A newAccum = collector.supplier().get();
          collector.accumulator().accept(newAccum, input);
          push(stack, newAccum);
        }
        push(stack, collector.supplier().get());