}

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

     */
    List<Capability> getRequestedCapabilities();

    /**
     * Endorse version constraints with {@link VersionConstraint#getStrictVersion()} strict versions} from the target module.
     *
     * Endorsing strict versions of another module/platform means that all strict versions will be interpreted during dependency
     * resolution as if they were defined by the endorsing module itself.
     *
     * @since 6.0
     */

kind: PeerAuthentication
metadata:
  name: valid-peer-authentication
spec:
  selector:
    matchLabels:
      app: httpbin
      version: v1
  mtls:
    mode: PERMISSIVE
  portLevelMtls:
    8080:

        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);

		if lenientErr != nil {
			// Lenient decoding failed with the current version, return the
			// original strict error.
			return nil, fmt.Errorf("failed lenient decoding: %v", err)
		}
		// Continue with the v1beta1 object that was decoded leniently, but emit a warning.
		klog.InfoS("Using lenient decoding as strict decoding failed", "err", err)
	}

	internalKC, ok := obj.(*kubeletconfig.KubeletConfiguration)
	if !ok {

) {
	ctx.Helper()
	wantSuccess := rewrite
	policyYAML := fmt.Sprintf(`apiVersion: security.istio.io/v1beta1
kind: PeerAuthentication
metadata:
  name: "mtls-strict-for-%v"
spec:
  selector:
    matchLabels:
      app: "%v"
  mtls:
    mode: STRICT
`, name, name)
	ctx.ConfigIstio().YAML(ns.Name(), policyYAML).ApplyOrFail(ctx)

	var healthcheck echo.Instance
	cfg := echo.Config{
		Namespace: ns,

        module('org', 'foo', version).with {
            participants << it
            it
        }
    }

    protected TestComponent strictly(String version) {
        prefer(version).strict()
    }

    protected void selected(ComponentResolutionState state) {
        assert details.hasSelected()
        assert details.selected == state
    }

    protected void selected(String version) {

    args:
      scoringStrategy:
        resources:
        - Name: cpu
          Weight: 1
`),
			wantErr: `strict decoding error: decoding .profiles[0].pluginConfig[0]: strict decoding error: decoding args for plugin NodeResourcesFit: strict decoding error: unknown field "scoringStrategy.resources[0].Name", unknown field "scoringStrategy.resources[0].Weight"`,
		},
		{
			name: "out-of-tree plugin args",
			data: []byte(`

	testenv.MustHaveCGO(t)

	// Make sure that the resulting binary can be put through strip.
	// Try both "strip" and "llvm-strip"; in each case ask out CC
	// command where to find the tool with "-print-prog-name" (meaning
	// that if CC is gcc, we typically won't be able to find llvm-strip).
	//
	// Interestingly, binutils version of strip will (unfortunately)
	// print error messages if there is a problem but will not return

                }
                edge("org:foo:[1.0,2.0)", "org:foo:1.1")
            }
        }
    }

    def "direct strict dependency should win over published transitive strict dependency"() {
        given:
        repository {
            'org:foo:15'()
            'org:foo:17'()
            'org:bar:1.0' {