defer w.Close()
	defer r.Close()

	copied := make(chan bool)

	var wg sync.WaitGroup
	wg.Add(1)
	go func() {
		// Accept a connection and copy 1 byte from the read end of
		// the pipe to the connection. This will call into sendfile.
		defer wg.Done()
		conn, err := ln.Accept()
		if err != nil {
			t.Error(err)
			return
		}
		defer conn.Close()

  /** The HTTP {@code Accept} header field name. */
  public static final String ACCEPT = "Accept";
  /** The HTTP {@code Accept-Charset} header field name. */
  public static final String ACCEPT_CHARSET = "Accept-Charset";
  /** The HTTP {@code Accept-Encoding} header field name. */
  public static final String ACCEPT_ENCODING = "Accept-Encoding";
  /** The HTTP {@code Accept-Language} header field name. */

  /** The HTTP {@code Accept} header field name. */
  public static final String ACCEPT = "Accept";
  /** The HTTP {@code Accept-Charset} header field name. */
  public static final String ACCEPT_CHARSET = "Accept-Charset";
  /** The HTTP {@code Accept-Encoding} header field name. */
  public static final String ACCEPT_ENCODING = "Accept-Encoding";
  /** The HTTP {@code Accept-Language} header field name. */

                String previousWatchedRoot = watchedDirectoryForSnapshot.remove(snapshot.getAbsolutePath());
                decrement(previousWatchedRoot, changedWatchedDirectories);
                snapshot.accept(new SubdirectoriesToWatchVisitor(path -> decrement(path, changedWatchedDirectories)));
            });
        addedSnapshots.stream()
            .filter(watchableHierarchies::shouldWatch)
            .forEach(snapshot -> {

				afterDial = time.Now()

				if err != nil {
					break
				}

				// Even though we're not calling Accept on the Listener, the kernel may
				// spuriously accept connections on its behalf. If that happens, we will
				// close the connection (to try to get it out of the kernel's accept
				// queue) and try a shorter timeout.
				//
				// We assume that we will reach a point where the call actually does

        if (requiredVersionSelector != null) {
            accepted = requiredVersionSelector.accept(candidate);
        } else if (preferredVersionSelector != null) {
            accepted = preferredVersionSelector.accept(candidate);
        }
        if (accepted && rejectedVersionsSelector != null) {
            accepted = !rejectedVersionsSelector.accept(candidate);
        }
        return accepted;
    }

    @Override

        connection.startListening(connectionArgs)

        if (acceptAsync) {
            Thread.start {
                accept()
            }
        }
    }

    def accept() {
        while (vm == null) {
            try {
                vm = connection.accept(connectionArgs)
                connection = null
            } catch (Exception e) {
            }
        }
    }

    /**

        this.connector = connector;
        this.executorFactory = executorFactory;
    }

    @Override
    public ConnectionAcceptor accept(Action<ObjectConnection> action) {
        return connector.accept(new ConnectEventAction(action), false);
    }

    private class ConnectEventAction implements Action<ConnectCompletion> {
        private final Action<ObjectConnection> action;

     *     public static final int CALCULATE_ACCESSIBLE_CONSTANT = CONSTANT;
     * }
     */
    public void consumeAccessibleDependent(String constantOrigin, String constantDependent) {
        accessibleDependentDelegate.accept(constantOrigin, constantDependent);
    }

    /**
     * Consume "private" dependents of a constant.
     *
     * Example of private constant dependent:
     * class A {
     *     public static int method() {

    def userInputHandler = new NonInteractiveUserInputHandler()

    def "always returns null for yes/no question"() {
        expect:
        userInputHandler.askYesNoQuestion('Accept license?') == null
        userInputHandler.askUser { it.askYesNoQuestion('Accept license?') }.getOrNull() == null
    }

    def "always returns default for select question"() {
        expect: