.isEqualTo(defaultThread.getUncaughtExceptionHandler());

    assertFalse(completed);
    thread.start();
    thread.join();
    assertTrue(completed);

    // Creating a new thread from the same ThreadFactory will have the same
    // pool ID but a thread ID of 2.
    Thread thread2 = threadFactory.newThread(monitoredRunnable);
    checkThreadPoolName(thread2, 2);

   * {@link Multimap} interface.
   */
  @CanIgnoreReturnValue
  @Override
  SortedSet<V> removeAll(@Nullable Object key);

  /**
   * Stores a collection of values with the same key, replacing any existing values for that key.
   *
   * <p>Because a {@code SortedSetMultimap} has unique sorted values for a given key, this method

 * the network with enhanced capabilities compared to the basic Open command.
 */
public class SmbComOpenAndX extends AndXServerMessageBlock {

    // flags (not the same as flags constructor argument)
    static final int FLAGS_RETURN_ADDITIONAL_INFO = 0x01;
    static final int FLAGS_REQUEST_OPLOCK = 0x02;
    static final int FLAGS_REQUEST_BATCH_OPLOCK = 0x04;

        assertNotNull(buf, "getBuffer should never return null");
        assertEquals(5, buf.length, "Newly allocated buffer length should match config maximum size");
    }

    // Happy path: get -> release -> get returns same instance, zeroed on release
    @Test
    @DisplayName("Release stores buffer for reuse and zeroes its contents")
    void releaseStoresAndZeroesBuffer() {
        BufferCacheImpl impl = new BufferCacheImpl(2, 10);

import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.isNull;
import static org.mockito.ArgumentMatchers.same;
import static org.mockito.Mockito.doAnswer;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;

        assertEquals("/site1/search", result.getRoutingPath());

        // The header remains for subsequent tests due to static request handling
        // Different matching header added to same request
        request.addHeader("X-Forwarded-Host", "test.com");
        result = virtualHostHelper.getVirtualHostPath(page);
        assertEquals("/site1/search", result.getRoutingPath()); // Still site1 due to header precedence

        void testValueConsistency() {
            // Given: Same input value
            int inputValue = 1000;
            int expectedMasked = inputValue & 0xFF; // 232

            // When: Creating multiple NdrShort instances
            NdrShort ndrShort1 = new NdrShort(inputValue);
            NdrShort ndrShort2 = new NdrShort(inputValue);

            // Then: All should have same masked value

    mergeAdjacentDeltaMappedRanges(sectionList)
  }

  return result.toMap()
}

/**
 * Modifies [ranges] to combine any adjacent [MappedRange.InlineDelta] of same size to single entry.
 * @returns same instance of [ranges] for convenience
 */
internal fun mergeAdjacentDeltaMappedRanges(ranges: MutableList<MappedRange>): MutableList<MappedRange> {
  var i = 0
  while (i < ranges.size) {

    assertBitEquals(1.0, at.get());
    for (double x : VALUES) {
      at.set(x);
      assertBitEquals(x, at.get());
    }
  }

  /** get returns the last value lazySet in same thread */
  public void testGetLazySet() {
    AtomicDouble at = new AtomicDouble(1.0);
    assertBitEquals(1.0, at.get());
    for (double x : VALUES) {
      at.lazySet(x);
      assertBitEquals(x, at.get());
    }

        int referent1 = Encdec.dec_uint32le(buffer, 0);
        assertTrue(referent1 > 0); // Should be a positive referent ID

        ndrBuffer.reset();
        ndrBuffer.enc_ndr_referent(obj1, 2); // Same object, should get same referent
        assertEquals(4, ndrBuffer.getIndex());
        assertEquals(referent1, Encdec.dec_uint32le(buffer, 0));

        ndrBuffer.reset();