* uninterruptibly.
   */
  @J2ktIncompatible
  @GwtIncompatible // concurrency
  @SuppressWarnings("GoodTime") // should accept a java.time.Duration
  public static boolean awaitUninterruptibly(CountDownLatch latch, long timeout, TimeUnit unit) {
    boolean interrupted = false;
    try {
      long remainingNanos = unit.toNanos(timeout);

        @DisplayName("Should decode with actual free units skipped")
        void testDecodeSkipsActualFreeUnits() throws SMBProtocolDecodingException {
            byte[] buffer = new byte[32];
            // total allocation units (8 bytes)
            buffer[4] = 0x01;
            // caller available allocation units (8 bytes)
            buffer[12] = 0x01;
            // actual free units (8 bytes) - should be skipped

        // Read total allocation units.
        info.alloc = readInt8(buffer, bufferIndex);
        bufferIndex += 8;

        // read caller available allocation units
        info.free = readInt8(buffer, bufferIndex);
        bufferIndex += 8;

        // skip actual free units
        bufferIndex += 8;

        info.sectPerAlloc = readInt4(buffer, bufferIndex);

    public V get(long timeout, TimeUnit unit)
        throws InterruptedException, ExecutionException, TimeoutException {
      Preconditions.checkNotNull(unit, "unit must not be null!");
      return get();
    }

    @Override
    public long getDelay(TimeUnit unit) {
      Preconditions.checkNotNull(unit, "unit must not be null!");
      return 0;
    }

    @Override
    public int compareTo(Delayed other) {

    public V get(long timeout, TimeUnit unit)
        throws InterruptedException, ExecutionException, TimeoutException {
      Preconditions.checkNotNull(unit, "unit must not be null!");
      return get();
    }

    @Override
    public long getDelay(TimeUnit unit) {
      Preconditions.checkNotNull(unit, "unit must not be null!");
      return 0;
    }

    @Override
    public int compareTo(Delayed other) {

    TimeUnit lastUnit;

    void assertLastMethodCalled(String method, long delay, TimeUnit unit) {
      assertEquals(method, lastMethodCalled);
      assertEquals(delay, lastDelay);
      assertEquals(unit, lastUnit);
    }

    void assertLastMethodCalled(String method, long initialDelay, long delay, TimeUnit unit) {
      assertEquals(method, lastMethodCalled);
      assertEquals(initialDelay, lastInitialDelay);

    delegate().putLast(e);
  }

  @Override
  public boolean offerFirst(E e, long timeout, TimeUnit unit) throws InterruptedException {
    return delegate().offerFirst(e, timeout, unit);
  }

  @Override
  public boolean offerLast(E e, long timeout, TimeUnit unit) throws InterruptedException {
    return delegate().offerLast(e, timeout, unit);
  }

  @Override
  public E takeFirst() throws InterruptedException {

    }
    {
      MockExecutor mock = new MockExecutor();
      TimeUnit unit = SECONDS;
      long timeout = 5;
      TestExecutor testExecutor = new TestExecutor(mock);
      List<Future<String>> futures = testExecutor.invokeAll(tasks, timeout, unit);
      mock.assertMethodWithTimeout("invokeAll", timeout, unit);
      checkResults(futures);
    }
  }

    delegate().putLast(e);
  }

  @Override
  public boolean offerFirst(E e, long timeout, TimeUnit unit) throws InterruptedException {
    return delegate().offerFirst(e, timeout, unit);
  }

  @Override
  public boolean offerLast(E e, long timeout, TimeUnit unit) throws InterruptedException {
    return delegate().offerLast(e, timeout, unit);
  }

  @Override
  public E takeFirst() throws InterruptedException {

  @Override
  public final ScheduledFuture<?> schedule(Runnable command, long delay, TimeUnit unit) {
    return delegate.schedule(wrapTask(command), delay, unit);
  }

  @Override
  public final <V extends @Nullable Object> ScheduledFuture<V> schedule(
      Callable<V> task, long delay, TimeUnit unit) {
    return delegate.schedule(wrapTask(task), delay, unit);
  }

  @Override
  public final ScheduledFuture<?> scheduleAtFixedRate(