errs = append(errs, fmt.Errorf("plugins %v in RecommendedPluginOrder are not registered",
			recommendPlugins.Difference(intersections).List()))
	}
	if !intersections.Equal(registeredPlugins) {
		// Developer error, this should never run in.
		errs = append(errs, fmt.Errorf("plugins %v registered are not in RecommendedPluginOrder",
			registeredPlugins.Difference(intersections).List()))
	}

     * The component identifier of the input artifact.
     */
    ComponentIdentifier getComponentId();

    /**
     * The from attributes of the registered transform.
     */
    Map<String, String> getFromAttributes();

    /**
     * The to attributes of the registered transform.
     */
    Map<String, String> getToAttributes();

    /**
     * The file name of the input artifact that is about to be transformed.

When a task is registered, it is known to the build.
It can be configured, and references to it can be passed around, but the task object itself has not been created, and its actions have not been executed.
The registered task will remain in this state until something in the build needs the instantiated task object.

        def otherObj = container.register("otherObj") {
            prop = 'value'
        }
        then:
        someObj.present
        otherObj.get().prop == 'value'
    }

    def "can find registered objects"() {
        when:
        container.register("someObj")
        container.register("otherObj") {
            prop = 'value'
        }
        def someObj = container.named("someObj")

// that provides the filesystem functionality. However, the POSIX filesystem
// needs to be statically registered in some tests and utilities for building
// the API files at the time of creating the pip package. Hence, we need to
// expose this function so that this filesystem can be statically registered
// when needed.
void TF_InitPlugin(TF_FilesystemPluginInfo* info);

        then:
        0 * _

        when:
        broadcast.something("12")

        then:
        1 * listener.something("12")
        0 * _
    }

    def "creates stateful listener registered after broadcaster is created"() {
        def created = Mock(Runnable)
        def listener = Mock(TestListener)

        when:
        def broadcast = listenerManager.getBroadcaster(TestListener)

        if (hasExtension(name)) {
            throw new IllegalArgumentException(
                format("Cannot add extension with name '%s', as there is an extension already registered with that name.", name));
        }
        extensions.put(name, new ExtensionHolder<>(name, publicType, extension));
    }

    public boolean hasExtension(String name) {
        return extensions.containsKey(name);

                    .contextualLabel("is registered as a software type plugin but does not expose a software type")
                    .severity(Severity.ERROR)

type format struct {
	name, magic  string
	decode       func(io.Reader) (Image, error)
	decodeConfig func(io.Reader) (Config, error)
}

// Formats is the list of registered formats.
var (
	formatsMu     sync.Mutex
	atomicFormats atomic.Value
)

// RegisterFormat registers an image format for use by [Decode].
// Name is the name of the format, like "jpeg" or "png".

	// Transport configured with proxy_url if set optionally.
	transport http.RoundTripper

	// The subnet base URL
	BaseURL string
}

var configLock sync.RWMutex

// Registered indicates if cluster is registered or not
func (c *Config) Registered() bool {
	configLock.RLock()
	defer configLock.RUnlock()

	return len(c.APIKey) > 0
}