expect:
        spec.isSatisfiedBy(new StackTraceElement("ClassName", "methodName", "SomeFile.java", 42))
        spec.isSatisfiedBy(new StackTraceElement("ClassName", "methodName", "OtherFile.java", 21))
        spec.isSatisfiedBy(new StackTraceElement('ClassName$1', "methodName", "ClassName.java", 21))
        spec.isSatisfiedBy(new StackTraceElement('ClassName$1$22', "methodName", "ClassName.kt", 21))
    }

        !spec.isSatisfiedBy(GradleVersion.version("1.0"))
        !spec.isSatisfiedBy(GradleVersion.version("1.0-milestone-9"))
        !spec.isSatisfiedBy(GradleVersion.version("1.0-snapshot-1"))
        !spec.isSatisfiedBy(GradleVersion.version("1.0-rc-1"))
        !spec.isSatisfiedBy(GradleVersion.version("1.0-12341010120000+1000"))

        spec.isSatisfiedBy(GradleVersion.version("1.1"))

        when:
        task.onlyIf(spec)

        then:
        !task.getOnlyIf().isSatisfiedBy(task)
    }

    def "can specify onlyIf predicate using description and spec"() {
        given:
        final task = getTask()
        final Spec<Task> spec = Mock(Spec.class)
        spec.isSatisfiedBy(task) >> false

        expect:
        task.getOnlyIf().isSatisfiedBy(task)

        expect:
        task.getOnlyIf().isSatisfiedBy(task)

        when:
        task.onlyIf(spec)

        then:
        spec.isSatisfiedBy(task) >> false
        assertFalse(task.getOnlyIf().isSatisfiedBy(task))
    }

    def onlyIfPredicateIsTrueWhenTaskIsEnabledAndAllPredicatesAreTrue() {
        final MutableBoolean condition1 = new MutableBoolean(true)

        def spec = factory.createSpec(source)
        spec.isSatisfiedBy(element("a/b/c.groovy"))
        spec.isSatisfiedBy(element("1/c/d/e.java"))

        !spec.isSatisfiedBy(element("c/a/b/d.java"))
        !spec.isSatisfiedBy(element("a/c/d.java"))
        !spec.isSatisfiedBy(element("a/c/d/e.groovy"))

        // Default excludes
        !spec.isSatisfiedBy(element("/.git/refs"))
    }

        truncationPointDetector.isSatisfiedBy(_) >>> [false, false, true, false]

        def spec = new TruncatedStackTraceSpec(truncationPointDetector)
        def element = new StackTraceElement("foo", "bar", "baz", 42)

        expect:
        !spec.isSatisfiedBy(element)
        !spec.isSatisfiedBy(element)
        spec.isSatisfiedBy(element)
        spec.isSatisfiedBy(element)
        spec.isSatisfiedBy(element)
    }

        def spec = parser.parseNotation(new Spec<DependencyResult>() {
            boolean isSatisfiedBy(DependencyResult element) {
                return element.requested.module == 'mockito-core'
            }
        })

        then:
        spec.isSatisfiedBy(mockito)
        !spec.isSatisfiedBy(other)
    }

    def "fails neatly for unknown notations"() {
        when:
        parser.parseNotation(['not supported'])

        expect:
        new DependencyResultSpec(notation).isSatisfiedBy(newDependency("org.foo", "foo-core", "1.0"))

        where:
        notation << ['org', 'org.foo', 'foo-core', '1.0', 'org.foo:foo-core', 'org.foo:foo-core:1.0']
    }

    def "knows mismatching dependencies"() {
        expect:
        !new DependencyResultSpec(notation).isSatisfiedBy(newDependency("org.foo", "foo-core", "1.0"))

        where:

        1 * resolver.selectWithName("b", projectModel1, false) >> selectionResult
        _ * selectionResult.collectTasks(_) >> { it[0] << excluded }
        0 * _

        and:
        !filter.isSatisfiedBy(excluded)
        filter.isSatisfiedBy(notExcluded)
    }

    def "qualified exclude filter configures target project and selects matching tasks from all candidates when subprojects not included"() {
        def excluded = Stub(Task)

        _ * connection.daemon >> daemon('1')
        _ * connection2.daemon >> daemon('2')

        1 * connector.maybeConnect(_) >> { ExplainingSpec spec ->
            assert spec.isSatisfiedBy(d1)
            assert spec.isSatisfiedBy(d2)
            connection
        }
        1 * connection.dispatch({it instanceof Stop})
        1 * connection.receive() >> new Success(null)