e.cause.message == "Could not find any public constructor for ${SomeType} which accepts parameters [java.lang.Object]."

        when:
        instantiator.newInstance(SomeType, "a", "b")

        then:
        e = thrown()
        e.cause.message == "Could not find any public constructor for ${SomeType} which accepts parameters [java.lang.String, java.lang.String]."

        when:

	testCases := []struct {
		accept   string
		expected string
	}{
		{
			// Misconstructed/incorrect accept headers should be passed to the unaggregated handler to return an error
			accept:   "application/json;foo=bar",
			expected: "unaggregated",
		}, {
			// Empty accept headers are valid and should be handled by the unaggregated handler
			accept:   "",
			expected: "unaggregated",
		}, {

        ConnectionAcceptor acceptor = Mock()
        Action<ObjectConnection> connectAction = Mock()
        RemoteConnection<InterHubMessage> backingConnection = Mock()
        ManagedExecutor executor = Mock()
        ConnectCompletion completion = Mock()
        Action<ConnectCompletion> acceptAction
        def connection

        when:
        server.accept(connectAction)

        then:

        ["value2"] as Set,
        ["value2", "value3"] as Set,
    ] as Set

    def "accept single values"() {
        when:
        checkValidCombinations([value])

        then:
        noExceptionThrown()

        where:
        value << ["value1", "value2"]
    }

    def "accept multiple values"() {
        when:
        checkValidCombinations(combination)

        then:

}

// AcceptUnix accepts the next incoming call and returns the new
// connection.
func (l *UnixListener) AcceptUnix() (*UnixConn, error) {
	if !l.ok() {
		return nil, syscall.EINVAL
	}
	c, err := l.accept()
	if err != nil {
		return nil, &OpError{Op: "accept", Net: l.fd.net, Source: nil, Addr: l.fd.laddr, Err: err}
	}
	return c, nil
}

 */
public interface PluginResolution {

    /**
     * The ID of the resolved plugin.
     */
    PluginId getPluginId();

    /**
     * Accepts a visitor and visits the resolved plugin.
     */
    default void accept(PluginResolutionVisitor visitor) { }

    /**
     * Apply the plugin to the provided plugin manager.
     */
    void applyTo(PluginManagerInternal pluginManager);

    /**

        @Override
        void resolve(DependencyMetadata dependency, VersionSelector acceptor, VersionSelector rejector, BuildableComponentIdResolveResult result) {
            if (!acceptor.isDynamic()) {
                def id = DefaultModuleComponentIdentifier.newId(DefaultModuleIdentifier.newId(moduleId.group, moduleId.name), acceptor.selector)
                resolvedOrRejected(id, rejector, result)
                return

		t.Skip("skipping in short mode")
	}

	timeout := 100 * time.Microsecond
	for !t.Failed() {
		acceptc := make(chan net.Conn)
		listener := newLocalListener(t)
		go func() {
			for {
				conn, err := listener.Accept()
				if err != nil {
					close(acceptc)
					return
				}
				acceptc <- conn
			}
		}()

		addr := listener.Addr().String()
		dialer := &net.Dialer{
			Timeout: timeout,

                  Implementations MAY choose to accept a Gateway with some Conflicted
                  Listeners only if they only accept the partial Listener set that contains
                  no Conflicted Listeners. To put this another way, implementations may
                  accept a partial Listener set only if they throw out *all* the conflicting

	}

	ln := newLocalListener(t, "tcp")
	done := make(chan struct{})
	go func() {
		var accepted []Conn
		defer func() {
			for _, c := range accepted {
				c.Close()
			}
			close(done)
		}()

		for {
			c, err := ln.Accept()
			if err != nil {
				return
			}
			accepted = append(accepted, c)
		}
	}()

	var dialed []Conn
	defer func() {
		ln.Close()
		for _, c := range dialed {