},
        {
            "name": "release",
            "attributes": {
                "buildType": "release"
            },
            "files": [ { "name": "a-1.2-release.jar", "url": "a-1.2-release.jar" } ],
            "dependencies": [ { "group": "test", "module": "c", "version": { "prefers": "2.2" } } ]
        }
    ]
}
"""

 */
package org.gradle.internal.logging.console

import org.gradle.internal.operations.OperationIdentifier
import spock.lang.Specification

class ProgressOperationTest extends Specification {

    def "message prefers status"() {
        given:
        ProgressOperation progressOperation = new ProgressOperation("STATUS", "VARIANT_CATEGORY", new OperationIdentifier(1), null)

        expect:

        when:
        changeMessage("goodbye world", first, second)

        then:
        succeeds("resolve")
    }

    @ToBeFixedForConfigurationCache
    def "prefers a source mapping defined in the root build to one defined in a nested build"() {
        given:
        vcsMapping('org.test:first', first)
        vcsMapping('org.test:second', second)

			expectedProto: protocol.UDP,
		},
		{
			name:          "resolves from port name",
			portName:      "http-something",
			expectedProto: protocol.HTTP,
		},
		{
			name:          "prefers appProto over portName",
			portName:      "http-something",
			appProto:      &https,
			expectedProto: protocol.HTTPS,
		},
		{
			name:          "resolves from appProto",
			portName:      "something-httpx",

                              optional: attributes.optional, exclusions: attributes.exclusions, rejects: attributes.rejects,
                              prefers: attributes.prefers, strictly: attributes.strictly,
                              endorseStrictVersions: attributes.endorseStrictVersions, reason: attributes.reason,
                              requireCapability: attributes.requireCapability

        locateComponent(_) >> windowsKitLookup
    }

    WindowsSdkLocator locator = new DefaultWindowsSdkLocator(legacyWindowsSdkLocator, windowsKitSdkLocator)

    def "prefers a windows kit sdk over a legacy sdk"() {
        def sdk = Mock(WindowsKitSdkInstall)

        given:
        legacySdkLookup.available >> true
        windowsKitLookup.available >> true

//
// Adding netdns=go to GODEBUG will prefer the go resolver.
// Adding netdns=cgo to GODEBUG will prefer the cgo resolver.
//
// The Resolver struct has a PreferGo field that user code
// may set to prefer the go resolver. It is documented as being
// equivalent to adding netdns=go to GODEBUG.
//
// When deciding which resolver to use, we first check the PreferGo field.
// If that is not set, we check the GODEBUG setting.

    }

    @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: