def binder = new RuleBinder(subjectReference, inputReferences, action, [])
            if (subjectReferenceBindingPath) {
                binder.subjectBinding.boundTo = new TestNode(subjectReferenceBindingPath, Object)
            }
            boundInputReferencePaths.each { index, path ->
                binder.inputBindings[index].boundTo = new TestNode(path, Object)
            }

        writeLn();
        writeLn("    @Inject");
        writeLn("    public " + className + "(DefaultProjectDependencyFactory factory, ProjectFinder finder) {");
        writeLn("        super(factory, finder);");
        writeLn("    }");
        writeLn();
        writeProjectAccessor(toJavaName(rootProjectName(current)), current);
        processChildren(current);

        writeLn("}");
    }

    }

    def createSourceFolder() {
        SourceFolder folder = new SourceFolder('src', 'bin2')
        folder.nativeLibraryLocation = 'mynative'
        folder.accessRules += [new AccessRule('nonaccessible', 'secret**')]
        folder.includes += ['**/Test1*', '**/Test2*']
        folder.excludes += ['**/Test3*', '**/Test4*']
        return folder
    }

    def "ignores null dir in equality"() {
        given:

        deletedFiles == [file, parent]
    }

    FilesFinder finder(files) {
        Stub(FilesFinder) {
            find(_, _) >> { baseDir, filter ->
                assert filter instanceof NonReservedFileFilter
                files.findAll { filter.accept(it) }
            }
        }
    }

    AbstractCacheCleanup cleanupAction(FilesFinder finder, Spec<File> spec) {
        new AbstractCacheCleanup(finder) {

        given:
        settingsFile << """
            rootProject.name = 'module-main'
            includeBuild('module-b-folder')
        """
        file('module-b-folder').mkdir()
        file('module-b-folder/settings.gradle') << """
            rootProject.name = 'module-b-name'
        """

        when:

  private val finder = FastFallbackExchangeFinder(routePlanner, taskRunner)

  @AfterEach
  fun tearDown() {
    taskFaker.close()
    routePlanner.close()
  }

  @Test
  fun takeConnectedConnection() {
    val plan0 = routePlanner.addPlan()
    plan0.connectState = TLS_CONNECTED

    taskRunner.newQueue().execute("connect") {
      val result0 = finder.find()

    def "does not assign an invalid project name from folder names"() {
        given:
        def buildFolder = file(".folder: name.")
        inDirectory(buildFolder)
        buildFolder.file("build.gradle") << "println rootProject.name"

        when:
        fails 'help'

        then:
        assertFailureContainsForbiddenCharacterMessage('project name', '.folder: name.')
    }

    }

    @Override
    public void configure(Binder binder) {
        if (extension.getKey() != null) {
            XmlNode configuration = extension.getConfiguration();
            if (configuration == null) {
                configuration = new XmlNodeImpl("configuration");
            }
            configuration = new Interpolator().transform(configuration);

            binder.bind(XmlNode.class)

        this.moduleVersion = moduleVersion;
    }

    /**
     * Returns a single jar or class folder
     */
    public File getLibraryFile() {
        return ((FilePath) this.getClasses().iterator().next()).getFile();
    }

    /**
     * Returns a single javadoc jar or javadoc folder
     */
    public File getJavadocFile() {
        if (getJavadoc().size() > 0) {

[user-feature] -down-> [state]

[admin-feature] -down-> [domain-model]
[admin-feature] -down-> [state]

[server-application] -down-> [SpringBoot]
[android-app] -down-> [Android]

folder {
   [build-logic]
}
folder {
   [platforms]
}
folder {
    [aggregation]
}