}
            }
            toBeRealized.get()

            task verify {
                doLast {
                    assert otherContainer.findByName("realized") != null
                    assert otherContainer.findByName("toBeRealized") != null
                }
            }
        """

        expect:
        succeeds "verify"
    }
}

        } else {
            handleAttemptToAddItemWithNonUniqueName(toAdd);
            return false;
        }
    }

    @Override
    protected void realized(ProviderInternal<? extends T> provider) {
        super.realized(provider);
        index.removePending(provider);
    }

    @Override
    public boolean addAll(Collection<? extends T> c) {
        assertMutable("addAll(Collection<T>)");

}


// MODULE: main
// MODULE_KIND: CodeFragment
// CONTEXT_MODULE: context

// FILE: fragment.kt
// CODE_FRAGMENT_KIND: EXPRESSION
// CODE_FRAGMENT_IMPORT: java.io.File

    }

    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 {

    } else {
      assertEquals(expectedLines.get(0), source.readFirstLine());
    }
  }

  public void testReadLines_toList() throws IOException {
    assertExpectedLines(source.readLines());
  }

  public void testIsEmpty() throws IOException {
    assertEquals(expected.isEmpty(), source.isEmpty());
  }

  public void testLength() throws IOException {

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.

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

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

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

            it.add(Providers.of("v5").withSideEffect(sideEffect5))
            it
        }
        source.addPendingCollection(provider5)

        then:
        0 * _ // no side effects until elements are realized

        when:
        source.removePending(provider2)
        source.removePendingCollection(provider4)

        then:
        0 * _ // can remove pending without running side effects

        when:

                    buildFile = new File(testProjectDir, 'build.gradle')
                    def pluginClasspath = getClass().classLoader.getResource("plugin-classpath.txt")
                      .readLines()
                      .collect { it.replace('\\\\', '\\\\\\\\') } // escape backslashes in Windows paths
                      .collect { "'\$it'" }
                      .join(", ")

            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