// In this test, we expect IOException when endpoint is blank
        try {
            conn.connect();
            fail("Should throw IOException when endpoint is not set");
        } catch (IOException e) {
            assertTrue(e.getMessage().contains("endpoint is blank"));
        }
    }

    /**
     * Test thread-safety of connect() method.

conscrypt-android = { module = "org.conscrypt:conscrypt-android", version.ref = "org-conscrypt" }
conscrypt-openjdk = { module = "org.conscrypt:conscrypt-openjdk-uber", version.ref = "org-conscrypt" }
converter-moshi = { module = "com.squareup.retrofit2:converter-moshi", version.ref = "retrofit" }
eclipseOsgi = "org.eclipse.platform:org.eclipse.osgi:3.23.200"

plugins {
  id("com.android.library")
  kotlin("android")
}

android {
  compileSdk = 35

  namespace = "okhttp.android.regression"

  defaultConfig {
    minSdk = 21
    targetSdk = 34

    // Make sure to use the AndroidJUnitRunner (or a sub-class) in order to hook in the JUnit 5 Test Builder
    testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
    testInstrumentationRunnerArguments += mapOf(

        super(buffer, access);
        this.endpoint = endpoint;

        // In real implementation, this would register the memory:
        // try {
        //     int accessFlags = convertAccessFlags(access);
        //     memoryRegister = endpoint.registerMemory(buffer, accessFlags).execute().free();
        // } catch (Exception e) {
        //     throw new RuntimeException("Failed to register memory region", e);

)

const (
	webhookQueueLength    = "queue_length"
	webhookTotalMessages  = "total_messages"
	webhookFailedMessages = "failed_messages"
	nameL                 = "name"
	endpointL             = "endpoint"
)

var (
	allWebhookLabels        = []string{nameL, endpointL}
	webhookFailedMessagesMD = NewCounterMD(webhookFailedMessages,
		"Number of messages that failed to send",
		allWebhookLabels...)

	return "minio-http-" + h.config.Name
}

// Type - returns type of the target
func (h *Target) Type() types.TargetType {
	return types.TargetHTTP
}

// Endpoint returns the backend endpoint
func (h *Target) Endpoint() string {
	return h.config.Endpoint.String()
}

func (h *Target) String() string {
	return h.config.Name
}

// IsOnline returns true if the target is reachable using a cached value

	Bucket   string                        `yaml:"bucket" json:"bucket"`
	Prefix   string                        `yaml:"prefix" json:"prefix"`
	Endpoint string                        `yaml:"endpoint" json:"endpoint"`
	Path     string                        `yaml:"path" json:"path"`
	Creds    BatchJobReplicateCredentials  `yaml:"credentials" json:"credentials"`
}

import org.gradle.api.Plugin
import org.gradle.api.Project
import org.gradle.kotlin.dsl.register

/**
 * Plugin that pre-downloads Android SDK components to prevent race conditions during parallel builds.
 *
 * When multiple Android builds run in parallel and share the same `ANDROID_HOME`, the Android Gradle Plugin
 * may attempt to download and install SDK components (platforms, build-tools, platform-tools) simultaneously.

	disks := er.getDisks()
	endpoints := er.getEndpoints()

	var localDisks []StorageAPI
	var localEndpoints []Endpoint

	for i, endpoint := range endpoints {
		if endpoint.IsLocal {
			localDisks = append(localDisks, disks[i])
			localEndpoints = append(localEndpoints, endpoint)
		}
	}

	return getStorageInfo(localDisks, localEndpoints, metrics)
}

	// mutate only if not a dry-run
	if opts.DryRun {
		return res, nil
	}

	for i := range beforeState {
		res.Before.Drives = append(res.Before.Drives, madmin.HealDriveInfo{
			UUID:     "",
			Endpoint: localDrives[i].Endpoint().String(),
			State:    beforeState[i],
		})
	}

	// check dangling and delete bucket only if its not a meta bucket
	if !isMinioMetaBucketName(bucket) && !isAllBucketsNotFound(errs) && opts.Remove {