createDirs("app")
        settingsFile << """
            include 'app'
        """
        addDependency("app", "impl")
        def app = new CompilationOutputsFixture(file("app/build/classes"))
        source api: ["class A {}"]
        source impl: ["class B extends A {}"]
        source app: ["class Unrelated {}", "class C extends B {}", "class D extends C {}"]
        app.snapshot { run language.compileTaskName }

The following example shows a more complicated transform.
It moves some selected classes of a JAR to a different package, rewriting the byte code of the moved classes and all classes using the moved classes (class relocation).
In order to determine the classes to relocate, it looks at the packages of the input artifact and the dependencies of the input artifact.

     *
     * Available for compatibility with previously published modules.  Should <strong>NOT</strong> be used for new publishing.
     * No plans for permanent removal.
     */
    @Deprecated
    public static final String DEPRECATED_JAVA_API_CLASSES = "java-api-classes";

    /**

        )
    }

    static ClassSetAnalysis snapshot(Map<String, HashCode> hashes) {
        new ClassSetAnalysis(new ClassSetAnalysisData(hashes, [:], [:], null))
    }

    def "knows when there are no affected classes since some other snapshot"() {
        ClassSetAnalysis s1 = snapshot(["A": TestHashCodes.hashCodeFrom(0xaa), "B": TestHashCodes.hashCodeFrom(0xbb)])

            } catch (Exception e) {
                throw new GradleException("Could not generate worker process bootstrap classes.", e);
            }
        }

        private Set<Class<?>> getClassesForWorkerJar() {
            // TODO - calculate this list of classes dynamically
            List<Class<?>> classes = Arrays.asList(
                GradleWorkerMain.class,
                BootstrapSecurityManager.class,

<!DOCTYPE suite SYSTEM "http://testng.org/testng-1.0.dtd">
<suite name="suite 1">
  <test name="test 1">
    <classes>
      <class name="${ATestNGClass.name}"/>
    </classes>
  </test>
  <test name="test 2">
    <classes>
      <class name="${ATestNGClass.name}"/>
    </classes>
  </test>
</suite>"""
        def suite2 = dir.file("suite2.xml") << """<?xml version="1.0" encoding="UTF-8"?>

        given:
        buildFile '''
            task assemble(type: BreakingTask) {
                dependsOn "classes"
            }
            task generatePermissions(type: BreakingTask) {
                dependsOn "classes"
            }
            task classes(type: BreakingTask) {
                finalizedBy "assemble", "generatePermissions"
                dependsOn "compileJava", "processResources"

    }

    @Requires(value = IntegTestPreconditions.NotEmbeddedExecutor, reason = "classloader isolation does not work here in embedded mode")
    @InspectsExecutedTasks
    def "buildSrc classes are not visible to injected classes"() {
        plugin.build()
        def buildSrcSrcDir = file("buildSrc/src/main/groovy/org/gradle/test")

        // these class names intentionally clash with what we are injecting

            }
        """

        when:
        resolve()

        then:
        result.assertTasksExecuted(":other-java:compileJava", ":java:compileJava", ":consumer:resolve")
        assertResolveOutput("""
            files: [main, api-1.0.jar, compile-only-api-1.0.jar]

        }
    }

    /**
     * Fixture for capturing simple test class requirements.  Note that this class should be used only for simple test classes
     * and should not be enhanced to capture complex test classes with arbitrary features.  Complex test classes should be captured
     * with a raw {@link TestSource} fixture.
     */
    class TestClass {
        final String name
        final String packageName