set.CreateStringSet("dep1", "dep2", "dep3"),
			set.CreateStringSet("dep1", "dep2", "dep3", "dep4"),
			[]string{},
		},
		// Test3: not currently under site replication.
		{
			[]madmin.PeerInfo{},
			set.CreateStringSet(),
			set.CreateStringSet("dep1", "dep2", "dep3", "dep4"),
			[]string{},
		},
	}

	for i, tc := range testCases {

	c.infReads.Store(t.IsZero())
	c.infWrites.Store(t.IsZero())
	return c.Conn.SetDeadline(t)
}

// SetReadDeadline sets the deadline for future Read calls
// and any currently-blocked Read call.
// A zero value for t means Read will not time out.
func (c *DeadlineConn) SetReadDeadline(t time.Time) error {
	c.mu.Lock()
	defer c.mu.Unlock()
	c.abortReads.Store(!t.IsZero() && time.Until(t) < 0)

      int64_t init_timeout_in_ms, int retries,
      bool clear_existing_contexts = false) = 0;

  // Initializes context for the local worker and no contexts will be created
  // for remote workers. Currently this only works for resetting context.
  // TODO(b/289445025): Consider removing this when we find a proper fix.
  virtual absl::Status InitializeLocalOnlyContext(const ServerDef& server_def,

        getMultiset().setCount(e0(), 1, 5));
    expectContents(nCopies(3, e0()));
  }

  /*
   * TODO: test that unmodifiable multisets either throw UOE or return false
   * when both are valid options. Currently we test the UOE cases and the
   * return-false cases but not their intersection
   */

 * @param <E> the element type
 */
public class MultiIterator<E> implements Iterator<E> {

    /** Array of {@link Iterator}s. */
    protected final Iterator<E>[] iterators;

    /** Index of the currently iterated {@link Iterator}. */
    protected int index;

    /**
     * Returns an {@link Iterable} that wraps a {@link MultiIterator} for use in a for-each statement.
     *
     * @param <E> the element type

    /**
     * {@inheritDoc}
     *
     * @see java.lang.AutoCloseable#close()
     */
    @Override
    void close() throws CIFSException;

    /**
     * Checks whether the tree is currently connected
     * @return the tree is connected
     */
    boolean isConnected();

    /**
     * Gets the server timezone offset in milliseconds
     * @return server timezone offset

 *
 * @author mbechler
 *
 * <p>This interface is intended for internal use.</p>
 */
public interface SmbSessionInternal extends SmbSession {

    /**
     * Determines whether this session is currently in use.
     *
     * @return whether the session is in use
     */
    boolean isInUse();

    /**
     * Returns the current session key used for signing and encryption.
     *

    }

    private gradlebuild.docs.dsl.docbook.model.ClassDoc loadClassDoc(String className) {
        if (currentlyBuilding.contains(className)) {
            throw new RuntimeException("Cycle building $className. Currently building $currentlyBuilding")
        }
        currentlyBuilding.addLast(className)
        try {
            ClassMetaData classMetaData = classMetaData.find(className)
            if (!classMetaData) {

// Enabled - indicates if callhome is enabled or not
func (c *Config) Enabled() bool {
	configLock.RLock()
	defer configLock.RUnlock()

	return c.Enable
}

// FrequencyDur - returns the currently configured callhome frequency
func (c *Config) FrequencyDur() time.Duration {
	configLock.RLock()
	defer configLock.RUnlock()

	if c.Frequency == 0 {
		return callhomeCycleDefault
	}

	return c.Frequency

     */
    public static final int CIPHER_AES256_GCM = 0x4;

    private int[] ciphers;

    /**
     * Constructs an encryption negotiate context.
     *
     * @param config the configuration (currently unused)
     * @param ciphers array of encryption cipher IDs to negotiate
     */
    public EncryptionNegotiateContext(final Configuration config, final int ciphers[]) {
        this.ciphers = ciphers;
    }