assertFalse(target.isOpen());
        assertTrue(target.isStale());
    }

    @Test
    @DisplayName("getInput and getOutput throw after close")
    void testGetInputOutputAndClosed() throws CIFSException {
        // After closing the handle, further calls throw
        target.close();
        CIFSException e1 = assertThrows(SmbException.class, target::getInput);

   *
   * <p>If {@code !range.contains(k)}, {@link #get(Comparable) get(k)} will return the same result
   * before and after a call to {@code remove(range)}. If {@code range.contains(k)}, then after a
   * call to {@code remove(range)}, {@code get(k)} will return {@code null}.
   */
  void remove(Range<K> range);

  /**

  }

  @Override
  protected void tearDown() throws Exception {

    // Make sure we have no waiting threads.
    latch.countDown();
  }

  /** Constructs a listenable future with a value available after the latch has counted down. */
  protected abstract <V> ListenableFuture<V> createListenableFuture(
      V value, @Nullable Exception except, CountDownLatch waitOn);

        Executors.newSingleThreadScheduledExecutor(new ThreadFactoryImpl());
    // Add a listener to shut down the executor after the service is stopped. This ensures that the
    // JVM shutdown will not be prevented from exiting after this service has stopped or failed.
    // Technically this listener is added after start() was called so it is a little gross, but it

 * Cache} interfaces. The {@code asMap} view (and its collection views) have <i>weakly consistent
 * iterators</i>. This means that they are safe for concurrent use, but if other threads modify the
 * cache after the iterator is created, it is undefined which of these changes, if any, are
 * reflected in that iterator. These iterators never throw {@link ConcurrentModificationException}.
 *

import jcifs.internal.smb1.ServerMessageBlock;
import jcifs.internal.util.SMBUtil;

/**
 * SMB1 Seek command response implementation.
 * Handles server responses to file seek operations, returning the new file
 * position after a seek request in SMB1 protocol file operations.
 *
 * @author mbechler
 */
public class SmbComSeekResponse extends ServerMessageBlock {

    private long offset;

    /**
     * Constructs a seek response.

	}
	left, err := v.UnmarshalMsg(bts)
	if err != nil {
		t.Fatal(err)
	}
	if len(left) > 0 {
		t.Errorf("%d bytes left over after UnmarshalMsg(): %q", len(left), left)
	}

	left, err = msgp.Skip(bts)
	if err != nil {
		t.Fatal(err)
	}
	if len(left) > 0 {
		t.Errorf("%d bytes left over after Skip(): %q", len(left), left)
	}
}

func BenchmarkMarshalMsghealingTracker(b *testing.B) {
	v := healingTracker{}

        long allocatedBeforeCleanup = bufferManager.getTotalAllocated();

        // Cleanup should not throw exception
        assertDoesNotThrow(() -> bufferManager.cleanup());

        // After cleanup, all regions should be released (but the count may not match exactly
        // if some regions were pooled rather than immediately released)

   * #collectValueFromNonCancelledFuture}. As this is called after the subclass is constructed,
   * we're guaranteed to have properly initialized the subclass.
   */
  final void init() {
    /*
     * requireNonNull is safe because this is called from the constructor after `futures` is set but
     * before releaseResources could be called (because we have not yet set up any of the listeners

        // Act
        blob.set(null);

        // Assert
        assertNotNull(blob.get(), "get() should return non-null after set(null)");
        assertEquals(0, blob.length(), "length() should be 0 after set(null)");
        assertEquals("", blob.toString(), "toString() should be empty after set(null)");
    }

    // Verifies constructor stores the exact array reference and exposes it via get()
    @Test