[new RootBuildLocation(), new IncludedBuildLocation()],
                [new RootBuildLocation(), new BuildSrcLocation(), new IncludedBuildLocation()],
            ]
        ].combinations().collect { language, locations ->
            new Spec(locations, language)
        }
    }

    static class Spec {

        final String copyTask = "copyTask"

import org.gradle.integtests.tooling.fixture.ToolingApiSpecification
import spock.lang.Issue

/**
 * Tests for the tooling API, which check fetching models and running actions using different
 * combinations of versions of the TAPI and Gradle.
 *
 * Support for clients using a tooling API version older than 3.0 was removed in Gradle 5.0, so
 * there is a class-level lower bound for both versions.
 *

    assertThat(frameLog(true, 3, 10000, TYPE_DATA, 0x20))
      .isEqualTo("<< 0x00000003 10000 DATA          COMPRESSED")
  }

  /**
   * Ensures that valid flag combinations appear visually correct, and invalid show in hex.  This
   * also demonstrates how sparse the lookup table is.
   */
  @Test
  fun allFormattedFlagsWithValidBits() {

import org.gradle.integtests.fixtures.KotlinDslTestUtil
import org.gradle.test.fixtures.file.TestFile

class BuildLogicChangeFixture {

    static List<Spec> specs() {
        [Kind.values(), Language.values()].combinations().collect { Kind kind, Language language ->
            new Spec(language, kind)
        }
    }

    @Immutable
    static class Spec {
        Language language
        Kind kind

        @Override

import org.gradle.test.fixtures.server.http.MavenHttpPluginRepository
import org.gradle.test.precondition.Requires
import org.gradle.test.preconditions.UnitTestPreconditions

// Restrict the number of combinations because that's not really what we want to test
@RequiredFeature(feature = GradleMetadataResolveRunner.REPOSITORY_TYPE, value = "maven")
@RequiredFeature(feature = GradleMetadataResolveRunner.GRADLE_METADATA, value = "true")

	"crypto/ed25519"
	"encoding/hex"
	"encoding/json"
	"internal/testenv"
	"os"
	"os/exec"
	"path/filepath"
	"testing"
)

// TestEd25519Vectors runs a very large set of test vectors that exercise all
// combinations of low-order points, low-order components, and non-canonical
// encodings. These vectors lock in unspecified and spec-divergent behaviors in
// edge cases that are not security relevant in most contexts, but that can

        assertForbidden(name, exception.getMessage())

        where:
        [name, objectType, domainObjectContainer] << [invalidNames, domainObjectContainersWithValidation].combinations().collect { [it[0], it[1][0], it[1][1]] }
    }

    def "names are not allowed to be empty"() {
        given:
        def name = ''

        when:
        NameValidator.validate('', 'name', '')

          parentBuilder) {
    List<TestSuite> derivedSuites = new ArrayList<>(super.createDerivedSuites(parentBuilder));

    if (!parentBuilder.getFeatures().contains(SUBSET_VIEW)) {
      // Other combinations are inherited from SortedSetTestSuiteBuilder.
      derivedSuites.add(createSubsetSuite(parentBuilder, Bound.NO_BOUND, Bound.INCLUSIVE));
      derivedSuites.add(createSubsetSuite(parentBuilder, Bound.EXCLUSIVE, Bound.NO_BOUND));

                 mapBegin: 'flatMap { it.fieldValueOutputFile }.map { it.asFile.readText(Charsets.UTF_8) }.map {', mapEnd: '}',
                 get: 'it']
            ]
        ].combinations()
        providerType = provider['type']
        kotlinVersionNumber = VersionNumber.parse('1.8.0')
        taskName = 'compileDebugKotlin'
    }

    private getRepositoriesBlock() {
        """

          }
        };
    try {
      iter.hasNext();
      fail();
    } catch (IllegalStateException expected) {
    }
  }

  // Technically we should test other reentrant scenarios (4 combinations of
  // hasNext/next), but we'll cop out for now, knowing that
  // next() both start by invoking hasNext() anyway.

  /** Throws an undeclared checked exception. */
  private static void sneakyThrow(Throwable t) {