}

    @Override
    public void rejections(Collection<RejectedVersion> rejections) {
        if (rejections.isEmpty()) {
            return;
        }
        if (this.rejections == null) {
            this.rejections = new ImmutableSet.Builder<>();
        }
        this.rejections.addAll(rejections);
    }

    @Override

    /**
     * Registers the list of rejections that happened during resolution for this module.
     * This method is used for dynamic modules, when there's often more than one
     * version which can match, but we actually select (or reject) more before selecting.
     *
     * @param rejections a collection of rejected versions
     */
    void rejections(Collection<RejectedVersion> rejections);

                assert actualStrictly == version
                this
            }

            DependencyView rejects(String... rejections) {
                Set<String> actualRejects = find()?.rejectsVersion
                Set<String> expectedRejects = rejections as Set
                assert actualRejects == expectedRejects
                this
            }

				if err == nil {
					return false
				}
				// We are only checking the string literals of the rejection reasons
				// from the webhook and the k8s api server as the returned errors are not
				// k8s typed errors.
				// Note: this explicitly does NOT catch OpenAPI schema rejections - only validating webhook rejections.
				return strings.Contains(err.Error(), "denied the request")
			}

        then:
        version.requiredVersion == '1.1'
        version.preferredVersion == ''
        version.strictVersion == '1.1'
        version.rejectedVersions == []
    }

    def "can clear list of rejections"() {
        given:
        def version = new DefaultMutableVersionConstraint('1.0')
        version.reject("1.1")

        when:
        version.reject()

        then:

   Dependency path ':test:unspecified' --> 'org:foo:1.1'
   Dependency path ':test:unspecified' --> 'org:bar:1.0' (runtime) --> 'org:foo:{require 1.0; reject 1.1}'""")
    }

    void "honors multiple rejections #rejects using dynamic versions using dependency notation #rejects"() {
        given:
        repository {
            (0..5).each {
                "org:foo:1.$it"()
            }
            'org:bar:1.0' {

            versionListingResult.applyTo(target);
            attemptCollector.applyTo(target);
            target.unmatched(unmatchedVersions);
            target.rejections(rejectedVersions);
        }
    }

    private static class CandidateResult implements ModuleComponentResolveState {
        private final ModuleComponentIdentifier identifier;

        resolve.expectGraph {
            root(":", ":test:") {
                edge("org:foo:{require 1.0; reject 1.1 & 1.2}", "org:foo:1.0")
            }
        }
    }

    void "honors multiple rejections #rejects using dynamic versions using dependency notation #notation"() {
        given:
        repository {
            (0..5).each {
                "org:foo:1.$it" {
                    withModule(IvyModule) {

        where:
        thing                    | defineAsConstraint
        "dependencies"           | false
        "dependency constraints" | true
    }

    def "can add rejections to #thing"() {
        given:
        repository {
            'org.test:moduleB:1.1' {
                variant 'customVariant', [format: 'custom']
            }
            'org.test:moduleA:1.0'() {

    private final Iterable<? extends ModelProjection> projections;

    public ChainingModelProjection(Iterable<? extends ModelProjection> projections) {
        this.projections = projections;
    }

    @Override
    public <T> boolean canBeViewedAs(ModelType<T> type) {
        for (ModelProjection projection : projections) {
            if (projection.canBeViewedAs(type)) {
                return true;