*/
package org.gradle.integtests.resolve.strict

import org.gradle.integtests.fixtures.GradleMetadataResolveRunner
import org.gradle.integtests.fixtures.RequiredFeature
import org.gradle.integtests.resolve.AbstractModuleDependencyResolveTest

class StrictVersionConstraintsFeatureInteractionIntegrationTest extends AbstractModuleDependencyResolveTest {
    def "can turn constraint into strict constraint by using a component metadata rule"() {

// A poset edge. The zero value is the null/empty edge.
// Packs target node index (31 bits) and strict flag (1 bit).
type posetEdge uint32

func newedge(t uint32, strict bool) posetEdge {
	s := uint32(0)
	if strict {
		s = 1
	}
	return posetEdge(t<<1 | s)
}
func (e posetEdge) Target() uint32 { return uint32(e) >> 1 }
func (e posetEdge) Strict() bool   { return uint32(e)&1 != 0 }
func (e posetEdge) String() string {

====

[[sec:strict-version-consequences]]
=== Consequences of using strict versions

Using a strict version must be carefully considered, in particular by library authors.
As the _producer_, a strict version will effectively behave like a _force_: the version declaration takes precedence over whatever is found in the transitive dependency graph.

   Constraint path ':test:unspecified' --> 'org:platform-b:1.0' (runtime) --> 'org:foo:{strictly 2.0}'"""
    }

    def "a module from which strict versions are endorsed can itself be influenced by strict versions endorsed form elsewhere"() {
        given:
        repository {
            'org:platform:1.0'() {
                constraint(group: 'org', artifact: 'foo', strictly: '1.0')

import org.gradle.test.fixtures.ivy.IvyModule
import spock.lang.Issue

abstract class AbstractRichVersionConstraintsIntegrationTest extends AbstractModuleDependencyResolveTest {

    void "can declare a strict dependency onto an external component"() {
        given:
        repository {
            'org:foo:1.0'()
        }

        buildFile << """
            dependencies {
                conf('org:foo:1.0!!')

                }
                module('org:bar:1.0') {
                    edge('org:foo:2.0', 'org:foo:1.0')
                }
            }
        }
    }

    def "a strict constraint wins over a nested strict constraint"() {
        boolean publishedConstraintsSupported = gradleMetadataPublished

        given:
        repository {
            'org:a:1.0' {

        then:
        LockfileFixture.verifyCustomLockfile(lockFile, 'classpath', ['org.foo:foo-plugin:1.1'])
    }

    def 'strict locks on buildscript classpath does not mean strict locks on project (initial unique: #unique)'() {
        given:
        mavenRepo.module('org.foo', 'foo-plugin', '1.0').publish()
        mavenRepo.module('org.foo', 'foo-plugin', '1.1').publish()

   matchLabels:
     app: foo
 mtls:
   mode: STRICT
 portLevelMtls:
   9000:
     mode: DISABLE
---`
	paDisableWithStrictOnPort9000 := `
apiVersion: security.istio.io/v1beta1
kind: PeerAuthentication
metadata:
 name: default
spec:
 selector:
   matchLabels:
     app: foo
 mtls:
   mode: DISABLE
 portLevelMtls:
   9000:
     mode: STRICT
---`
	paDisableWithPermissiveOnPort9000 := `

    }

    def 'fails with missing lockfile in strict mode (Unique: #unique)'() {
        given:
        provider.getLockMode().set(LockMode.STRICT)

        when:
        provider.loadLockState('conf', owner)

        then:
        def ex = thrown(MissingLockStateException)
        1 * owner.getCapitalizedDisplayName() >> "Owner"
        ex.message == 'Locking strict mode: Owner is locked but does not have lock state.'

        Class<?> fromRawClazz = getRawType(from);
        if (strict && !toRawClazz.equals(fromRawClazz)) {
            return false;
        }
        if (!strict && !toRawClazz.isAssignableFrom(fromRawClazz)) {
            return false;
        }
        if (toRawClazz.isArray()) {
            return true;
        }
        Type[] fromTypeArguments = getActualTypeArguments(from);