runtime.Serializer
	recognizer.RecognizingDecoder
}

var _ Serializer = &serializer{}

type options struct {
	strict bool
}

type Option func(*options)

func Strict(s bool) Option {
	return func(opts *options) {
		opts.strict = s
	}
}

type serializer struct {
	metaFactory metaFactory
	creater     runtime.ObjectCreater
	typer       runtime.ObjectTyper
	options     options
}

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

 */
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"() {

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

            analysisFlags = mapOf(
                JvmAnalysisFlags.javaTypeEnhancementState to JavaTypeEnhancementState(
                    Jsr305Settings(ReportLevel.STRICT, ReportLevel.STRICT)
                ) { ReportLevel.STRICT },
            )
        )
    )

    put(JVMConfigurationKeys.SAM_CONVERSIONS, JvmClosureGenerationScheme.CLASS)
    put(JVMConfigurationKeys.PARAMETERS_METADATA, true)

// the search is aborted and true is returned. The root node is
// visited too.
// If strict, ignore edges across a path until at least one
// strict edge is found. For instance, for a chain A<=B<=C<D<=E<F,
// a strict walk visits D,E,F.
// If the visit ends, false is returned.
func (po *poset) dfs(r uint32, strict bool, f func(i uint32) bool) bool {
	closed := newBitset(int(po.lastidx + 1))
	open := make([]uint32, 1, 64)

        this.scope = scope;
        this.strict = true;
        return this;
    }

    public ServiceRegistry build() {
        ServiceRegistry[] parents = this.parents.toArray(new ServiceRegistry[0]);

        DefaultServiceRegistry registry = scope != null
            ? new ScopedServiceRegistry(scope, strict, displayName, parents)
            : new DefaultServiceRegistry(displayName, parents);

      app: a
  mtls:
    mode: DISABLE
---
apiVersion: security.istio.io/v1beta1
kind: PeerAuthentication
metadata:
  name: "b-strict"
  annotations:
    test-suite: "beta-mtls-automtls-workload"
spec:
  selector:
    matchLabels:
      app: b
  mtls:
    mode: STRICT
  portLevelMtls:
    # 8090 is the targetPort for service http port.
    8090:
      mode: DISABLE

import org.gradle.api.artifacts.dsl.LockMode

class DependencyLockingStrictModeIntegrationTest extends AbstractValidatingLockingIntegrationTest {

    @Override
    LockMode lockMode() {
        LockMode.STRICT
    }

    def 'fails without lock file present and does not create one'() {
        mavenRepo.module('org', 'foo', '1.0').publish()

        buildFile << """
dependencyLocking {
    lockAllConfigurations()

        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']