}

        return gradleProject;
    }

    private static List<LaunchableGradleProjectTask> collectTasks(DefaultGradleProject owner, TaskContainerInternal tasks) {
        tasks.discoverTasks();
        tasks.realize();

        return tasks.getNames().stream()
            .map(tasks::findByName)
            .filter(Objects::nonNull)
            .map(task -> buildTask(owner, task))
            .collect(toList());
    }

import org.gradle.api.NonNullApi;

@NonNullApi
public class GradleProjectBuilderOptions {

    /**
     * Determines whether a builder for the {@link org.gradle.tooling.model.GradleProject} model should realize tasks.
     * <p>
     * This method has to be invoked during builder execution time to provide an effective value.

    }

    def "can put existing unmanaged instance"() {
        when:
        mutate {
            put("foo", "bar")
        }

        then:
        registry.realize("map.foo", String) == "bar"
    }

    @Managed
    abstract static class Invalid<T> implements SpecialNamedThingInterface {}

    def "cannot create invalid subtype"() {
        when:
        mutate {

            components {
                main(NativeLibrarySpec)
            }
        }
        project.evaluate()

        when:
        CUnitTestSuiteSpec testSuite = project.modelRegistry.realize("testSuites", modelMap(TestSuiteSpec)).mainTest
        def sources = testSuite.sources.values()
        def binaries = testSuite.binaries.values()

        then:
        sources.size() == 2

        dsl {
            apply plugin: ComponentModelBasePlugin
            model {
                baseComponent(type) {
                }
            }
        }

        then:
        type.isInstance(realize("baseComponent"))

        where:
        type                 | _
        GeneralComponentSpec | _
        ApplicationSpec      | _
        LibrarySpec          | _
    }

        // Configure task through suite
        testing {
            suites {
                test {
                    useJUnitJupiter()
                    targets.all {
                        // explicitly realize the task now to cause this configuration to run now
                        testTask.get().configure {
                            options {
                                includeTags 'fast'
                            }

class ForceRealizedMetadataIntegrationTest extends AbstractHttpDependencyResolutionTest {
    MavenHttpModule direct
    MavenHttpModule transitive

    def setup() {
        executer.withArgument("-Dorg.gradle.integtest.force.realize.metadata=true")

        buildFile << """
            plugins {
                id 'java'
            }

            repositories {
                maven { url '$mavenHttpRepo.uri' }
            }

        when:
        dsl {
            apply plugin: BinaryBasePlugin
            model {
                baseBinary(BinarySpec) {
                }
            }
        }

        then:
        realize("baseBinary") instanceof BinarySpec
    }

    def "adds a 'binaries' container to the project model"() {
        when:
        dsl {
            apply plugin: BinaryBasePlugin
        }

        then:

        dsl {
            apply plugin: TestingModelBasePlugin
            model {
                baseComponent(TestSuiteSpec) {
                }
            }
        }

        then:
        realize("baseComponent") instanceof TestSuiteSpec
    }

    def "adds a 'testSuites' container to the project model"() {
        when:
        dsl {
            apply plugin: TestingModelBasePlugin
        }

    TestNameTestDirectoryProvider testDir = new TestNameTestDirectoryProvider(getClass())

    final def project = TestUtil.create(testDir).rootProject()
    @Rule SetRuleContext setContext = new SetRuleContext()

    def realize(String name) {
        project.modelRegistry.find(name, ModelType.UNTYPED)
    }

    ModelMap<Task> realizeTasks() {
        project.modelRegistry.find("tasks", ModelTypes.modelMap(Task))
    }