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

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