//these meta tests mess with the daemon log: do not interfere with other tests when running in parallel
        requireIsolatedTestKitDir = true
    }

    def iteration = 0

    def "retries on clock shift issue for <2.10"() {
        given:
        iteration++
        def isVersionWithIssue = gradleVersion < GradleVersion.version('2.10')

        when:
        throwWhen(new GradleConnectionException("Test Exception",

#include "tensorflow/compiler/jit/xla_device.h"
#include "tensorflow/compiler/jit/xla_launch_util.h"
#include "tensorflow/compiler/jit/xla_platform_info.h"
#include "xla/stream_executor/integrations/tf_allocator_adapter.h"
#include "tensorflow/core/framework/allocator.h"
#include "tensorflow/core/framework/op.h"
#include "tensorflow/core/framework/op_kernel.h"
#include "tensorflow/core/framework/tensor.h"

//
// This analyzer reports places where a function literal references the
// iteration variable of an enclosing loop, and the loop calls the function
// in such a way (e.g. with go or defer) that it may outlive the loop
// iteration and possibly observe the wrong value of the variable.
//
// Note: An iteration variable can only outlive a loop iteration in Go versions <=1.21.

        for i = range s {}
        for i, j /* ERRORx `range over .* permits only one iteration variable` */ = range s {}
        for i, j, k /* ERRORx `range over .* permits only one iteration variable|at most 2 expressions` */ = range s {}
        for i, j, k, l /* ERRORx `range over .* permits only one iteration variable|at most 2 expressions` */ = range s {}

     *
     * @return The elements of this set in the set's iteration order.
     */
    List<T> getAll();

    /**
     * Returns the element at the given index according to the set's iteration order.
     *
     * @param index The index of the element to get.
     * @return The element at the given index according to the set's iteration order.
     */

		m[math.NaN()] = i
	}
	// Trigger growth.
	m[math.NaN()] = N

	// Iterate through map.
	i := 0
	for range m {
		if i == 6 {
			// Partway through iteration, clear the map.
			clear(m)
		} else if i > 6 {
			// If we advance to the next iteration, that's a bug.
			panic("BAD")
		}
		i++
	}
	if len(m) != 0 {
		panic("clear did not empty the map")
	}
}

func g() {
	// Allocate map.

        then:
        daemon.assertIdle()

        expect:
        long endOfDaemonLog = daemon.logLineCount
        numberOfRuns.times { iteration ->
            // when:
            println("Running iteration ${iteration + 1}")
            changeSourceFiles(iteration, numberOfChangesBetweenBuilds)
            waitForChangesToBePickedUp()
            succeeds("assemble")

            // then:

class ContinuousBuildCrossVersionToolingApiSpecificationRetryTest extends ContinuousBuildToolingApiSpecification {

    def iteration = 0

    def "retries if continuous build test times out"() {
        given:
        iteration++

        when:
        throwWhen(new RuntimeException("Timeout waiting for build to complete."), iteration == 1)

        then:
        true
    }

// or to create an empty directory.
//
// File system operations read directly from the map,
// so that the file system can be changed by editing the map as needed.
// An implication is that file system operations must not run concurrently
// with changes to the map, which would be a race.
// Another implication is that opening or reading a directory requires
// iterating over the entire map, so a MapFS should typically be used with not more

        operations.size() == 10
        def rootTestOp = this.operations.first(ExecuteTestBuildOperationType)
        assertJunit(rootTestOp, this.operations)

        when:
        run "test", "--rerun-tasks"

        rootTestOp = this.operations.first(ExecuteTestBuildOperationType)
        operations = this.operations.all(ExecuteTestBuildOperationType)

        then: