Justin Van Dort <******@****.***> 1717185987 -0400

    }

    def "throws exception when single values are not found"() {
        when:
        checkValidCombinations(["nonexistent1", "nonexistent2"])

        then:
        final ex = thrown(IllegalArgumentException)
        ex.message.startsWith("Requested requirements [nonexistent1, nonexistent2] were not in the list of accepted combinations.")
    }

    """Tests that parameter_combinations returns correct combinations."""
    test_parameters = [{
        'shapes': [
            [3, 3],
            [3, None],
        ],
        'has_bias': [True, False],
    }]
    combinations = testing.parameter_combinations(test_parameters)

    self.assertLen(combinations, 4)
    self.assertIn({'shapes': [3, 3], 'has_bias': True}, combinations)

    strategy_combinations.one_device_strategy_gpu,
    strategy_combinations.tpu_strategy,
]


class MnistTrainTest(test_util.TensorFlowTestCase, parameterized.TestCase):

  @combinations.generate(combinations.combine(strategy=strategies))
  def testMnistTrain(self, strategy):
    accuracy = mnist_train.main(strategy)
    self.assertGreater(accuracy, 0.7, 'accuracy sanity check')


if __name__ == '__main__':

            }
            val combinations = buildList { combinations(typesToCheckOn, persistentListOf(), typeParameters.size) }
            check(combinations.size == typesToCheckOn.size.toDouble().pow(typeParameters.size).toInt())
            val allSubstitutors = buildList {
                combinations.forEach { typesPermutation ->

package org.gradle.integtests.resolve.attributes


import org.gradle.integtests.fixtures.AbstractIntegrationSpec

class ExclusiveVariantsIntegrationTest extends AbstractIntegrationSpec {
    def "matching attribute combinations and capability #capability fails to resolve"() {
        given:
        buildFile << """
            plugins {
                id 'java'
            }

            configurations {
                sample1 {

        if (!found) {
            String message = String.format(
                "Requested requirements [%s] were not in the list of accepted combinations. " +
                    "Add it to 'subprojects/internal-testing/src/main/resources/valid-precondition-combinations.csv' to be accepted. " +
                    "See the documentation of this class to learn more about this feature.",
                String.join(", ", predicateClassNames)

 * <p>
 * If you need a new combination of {@link TestPrecondition} classes, go to {@code subprojects/internal-testing/src/main/resources/valid-precondition-combinations.csv} and simply add it.
 * <p>

            return createCacheBuilder(
                (Integer) combination.get(0),
                (Integer) combination.get(1),
                (Integer) combination.get(2),
                (DurationSpec) combination.get(3),
                (DurationSpec) combination.get(4),
                (DurationSpec) combination.get(5),
                (Strength) combination.get(6),

                                     "System.clearProperty(*['some.property'])",
                                     "clearProperty('some.property')",
                                 ], [false, true]].combinations()
        indyStatus = enableIndy ? "with indy" : "without indy"
    }

    def "#setProperties is instrumented in dynamic Groovy #indyStatus"() {
        def configurationCache = newConfigurationCacheFixture()