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

    private GradleRuntimeShadedJarDetector() {
    }

    public static boolean isLoadedFrom(Class<?> clazz) {
        if (clazz == null) {
            throw new IllegalArgumentException("Need to provide valid class reference");
        }

        CodeSource codeSource = clazz.getProtectionDomain().getCodeSource();

        if (codeSource != null) {
            URL location = codeSource.getLocation();

        return this.info;
    }


    /**
     * @param clazz
     * @return the filesystem info
     * @throws CIFSException
     */
    @SuppressWarnings ( "unchecked" )
    public <T extends FileSystemInformation> T getInfo ( Class<T> clazz ) throws CIFSException {
        if ( !clazz.isAssignableFrom(this.info.getClass()) ) {

            for (Method method : clazz.getDeclaredMethods()) {
                if (method.getName().equals("parseMap")) {
                    method.setAccessible(true);
                    return method;
                }
            }
            throw new UnsupportedOperationException(String.format("No parseMap() method found on class %s.", clazz.getSimpleName()));
        }

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

        def clazz = loadClassForJar()

        expect:
        GradleRuntimeShadedJarDetector.isLoadedFrom(clazz)
    }

    def "cannot find marker file in standard JAR file"() {
        given:
        createJarWithoutMarkerFile(jarFile)
        def clazz = loadClassForJar()

        expect:
        !GradleRuntimeShadedJarDetector.isLoadedFrom(clazz)
    }

    }

    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')]