def listener1 = Mock(Dispatch)
        def listener2 = Mock(TestListener)
        def listener3 = Mock(Dispatch)
        def failure1 = new RuntimeException()
        def failure2 = new Exception()
        def invocation = new MethodInvocation(method, ["param"] as Object[])

        when:
        def dispatch = BroadcastDispatch.empty(TestListener).add(listener1).add(listener2).add(listener3)

        where:
        type << [
            new ModelType<ModelSet<?>>() {},
            new ModelType<ModelSet<? extends A1>>() {},
            new ModelType<ModelSet<? super A1>>() {}
        ]
    }

    def "type argument of a model set has to be a valid managed type"() {
        given:
        def type = new ModelType<ModelSet<ModelMap>>() {}

        when:
        extract(type)

    def dependencyResolver = new TaskDependencyResolver([new TaskNodeDependencyResolver(taskNodeFactory)])
    def projectStateRegistry = Stub(ProjectStateRegistry)
    def executionPlan = newExecutionPlan()
    def taskGraph = new DefaultTaskExecutionGraph(

        def watchableHierarchy = new File("watchable")
        def watcherProbe = new File(watchableHierarchy, ".gradle/watch-probe")
        def anotherWatchableHierarchy = new File("anotherWatchable")
        def anotherWatcherProbe = new File(anotherWatchableHierarchy, ".gradle/watch-probe")
        def newWatchableHierarchy = new File("newWatchable")
        def newWatcherProbe = new File(newWatchableHierarchy, ".gradle/watch-probe")

        InvalidPublicationChecker checker = new InvalidPublicationChecker(publication.getName(), ':task', [] as Set)
        ModuleMetadataSpec spec = new ModuleMetadataSpecBuilder(
            publication,
            publications,
            checker,
            resolverFactory
        ).build().get()
        checker.validate()

        new GradleModuleMetadataWriter(
            new BuildInvocationScopeId(buildId),

        if(binary){
            htmlResult = new HtmlTestExecutionResult(projectDir, "$buildDirName/reports${binaryPath}/tests/")
            xmlResult = new JUnitXmlTestExecutionResult(projectDir, "$buildDirName/test-results${binaryPath}")

            results << htmlResult
            results << xmlResult
        }else{
            htmlResult = new HtmlTestExecutionResult(projectDir, "$buildDirName/reports/tests/${testTaskName}")

            } else {
                throw new MissingMethodException(name, getClass(), args)
            }
        }

        BuildTestFile createNestedBuild(String name, Closure configuration = {}) {
            includeBuild(name)
            def nestedBuild = new BuildTestFile(build.file(name), name)
            nestedBuilds.add(nestedBuild)

                    private static List<Runner> extractAndCreateRunners(Class<?> klass) throws InitializationError {
                        List<Runner> runners = new ArrayList<Runner>();
                        for (Locale locale : localesToUse) {
                            runners.add(new LocalesRunner(locale, klass));
                        }
                        return runners;
                    }

    }
}

"""
        when:
        run 'assemble'

        then:
        def ear = new JarTestFixture(file('build/libs/root.ear'))
        ear.assertContainsFile("CUSTOM/lib/earLib.jar")
        ear.assertFileContent("META-INF/application.xml", CoreMatchers.containsString("cool ear"))
        def appXml = new XmlSlurper().parseText(ear.content('META-INF/application.xml'))
        appXml.'library-directory'.text() == 'CUSTOM/lib'

        then:
        result.assertTasksNotSkipped()

        when:
        file("file-source.txt").text = "new-file1"
        run("merge")

        then:
        result.assertTasksNotSkipped(":createFiles", ":merge")
        file("output/merged.txt").text == 'new-file1,new-file1'
    }

    def "can wire the output directory of multiple tasks as input to another task using property"() {