return absl::OkStatus();
  }
};

// Computes:
//
// @tf.custom_gradient
// def f(input):
//   def grad(grads):
//     return grads[0]
//   return tf.exp(input), grad
// outputs = [f(inputs[0])]
Status ExpWithPassThroughGrad(AbstractContext* ctx,
                              absl::Span<AbstractTensorHandle* const> inputs,
                              absl::Span<AbstractTensorHandle*> outputs) {

// CHECK-NEXT:       has_rank: true
// CHECK-NEXT:     } ],
// CHECK-NEXT:     inputs: [ 0, 1 ],
// CHECK-NEXT:     outputs: [ 3 ],
// CHECK-NEXT:     operators: [ {
// CHECK-NEXT:       inputs: [ 0, 1 ],
// CHECK-NEXT:       outputs: [ 2 ]
// CHECK-NEXT:     }, {
// CHECK-NEXT:       opcode_index: 1,
// CHECK-NEXT:       inputs: [ 2, 0, 1 ],
// CHECK-NEXT:       outputs: [ 3 ],

    @Override
    public List<? extends ModelReference<?>> getInputs() {
        return inputs;
    }

    protected void invoke(ModelRuleInvoker<?> ruleInvoker, List<ModelView<?>> inputs, ModelMap<?> modelMap, T baseTypeParameter, Object... ignoredInputs) {
        List<Object> ignoredInputsList = Arrays.asList(ignoredInputs);
        Object[] args = new Object[inputs.size() + 2 - ignoredInputs.length];
        args[0] = modelMap;

            // TODO when implemented, this assertion should be replaced with the commented one:
            inputs.expect(allOf(startsWith("Plugin class 'SneakyPluginA': file '${FileUtils.testFileName}'"), containsString(FileUtils.testFileName)))
            /*
            pluginClasses.forEach {
                inputs = inputs.expect(allOf(startsWith("Plugin class '$it':"), containsString(FileUtils.testFileName))))
            }*/
        }

 * limitations under the License.
 */

/**
 * Configuration input tracking implementation.
 * <p>
 * The build configuration may be influenced by various "environmental" inputs.
 * For example, build logic may read files or access environment variables.

                           bool allow_mixing_unknown_and_cpu,
                           absl::Span<const absl::string_view> inputs) {
  string result;
  TF_ASSERT_OK(PickDeviceHelper(allow_mixing_unknown_and_cpu, inputs, &result))
      << "inputs = [" << absl::StrJoin(inputs, ", ")
      << "], allow_mixing_unknown_and_cpu=" << allow_mixing_unknown_and_cpu
      << ", expected_result=" << expected_result;

        "inputs.file('a')"                                          | "TaskInputs.file(Object)"
        "inputs.files('a')"                                         | "TaskInputs.files(Object...)"
        "inputs.dir('a')"                                           | "TaskInputs.dir(Object)"
        "inputs.property('key', 'value')"                           | "TaskInputs.property(String, Object)"

func (f *Selector) Selects(inputs Set) bool {
	return !inputs.containsAny(f.absent) && inputs.containsAll(f.present)
}

// Excludes returns false, if the given set of labels, even combined with new ones, could end up satisfying the Selector.
// It returns false, if Matches would never return true, even if new labels are added to the input set.
func (f *Selector) Excludes(inputs Set) bool {
	return inputs.containsAny(f.absent)
}

                inputFile.set(layout.projectDirectory.file("inputs/file.txt"))
                outputFile.set(layout.buildDirectory.file("archive.${archiveType}"))
            }
        """
    }

    def "can create readonly FileTree for #archiveType archive in task action"() {

        given:
        file("inputs/file.txt") << "some text"
        buildFile << """

                this.inputs = ImmutableList.copyOf(inputs);
                this.action = action;
            }

            @Override
            public void execute(MutableModelNode modelNode, List<ModelView<?>> inputs) {
                action.execute(modelNode, inputs);
            }

            @Override
            public List<? extends ModelReference<?>> getInputs() {
                return inputs;
            }