def "can serialize and deserialize a validation problem"() {
        given:
        def problem = problemReporter.create {
            it.id("id", "label", GradleCoreProblemGroup.validation())
        }

        when:
        def json = gson.toJson([problem])
        def deserialized = ValidationProblemSerialization.parseMessageList(json)

        then:

def ComplexTensor : TensorOf<[AnyComplex]>;
def RealTensor : TensorOf<[AnySignlessInteger, AnyFloat]>;

def LowerSquareOp : Pat<(TF_SquareOp $val), (TF_MulOp $val, $val)>;

def LowerSquaredDifferenceOpOnRealTensors : Pat<
  (TF_SquaredDifferenceOp RealTensor: $lhs, RealTensor:$rhs),
  (TF_SquareOp (TF_SubOp $lhs, $rhs))>;

def LowerSquaredDifferenceOpOneComplexTensors : Pat<

    }

    def "can override values from descriptor"() {
        def id = DefaultModuleComponentIdentifier.newId(DefaultModuleIdentifier.newId("group", "module"), "version")
        def newId = DefaultModuleComponentIdentifier.newId(DefaultModuleIdentifier.newId("group", "module"), "1.2")
        def sources = ImmutableModuleSources.of(Stub(ModuleSource))

        def metadata = mavenMetadataFactory.create(id, [])

        def extId = DefaultModuleComponentIdentifier.newId(DefaultModuleIdentifier.newId('group', 'external'), '1.0')
        def attributes = AttributeTestUtil.attributesFactory().mutable()
        attributes.attribute(Attribute.of('type', String), 'custom')
        attributes.attribute(Attribute.of('format', String), 'jar')
        def v1Result = Mock(ResolvedVariantResult)
        def v1State = Mock(VariantGraphResolveState) {

class IntQuestionPromptEventTest extends Specification {
    def "formats prompt"() {
        def event = new IntQuestionPromptEvent(123, "question?", 2, 4)
        assert event.prompt == "enter value (min: 2, default: 4): "
    }

    def "accepts valid input"() {
        def event = new IntQuestionPromptEvent(123, "question?", 2, 4)

        expect:
        def result = event.convert(input)
        result.response == expected

        0 * _._
    }

    def "creates a new implementation when classpath has not been seen before"() {
        def connection1 = Mock(ConsumerConnection)
        def connection2 = Mock(ConsumerConnection)
        def distribution1 = Mock(Distribution)
        def distribution2 = Mock(Distribution)

        when:

        configurationCache.assertStateLoaded()
    }

    def "can publish ivy publication metadata to remote repository"() {
        def username = "someuser"
        def password = "somepassword"
        def projectConfig = configureProject(username, password, "ivyRepo", false)
        def configurationCache = newConfigurationCacheFixture()
        def metadataFile = file('build/publications/ivy/module.json')

        expect:

        1 * redirector.setOutputOwner("2")
        0 * _
    }

    def "when test completes its parent will be the owner of output"() {
        def test = new DefaultTestDescriptor("2", "Bar", "Baz")
        def testEvent = new TestStartEvent(2, "99")
        def complete = new TestCompleteEvent(1)

        processor.started(new DefaultTestSuiteDescriptor("1", "Foo"), new TestStartEvent(1))
        processor.started(test, testEvent)

    def 'reset a cloned repository with local commits'() {
        given:
        def target = tmpDir.file('versionDir')
        gitVcs.populate(target, repoHead, repoSpec)

        def removed = target.file("source.txt")
        removed.delete()
        def changed = target.file("dir/another.txt")
        changed << "changed!"

        def targetRepo = GitFileRepository.init(target)

        def fromFirstExtraction = extractor.extract(AbstractPropertyRules)
        def fromSecondExtraction = extractor.extract(AbstractPropertyRules)

        then:
        !fromFirstExtraction.is(fromSecondExtraction)
    }

    def "cache does not hold strong references"() {
        given:
        def cl = new GroovyClassLoader(getClass().classLoader)
        def source = cl.parseClass('''
            import org.gradle.model.*