if err != nil {
		// Failed to create newbucket, abort.
		t.Fatalf("%s : %s", instanceType, err.Error())
	}
	// Initiate Multipart Upload on the above created bucket.
	res, err := obj.NewMultipartUpload(context.Background(), bucket, object, opts)
	if err != nil {
		// Failed to create NewMultipartUpload, abort.
		t.Fatalf("%s : %s", instanceType, err.Error())
	}

	retry.WithMax(5),
	retry.WithBackoff(wrapBackoffWithMetrics(retry.BackoffExponentialWithJitter(100*time.Millisecond, 0.1))),
	retry.WithCodes(codes.Canceled, codes.DeadlineExceeded, codes.ResourceExhausted, codes.Aborted, codes.Internal, codes.Unavailable),
}

// CARetryInterceptor is a grpc UnaryInterceptor that adds retry options, as a convenience wrapper

"sniHosts"
"redirectCode"
"retryRemoteLocalities"
"retryOn"
"perTryTimeout"
"attempts"
"allowOrigins"
"allowMethods"
"allowHeaders"
"exposeHeaders"
"maxAge"
"allowCredentials"
"abort"
"set"
"add"
"remove"
"fixedDelay"
"percentage"
"percent"
"httpStatus"
"address"
"network"

			waitErrsToReturn: map[string]error{
				waitForHashes:        nil,
				waitForHashChange:    nil,
				waitForPodsWithLabel: errors.New("boo! failed"),
			},
			moveFileFunc:         os.Rename,
			expectedErr:          true,
			manifestShouldChange: false,
		},
		{
			description: "any path-moving error should result in a rollback and an abort 1",

			},
		},
		{
			name: "grpc abort",
			fault: &networking.HTTPFaultInjection{
				Abort: &networking.HTTPFaultInjection_Abort{
					ErrorType: &networking.HTTPFaultInjection_Abort_GrpcStatus{
						GrpcStatus: "DEADLINE_EXCEEDED",
					},
					Percentage: &networking.Percent{
						Value: float64(50),
					},
				},
			},
			want: &xdshttpfault.HTTPFault{
				Abort: &xdshttpfault.FaultAbort{

 * specific language governing permissions and limitations
 * under the License.
 */
package org.apache.maven;

/**
 * A special throwable used to signal a graceful abort of the build.
 */
public class BuildAbort extends Error {

    public BuildAbort(String message) {
        super(message);
    }

    public BuildAbort(String message, Throwable cause) {

     */
    <T> ExecutionResult<Void> process(WorkSource<T> workSource, Action<T> worker);

    /**
     * Verifies that this executor and the work it is running is healthy (not starved or deadlocked). Aborts any current work when not healthy, so that {@link #process(WorkSource, Action)}
     * returns with a failure result.
     *

#include "libcgo.h"

void
fatalf(const char* format, ...)
{
	va_list ap;

	fprintf(stderr, "runtime/cgo: ");
	va_start(ap, format);
	vfprintf(stderr, format, ap);
	va_end(ap);
	fprintf(stderr, "\n");
	abort();

void
x_cgo_sys_thread_create(void* (*func)(void*), void* arg) {
	pthread_t p;
	int err = _cgo_try_pthread_create(&p, NULL, func, arg);
	if (err != 0) {
		fprintf(stderr, "pthread_create failed: %s", strerror(err));
		abort();
	}
}

uintptr_t
_cgo_wait_runtime_init_done(void) {
	void (*pfn)(struct context_arg*);
	pfn = __atomic_load_n(&cgo_context_function, __ATOMIC_CONSUME);

	int done = 2;

//go:cgo_import_dynamic libc_arc4random_buf arc4random_buf "/usr/lib/libSystem.B.dylib"

func libc_arc4random_buf_trampoline()

// ARC4Random calls the macOS arc4random_buf(3) function.
func ARC4Random(p []byte) {
	// macOS 11 and 12 abort if length is 0.
	if len(p) == 0 {
		return
	}
	syscall_syscall(abi.FuncPCABI0(libc_arc4random_buf_trampoline),
		uintptr(unsafe.Pointer(unsafe.SliceData(p))), uintptr(len(p)), 0)