}

        return map;
    }

    public boolean hasDetailsOfType(Class<?> clazz) throws ClassNotFoundException {
        Class<?> detailsType = getDetailsType();
        return detailsType != null && clazz.isAssignableFrom(detailsType);
    }

    public Class<?> getDetailsType() throws ClassNotFoundException {

                .distinct()
                .forEach(key -> {
                    Class<?> clazz = key.getRawType();
                    Class<Object> itf = (clazz.isInterface()
                            ? null
                            : (Class<Object>) (clazz.getInterfaces().length > 0 ? clazz.getInterfaces()[0] : clazz));
                    if (itf != null) {

            throw new IllegalStateException();
        }
        values.remove(0);
    }

    public <T> void seed(Class<T> clazz, Provider<T> value) {
        getScopeState().seed(clazz, value);
    }

    public <T> void seed(Class<T> clazz, final T value) {
        seed(clazz, (Provider<T>) () -> value);
    }

    public <T> Provider<T> scope(final Key<T> key, final Provider<T> unscoped) {

        if (stack.isEmpty()) {
            values.remove();
        }
    }

    public <T> void seed(Class<T> clazz, Provider<T> value) {
        getScopeState().seeded.put(Key.get(clazz), value);
    }

    public <T> void seed(Class<T> clazz, final T value) {
        getScopeState().seeded.put(Key.get(clazz), Providers.of(value));
    }

    public <T> Provider<T> scope(final Key<T> key, final Provider<T> unscoped) {

        when:
        def clazz = classLoader.parseClass """
            import org.gradle.api.artifacts.Configuration.State
            import org.gradle.model.Managed

            @Managed
            interface ManagedType {
                $someType.canonicalName getManagedProperty()
            }

        """

        then:

@GroovyASTTransformation
public class MagicInterfaceTransform implements ASTTransformation {
    public void visit(ASTNode[] nodes, SourceUnit source) {
        ClassNode clazz = (ClassNode) nodes[1];
        clazz.addInterface(new ClassNode(Marker.class));
    }

    }

    private <T extends Credentials> T setCredentials(Class<T> clazz) {
        this.usesCredentials = true;
        T t = newCredentials(clazz);
        credentials.set(t);
        return t;
    }

    private <T extends Credentials> T newCredentials(Class<T> clazz) {
        return instantiator.newInstance(getCredentialsImplType(clazz));
    }

    public Property<Credentials> getConfiguredCredentials() {

        given:
        def jar = distDir.file("$jarDirectory/mydep-1.2.jar")
        createJarFile(jar)

        when:
        def clazz = loadClassFromJar(jar)
        def installation = CurrentGradleInstallationLocator.locateViaClass(clazz).getInstallation()

        then:
        installation.gradleHome == distDir
        installation.libDirs == [new File(distDir, 'lib'), new File(distDir, 'lib/plugins')]

    @Override
    public ClassLoaderScope getParent() {
        return this; // should this be null?
    }

    @Override
    public boolean defines(Class<?> clazz) {
        return localClassLoader.equals(clazz.getClassLoader()) || exportClassLoader.equals(clazz.getClassLoader());
    }

    @Override
    public ClassLoaderScope lock() {
        return this;
    }

    @Override
    public boolean isLocked() {

            assert source.exists()
            def clazz = new File(dstDir, "org/test/${className}.class")
            assert clazz.exists()
            assertCompatibleWithJava8(clazz)
        }
    }

    private static void assertCompatibleWithJava8(File clazz) {
        ClassVisitor cv = new ClassVisitor(Opcodes.ASM7) {
            @Override