private static final String FLAKINESS_RATE_TITLE = "Flakiness rate of a scenario is the number of times the scenario had a regression of an improvement with more than 99.9% " +
            " in the flakiness detection builds divided by the total number of runs of the scenario.";
        private static final String FAILURE_THRESHOLD_TITLE = "The failure threshold of flaky scenario, if a flaky scenario performance test's difference is higher than this value, " +

            withArgument("--parallel")
            vfsLogs = enableVerboseVfsLogs()
            inDirectory(rootProject)
        }
    }

    def "file watching works with multiple builds on the same daemon"() {
        def numberOfChangesBetweenBuilds = maxFileChangesWithoutOverflow
        int numberOfRuns = 50

        int numberOfOverflows = 0

        when:
        succeeds("assemble")

        when:
        def build = executer.withTasks("help").withArguments("--info").start()

        then:
        build.waitForFinish()

        and:
        daemons.daemons.size() == 2

        and:
        !build.standardOutput.contains(DaemonMessages.WAITING_ON_CANCELED)
    }

    def "starts a new daemon when daemons with canceled builds do not become available"() {
        buildFile << """

     * This is the behavior in composite builds.
     */
    abstract boolean isAutoDependencySubstitution();

    def "project (#projectDep) vs external (#transitiveDep) resolves to (#winner), when preferProjectModules=#preferProjectModules and depSubstitution=#depSubstitution"() {
        given:
        //required for composite builds
        buildTestFixture.withBuildInSubDir()

}

// You can have a faster feedback loop by running `configuration-cache-report` as an included build
// See https://github.com/gradle/configuration-cache-report#development-with-gradlegradle-and-composite-build
dependencies {
    configurationCacheReportPath(libs.configurationCacheReport)
}

tasks.processResources {

        """.stripIndent()
    }

    /**
     * Generates build logic to ensure builds last for a given minimum time.
     *
     * This is used to ensure that the lastModified() timestamps actually change in between builds.
     * If the build is very fast, the timestamp of the file will not change and the JDK file watch service won't see the change.
     */

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

/**
 * Types related to the build definition for included builds.
 */

                }
                configurations['default'].outgoing.artifact(jar)
            }
        '''
        fixture.prepare()
    }

    @ToBeFixedForConfigurationCache
    def "selects and builds from master for latest.integration selector"() {
        given:
        buildFile << """
            dependencies { compile 'test:test:latest.integration' }
        """
        repo.commit("v1")

    }

    /**
     * Pause between builds for the following reasons:
     *
     * <ul>
     * <li>better simulate a normal development lifecycle where builds are rarely executed
     * back-to-back, as there is typically some work being done between the builds,</li>
     * <li>give file system events a chance to arrive; otherwise we might detect them during
     * the build, and invalidating the VFS,

class SourceDependencyIncludedBuildIntegrationTest extends AbstractIntegrationSpec {
    @Rule
    GitFileRepository repo = new GitFileRepository('buildB', temporaryFolder.getTestDirectory())

    def "source dependency cannot (yet) define any included builds"() {
        settingsFile << """
            rootProject.name = 'buildA'
            sourceControl {
                vcsMappings {
                    withModule("org.test:buildB") {