def setup() {
        runner.minimumBaseVersion = "4.0"
    }

    def "build with #parallelWorkers parallel workers"() {
        given:
        runner.tasksToRun = ['build']
        runner.warmUpRuns = 5
        runner.runs = 10

        runner.args += ["-Dorg.gradle.parallel=${parallelWorkers ? true : false}"]
        if (parallelWorkers) {
            runner.args += ["--max-workers=$parallelWorkers".toString()]

        given:
        runner.tasksToRun = ["assemble"]
        // use the deprecated property so it works with previous versions
        runner.args = ["-D${ConfigurationCacheOption.DEPRECATED_PROPERTY_NAME}=true"]

        and:
        runner.useDaemon = daemon == hot
        runner.addBuildMutator { configurationCacheInvocationListenerFor(it, action, stateDirectory) }
        runner.warmUpRuns = daemon == hot ? 20 : 1

        }

        when:
        def result = runner.run()

        then:
        result.assertCurrentVersionHasNotRegressedWithHighRelativeMedianDifference()
    }

    private setupRunner() {
        def iterations = determineIterations()
        runner.warmUpRuns = iterations
        runner.runs = iterations
    }

    private determineIterations() {

}

func Test_BoundedFrequencyRunnerNoBurst(t *testing.T) {
	obj := &receiver{}
	timer := newFakeTimer()
	runner := construct("test-runner", obj.F, minInterval, maxInterval, 1, timer)
	stop := make(chan struct{})

	var upd timerUpdate

	// Start.
	go runner.Loop(stop)
	upd = <-timer.updated // wait for initial time to be set to max
	checkTimer("init", t, upd, true, maxInterval)

                .pluginTypes("org.codelibs.opensearch.extension.ExtensionPlugin"));
        runner.ensureYellow();
    }

    @AfterClass
    public static void afterClass() throws Exception {
        runner.close();
        runner.clean();
    }

    @Before
    public void before() throws Exception {
        try {
            runner.admin().indices().prepareDelete("_all").execute().actionGet();

    def setup() {
        runner.minimumBaseVersion = '4.6'
    }

    def "up-to-date assemble (swift)"() {
        given:
        runner.tasksToRun = ["assemble"]

        when:
        def result = runner.run()

        then:
        result.assertCurrentVersionHasNotRegressed()
    }

    def "incremental compile"() {
        given:
        runner.tasksToRun = ["assemble"]

                .pluginTypes("org.codelibs.opensearch.extension.ExtensionPlugin"));
        runner.ensureYellow();
    }

    @AfterClass
    public static void afterClass() throws Exception {
        runner.close();
        runner.clean();
    }

    @Before
    public void before() throws Exception {
        try {
            runner.admin().indices().prepareDelete("_all").execute().actionGet();

package org.example

import org.gradle.testkit.runner.GradleRunner
import spock.lang.Specification
import spock.lang.TempDir

import static org.gradle.testkit.runner.TaskOutcome.*

class BuildLogicFunctionalTest extends Specification {

    @TempDir File testProjectDir
    File buildFile

    def setup() {
        new File(testProjectDir, 'settings.gradle') << ""
        buildFile = new File(testProjectDir, 'build.gradle')
    }

        // Set the current build operation to a known value for initializing the runner
        currentBuildOperationRef.set(EXPECTED_INNER_BUILD_OPERATION)
        def runner = runner()
        // Then act as if we've been moved to a code section with a new build operation active
        currentBuildOperationRef.set(EXPECTED_OUTER_BUILD_OPERATION)

        when:
        runner.run()

        then:
        1 * delegate.run() >> {

		},
		runner:   runner,
		spec:     spec,
		readOnly: readOnly,
	}, nil
}

// NewUnmounter is part of the volume.VolumePlugin interface.
func (plugin *flexVolumePlugin) NewUnmounter(volName string, podUID types.UID) (volume.Unmounter, error) {
	return plugin.newUnmounterInternal(volName, podUID, plugin.host.GetMounter(plugin.GetPluginName()), plugin.runner)
}