given:
        cannotSeePackage('org.junit')
        cannotSeePackage('org.junit.runner')

        and:
        withSpec { FilteringClassLoader.Spec spec ->
            spec.allowPackage('org.junit')
        }

        expect:
        canSeePackage('org.junit')
        canSeePackage('org.junit.runner')
    }

    void passesThroughDefaultPackage() {
        given:

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

package gradlebuild.testcleanup

import org.gradle.internal.impldep.org.apache.commons.lang.StringUtils
import org.gradle.testkit.runner.GradleRunner
import org.gradle.testkit.runner.TaskOutcome
import org.junit.jupiter.api.Assertions.assertEquals
import org.junit.jupiter.api.Assertions.assertTrue

        Map<String, String> envVars = [:],
        Closure<Void> runner = this::configurationCacheRun
    ) {
        def allArgs = tasks + getEncryptionOptions(kind) + additionalArgs + ["-s"]
        // envVars overrides encryption env vars
        def allVars = getEncryptionEnvVars(kind) + envVars
        executer.withEnvironmentVars(allVars)
        runner(*allArgs)
    }

	if err != nil {
		t.Fatal(err)
	}
	t.Logf("copied GOROOT from %s to %s", testenv.GOROOT(t), gorootCopyDir)
	return gorootCopyDir
}

type runner struct {
	Dir string
	Env []string
}

// run runs the command and requires that it succeeds.
func (r runner) run(t *testing.T, args ...string) {
	t.Helper()
	cmd := testenv.Command(t, args[0], args[1:]...)
	cmd.Dir = r.Dir
	cmd.Env = slices.Clip(r.Env)

/*
 * Copyright 2013 the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,

		// apiserver if we can't repair them.
		wg := sync.WaitGroup{}
		wg.Add(2)
		runner := async.NewRunner(
			func(stopCh chan struct{}) { p.startServiceClusterIPRepair(wg.Done, stopCh) },
			func(stopCh chan struct{}) { p.startServiceNodePortsRepair(wg.Done, stopCh) },
		)
		runner.Start()
		go func() {
			defer runner.Stop()
			<-context.StopCh
		}()

		panic("call to scope without running the test framework")
	}

	ctx, span := tracing.Start(rt.suiteContext().traceContext, t.Name())

	runner := &testImpl{
		tc:     ctx,
		ts:     span,
		s:      rt.suiteContext(),
		goTest: t,
	}

	return runner
}

func (t *testImpl) Label(labels ...label.Instance) Test {
	t.labels = append(t.labels, labels...)
	return t
}

class JUnitPlatformIntegrationTest extends JUnitPlatformIntegrationSpec {

    def 'can work with junit-platform-runner'() {
        given:
        buildFile << """
        dependencies {
            testImplementation 'org.junit.platform:junit-platform-runner:1.0.3'
        }
        """
        createSimpleJupiterTest()

        expect:
        succeeds('test')
    }

func NewManager(
	statusManager status.Manager,
	livenessManager results.Manager,
	readinessManager results.Manager,
	startupManager results.Manager,
	runner kubecontainer.CommandRunner,
	recorder record.EventRecorder) Manager {

	prober := newProber(runner, recorder)
	return &manager{
		statusManager:    statusManager,
		prober:           prober,
		readinessManager: readinessManager,

     *
     * @implNote To support the Gradle embedded test runner, this method's return value should not be cached in a static field.
     */
    private String[] determineHttpsProtocols() {
        /*
         * System property retrieval is executed within the constructor to support the Gradle embedded test runner.
         */
        String httpsProtocols = System.getProperty(HTTPS_PROTOCOLS);