}

    @Issue("gradle/gradle#4186")
    def "should choose highest when multiple prefer versions disagree"() {
        repository {
            'org:bar:1' {
                dependsOn(group: 'org', artifact: 'foo', prefers: '1.1')
            }
            'org:baz:1' {
                dependsOn(group: 'org', artifact: 'foo', prefers: '1.0')
            }
            'org:foo' {
                '1.0'()

        analyser().collectFailures(failure, result)

        then:
        result.size() == 1
        def transformedFailure = result[0]
        transformedFailure.is(cause)
    }

    def 'prefers script exception over contextual exception'() {
        given:
        def cause = new GradleScriptException("broken", new ContextualException())
        def failure = new TaskExecutionException(null, cause)

        "TestSuite" | "LinuxTest"  | null           | "testSuite/linuxTest"
        "TestSuite" | "LinuxTest"  | "bin-files"    | "bin-files/testSuite/linuxTest"
    }

    def "prefers role over binary type in output directory names"() {
        def namingScheme = DefaultBinaryNamingScheme.component("testSuite").withBinaryType("GoogleTestExecutable").withVariantDimension("linux")

        expect:

        return attributeContainerSerializer.read(decoder);
    }

    ImmutableVersionConstraint readVersionConstraint(Decoder decoder) throws IOException {
        String requires = decoder.readString();
        String prefers = decoder.readString();
        String strictly = decoder.readString();
        int rejectCount = decoder.readSmallInt();
        List<String> rejects = Lists.newArrayListWithCapacity(rejectCount);

        "a->a(*),b(*);b->b(*)"  | ["projectB-a-1.5.jar", "projectB-b-1.5.jar", "projectC-1.7.jar", "projectD-1.7.jar"]
    }

    def "prefers revConstraint over rev when dynamic resolve mode is used"() {
        given:
        buildFile << """
configurations {
    compile
}
dependencies {
    repositories {
        ivy {

        schema.accept(usage, "requested", "best")
        schema.prefer(usage, "best")
        def other = Attribute.of('other', String)
        schema.attribute(other)
        schema.accept(other, "requested", "compatible")
        schema.accept(other, "requested", "best")
        schema.prefer(other, "best")

        def candidate1 = attributes(usage: "best", other: "compatible")

        // rules are called in order
        closureCalled == 0..7
    }

    // Short circuiting tests will need to be removed once the extra param feature is removed
    def "short-circuit prefers non-metadata rules over rules requiring metadata"() {
        def metadataProvider = Mock(MetadataProvider)
        def closuresCalled = []

        when:
        rule { ComponentSelection cs -> closuresCalled << 0 }

- `requires`: optional. The required version for this dependency.
- `prefers`: optional. The preferred version for this dependency.
- `strictly`: optional. A strictly enforced version requirement for this dependency.
- `rejects`: optional. An array of rejected versions for this dependency.

        // all other matching attempts are not compatible
        _ * attributeMatcher.isMatching(_ ,_) >> false
        0 * attributeMatcher._
    }

    def "prefers direct transformation over indirect"() {
        def requested = AttributeTestUtil.attributes([usage: "requested"])

        def fromSource = AttributeTestUtil.attributes([usage: "fromSource"])

            }
            if (version.requires != null) {
                write("requires", version.requires);
            }
            if (version.preferred != null) {
                write("prefers", version.preferred);
            }
            if (!version.rejectedVersions.isEmpty()) {
                writeArray("rejects", version.rejectedVersions);
            }
        });
    }