@CanIgnoreReturnValue // TODO(b/27479612): consider removing this
  @Override
  public V get(K key) throws ExecutionException {
    return delegate().get(key);
  }

  @CanIgnoreReturnValue // TODO(b/27479612): consider removing this
  @Override
  public V getUnchecked(K key) {
    return delegate().getUnchecked(key);
  }

  @CanIgnoreReturnValue // TODO(b/27479612): consider removing this
  @Override

     *
     * @return the share this referral points to
     */
    String getShare();

    /**
     * Get the number of characters from the UNC path that were consumed by this referral
     *
     * @return the number of characters from the unc path that were consumed by this referral
     */
    int getPathConsumed();

    /**
     * Get the replacement path for this referral
     *

            assertEquals(free * sectPerAlloc * bytesPerSect, fileFsSizeInfo.getFree());
        }

        @Test
        @DisplayName("Should return correct number of bytes consumed from buffer")
        void shouldReturnCorrectBytesConsumed() throws SMBProtocolDecodingException {
            // Given - larger buffer than needed
            byte[] buffer = new byte[100];

   */
  @CanIgnoreReturnValue // TODO(kak): consider removing this
  @Override
  protected final <T extends @Nullable Object> RunnableFuture<T> newTaskFor(Callable<T> callable) {
    return TrustedListenableFutureTask.create(callable);
  }

  @CanIgnoreReturnValue // TODO(kak): consider removing this
  @Override
  public ListenableFuture<?> submit(Runnable task) {

 * limitations under the License.
 */
package okhttp3.internal.http2.flowcontrol

class WindowCounter(
  val streamId: Int,
) {
  /** The total number of bytes consumed. */
  var total: Long = 0L
    private set

  /** The total number of bytes acknowledged by outgoing `WINDOW_UPDATE` frames. */
  var acknowledged: Long = 0L
    private set

  val unacknowledged: Long

      idx += doParseTrieToBuilder(new ArrayDeque<>(), encoded, idx, builder);
    }

    return builder.buildOrThrow();
  }

  /**
   * Parses a trie node and returns the number of characters consumed.
   *
   * @param stack The prefixes that precede the characters represented by this node. Each entry of
   *     the stack is in reverse order.
   * @param encoded The serialized trie.

- Dynamic resource allocation: when a claim uses "wait for first consumer" allocation (the default), then it will now get deallocated after it was used by a pod. That ensures that the next pod isn't affected by previous scheduling decision and that resources are not kept allocated unless really needed. If keeping a claim...

import okhttp3.internal.http.parseChallenges
import okio.Buffer
import okio.Socket

/**
 * An HTTP response. Instances of this class are not immutable: the response body is a one-shot
 * value that may be consumed only once and then closed. All other properties are immutable.
 *
 * This class implements [Closeable]. Closing it simply closes its response body. See
 * [ResponseBody] for an explanation and examples.
 */

        assertEquals(2, sis.read());

        // Read second message
        assertEquals(3, sis.read());
        assertEquals(4, sis.read());
        assertEquals(5, sis.read());

        // After all data is consumed, next read throws IOException
        assertThrows(IOException.class, () -> sis.read());
    }

    @Test
    @DisplayName("EOF handling when stream ends mid-header")

        assertEquals("smb://dfs-server/dfs-share" + l.getUNCPath().replace('\\', '/'), l.getDfsPath());
        assertEquals("dfs-share", l.getShare());

        // Path consumed negative -> coerced to 0
        when(dr.getPathConsumed()).thenReturn(-1);
        String unc2 = l.handleDFSReferral(dr, null);
        assertTrue(unc2.contains("dfs/path") || unc2.contains("dfs\\path"));
    }