if err != nil {
			klog.V(2).Infof("Could not list Nodes with field selector %q: %v", fieldSelector, err)
			lastError = err
			return false, nil
		}
		return true, nil
	})
	if err != nil {
		return errors.Wrap(lastError, "could not check if there is at least one Node that can schedule a test Pod")
	}

	if len(nodes.Items) == 0 {

	ErrSTSIAMNotInitialized
	ErrSTSUpstreamError
	ErrSTSInternalError
)

type stsErrorCodeMap map[STSErrorCode]STSError

func (e stsErrorCodeMap) ToSTSErr(errCode STSErrorCode) STSError {
	apiErr, ok := e[errCode]
	if !ok {
		return e[ErrSTSInternalError]
	}
	return apiErr
}

// error code to STSError structure, these fields carry respective
// descriptions for all the error responses.
var stsErrCodes = stsErrorCodeMap{

			if err != nil {
				lastError = formatError(fmt.Sprintf("error: %v", err))
				return false, err
			}
			resp, err := client.Do(req)
			if err != nil {
				lastError = formatError(fmt.Sprintf("error: %v", err))
				return false, nil
			}
			defer func() {
				_ = resp.Body.Close()
			}()
			if resp.StatusCode != http.StatusOK {

	maxDurationBeforeRetry = 2*time.Minute + 2*time.Second
)

// ExponentialBackoff contains the last occurrence of an error and the duration
// that retries are not permitted.
type ExponentialBackoff struct {
	lastError           error
	lastErrorTime       time.Time
	durationBeforeRetry time.Duration
}

// SafeToRetry returns an error if the durationBeforeRetry period for the given

        String gradleStderr = result.getError();
        if (!outputs.isEmpty()) {
            gradleStdout = fileContents(outputs.get(0).stdout);
            gradleStderr = fileContents(outputs.get(0).stderr);
        }
        System.out.println(result.getOut());
        System.out.println(gradleStdout);
        System.out.println(gradleStderr);
        System.out.println(result.getError());

    assertThat(successCalls[0]).isEqualTo(1);
    assertThat(failureCalls[0]).isEqualTo(0);
  }

  public void testOnSuccessThrowsError() throws Exception {
    class TestError extends Error {}
    TestError error = new TestError();
    String result = "result";
    SettableFuture<String> future = SettableFuture.create();
    int[] successCalls = new int[1];
    int[] failureCalls = new int[1];

package main

/*
char *geterror() {
	return "cgo error";
}
*/
import "C"
import (
	"fmt"
)

func init() {
	register("CgoPanicDeadlock", CgoPanicDeadlock)
}

type cgoError struct{}

func (cgoError) Error() string {
	fmt.Print("") // necessary to trigger the deadlock
	return C.GoString(C.geterror())
}

func CgoPanicDeadlock() {
	panic(cgoError{})

    }

    public static void setError(final int statusCode, final String message) {
        LaRequestUtil.getOptionalRequest().ifPresent(req -> req.setAttribute(WEB_API_EXCEPTION, new WebApiException(statusCode, message)));
    }

    public static void setError(final int statusCode, final Exception e) {

// Copyright 2009 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

#include <string.h> /* for strerror */
#include <pthread.h>
#include <signal.h>
#include "libcgo.h"
#include "libcgo_unix.h"

static void* threadentry(void*);
static void (*setg_gcc)(void*);

void
x_cgo_init(G *g, void (*setg)(void*), void **tlsg, void **tlsbase)
{

			policyOpt, _ := NewStaticPolicyOptions(testCase.policyOption)
			err := ValidateStaticPolicyOptions(policyOpt, testCase.topology, topoMgrStore)
			gotError := (err != nil)
			if gotError != testCase.expectedErr {
				t.Errorf("testCase %q failed, got %v expected %v", testCase.description, gotError, testCase.expectedErr)
			}
		})
	}