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"
            }

import org.apache.maven.bridge.MavenRepositorySystem;
import org.apache.maven.plugin.LegacySupport;
import org.apache.maven.project.ProjectBuilder;

/**
 * This realizes the metadata source via the default hint to provide backward-compat with Maven 2.x whose Plexus version
 * registered component descriptors twice: once keyed by role+roleHint and once keyed by role only. This effectively

public interface ElementSource<T> extends Iterable<T>, WithEstimatedSize, PendingSource<T>, WithMutationGuard {
    /**
     * Iterates over and realizes each of the elements of this source.
     */
    @Override
    Iterator<T> iterator();

    /**
     * Iterates over only the realized elements (without flushing any pending elements)
     */
    Iterator<T> iteratorNoFlush();

    /**

    }

    def "realizes pending elements on flush"() {
        when:
        source.addPending(provider1)
        source.addPending(provider2)
        source.addPending(provider3)
        source.realizePending()

        then:
        source.iteratorNoFlush().collect() == ["provider1", "provider2", "provider3"]
    }

    def "realizes only pending elements with a given type"() {

        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);

    /**

        }
        elements.add(element);
    }

    /**
     * Realizes the contents of this collection, running configuration actions and firing notifications. No further elements can be added.
     */
    public void realizeNow() {
        if (state != State.Collecting) {

            // Collect elements discarding potential side effects aggregated in the returned value
            collector.collectInto(builder);
            List<T> realized = builder.build();
            for (T element : realized) {
                doAddRealized(element);
            }
        }
    }

    private void doAddRealized(T value) {
        if (values.add(value) && addRealizedAction != null) {

        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) {

        }

        then:
        def list = registry.realize(collectionPath, collectionType)
        list == checkable(['bar'])
    }

    def "can remove all elements"() {
        when:
        mutate {
            add 'foo'
            add 'bar'
            clear()
        }

        then:
        def list = registry.realize(collectionPath, collectionType)
        list == checkable([])
    }