def a = new File("a.jar")
        def b = new File("b.jar")

        when:
        def originalClasspath = DefaultClassPath.of(a, b)
        def newClasspath = originalClasspath.removeIf { it.name.startsWith("c") }

        then:
        originalClasspath.asFiles == [a, b]
        newClasspath.is(originalClasspath)
    }

    def "classpaths are equal when the contain the same sequence of files"() {

    private final ClassPath originalClassPath;
    // mapping of original -> "double"
    private final ImmutableMap<File, File> transforms;

    private TransformedClassPath(ClassPath originalClassPath, Map<File, File> transforms) {
        assert !(originalClassPath instanceof TransformedClassPath);
        this.originalClassPath = originalClassPath;
        this.transforms = ImmutableMap.copyOf(transforms);

            this.hashToOriginalFile = Lazy.locking().of(() -> {
                Set<File> originalClasspath = getOriginalClasspath().getFiles();
                Map<String, File> originalFiles = Maps.newHashMapWithExpectedSize(originalClasspath.size());
                originalClasspath.forEach(file -> {
                    String fileHash = getArtifactHash(file);
                    if (fileHash != null) {

        def originalJvmArguments = ['arg3', 'arg4']
        def originalClasspath = [new File('/Users/foo/bar/test.jar').absoluteFile]

        when:
        def runner = createRunner()
            .withArguments(originalArguments)
            .withJvmArguments(originalJvmArguments)
            .withPluginClasspath(originalClasspath) as DefaultGradleRunner

        then:

        List<File> originalClasspath = spec.getCompileClasspath();
        File destinationDir = spec.getDestinationDir();
        spec.setCompileClasspath(ImmutableList.<File>builderWithExpectedSize(originalClasspath.size() + 1)
            .add(destinationDir)
            .addAll(originalClasspath)
            .build());
    }

    @Override

    @Rule TestNameTestDirectoryProvider tmpDir = new TestNameTestDirectoryProvider(getClass())

    /**
     * Returns the classpath for the given classes.
     */
    List<File> originalClassPath(Class<?>... classes) {
        return classes.collect { ClasspathUtil.getClasspathForClass(it) }
    }


    /**

            action.execute(null)
        } finally {
            loader?.close()
        }
    }

    private List<File> getToolingApiClassPath() {
        originalClassPath(BuildAction)
    }

    private List<URL> classpathFor(Class<?> cl) {
        List<URI> classpath = []
        factory.getClassPathFor(cl, classpath)
        return classpath.collect { it.toURL() }
    }

    instrument{{"Instrument and upgrade\n(Artifact transform)"}}
    typeHierarchy(Classpath with all super types)
    artifactOutput("1. Artifact metadata: hash, name\n2. Direct Super types\n3. Class dependencies")
    originalClasspath(Original classpath)
    originalClasspathInput("Original classpath as input:\nto recalculate Resolve supertypes\nstep on classpath change")