when:
        def result = serialize(newSelector(UTIL, constraint(version, strict, rejects), attributes(foo: 'bar'), [capability("foo")]), serializer)

        then:
        result == newSelector(UTIL, constraint(version, strict, rejects), attributes(foo: 'bar'), [capability("foo")])

        where:
        version | strict   | rejects
        '5.0'   | ''       | []
        '5.0'   | ''       | ['1.0']

import org.gradle.test.fixtures.dsl.GradleDsl

import static org.junit.Assume.assumeFalse


class VersionNumberIntegrationTest extends AbstractIntegrationSpec {

    def "nullability with Kotlin jsr-305 strict"() {
        assumeFalse(GradleContextualExecuter.embedded)

        given:
        file("src/main/kotlin/Test.kt") << """
            import org.gradle.util.internal.VersionNumber

            fun test() {

```yaml
apiVersion: security.istio.io/v1beta1
kind: PeerAuthentication
metadata:
  name: strict-and-permissive-mtls
spec:
  selector:
    matchLabels:
      app: a
  mtls:
    mode: STRICT
  portLevelMtls:
    9090:
      mode: PERMISSIVE
```

will be translated into this `Authorization`:

```yaml
action: DENY
groups:
- rules:

   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 := `

	_ = *intp    // ERROR "removed nil check"
	_ = *arrayp  // ERROR "removed nil check"
	_ = *structp // ERROR "generated nil check"
	_ = *emptyp  // ERROR "generated nil check"
	_ = *arrayp  // ERROR "removed nil check"
}

func f2() {
	var (
		intp       *int
		arrayp     *[10]int
		array0p    *[0]int
		bigarrayp  *[1 << 20]int
		structp    *Struct
		bigstructp *BigStruct
		emptyp     *Empty
		empty1p    *Empty1
	)

John Howard <******@****.***> 1709232034 -0800

strict digraph full {

    }

    private static CapabilityNotationParser createSingletonConverter(boolean strict) {
        NotationParser<Object, Capability> parser = NotationParserBuilder.toType(Capability.class)
            .converter(new StringNotationParser(strict))
            .converter(strict ? new StrictCapabilityMapNotationParser() : new LenientCapabilityMapNotationParser())
            .toComposite();

groovy-with-ref2 = { group = "org.codehaus.groovy", name = "groovy", version.ref = "rich-groovy" }
groovy-with-ref3 = { group = "org.codehaus.groovy", name = "groovy", version.ref = "version-with-bang" }

strict-with-bang = "g:a:1.1!!"
strict-with-bang-and-range = { module="g:a", version="[1.0,2.0]!!1.1"}

[versions]
groovy = "2.5.6"
rich-groovy = { strictly = "[2.5, 3.0[", prefer = "2.5.6" }

 * limitations under the License.
 */
package org.gradle.api.artifacts.verification;

/**
 * The different dependency verification modes. By default, Gradle
 * will use the strict mode, which means that it will verify dependencies
 * and fail <i>as soon as possible</i>, to avoid as much compromising of
 * the builds as possible.
 *
 * There are, however, two additional modes which can be used: the lenient