def "incremental task with NAME_ONLY inputs (matching file names and content) detects deleted file"() {
        def inputs = folderNames().collect { file("${it}/input.txt").createFile() }

        buildFile << incrementalTaskWithNameOnlyInputFiles(inputs)
        run INCREMENTAL_TASK_NAME

        when:
        inputs[1..2]*.delete()
        println "${inputs} exists: ${inputs*.exists()}"
        run INCREMENTAL_TASK_NAME, "--info"

    private final String[] inputs;

    private final String output;

    private String[] newInputs;

    private String newOutput;

    public CharMappingItem(final long id, final String[] inputs, final String output) {
        this.id = id;
        this.inputs = inputs;
        this.output = output == null ? null : output.replace("\n", " ");
        Arrays.sort(inputs);

        if (id == 0) {

    protected AbstractModelAction(ModelReference<T> subject, ModelRuleDescriptor descriptor, ModelReference<?>... inputs) {
        this(subject, descriptor, inputs == null ? EMPTY_MODEL_REF_LIST : Arrays.asList(inputs));
    }

    protected AbstractModelAction(ModelReference<T> subject, ModelRuleDescriptor descriptor, List<? extends ModelReference<?>> inputs) {

        return new AbstractModelAction<T>(reference, descriptor, input1, input2) {
            @Override
            public void execute(MutableModelNode modelNode, List<ModelView<?>> inputs) {
                action.execute(modelNode,
                    Cast.<I>uncheckedCast(inputs.get(0).getInstance()),
                    Cast.<J>uncheckedCast(inputs.get(1).getInstance())
                );
            }
        };
    }

        private final ModelType<T> type;
        private final List<ModelReference<?>> inputs;

        private UnmanagedElementCreationAction(ModelRuleDescriptor descriptor, ModelReference<?> subject, List<ModelReference<?>> inputs, ModelType<T> type) {
            this.subject = subject;
            this.inputs = inputs;
            this.descriptor = descriptor;
            this.type = type;
        }

        @Override

                && Objects.equals(inputs, that.inputs);
    }

    @Override
    public int hashCode() {
        return Objects.hash(modelId, location, inputs);
    }

    Stream<InputSource> sources() {
        return inputs != null ? inputs.stream() : Stream.of(this);
    }

    @Override
    public String toString() {
        if (inputs != null) {

    private final List<ModelReference<?>> inputs;

    public MethodBackedModelAction(ModelRuleDescriptor descriptor, ModelReference<T> subject, List<ModelReference<?>> inputs) {
        super(subject, descriptor);
        this.inputs = inputs;
    }

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

    @Override

public class SynonymItem extends DictionaryItem {
    private final String[] inputs;

    private final String[] outputs;

    private String[] newInputs;

    private String[] newOutputs;

    public SynonymItem(final long id, final String[] inputs, final String[] outputs) {
        this.id = id;
        this.inputs = inputs;
        this.outputs = outputs;

        if (id == 0) {
            // create

jobs:
  cherrypick:
    name: Cherrypick to ${{ github.event.inputs.release_branch}} - ${{ github.event.inputs.git_commit }}
    runs-on: ubuntu-latest
    if: github.repository == 'tensorflow/tensorflow' # Don't do this in forks
    steps:
    - name: Checkout code
      uses: actions/checkout@755da8c3cf115ac066823e79a1e1788f8940201b # v3.2.0
      with:
        ref: ${{ github.event.inputs.release_branch }}

  std::vector<std::pair<string, Tensor>> inputs;
  TF_EXPECT_OK(GetInputValues(sig_, request_, inputs));

  std::vector<std::pair<string, TensorProto>> exp_inputs;
  ConvertOutputTensorToProto(inputs, exp_inputs);

  EXPECT_THAT(exp_inputs,
              UnorderedElementsAre(Pair("feed_x", EqualsProto(input_x_)),
                                   Pair("feed_y", EqualsProto(input_y_))));
}