u:    u,
		rest: rest.NewClient(u, tr, nil),
	}
}

// Close closes the underlying socket file descriptor.
func (restClient *ReconnectRESTClient) IsOnline() bool {
	// If rest client has not connected yet there is nothing to close.
	return restClient.rest != nil
}

func (restClient *ReconnectRESTClient) IsLocal() bool {
	return false
}

// Close closes the underlying socket file descriptor.

// Connection represents an upgraded HTTP connection.
type Connection interface {
	// CreateStream creates a new Stream with the supplied headers.
	CreateStream(headers http.Header) (Stream, error)
	// Close resets all streams and closes the connection.
	Close() error
	// CloseChan returns a channel that is closed when the underlying connection is closed.
	CloseChan() <-chan bool
	// SetIdleTimeout sets the amount of time the connection may remain idle before

        8        | 9        | false
        8        | 10       | false
        8        | 11       | false
    }

    @Unroll("disamgiguates when consumer=#consumer and candidates=#candidates chooses=#expected")
    def "check disambiguation rules"() {
        MultipleCandidatesResult details = Mock()

        when:
        disambiguationRules.execute(details)

        then:

public interface BlockStore {
    /**
     * Opens this store, calling the given action if the store is empty.
     */
    void open(Runnable initAction, Factory factory);

    /**
     * Closes this store.
     */
    void close();

    /**
     * Discards all blocks from this store.
     */
    void clear();

    /**
     * Removes the given block from this store.
     */

package cmd

import (
	"flag"
	"os"
	"os/signal"
	"syscall"

	"github.com/spf13/cobra"
	"github.com/spf13/pflag"

	"istio.io/istio/pkg/log"
)

// WaitSignal awaits for SIGINT or SIGTERM and closes the channel
func WaitSignal(stop chan struct{}) {
	sigs := make(chan os.Signal, 1)
	signal.Notify(sigs, syscall.SIGINT, syscall.SIGTERM)
	<-sigs
	close(stop)
	_ = log.Sync()
}

class LatestModuleConflictResolverTest extends AbstractConflictResolverTest {

    def setup() {
        resolver = new LatestModuleConflictResolver(new DefaultVersionComparator(), new VersionParser())
    }

    def "chooses latest module version #version for candidates #candidates"() {
        given:
        candidateVersions candidates

        when:
        resolveConflicts()

        then:
        selected version

  @CheckForNull private Reader current;

  MultiReader(Iterator<? extends CharSource> readers) throws IOException {
    this.it = readers;
    advance();
  }

  /** Closes the current reader and opens the next one, if any. */
  private void advance() throws IOException {
    close();
    if (it.hasNext()) {
      current = it.next().openStream();
    }
  }

  @Override

  @CheckForNull private Reader current;

  MultiReader(Iterator<? extends CharSource> readers) throws IOException {
    this.it = readers;
    advance();
  }

  /** Closes the current reader and opens the next one, if any. */
  private void advance() throws IOException {
    close();
    if (it.hasNext()) {
      current = it.next().openStream();
    }
  }

  @Override

	c := make([]byte, len(src))
	w.S.XORKeyStream(c, src)
	n, err = w.W.Write(c)
	if n != len(src) && err == nil { // should never happen
		err = io.ErrShortWrite
	}
	return
}

// Close closes the underlying Writer and returns its Close return value, if the Writer
// is also an io.Closer. Otherwise it returns nil.
func (w StreamWriter) Close() error {
	if c, ok := w.W.(io.Closer); ok {
		return c.Close()
	}

 * <li>The client sends a {@link Finished} message once it has received the {@link Result} message.
 *     It may no longer send any messages.</li>
 * <li>The client closes the connection.</li>
 * <li>The daemon closes the connection once it has received the {@link Finished} message.</li>
 * </ul>
 *
 * <p>To stop a daemon:</p>
 *
 * <ul>
 * <li>The client creates a connection to daemon.</li>