Label(label.CustomSetup).
		RequireMinVersion(19).
		Setup(func(ctx resource.Context) error {
			var clients []kube.Client
			for _, c := range ctx.AllClusters() {
				clients = append(clients, c)
			}
			var err error
			certs, err = csrctrl.RunCSRController("clusterissuers.istio.io/signer1,clusterissuers.istio.io/signer2", stopChan, clients)
			return err
		}).
		Setup(istio.Setup(nil, func(ctx resource.Context, cfg *istio.Config) {

### 2. Run MinIO Server with Erasure Code

Example: Start MinIO server in a 12 drives setup, using MinIO binary.

```sh
minio server /data{1...12}
```

Example: Start MinIO server in a 8 drives setup, using MinIO Docker image.

```sh
podman run \
  -p 9000:9000 \
  -p 9001:9001 \
  --name minio \
  -v /mnt/data1:/data1 \
  -v /mnt/data2:/data2 \

@TargetGradleVersion(">=5.6")
@Timeout(60)
class TestLauncherDebugTestsCrossVersionTest extends ToolingApiSpecification implements WithOldConfigurationsSupport {
    @Rule
    JDWPUtil jdwpClient = new JDWPUtil()

    def setup() {
        buildFile << """
            plugins { id 'java-library' }
            ${mavenCentralRepository()}
            dependencies { ${testImplementationConfiguration} 'junit:junit:4.13' }
        """

To use it:

1. Install Istio by following the [istio install instructions](https://istio.io/docs/setup/).

1. Start the httpbin service inside the Istio service mesh:

    If you have [automatic sidecar injection](https://istio.io/docs/setup/additional-setup/sidecar-injection/#automatic-sidecar-injection) enabled:

    ```bash
    kubectl apply -f httpbin.yaml
    ```

	t.Helper()
	i, err := Ingresses(ctx)
	if err != nil {
		t.Fatal(err)
	}
	return i
}

// Setup is a setup function that will deploy Istio on Kubernetes environment
func Setup(i *Instance, cfn SetupConfigFn, ctxFns ...SetupContextFn) resource.SetupFn {
	return func(ctx resource.Context) error {
		cfg, err := DefaultConfig(ctx)
		if err != nil {

== What you'll need

* A command prompt
* The Java Development Kit (JDK), version 1.8 or higher
* A TeamCity installation (setup steps explained in this guide)


== Setup a typical project

For demonstration purposes, this guide is going to focus on building a Java-based project; however, this setup will work with any Gradle-compatible project.

        then:
        result == null

        and:
        1 * delegate.withContent(location, false, _) >> null

        and:
        0 * action._
    }

    def "reads empty content"() {
        setup:
        expectReadBuildOperation(0)
        expectResourceRead(new ByteArrayInputStream())

        when:
        def result = accessor.withContent(location, false, action)

        then:

@TargetGradleVersion(">=5.6")
class ClosedProjectSubstitutionCrossVersionSpec extends ToolingApiSpecification {

    def "will substitute and run build dependencies for closed projects on startup"() {
        setup:
        multiProjectBuildInRootFolder("parent", ["child1", "child2"]) {
            buildFile << """
            subprojects {
                apply plugin: 'java-library'
            }
            project(":child1") {

jobs:
  generate-and-submit:
    permissions:
      contents: write
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v4
    - uses: actions/setup-java@v4
      with:
        distribution: temurin
        java-version: 11
    - name: Setup Gradle
      uses: gradle/actions/dependency-submission@v3
      with:
        # Action runs a custom dependencies task that fails with config-cache on Gradle 8.7 (works with 8.6)

    final String artifactVersion = "1.85"
    MavenS3Module module

    @Override
    def setup() {
        proxyServer.start()
        module = getMavenS3Repo().module("org.gradle", "test", artifactVersion)
    }

    def "should proxy requests using HTTP system proxy settings"() {
        setup:
        module.publish()

        buildFile << mavenAwsRepoDsl()
        buildFile << """