def setup() {
        resolve.prepare()
        resolve.addDefaultVariantDerivationStrategy()
        settingsFile << """
            rootProject.name = 'testproject'
        """
    }

    @Requires(UnitTestPreconditions.Online)
    def "resolves dependencies on real projects"() {
        // Real but ancient projects

        given:
        def repo1 = ivyHttpRepo('ivy-repo-a')
        def module1 = repo1.module('org.gradle', 'testproject', '1.0').publish()
        def repo2 = ivyHttpRepo('ivy-repo-b')
        def module2 = repo2.module('org.gradle', 'testproject', '1.0').publishWithChangedContent()

        and:
        createDirs("a", "b")
        settingsFile << "include 'a','b'"
        buildFile << """

     * in the flakiness detection builds divided by the total number of runs of the scenario.
     *
     * <pre>
     *  SELECT TESTID, TESTPROJECT, AVG(CONVERT(CASEWHEN(DIFFCONFIDENCE &gt; 0.97, 1, 0), DECIMAL)) AS FAILURE_RATE,
     *  FROM TESTEXECUTION
     *  WHERE (CHANNEL = 'flakiness-detection-master' OR CHANNEL = 'flakiness-detection-release')
     *  GROUP BY TESTID

        return "$scenarioName | $testProject | ${scenarioClass.substring(scenarioClass.lastIndexOf(".") + 1)}"
    }

    String getScenarioName() {
        return performanceExperiment.scenario.testName
    }

    String getScenarioClass() {
        return performanceExperiment.scenario.className
    }

    String getTestProject() {
        return performanceExperiment.testProject
    }

    boolean isCrossVersion() {

import model.CIBuildModel
import model.Stage

class TestPerformanceTest(model: CIBuildModel, stage: Stage) : BaseGradleBuildType(stage, init = {
    val os = Os.LINUX
    val buildTypeThis = this
    val testProject = "smallJavaMultiProject"

    fun BuildSteps.gradleStep(tasks: List<String>) {
        gradleWrapper {
            name = "GRADLE_RUNNER"
            gradleParams = (
                tasks +

        List<JUnitTestCase> testCases = testSuite.testCases ?: []
        return testCases.findAll { !it.skipped }.collect {
            def agentName = System.getenv("BUILD_AGENT_NAME") ?: null
            new ScenarioBuildResultData(
                scenarioName: it.name,
                scenarioClass: it.className,
                testProject: testProject,

            allowEmpty = true,
            description = "The baselines you want to run performance tests against. Empty means default baseline."
        )
        text(
            "testProject",
            "",
            display = ParameterDisplay.PROMPT,
            allowEmpty = false,
            description = "The test project to use. E.g. largeJavaMultiProject"
        )

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

package org.gradle.performance.fixture;

public interface IncrementalTestProject extends TestProject {
    void configureForAbiChange(CrossVersionPerformanceTestRunner runner);
    void configureForAbiChange(GradleBuildExperimentSpec.GradleBuilder builder);

        assertEquals(Arrays.asList("parent", "module-b", "module-a"), reactorOrder);
    }

    private <T> List<String> getReactorOrder(String testProject, Class<T> participant) throws Exception {
        PlexusContainer container = getContainer();

        ComponentDescriptor<T> cd = new ComponentDescriptor<>(participant, container.getContainerRealm());

        def module = publishModule("org.gradle.integtests.resolve", "testproject", "1.0-SNAPSHOT")

        and: "Server handles requests"
        expectModuleServed(module)

        and:
        run 'retrieve'

        then:
        file('build').assertHasDescendants('testproject-1.0-SNAPSHOT.jar')
        def snapshot = file('build/testproject-1.0-SNAPSHOT.jar').assertIsCopyOf(module.artifactFile).snapshot()