class TransformedClassPathTest extends Specification {
    def "transformed jars are returned when present"() {
        given:
        TransformedClassPath cp = transformedClassPath("original.jar": "transformed.jar")

        expect:
        cp.findTransformedEntryFor(file("original.jar")) == file("transformed.jar")
    }

    def "transformed jars are returned in the list of transformed files"() {
        given:

        createFile(new File(cachesDir, "transforms-1/first/transformed/file"))
        createFile(new File(cachesDir, "transforms-1/first/metadata.bin"))
        createFile(new File(cachesDir, "transforms-1/first/transformed/instrumented/file"))
        createFile(new File(cachesDir, "transforms-1/second/transformed/original/file"))
        createFile(new File(cachesDir, "transforms-2/first/transformed/instrumented/file"))

    String ROLE = ArtifactTransformation.class.getName();

    /**
     * Take in an artifact and return the transformed artifact for locating in the remote repository. If no
     * transformation has occurred the original artifact is returned.
     *
     * @param artifact           Artifact to be transformed.
     * @param request the repositories to check
     */

    String ROLE = ArtifactTransformationManager.class.getName();

    /**
     * Take in an artifact and return the transformed artifact for locating in the remote repository. If no
     * transformation has occurred the original artifact is returned.
     *
     * @param artifact           Artifact to be transformed.
     * @param request the repositories to check
     */

        expect:
        parse(source) == transformed

        where:
        source              | transformed
        "text<p>para 2</p>" | "<p>text</p><p>para 2</p>"
        "text<h2>text</h2>" | "<p>text</p><h2>text</h2>"
    }

    def "does not add implicit <p> element for elements with inline content"() {
        expect:
        parse(source) == transformed

        where:

                        return project.getConfigurations().create("transformed", transformed -> {
                            transformed.setCanBeConsumed(false);
                            transformed.setCanBeResolved(true);
                            transformed.extendsFrom(base);

                            transformed.getAttributes().attribute(ARTIFACT_TYPE_ATTRIBUTE, TXT_TYPE);
                        });

 *
 * @param <OUT> The type the value is transformed to.
 * @param <IN> The type of the value to be transformed.
 */
public interface InternalTransformer<OUT, IN> {
    /**
     * Transforms the given object, and returns the transformed value.
     *
     * @param in The object to transform.
     * @return The transformed object.
     */
    OUT transform(IN in);

    }

    /**
     * The files which should be transformed.
     */
    public abstract ImmutableList<File> getFiles();

    /**
     * Component identifier of the initial subject.
     */
    public abstract ComponentIdentifier getInitialComponentIdentifier();

    /**
     * Creates a subsequent subject by having transformed this subject.
     */

        }

        def transformed = jar(testDir.file("transformed.jar")) {
            manifest {
                multiRelease()
            }

            entry("Foo.class", INSTRUMENTED_CLASS)
            entry(MarkerResource.RESOURCE_NAME, MarkerResource.TRANSFORMED.asBytes())
        }

        TransformedClassPath cp = classPath((original): transformed)

        expect:

        result.assertTasksNotSkipped(":b:producer", ":c:producer", ":a:resolve")
        transformed("b.jar", "c.jar")
        outputContains("result = [b.jar.green, c.jar.green]")

        when:
        succeeds(":a:resolve")

        then: // no change, should be up to date
        result.assertTasksNotSkipped(":a:resolve")
        transformed()
        outputContains("result = [b.jar.green, c.jar.green]")

        when: