Jesse Wilson <******@****.***> 1704676402 -0500

        then:
        1 * executor.run(_, _) >> { ConsumerAction action, ResultHandlerVersion1 handler ->
            action.run(connection)
            handler.onComplete(null)
        }
        1 * connection.runTests(_, _) >> { TestExecutionRequest request, ConsumerOperationParameters params ->
            assert request.testClassNames == ["test"]
            assert request.testExecutionDescriptors == []

    }

    @Override
    public void runTests(final TestExecutionRequest testExecutionRequest, ConsumerOperationParameters operationParameters) {
        final BuildCancellationTokenAdapter cancellationTokenAdapter = new BuildCancellationTokenAdapter(operationParameters.getCancellationToken());
        ((InternalTestExecutionConnection) getDelegate()).runTests(testExecutionRequest, cancellationTokenAdapter, operationParameters);
    }

        TestExecutionRequest testExecutionRequest = Mock(TestExecutionRequest)
        ConsumerOperationParameters operationParameters = Mock()
        when:
        connection.runTests(testExecutionRequest, operationParameters)

        then:
        1 * delegate.runTests(testExecutionRequest, _, operationParameters)
    }

    private TestConnection newDelegateConnection() {
        TestConnection delegate = Mock(TestConnection)

cleanup() {
  if [[ -z "${CLEANUP_REQUIRED}" ]]; then
    return
  fi
  kube::log::status "Cleaning up etcd"
  kube::etcd::cleanup
  CLEANUP_REQUIRED=
  kube::log::status "Integration test cleanup complete"
}

runTests() {
  kube::log::status "Starting etcd instance"
  CLEANUP_REQUIRED=1
  kube::etcd::start
  # shellcheck disable=SC2034
  local ETCD_SCRAPE_PID # Set in kube::etcd::start_scraping, used in cleanup

        delegate.run(phasedBuildAction, operationParameters);
    }

    @Override
    public void runTests(TestExecutionRequest testExecutionRequest, ConsumerOperationParameters operationParameters) {
        validateParameters(operationParameters);
        delegate.runTests(testExecutionRequest, operationParameters);
    }

    @Override

		failed = true
	}
	totalTests++
	return fmt.Sprintf("%s %s%s", testName, "FAILED", pos)
}

// runTests assures that the package and its dependencies is
// built with instrumentation enabled and returns the output of 'go test'
// which includes possible data race reports from ThreadSanitizer.
func runTests(t *testing.T) ([]byte, error) {
	tests, err := filepath.Glob("./testdata/*_test.go")
	if err != nil {
		return nil, err

setup
run_kube_apiserver
run_kube_controller_manager
create_node
export SUPPORTED_RESOURCES=("*")
# WARNING: Do not wrap this call in a subshell to capture output, e.g. output=$(runTests)
# Doing so will suppress errexit behavior inside runTests
runTests

        if (getRunTestCount() == 0) {
            return null;
        }

        BigDecimal runTests = BigDecimal.valueOf(getRunTestCount());
        BigDecimal successful = BigDecimal.valueOf(getRunTestCount() - getFailureCount());

        return successful.divide(runTests, 2, RoundingMode.DOWN).multiply(BigDecimal.valueOf(100)).intValue();
    }

    protected void failed(TestResult failedTest) {

 *
 * @since 2.6-rc-1
 */
public interface InternalTestExecutionConnection extends InternalProtocolInterface {
    BuildResult<?> runTests(InternalTestExecutionRequest testExecutionRequest, InternalCancellationToken cancellationToken, BuildParameters operationParameters);