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 }}"

        redirector.start()
        System.out.println('this is stdout')
        System.err.println('this is stderr')
        redirector.stop()

        then:
        System.out == outputs.stdOutPrintStream
        System.err == outputs.stdErrPrintStream
    }

    def startAndStopRedirectsStdOut() {
        when:
        redirector.redirectStandardOutputTo(stdOutListener)
        redirector.start()

            withArgument("--max-workers=$threadCount")
        }
    }

    def "overlapping outputs prevent parallel execution"() {
        given:
        withParallelThreads(2)

        and:
        buildFile << """
            aPing.outputs.dir "dir"
            bPing.outputs.file "dir/file"
        """
        expect:
        2.times {

            logger2.log(it, "Test");
            logger3.log(it, "Test");
        }
        redirector.stop()

        then:
        0 * _

        System.out == outputs.stdOutPrintStream
        System.err == outputs.stdErrPrintStream
    }

    def "start and stop output with redirection and default logging"() {
        when:
        redirector.redirectStandardOutputTo(stdOutListener)

      float_graph->tensors()->Get(op->outputs[0])->quantization();
  auto output_quant_params =
      subgraph->tensors[op->outputs[0]]->quantization.get();
  ASSERT_THAT(*float_output_quant_params->min(), SizeIs(1));
  ASSERT_THAT(*float_output_quant_params->max(), SizeIs(1));
  ASSERT_THAT(output_quant_params->scale, SizeIs(1));

  // Make sure the input min/maxes are propagated to outputs.

      output_args_(op_.Outputs().begin(), op_.Outputs().end()),
      argument_attrs_(op_.Attributes().begin(), op_.Attributes().end()) {
  // Initialize function arguments
  all_arguments_.push_back(OpArgumentView("AbstractContext*", "ctx"));
  for (const auto& arg : op_.Inputs()) {
    all_arguments_.push_back(OpArgumentView(arg));
  }
  for (const auto& arg : op_.Outputs()) {

        // TODO - should just write this as a bean field of the outputs object, and also do this for the registered properties above
        if (task.outputs.upToDateSpec.isEmpty) {
            writeBoolean(false)
        } else {
            writeBoolean(true)
            write(task.outputs.upToDateSpec)
        }
    }

    private

    }

    def "task depends on other task whose outputs are its inputs"() {
        buildFile << """
            task a {
                outputs.file 'a.txt'
                def outputFile = file('a.txt')
                doLast {
                    outputFile << "Data"
                }
            }

            task b {
                inputs.files tasks.a.outputs.files
            }
        """

                    inputArtifact.get().asFile
                }

                void transform(TransformOutputs outputs) {
                    def output = outputs.file(input.name + ".txt")
                    println "Transformed \$input.name to \$input.name into \${output.parentFile}"
                    outputs.file(inputArtifact)
                    output.text = String.valueOf(input.length())
                }
            }

	if [[ $? -eq 0 ]]; then
		echo "Outputs are consistent."
		break
	fi

	remaining_attempts=$((max_wait_attempts - attempt))
	if ((attempt >= max_wait_attempts)); then
		echo "Outputs remain inconsistent after $max_wait_attempts attempts. Exiting with error."
		exit 1
	else
		echo "Outputs are inconsistent. Waiting for $wait_interval seconds (attempt $attempt/$max_wait_attempts)."