import org.gradle.tooling.model.GradleProject
import org.gradle.tooling.model.idea.IdeaProject

@TargetGradleVersion(">=6.1")
class GradleProjectBuilderOptionsCrossVersionSpec extends ToolingApiSpecification {

    def "realizes #description when fetching GradleProject with option value #optionDescription"() {
        buildFile << """
            tasks.create("a") {
                println "realizing non-lazy task"
            }

        target << "apply plugin: '${getPluginName()}'\n"
    }

    def "does not realize all possible tasks"() {
        // TODO: This isn't done yet, we still realize many tasks
        // Eventually, this should only realize "help"

        Assume.assumeFalse(pluginName in [
            'xctest', // Almost, still realizes compileTestSwift

            'visual-studio',
            'xcode',

 *
 * @param <T> the type of elements
 * @param <C> type of collection
 */
interface CollectionSupplier<T, C extends Collection<? extends T>> extends ValueSupplier {
    /**
     * Realizes and returns the (collection) value.
     */
    Value<? extends C> calculateValue(ValueConsumer consumer);

    /**

        return buildHierarchy(project.getRootProject(), realizeTasks);
    }

    /**
     * When {@code realizeTasks} is false, the project's task graph will not be realized, and the task list in the model will be empty
     */
    private static DefaultGradleProject buildHierarchy(Project project, boolean realizeTasks) {

            tasks.register("bar", Delete)
        """

        when:
        succeeds "help"

        then:
        // help task is realized and configured
        outputContains("configured :help")

        // are "built-in" tasks realized and configured?
        if (realizesBuiltInTasks) {
            outputContains("configured :tasks")
            outputContains("configured :projects")
        } else {

        project.apply plugin: 'custom-rule-source'

        then:
        project.modelRegistry.realize("foo", String) == "bar"
    }

    def "can apply a rule source by type"() {
        when:
        def project = buildProject()
        project.apply type: CustomRuleSource

        then:
        project.modelRegistry.realize("foo", String) == "bar"
    }

        source.contains("foo")
    }

    def "an element added as both a provider and a realized value is not duplicated"() {
        when:
        source.add("foo")
        source.addPending(provider("foo"))

        then:
        source.iterator().collect() == ["foo"]
    }

    def "an element added as both a provider and a realized value has the correct order"() {
        when:
        source.addPending(provider("foo"))

class ProjectVariantResolutionIntegrationTest extends AbstractIntegrationSpec implements VariantAwareDependencyResolutionTestFixture, TasksWithInputsAndOutputs {
    def "does not realize tasks that produce outgoing artifacts that are not required"() {
        createDirs("a", "b")
        settingsFile << """
            include 'a', 'b'
        """
        setupBuildWithColorVariants()

                            bool smuggle_disallowed_ops);

// This function is a common entry point for all graph optimizations that are
// not specific to any hardware. It legalizes SHLO->MHLO, does MHLO->MHLO
// optimizations by calling `AddMhloOptimizationPasses` internally, and
// legalizes MHLO->SHLO
void AddStablehloOptimizationPasses(OpPassManager& pm);

// Adds all the backend-agonstic stableHLO optimization passes

    public void assertOutputMatches(String expected, String actual, boolean ignoreExtraLines) {
        List actualLines = new ArtifactResolutionOmittingOutputNormalizer().normalize(actual).readLines().findAll { !it.isEmpty() }
        List expectedLines = expected.readLines().findAll { !it.isEmpty() }
        assertOutputLinesMatch(expectedLines, actualLines, ignoreExtraLines, actual)
    }