abstract ConfigurableFileCollection getOutputFiles()

                @Inject
                abstract ProjectLayout getLayout()

                @TaskAction
                void doStuff() {
                    layout.buildDirectory.file("dir1/output1.txt").get().asFile.text = "first"
                    layout.buildDirectory.file("dir2/output2.txt").get().asFile.text = "second"
                }

import javax.xml.transform.TransformerFactory;
import javax.xml.validation.SchemaFactory;
import javax.xml.xpath.XPathFactory;

public class DefaultClassLoaderFactoryTestHelper {
    public void doStuff() throws Exception {
        SAXParserFactory.newInstance().newSAXParser();
        DocumentBuilderFactory.newInstance().newDocumentBuilder();
        DatatypeFactory.newInstance().newXMLGregorianCalendar();

 * limitations under the License.
 */



package org.gradle.internal.instantiation.generator

class TestDecoratedGroovyBean {
    def String prop

    def doStuff(String value) {
        "{$value}"
    }

 */

package org.gradle.testfixtures

import org.gradle.api.DefaultTask
import org.gradle.api.tasks.TaskAction


class CustomTask extends DefaultTask {
    String property

    @TaskAction
    def doStuff() {
        property = 'some value'
    }

try {
    buildscript.classLoader.loadClass('BuildSrcClass')
    assert false: 'should fail'
} catch (ClassNotFoundException e) {
    // expected
}
"""
        buildFile << 'task doStuff'

        when:
        run('doStuff')

        then:
        output.contains('quiet message')
        errorOutput.contains('error message')
    }

    private TestFile createBuildSrc() {

                @InputFile
                abstract RegularFileProperty getInputFile()
                @OutputFile
                abstract RegularFileProperty getOutputFile()
                @TaskAction
                void doStuff() {
                    outputFile.get().asFile.text = inputFile.get().asFile.text
                }
            }
            tasks.register("myTask", MyTask) {
                inputFile = file("input.txt")

                abstract DirectoryProperty getLocalStateDirectory()
                @OutputFile
                abstract RegularFileProperty getOutputFile()

                @TaskAction
                void doStuff() {
                    def localStateDir = localStateDirectory.get().asFile
                    localStateDir.mkdirs()
                    new File(localStateDir, "localState.txt").text = "localState"

        then:
        c != DefaultClassLoaderFactoryTestHelper

        when:
        Thread.currentThread().contextClassLoader = cl
        c.getConstructor().newInstance().doStuff()

        then:
        notThrown()
    }

    def getClasspath() {
        return DefaultClassPath.of(ClasspathUtil.getClasspathForClass(DefaultClassLoaderFactoryTestHelper))
    }

    def "nested destroyables are discovered"() {
        buildFile << classesForNestedProperties()
        buildFile << """
            class MyDestroyer extends DefaultTask {
                @TaskAction void doStuff() {}
                @Nested
                Object bean
            }
            class DestroyerBean {
                @Destroys File destroyedFile
            }

                @Input
                public FileTree getFileTree() {
                    return getProject().files().getAsFileTree();
                }

                @TaskAction
                public void doStuff() { }
            }
        """

        when:
        executer.withArgument("-Dorg.gradle.internal.max.validation.errors=7")

        then:
        assertValidationFailsWith([