return requestBody;
    }

    @Override
    protected Map<String, Object> getUpdateMap() {
        final Map<String, Object> updateMap = new HashMap<>();
        updateMap.put("output", "new_output");
        return updateMap;
    }

    @Test
    void crudTest() {
        testCreate();
        testRead();
        testUpdate();
        testDelete();
    }

        return requestBody;
    }

    @Override
    protected Map<String, Object> getUpdateMap() {
        final Map<String, Object> updateMap = new HashMap<>();
        updateMap.put("output", "new_output");
        return updateMap;
    }

    @Test
    void crudTest() {
        testCreate();
        testRead();
        testUpdate();
        testDelete();
    }

    public String getNewOutput() {
        return newOutput;
    }

    public void setNewOutput(final String newOutputs) {
        newOutput = newOutputs;
    }

    public String getInput() {
        return input;
    }

    public String getOutput() {
        return output;
    }

    public boolean isUpdated() {
        return newInput != null && newOutput != null;
    }

    public boolean isDeleted() {

    public void setNewInputs(final String[] newInputs) {
        this.newInputs = newInputs;
    }

    public String getNewOutput() {
        return newOutput;
    }

    public void setNewOutput(final String newOutput) {
        this.newOutput = newOutput == null ? null : newOutput.replace("\n", " ");
    }

    public String[] getInputs() {
        return inputs;
    }

    public String getInputsValue() {

    public void setNewInputs(final String[] newInputs) {
        this.newInputs = newInputs;
    }

    public String[] getNewOutputs() {
        return newOutputs;
    }

    public void setNewOutputs(final String[] newOutputs) {
        this.newOutputs = newOutputs;
    }

    public String[] getInputs() {
        return inputs;
    }

    public String getInputsValue() {
        if (inputs == null) {

  Tape tape(/*persistent=*/false);
  tape.Watch(inputs[0]);
  AbstractTensorHandle* neg_output;
  TF_RETURN_IF_ERROR(ops::Neg(ctx, inputs[0], &neg_output, "Neg"));
  tape.RecordOperation(inputs, {neg_output}, nullptr, "Neg");
  return tape.ComputeGradient(ctx,
                              /*targets=*/{neg_output},
                              /*sources=*/inputs,

        return requestBody;
    }

    @Override
    protected Map<String, Object> getUpdateMap() {
        final Map<String, Object> updateMap = new HashMap<>();
        updateMap.put("outputs", "new_outputs");
        return updateMap;
    }

    @Test
    void crudTest() {
        testCreate();
        testRead();
        testUpdate();
        testDelete();
    }

            validateSynonymString(action, newInputs, "inputs", hook);
            entity.setNewInputs(newInputs);
            final String[] newOutputs = splitLine(form.outputs);
            validateSynonymString(action, newOutputs, "outputs", hook);
            entity.setNewOutputs(newOutputs);
            return entity;
        });
    }

    // ===================================================================================

            validateMappingString(action, newInputs, "inputs", hook);
            entity.setNewInputs(newInputs);
            final String newOutput = form.output;
            entity.setNewOutput(newOutput);
            return entity;
        });
    }

    // ===================================================================================