## Modify test for regression search

First, you should change the test so that
 - only the version you are interested in is used as a reference
 - only the test you are interested in is executed
 - tighten the regression limits to get significant results
 - only search for memory/execution time regressions depending on what you are interested in
 

public class GradleVersionSpec {
    private GradleVersion lowestTestedVersion = getLowestTestedVersion();

    private static GradleVersion getLowestTestedVersion() {
        String property = System.getProperty("org.gradle.integtest.crossVersion.lowestTestedVersion");
        if(property == null) {
            return GradleVersion.version("0.0");
        }
        return GradleVersion.version(property);
    }

    public GradleVersionSpec() {

	apis := fuzzAPIGroups(1, 3, 10)
	manager.SetGroups(apis.Items)

	interests := []string{"aggregator_discovery_aggregation_count_total"}

	_, _, _ = fetchPath(manager, "application/json", discoveryPath, "")
	// A single fetch should aggregate and increment regeneration counter.
	if err := testutil.GatherAndCompare(legacyregistry.DefaultGatherer, formatExpectedMetrics(1), interests...); err != nil {
		t.Fatal(err)
	}

 *
 * Facilitates running the same test in different execution modes.
 */
public class GradleContextualExecuter extends AbstractDelegatingGradleExecuter {

    private static final String EXECUTER_SYS_PROP = "org.gradle.integtest.executer";

    private Executer executerType;

    private enum Executer {
        embedded(false),
        forking(true),
        noDaemon(true),
        parallel(true, true),
        configCache(true),

## Major Themes

Kubernetes is developed by community members whose work is organized into
[Special Interest Groups][]. For the 1.8 release, each SIG provides the
themes that guided their work.

[Special Interest Groups]: https://github.com/kubernetes/community/blob/master/sig-list.md

### SIG API Machinery

}

sourceSets {
    create("integTest")
}

val taskProvider = tasks.register<Test>("integTest") {
    classpath = sourceSets["integTest"].runtimeClasspath
    testClassesDirs = sourceSets["integTest"].output.classesDirs
}

val TaskContainer.integTest: TaskProvider<Test> get() = taskProvider // define accessor we would get if 'integTest' was defined in plugin

// tag::integTest[]
tasks.integTest {

plugins {
    id('java-library')
}

sourceSets {
    integTest
}

tasks.register("integTest", Test) {
    classpath = sourceSets.integTest.runtimeClasspath
    testClassesDirs = sourceSets.integTest.output.classesDirs
}

// tag::integTest[]
tasks.named('integTest') {
    inputs.property("operatingSystem") {
        System.getProperty("os.name")
    }
}
// end::integTest[]

// tag::distributionPathInput[]

    }

    @Nullable
    public TestFile getBinDistribution() {
        return optionalFile("integTest.binDistribution");
    }

    @Nullable
    public TestFile getAllDistribution() {
        return optionalFile("integTest.allDistribution");
    }

    @Nullable
    public TestFile getDocsDistribution() {
        return optionalFile("integTest.docsDistribution");

                    }
                }
                integTest(JvmTestSuite) {
                    useJUnit()
                }
            }
        }

        tasks.named('check') {
            dependsOn testing.suites.integTest
        }

        tasks.register('checkConfiguration') {
            dependsOn test, integTest
            def testCompile = configurations.testCompileClasspath

        testing {
            suites {
                test {
                    useJUnit()
                }
                integTest(JvmTestSuite) // implicitly uses JUnit Jupiter
            }
        }

        tasks.named('check') {
            dependsOn testing.suites.integTest
        }
        """

        file('src/test/java/example/UnitTest.java') << '''
            package example;