Name:    clusterIPsSet,
		Type:    ipvX_addr,
		Comment: ptr.To("Active ClusterIPs"),
	})

	// reject traffic to invalid ports of ClusterIPs.
	tx.Add(&knftables.Rule{
		Chain: clusterIPsCheckChain,
		Rule: knftables.Concat(
			ipX, "daddr", "@", clusterIPsSet, "reject",
		),
		Comment: ptr.To("Reject traffic to invalid ports of ClusterIPs"),
	})

	// drop traffic to unallocated ClusterIPs.

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

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

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

    @Override

// 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:

		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

    @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>

import org.gradle.api.artifacts.ComponentMetadata;

import java.util.List;

/**
 * A version selector which is the union of other selectors. This is used by the
 * "rejects" clauses of version constraints, where each reject is turned into a
 * version selector, then the whole selector is the union of all of them.
 */
public class UnionVersionSelector implements CompositeVersionSelector {
    private final List<VersionSelector> selectors;