.withJvmTestClasses("example.MyTest")
                .debugTestsOn(jdwpClient.port)
                .run()
        }

        then:
        true // test successfully executed with debugger attached
    }

    def "forks only one JVM to debug"() {
        setup:
        buildFile << """
             tasks.withType(Test) {
                  forkEvery = 1
                  maxParallelForks = 2

import java.io.File;

/**
 * Controls the state (not loaded / loaded) of the attached {@link GradleProperties} instance
 * so that the set of Gradle properties is deterministically loaded only once per build.
 */
@ServiceScope(Scope.Build.class)
public interface GradlePropertiesController {

    /**
     * The {@link GradleProperties} instance attached to this service.
     */
    GradleProperties getGradleProperties();

    /**

	// ObjectTTLAnnotationKey represents a suggestion for kubelet for how long it can cache
	// an object (e.g. secret, config map) before fetching it again from apiserver.
	// This annotation can be attached to node.
	ObjectTTLAnnotationKey string = "node.alpha.kubernetes.io/ttl"

	// annotation key prefix used to identify non-convertible json paths.
	NonConvertibleAnnotationPrefix = "non-convertible.kubernetes.io"

	// ObjectTTLAnnotationKey represents a suggestion for kubelet for how long it can cache
	// an object (e.g. secret, config map) before fetching it again from apiserver.
	// This annotation can be attached to node.
	ObjectTTLAnnotationKey string = "node.alpha.kubernetes.io/ttl"

	// NonConvertibleAnnotationPrefix annotation key prefix used to identify non-convertible json paths.

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.api.problems.internal;

/**
 * Marker interface for additional data that can be attached to a {@link Problem}.
 */
public interface AdditionalDataSpec {

import java.lang.annotation.ElementType;
import java.lang.annotation.Inherited;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * Attached to a service implementation to indicate that the instance should be registered as a listener.
 *
 * <p>Generally, it is better to use {@link StatefulListener}, which is lazy and applies some validation to ensure no events are missed.

		}

		// Gateway attached
		if config.CanonicalGroup(targetRef.GetGroup()) == gvk.KubernetesGateway.CanonicalGroup() &&
			targetRef.GetKind() == gvk.KubernetesGateway.Kind &&
			target.Name == gatewayName &&
			(targetRef.GetNamespace() == "" || targetRef.GetNamespace() == p.Namespace) {
			return true
		}

		// Service attached
		if p.IsWaypoint &&

!!! tip "Tipp"

 */

package org.gradle.api.internal.tasks.testing.redirector;

public interface StandardOutputRedirector {

    /**
     * Starts redirection of System.out and System.err to the listener attached to
     * {@link #redirectStandardErrorTo(OutputListener)} and
     * {@link #redirectStandardOutputTo(OutputListener)
     */
    void start();

    /**

 * A provider whose value is computed by a {@link Callable}.
 *
 * The given {@link Callable} is stored to the configuration cache, so it must only hold references
 * to configuration cache safe state.
 *
 * Task dependencies attached to the computed value are ignored by this provider.
 *
 * <h3>Configuration Cache Behavior</h3>
 * <b>Lazy</b>. The given {@link Callable} is stored to the cache so the value can be recomputed on each run.
 */