for ix := range keys {
		stringKeys[ix] = keys[ix].String()
	}
	sort.Strings(stringKeys)

	for _, key := range stringKeys {
		provider := providers[key]
		if provider.Enabled() {
			klog.V(4).Infof("Registering credential provider: %v", key)
			keyring.Providers = append(keyring.Providers, provider)
		}
	}

	return keyring

// the ServerShutdownSignal interface instance.
func WithServerShutdownSignal(parent context.Context, window ServerShutdownSignal) context.Context {
	if ServerShutdownSignalFrom(parent) != nil {
		return parent // Avoid double registering.
	}

	return context.WithValue(parent, serverShutdownSignalKey, window)

     *
     * @param alias an identifier for the version
     * @param version the version alias name
     */
    String version(String alias, String version);

    /**
     * Entry point for registering a library alias.
     *
     * @param alias the alias of the library
     * @param group the group of the library
     * @param artifact the artifact ID of the library

====


## Receiving a problem report

Problems are emitted as Tooling API progress events. They can be processed by registering a `ProgressListener`:

====
include::sample[dir="groovy",files="sample-ide/src/main/java/org/gradle/sample/SampleIde.java[tags=problems-tapi-event]"]

// Interface for an Operation capabilities which should be tied to
// a specific hardware.
// Users should implement the interface and use TargetHardwareOpRegistration
// for registering the operation.
class TargetHardwareOperation {
 public:
  virtual ~TargetHardwareOperation() = default;

  virtual double GetOpCost(mlir::Operation* op) const = 0;

 * (i.e. the <i>main</i> artifact) or the ones that will be used when building <i>tests</i>).
 * <p>
 * This extensible enum has two defined values, {@link #MAIN} and {@link #TEST},
 * but can be extended by registering a {@code org.apache.maven.api.spi.ProjectScopeProvider}.
 * <p>
 * Implementation must have {@code equals()} and {@code hashCode()} implemented, so implementations of this interface
 * can be used as keys.
 *

	if err == nil {
		t.Error("expected error registering ReplyNotPointer")
	}
	err = Register(new(ArgNotPublic))
	if err == nil {
		t.Error("expected error registering ArgNotPublic")
	}
	err = Register(new(ReplyNotPublic))
	if err == nil {
		t.Error("expected error registering ReplyNotPublic")
	}
	err = Register(NeedsPtrType(0))
	if err == nil {
		t.Error("expected error registering NeedsPtrType")

/**
 * A view of the properties of a task.
 *
 * This includes inputs, outputs, destroyables and local state properties.
 *
 * Once created, the view is immutable and registering additional or changing existing task properties will not be detected.
 *
 * Created by {@link DefaultTaskProperties#resolve(PropertyWalker, FileCollectionFactory, TaskInternal)}.
 */
@NonNullApi

//	                      Out                                    Out                            Out
//
// The pluginwatcher module follows strictly and sequentially this state machine for each *plugin name*.
// e.g: If you are Registering a plugin foo, you cannot get a DeRegister call for plugin foo
// until the Register("foo") call returns. Nor will you get a Validate("foo", "Different endpoint", ...)
// call until the Register("foo") call returns.
//

        then:
        0 * validator.validateMutation(_)
    }

    def "registering an all rule toggles the hasRule flag"() {
        given:
        def action = Mock(Action)

        when:
        substitutions.all(action)

        then:
        substitutions.rulesMayAddProjectDependency()
    }

    def "registering a substitute rule with (#from, #to) causes hasRule #result"() {
        given: