* Specifies the target machines this component should be built for.  The "machines" extension property (see {@link org.gradle.nativeplatform.TargetMachineFactory}) can be used to construct common operating system and architecture combinations.
     *
     * <p>For example:</p>
     * <pre>
     * targetMachines = [machines.linux.x86_64, machines.windows.x86_64]
     * </pre>
     *
     * @since 5.2
     */

      "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) {

	// Version detection on Wasm varies depending on the underlying runtime
	// (browser, node, etc), nor is there a standard via something like
	// WASI (see https://go.dev/issue/31105). For now, attempt a few simple
	// combinations for the convenience of reading logs at build.golang.org
	// and local development. It's not a goal to recognize all environments.
	if v, ok := node(); ok {
		return "Node.js " + v, nil
	}

	f(A, B /* ERROR "type namedB of B does not match inferred type namedA for T" */)
	f(B, A /* ERROR "type namedA of A does not match inferred type namedB for T" */)

	// Ensure that all combinations of directional and
	// bidirectional channels with a named directional
	// channel lead to the correct (named) directional
	// channel.
	B = f(a, b)
	B = f(a, B)
	B = f(b, a)
	B = f(B, a)

	B = f(a, b, B)

        outputContains ':runWork FROM-CACHE'

        and:
        outputDoesNotContain expectedOutput

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

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

    assertThat(TWO_VALUES_PAIRED_STATS.populationCovariance())
        .isWithin(ALLOWED_ERROR)
        .of(TWO_VALUES_SUM_OF_PRODUCTS_OF_DELTAS / 2);
    // For datasets of many double values, we test many combinations of finite and non-finite
    // x-values:
    for (ManyValues values : ALL_MANY_VALUES) {
      PairedStats stats = createPairedStatsOf(values.asIterable(), OTHER_MANY_VALUES);

        false       | false         | true              || ConfigurationRoles.DEPENDENCY_SCOPE
    }

    def "can not find unknown usage combinations consumable=#consumable, resolvable=#resolvable, declarable=#declarable"() {
        expect:
        !ConfigurationRoles.byUsage(consumable, resolvable, declarable).isPresent()

        where:

        ConcurrentTestUtil.poll(buildTimeout, 0.5) {
            assert !gradle.isRunning()
        }

        where:
        [inputBefore, flushBefore] << [['', ' ', 'a', 'some input', 'a' * 8192], [true, false]].combinations()
    }

    def "does not cancel continuous build when other than ctrl+d is entered"() {
        given:
        setupJavaProject()

        when:
        succeeds("build")

        then:

        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
    }