# Assert test2json has properly attributed output.
go test -json -parallel 3 chatty_parallel_test.go -v
stdout -count=2 '"Test":"TestChattyParallel/sub-0","Output":"    chatty_parallel_test.go:32: this is sub-0\\n"'
stdout -count=2 '"Test":"TestChattyParallel/sub-1","Output":"    chatty_parallel_test.go:32: this is sub-1\\n"'
stdout -count=2 '"Test":"TestChattyParallel/sub-2","Output":"    chatty_parallel_test.go:32: this is sub-2\\n"'

    def "snapshots outputs"() {
        def outputSnapshot = Mock(FileSystemSnapshot)

        when:
        def result = outputSnapshotter.snapshotOutputs(work, workspace)

        then:
        1 * work.visitOutputs(workspace, _ as UnitOfWork.OutputVisitor) >> { File workspace, UnitOfWork.OutputVisitor outputVisitor ->

    @Override
    public void transform(TransformOutputs outputs) {
        // We simulate fan-in behaviour:
        // We expect that a transform before this one outputs three artifacts: 1. analysis metadata, 2. the original file and 3. instrumentation marker file.
        // So if the input is analysis metadata we use it and create instrumented artifact, otherwise it's original artifact and we output that.
        File input = getInput().get().getAsFile();

            createNewFile(outputs.file(AGENT_INSTRUMENTATION_MARKER.getFileName()));
            doTransform(artifactToTransform, outputs, originalName -> INSTRUMENTED_ENTRY_PREFIX + originalName);
        } else {
            createNewFile(outputs.file(LEGACY_INSTRUMENTATION_MARKER.getFileName()));
            doTransform(artifactToTransform, outputs, originalName -> originalName);
        }
    }

         * Value will be null for any other outcome.
         *
         * This value may also be null for an UP_TO_DATE outcome where the task executed, but then decided it was UP_TO_DATE.
         * That is, it was not UP_TO_DATE due to Gradle's core input/output incremental build mechanism.

            } }
        """

        when:
        fails('failing')

        then:
        result.groupedOutput.task(':failing').output == 'hello'
        result.formattedOutput.contains(failingTask.output)
    }

    def "group header is printed red if task failed and there is no output"() {
        given:
        buildFile << """
            task failing { doFirst {
                throw new RuntimeException('Failure...')

                @OutputFile
                File output

                @TaskAction
                void upper() {
                  output.text = input.text.toUpperCase()
                }
            }

            task upper(type: UpperFile) {
                input = file("input")
                output = file("output")
            }

            task build(type: GradleBuild) {

          TAG="quay.io/minio/minio:${{ steps.vars.outputs.sha_short }}" make docker

      - name: multipart uploads test
        run: |
          ${GITHUB_WORKSPACE}/.github/workflows/multipart/migrate.sh "${{ steps.vars.outputs.sha_short }}"

      - name: compress and encrypt
        run: |
          ${GITHUB_WORKSPACE}/.github/workflows/run-mint.sh "compress-encrypt" "minio" "minio123" "${{ steps.vars.outputs.sha_short }}"

    const std::vector<std::string>& output_names,
    const std::vector<std::string>& target_nodes,
    std::vector<Tensor>* outputs) {
  tensorflow::RunMetadata run_metadata;
  return Run(tensorflow::RunOptions(), inputs, output_names, target_nodes,
             outputs, &run_metadata);
}

Status FakeSession::Run(
    const tensorflow::RunOptions& run_options,

    DCHECK_EQ(inputs.size(), 1);
    outputs->emplace_back(ops::Subtract(scope, inputs[0], 1));
    return scope.status();
  };

  string frame_name = BackPropFrameName(while_ctx->frame_name());
  std::vector<Output> outputs;
  TF_RETURN_IF_ERROR(BuildWhileLoop(
      scope, {loop_count}, cond_fn, body_fn, frame_name, &outputs,
      /* create_while_ctx */ false, backprop_execution_pred));