This project collections information about where test preconditions can be satisfied.
We can use this information (i.e. by looking at the test results in Develocity) to see if we have any preconditions or combinations of preconditions, which are never satisfied – a situation which we otherwise would hardly notice.

        failure.details.actual == expectedActual
        failure.details.actualContent == expectedActualContent

        where:
        // How this works is that the test will execute all combinations of the two triples,
        // but won't change the order of the elements in each triple.
        //
        // E.g.: [null, null, null], ["actual", "actual", null] => [null, null, null, "actual", "actual", null]

                processBuilder().java
            ],
            [
                "resolveCollection",
                "resolveProviders"
            ]
        ].combinations()
    }

    def "using #snippetsFactory.summary in transform action with #task of buildSrc build is not a problem"(SnippetsFactory snippetsFactory, String task) {
        given:
        createDir("buildSrc") {

/**
 * This class executes a special test suite, checking all the allowed precondition combinations.
 *
 * <p>
 * Each combination can have three outcomes:
 * <ul>
 *     <li><b>Successful:</b> the precondition combination could be satisfied.</li>
 *     <li>
 *         <b>Skipped:</b> the precondition combination could <i>not</i> be satisfied.

        where:
        [target, parameter, injectionStyle] << [
            ScriptTarget.values(),
            ParameterKind.values(),
            InjectionStyle.values()
        ].combinations()
    }

    def '#target #injectionStyle with #parameter can react to configuration failure'() {
        given:
        withLavaLampPluginFor target, parameter, injectionStyle

/**
 * Annotation defining a set of requirements.
 * These requirements should be met per test-class or method, or else the test is ignored.
 *
 * <p>
 * Combinations are pre-defined. See {@link RequiresExtension} for more info how to introduce a new combination.
 *
 * @see RequiresExtension
 */
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.METHOD, ElementType.TYPE})
@Inherited

      "DATA", "HEADERS", "PRIORITY", "RST_STREAM", "SETTINGS", "PUSH_PROMISE", "PING", "GOAWAY",
      "WINDOW_UPDATE", "CONTINUATION",
    )

  /**
   * Lookup table for valid flags for DATA, HEADERS, CONTINUATION. Invalid combinations are
   * represented in binary.
   */
  private val FLAGS = arrayOfNulls<String>(0x40) // Highest bit flag is 0x20.
  private val BINARY =
    Array(256) {

        outputContains ':runWork FROM-CACHE'

        and:
        outputDoesNotContain expectedOutput

        where:
        [isolationMode, primitiveType] << [isolationModes(), primitiveTypes()].combinations()
        expectedOutput = expectedOutputFor(primitiveType)
    }

    @Issue('https://github.com/gradle/gradle/issues/26596')

        then:
        executedAndNotSkipped(":taskWithInputs")

        where:
        [api, pathSensitivity] << [Api.values(), [PathSensitivity.RELATIVE, PathSensitivity.ABSOLUTE, PathSensitivity.NAME_ONLY]].combinations()
    }

    def "input directories ignore empty directories by default (#api)"() {
        buildFile """
            @CacheableTask
            abstract class TaskWithInputs extends DefaultTask {

        [kotlinPluginVersion, androidPluginVersion, parallel] << [
                TestedVersions.kotlin.versions,
                TestedVersions.androidGradle.versions,
                [true, false]
        ].combinations()

        dsl = getDSL().name()
    }

    @Override
    protected int maxConfigurationCacheProblems() {
        return hasConfigurationCacheWarnings(kotlinPluginVersion) ? 2 : 0
    }