}

    def "accepts candidate version iff it literally matches the selector"() {
        expect:
        accept("", "")
        accept("1.0", "1.0")
        accept("2.0", "2.0")
        accept("!@#%", "!@#%")
        accept("hey joe", "hey joe")
        !accept("1.0", "1.1")
        !accept("2.0", "3.0")
        !accept("!@#%", "%#@!")
        !accept("hey joe", "hoe hey")
    }

        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:

 */
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);

    /**

	}

	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 {

                            LOGGER.error("Cannot accept connection from remote address {}.", remoteInetAddress);
                            socket.close();
                            continue;
                        }
                        LOGGER.debug("Accepted connection from {} to {}.", socket.socket().getRemoteSocketAddress(), socket.socket().getLocalSocketAddress());

    public static final String QUESTION = "Accept license?"
    public static final String YES = 'yes'
    public static final String NO = 'no'
    public static final byte EOF = 4
    public static final String PROMPT = "$QUESTION [$YES, $NO]"
    private static final String ANSWER_PREFIX = 'License accepted:'

    private BuildScanUserInputFixture() {}

    static String buildScanPlugin() {

        return String.format(
                "The closure '%s' is not valid as an action for argument '%s'. It should accept no parameters, or one compatible with type '%s'. It accepts (%s).",
                closure, argument, argument.getClass().getName(), CollectionUtils.join(", ", classNames)
        );
    }

    /**
     * The closure being used as an action.