result.task(':library:sourceSets').outcome == TaskOutcome.SUCCESS

        where:
        [agpVersion, ide] << [
            TestedVersions.androidGradle.toList(),
            [false, true]
        ].combinations()
    }

    def "android library and application APK assembly (agp=#agpVersion, ide=#ide)"() {

        given:
        AGP_VERSIONS.assumeCurrentJavaVersionIsSupportedBy(agpVersion)

        and:

    static final List<List<BuildInitDsl>> scriptDslCombinationsFor(int count) {
        return ([SCRIPT_DSLS] * count).combinations()
    }

    static ScriptDslFixture of(BuildInitDsl scriptDsl, TestFile rootDir, String subprojectName) {
        new ScriptDslFixture(scriptDsl, rootDir, subprojectName)
    }

    final BuildInitDsl scriptDsl

        where:
        // make sure that multi-byte unicode characters get split in different chunks
        [chunkSize, preUseBuffer] << [(1..(TEST_STRING_BYTES.length * 3)).toList() + [100, 1000], [false, true]].combinations()
    }

    def "empty buffer to String returns empty String"() {
        given:
        def byteBuffer = new StreamByteBuffer()

        expect:
        byteBuffer.readAsString() == ''
    }

            [apiUsingUsage(), apiUsingUsage("fromResolutionOf('compileClasspath')")],
            [runtimeUsingUsage(), runtimeUsingUsage("fromResolutionOf('runtimeClasspath')")]
        ].combinations() + [[allVariants(), noop()]])
    }

    def "dependency constraints which are unresolved are published as is"() {
        javaLibrary(mavenRepo.module("org.test", "foo", "1.0")).withModuleMetadata().publish()

		},
	}
}

// Analyze implements Analyzer
func (d *DestinationRuleAnalyzer) Analyze(ctx analysis.Context) {
	// To avoid repeated iteration, precompute the set of existing destination host+subset combinations
	destHostsAndSubsets := initDestHostsAndSubsets(ctx)

	ctx.ForEach(gvk.VirtualService, func(r *resource.Instance) bool {
		d.analyzeVirtualService(r, ctx, destHostsAndSubsets)
		return true
	})
}

                [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")