set.resources.srcDirs == toLinkedSet(project.file('src/custom/resources'))
        set.java.destinationDirectory.set(new File(project.buildDir, 'classes/java/custom'))
        set.output.resourcesDir == new File(project.buildDir, 'resources/custom')
        set.output.generatedSourcesDirs.files == toLinkedSet(new File(project.buildDir, 'generated/sources/annotationProcessor/java/custom'))

    ]

    @Rule
    HttpServer server = new HttpServer()
    @Rule
    TestNameTestDirectoryProvider tempDir = new TestNameTestDirectoryProvider(getClass())

    BuildCacheServiceFactory.Describer buildCacheDescriber
    HttpClientHelper.Factory httpClientHelperFactory = HttpClientHelper.Factory.createFactory(new DocumentationRegistry())

    def key = new TestBuildCacheKey(0x01234567abcdef)

    def classpathHasher = Mock(ClasspathHasher)
    def autoAppliedPluginHandler = Mock(AutoAppliedPluginHandler)
    def compileOperationsFactory = new DefaultCompileOperationFactory(documentationRegistry)

    def factory = new DefaultScriptPluginFactory(
        new DefaultServiceRegistry(),
        scriptCompilerFactory,
        loggingManagerFactory,
        autoAppliedPluginHandler,
        pluginRequestApplicator,

                    throw new RuntimeException("Boo!");
                }
            }
        """
        file("src/test/java/org/gradle/OtherTest.java") << """
            package org.gradle;
            ${testFrameworkImports}
            public class OtherTest {
                @Test public void pass() {}
                @Test public void fail() { throw new RuntimeException("Boo!"); }
            }

    def snapshotter = new DefaultFileCollectionSnapshotter(fileSystemAccess, TestFiles.fileSystem())
    def fingerprinter = new AbsolutePathFileCollectionFingerprinter(DirectorySensitivity.DEFAULT, snapshotter, FileSystemLocationSnapshotHasher.DEFAULT)
    def executionHistoryStore = new TestExecutionHistoryStore()
    def outputChangeListener = new OutputChangeListener() {
        @Override

        expectGetArtifact << new ArtifactExpectation(InteractionExpectation.GET, artifact)
    }

    void expectGetArtifact(Map<String, String> artifact) {
        expectGetArtifact << new ArtifactExpectation(InteractionExpectation.GET, artifact)
    }

    void expectHeadArtifact(String artifact = '') {
        expectGetArtifact << new ArtifactExpectation(InteractionExpectation.HEAD, artifact)
    }

    final CapabilityNotationParser capabilityNotationParser = new CapabilityNotationParserFactory(false).create()
    final ProviderFactory providerFactory = new DefaultProviderFactory(
        new DefaultValueSourceProviderFactory(
            new DefaultListenerManager(Scope.Build),
            TestUtil.instantiatorFactory(),
            new TestIsolatableFactory(),
            Stub(GradleProperties),

        }
        def cachedEntry = new CrossBuildCachingRuleExecutor.CachedEntry<ComponentMetadata>(0, implicits, cachedResult)
        def ruleServices = [:]
        def someService = Mock(SomeService)
        if (ruleClass == TestSupplierWithService) {
            ruleServices['SomeService'] = someService
        }
        def reexecute = mustRefresh || expired
        def moduleSources = new MutableModuleSources()

    def "can configure output file for binaries"() {
        given:
        def app = new CppHelloWorldApp()
        app.writeSources(file("src/main"))
        app.library.writeSources(file("src/hello"))

        and:
        buildFile << """
apply plugin: 'cpp'
model {
    components {
        def modPath = { File original -> new File(original.parent + "/new_output/_" + original.name) }
        main(NativeExecutableSpec) {

        validateOutput()
        result
    }

    void collectOutputs(LongRunningOperation op) {
        op.setStandardOutput(new TeeOutputStream(stdout, System.out))
        op.setStandardError(new TeeOutputStream(stderr, System.err))
    }

    def validateOutput() {
        def assertion = new ResultAssertion(0, [], false, true, true)
        assertion.validate(stdout.toString(), "stdout")