Consider an application streaming a video over http/2. Perhaps the user pauses the video and the application stops reading bytes from this stream. The buffer will fill up, and flow control prevents the server from sending more data on this stream. When the user unpauses her video the buffer drains, the read is acknowledged, and the server proceeds to stream data.

#### Shared reader thread

// client setting, note this will fail if set to empty when
// constructor initializes.
func DomainNames(domainNames []string) EtcdOption {
	return func(args *CoreDNS) {
		args.domainNames = domainNames
	}
}

// DomainIPs set a list of custom domain IPs, note this will
// fail if set to empty when constructor initializes.
func DomainIPs(domainIPs set.StringSet) EtcdOption {

 * support them). All optional multimap methods are supported, and all returned views are
 * modifiable.
 *
 * <p>This class is not threadsafe when any concurrent operations update the multimap. Concurrent
 * read operations will work correctly. To allow concurrent update operations, wrap your multimap
 * with a call to {@link Multimaps#synchronizedSortedSetMultimap}.
 *

   *
   * <p>The resulting set's iterator does not support {@code remove()}, but all other set methods
   * are supported. When given an element that doesn't satisfy the predicate, the set's {@code
   * add()} and {@code addAll()} methods throw an {@link IllegalArgumentException}. When methods
   * such as {@code removeAll()} and {@code clear()} are called on the filtered set, only elements

        // Act: create wrapper using delegate, then acquire and release once
        SmbTreeConnectionTrace wrapper = new SmbTreeConnectionTrace(delegate);
        wrapper.acquire();
        wrapper.release();

        // Assert: delegate interactions occur when usage transitions happen
        verify(delegate, times(1)).acquire();
        verify(delegate, times(1)).release();

 * Sec-WebSocket-Extensions: permessage-deflate; server_max_window_bits="15";
 *     client_max_window_bits="15"; server_no_context_takeover; client_no_context_takeover
 * ```
 *
 * If any other extension or parameter is specified, then [unknownValues] will be true. Such
 * responses should be refused as their web socket extensions will not be understood.
 *
 * Note that [java.util.zip.Deflater] is hardcoded to use 15 bits (32 KiB) for

        dataStore.stop();
        dataStore.stop();

        assertEquals(3, stopCallCount.get());
    }

    @Test
    public void test_store_and_stop_lifecycle() {
        // Test full lifecycle: store then stop
        final AtomicBoolean storeCalled = new AtomicBoolean(false);
        final AtomicBoolean stopCalled = new AtomicBoolean(false);
        final AtomicBoolean isActive = new AtomicBoolean(false);

func NewWriter(w io.Writer) *Writer {
	return &Writer{cw: &countWriter{w: bufio.NewWriter(w)}}
}

// SetOffset sets the offset of the beginning of the zip data within the
// underlying writer. It should be used when the zip data is appended to an
// existing file, such as a binary executable.
// It must be called before any data is written.
func (w *Writer) SetOffset(n int64) {
	if w.cw.count != 0 {

   * When multiple elements are equivalent according to {@code compareTo()}, only the first one
   * specified is included. To create a copy of a {@code SortedSet} that preserves the comparator,
   * call {@link #copyOfSorted} instead. This method iterates over {@code elements} at most once.
   *
   * <p>Note that if {@code s} is a {@code Set<String>}, then {@code ImmutableSortedSet.copyOf(s)}

			// If there is no claim-based provider configured, then an
			// unrecognized roleArn is an error
			if strings.TrimSpace(iamPolicyClaimNameOpenID()) == "" {
				writeSTSErrorResponse(ctx, w, ErrSTSInvalidParameterValue,
					fmt.Errorf("Error processing %s parameter: %v", stsRoleArn, err))
				return
			}
			// If there *is* a claim-based provider configured, then
			// treat an unrecognized roleArn the same as no roleArn