connection.flush()
      cancelStreamIfNecessary()
    }
  }

  companion object {
    internal const val EMIT_BUFFER_SIZE = 16384L
  }

  /** [delta] will be negative if a settings frame initial window is smaller than the last. */
  fun addBytesToWriteWindow(delta: Long) {
    writeBytesMaximum += delta
    if (delta > 0L) {
      notifyAll()
    }
  }

  @Throws(IOException::class)

    @DisplayName("Path Consumed Tests")
    class PathConsumedTests {

        @Test
        @DisplayName("Should strip path consumed correctly")
        void testStripPathConsumed() {
            // Set initial pathConsumed using fromReferral
            setupReferralDataWithPathConsumed(10);

            referralData.stripPathConsumed(5);
            assertEquals(5, referralData.getPathConsumed());
        }

            assertEquals(2000L * 16 * 1024, fileFsFullSizeInfo.getCapacity());
            assertEquals(1500L * 16 * 1024, fileFsFullSizeInfo.getFree());
        }

        @Test
        @DisplayName("Should have initial zero state")
        void shouldHaveInitialZeroState() {
            // Given - newly created instance
            FileFsFullSizeInformation freshInfo = new FileFsFullSizeInformation();

            // Then

    assertSame(NULL_TICKER, map.ticker);

    assertEquals(4, map.concurrencyLevel);

    // concurrency level
    assertThat(map.segments).hasLength(4);
    // initial capacity / concurrency level
    assertEquals(16 / map.segments.length, map.segments[0].table.length());

    assertFalse(map.evictsBySize());
    assertFalse(map.expires());
    assertFalse(map.expiresAfterWrite());

     * NodeAndRemainingSuccessors} instance to the stack. In the latter case, we'll compute the
     * successors if we determine that we need them after we've performed the initial processing of
     * the node.
     */
    @Nullable Queue<N> remainingSuccessors;

    NodeAndRemainingSuccessors(N node) {
      this.node = node;
    }
  }

  /**

     * NodeAndRemainingSuccessors} instance to the stack. In the latter case, we'll compute the
     * successors if we determine that we need them after we've performed the initial processing of
     * the node.
     */
    @Nullable Queue<N> remainingSuccessors;

    NodeAndRemainingSuccessors(N node) {
      this.node = node;
    }
  }

  /**

   * in Waiter.
   */

  /**
   * This field encodes the current state of the future.
   *
   * <p>The valid values are:
   *
   * <ul>
   *   <li>{@code null} initial state, nothing has happened.
   *   <li>{@link Cancellation} terminal state, {@code cancel} was called.
   *   <li>{@link Failure} terminal state, {@code setException} was called.

 * provide two {@code static} creation methods: {@code create()}, returning an empty multiset, and
 * {@code create(Iterable<? extends E>)}, returning a multiset containing the given initial
 * elements. This is simply a refinement of {@code Collection}'s constructor recommendations.
 *
 * <p>As with other collection types, the modification operations are optional, and should throw

   * that are not the first to be added or last to be removed for their key.
   */
  private transient int modCount;

  /** Creates a new, empty {@code LinkedListMultimap} with the default initial capacity. */
  public static <K extends @Nullable Object, V extends @Nullable Object>
      LinkedListMultimap<K, V> create() {
    return new LinkedListMultimap<>();
  }

  /**

   * in Waiter.
   */

  /**
   * This field encodes the current state of the future.
   *
   * <p>The valid values are:
   *
   * <ul>
   *   <li>{@code null} initial state, nothing has happened.
   *   <li>{@link Cancellation} terminal state, {@code cancel} was called.
   *   <li>{@link Failure} terminal state, {@code setException} was called.