// Tests input and output names from FlatBuffer are added to `tf.entry_function` attribute.

// CHECK-LABEL: @main
func.func @main(%arg0: tensor<4xi8>, %arg1: tensor<4xi32>) -> (tensor<4xi32>, tensor<4xi8>)
// CHECK: attributes {tf.entry_function = {inputs = "input0,input1", outputs = "output0,output1"}}
attributes {tf.entry_function = {inputs = "input0,input1", outputs = "output0,output1"}} {

        run "compileJava"
        a.text = "@Helper class A { public void foo() {} }"
        outputs.snapshot { run "compileJava" }

        when:
        b.text = " class B { }"
        run "compileJava"

        then:
        outputs.deletedFiles("BHelper", "BHelperResource")
        outputs.recompiledFiles("B")
    }

    def "generated files are recompiled when annotated file is affected by a change"() {

                absl::Span<AbstractTensorHandle*> outputs) {
  return ops::AddV2(ctx, inputs[0], inputs[1], &outputs[0], "Add");
}

Status ExpModel(AbstractContext* ctx,
                absl::Span<AbstractTensorHandle* const> inputs,
                absl::Span<AbstractTensorHandle*> outputs) {
  return ops::Exp(ctx, inputs[0], &outputs[0], "Exp");
}

Status SqrtModel(AbstractContext* ctx,

          ],
          "name": "output0",
          "quantization": {
          }
        },
        {
          "shape": [
            128,
            32,
            32,
            3
          ],
          "name": "output1",
          "quantization": {
          }
        }
      ],
      "inputs": [
        0,
        1
      ],
      "outputs": [
        2,
        3
      ],

      [](const Scope& s, const std::vector<Output>& inputs, Output* output) {
        *output = ops::Less(s, inputs[0], 10);
        return s.status();
      },
      [](const Scope& s, const std::vector<Output>& inputs,
         std::vector<Output>* outputs) {
        outputs->push_back(ops::AddN(s, {inputs[0], inputs[1]}));
        outputs->push_back(ops::AddN(s, {inputs[1], 1}));
        outputs->push_back(inputs[2]);

        then:
        outputs.stdOut == ''
        outputs.stdErr == ''

        when:
        loggingManager.levelInternal = LogLevel.WARN
        loggingManager.start()
        logger.warn("warning")
        logger.error("error")

        then:
        outputs.stdOut == TextUtil.toPlatformLineSeparators('warning\n')
        outputs.stdErr == TextUtil.toPlatformLineSeparators('error\n')

     *     public void transform(TransformOutputs outputs) {
     *         outputs.dir(getInputArtifact().get().getAsFile());
     *         outputs.dir(new File(getInputArtifact().get().getAsFile(), "sub-dir"));
     *     }
     * }
     * </pre>
     *
     * <p>
     *     For a <strong>relative path</strong>, Gradle creates an output directory into which the {@link TransformAction} must place its output files.
     *     Example:
     * </p>

                absl::Span<AbstractTensorHandle*> outputs, bool use_function) {
  if (use_function) {
    const char* fn_name = "test_fn";
    core::RefCountPtr<AbstractFunction> scoped_func;
    // Returning null tensors from a tf.function is not supported, so we keep
    // track of indices in the model's outputs are nullptr in this set.
    // The FunctionDef only outputs the non-null tensors. We later pad the

  std::vector<Tensor> outputs;

  TF_EXPECT_OK(session.Run({{a, {1, 1}}}, {c}, &outputs));
  test::ExpectTensorEqual<int>(outputs[0], test::AsTensor<int>({3, 3}, {2}));

  auto d = Add(root, c, {39, 39});
  outputs.clear();
  TF_EXPECT_OK(session.Run({{a, {-10, 1}}}, {d}, &outputs));
  test::ExpectTensorEqual<int>(outputs[0], test::AsTensor<int>({31, 42}, {2}));
}

         """

        outputs.snapshot { succeeds("compileDebugSwift") }
        file("src/main/swift/multiply.swift").delete()

        expect:
        succeeds("compileDebugSwift")
        outputs.recompiledClasses()
        outputs.deletedClasses("multiply")
    }

    def 'changing compiler arguments rebuilds everything'() {
        given: