return descriptorClass.cast(metadataProvider.getIvyModuleDescriptor());
            }
        }
        return null;
    }

    @Override
    public void reject(String reason) {
        rejected = true;
        rejectionReason = reason;
    }

    @Override
    public boolean isRejected() {
        return rejected;
    }

    @Override

		add chain ip kube-proxy reject-chain { comment "helper for @no-endpoint-services / @no-endpoint-nodeports" ; }
		add rule ip kube-proxy reject-chain reject

		add map ip kube-proxy no-endpoint-services { type ipv4_addr . inet_proto . inet_service : verdict ; comment "vmap to drop or reject packets to services with no endpoints" ; }

		clientErr, _ := boringHandshake(t, clientConfig, serverConfig)

		if (clientErr == nil) == ok {
			if ok {
				t.Logf("%s: accept", desc)
			} else {
				t.Logf("%s: reject", desc)
			}
		} else {
			if ok {
				t.Errorf("%s: BAD reject (%v)", desc, clientErr)
			} else {
				t.Errorf("%s: BAD accept", desc)
			}
		}
	}

	// server verifying client cert

// a syscall (in the tracer's model). Because the actual
// m can be reused, it's possible for that m to have never
// had its P (in _Psyscall) stolen if the runtime doesn't
// model the scenario correctly. Make sure we reject such
// traces.

package main

import (
	"internal/trace"
	"internal/trace/event/go122"
	testgen "internal/trace/internal/testgen/go122"
)

func main() {
	testgen.Main(gen)
}

        output.contains "** Accepted version: 1.3.0"

        where:
        dsl << ['groovy', 'kotlin']
    }

    @UsesSample("dependencyManagement/customizingResolution-selectionRule")
    def "can run reject sample with #dsl dsl"() {
        executer.inDirectory(sample.dir.file(dsl))

        when:
        run "printRejectConfig"

        then:
        output.contains "Resolved: api-1.4.jar"

        where:

    @Nullable
    <T> T getDescriptor(Class<T> descriptorClass);

    /**
     * Rejects the candidate for the resolution.
     *
     * @param reason The reason the candidate was rejected.
     */
    void reject(String reason);

        then:
        _ * componentSelectionRules.rules >> rules({ ComponentSelection selection ->
            if (selection.candidate.version != '1.3') {
                selection.reject("rejected")
            }
        })
        1 * selectedComponentResult.getContentFilter() >> null
        1 * selectedComponentResult.notMatched(c.id, _)

	// in log messages.  This method always returns quickly (without
	// waiting for the request to be dequeued).  If this method
	// returns a nil Request value then caller should reject the
	// request and the returned bool indicates whether the QueueSet
	// was idle at the moment of the return.  Otherwise idle==false
	// and the client must call the Finish method of the Request
	// exactly once.

May be followed by a `because` text.

| Was requested : reject version <versions>
| The dependency appears with a <<rich_versions#rich-version-constraints, rich version>> containing one or more `reject`.
May be followed by a `because` text.

| By conflict resolution : between versions <version>

            this
        }

        @Override
        void addCause(ComponentSelectionDescriptorInternal componentSelectionDescriptor) {

        }

        @Override
        void reject() {

        }

        @Override
        String getVersion() {
            id.version
        }

        String toString() { id }

        @Override