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
}

    /**
     * Retrieves a deployment handle from the registry with the given name and type.
     *
     * @return the registered deployment handle; null if no deployment is registered with the given name
     */
    @Nullable
    <T extends DeploymentHandle> T get(String name, Class<T> handleType);

    /**
     * Behavior when a deployment is out-of-date.
     */

        << "Previously registered pass with the same priority: "
        << inserted.first->pass->name().str();
  }

  // Free the memory allocated for all passes.
  void ClearPasses() { passes_.clear(); }

  const Passes& passes() const { return passes_; }

 private:
  Passes passes_;
};

// Function optimization pass that runs all MLIR passes registered in
// MlirOptimizationPassRegistry.

        def fooFactory1 = factory(Foo)
        def fooFactory2 = factory(Foo)

        when:
        registry.withFactories(fooFactory1, fooFactory2)

        then:
        def e = thrown(IllegalArgumentException)
        e.message.matches("A managed factory with type [^\\s]+ \\(id: [^\\s]+\\) has already been registered.")
    }

func (o *DefaultResourceEncodingConfig) StorageEncodingFor(resource schema.GroupResource) (schema.GroupVersion, error) {
	if !o.scheme.IsGroupRegistered(resource.Group) {
		return schema.GroupVersion{}, fmt.Errorf("group %q is not registered in scheme", resource.Group)
	}

	resourceOverride, resourceExists := o.resources[resource]
	if resourceExists {
		return resourceOverride.ExternalResourceEncoding, nil
	}

        return registry;
    }

    /**
     * Returns the list of {@link ResolutionFailureDescriber}s registered for the given {@link ResolutionFailure} type.
     *
     * @param failureType The type of failure to describe
     * @param <FAILURE> The type of failure to describe
     * @return The list of describers registered for the given failure type
     */