assertTrue(ex instanceof CIFSException, "Should be a CIFSException subtype");

        // Assert throwing/catching behavior with assertThrows
        SMBProtocolDecodingException thrown = assertThrows(SMBProtocolDecodingException.class, () -> {
            throw new SMBProtocolDecodingException();
        }, "Should be throwable via assertThrows");

  public void testGetRandomAccess() {
    Multimap<String, Integer> multimap = create();
    multimap.put("foo", 1);
    multimap.put("foo", 3);
    assertFalse(multimap.get("foo") instanceof RandomAccess);
    assertFalse(multimap.get("bar") instanceof RandomAccess);
  }

  /**
   * Confirm that removeAll() returns a List that implements RandomAccess, even though get()
   * doesn't.
   */

   * they are returned by the iterable's iterator.
   *
   * @since 12.0
   */
  public static <E> ArrayDeque<E> newArrayDeque(Iterable<? extends E> elements) {
    if (elements instanceof Collection) {
      return new ArrayDeque<>((Collection<? extends E>) elements);
    }
    ArrayDeque<E> deque = new ArrayDeque<>();
    Iterables.addAll(deque, elements);
    return deque;
  }

     */
    @Override
    public boolean renewCredentials(final String locationHint, final Throwable error) {
        final Credentials cred = getCredentials();
        if (cred instanceof final SmbRenewableCredentials renewable) {
            final CredentialsInternal renewed = renewable.renew();
            if (renewed != null) {
                this.creds = renewed;
                return true;

            final CacheEntry<Map<String, CacheEntry<DfsReferralDataInternal>>> entry = new CacheEntry<>(tf.getConfig().getDfsTtl() * 10L);
            this._domains = entry;
            if (tf.getConfig().isDfsStrictView() && ioe instanceof SmbAuthException) {
                throw (SmbAuthException) ioe;
            }
            return this._domains.map;
        }
        return null;
    }

    /**
     *
     * {@inheritDoc}

        // First call should create a new Handler
        URLStreamHandler handler1 = cifsContextWrapper.getUrlHandler();
        assertNotNull(handler1);
        assertTrue(handler1 instanceof Handler);

        // Second call should return the same instance
        URLStreamHandler handler2 = cifsContextWrapper.getUrlHandler();
        assertEquals(handler1, handler2);
    }

    @Test
    void testGetSIDResolver() {

        assertEquals(NbtException.getErrorString(errorClass, errorCode), exception.getMessage(),
                "Exception message should match getErrorString output");
        assertTrue(exception instanceof CIFSException, "NbtException should be an instance of CIFSException");
    }

    /**
     * Test the getErrorString method with various error classes and codes to ensure all branches are covered.
     */
    @ParameterizedTest

        checkState(newMap instanceof MapMakerInternalMap);
        newMap.putAll(map);
        return newMap;
      }
    },
    MapMakerStrongKeysWeakValues {
      @Override
      public <K extends Comparable<K>, V> Map<K, V> create(Map<K, V> map) {
        ConcurrentMap<K, V> newMap = new MapMaker().weakValues().makeMap();
        checkState(newMap instanceof MapMakerInternalMap);
        newMap.putAll(map);

                }

                return loc;
            } else {
                if (!t.isInDomainDfs() || (request instanceof NtTransQuerySecurityDesc) || (request instanceof SmbComClose)
                        || (request instanceof SmbComFindClose2)) {
                    log.trace("Not in DFS");
                    return loc;
                }
                if (log.isDebugEnabled()) {

  }

  public static final class NullsBeforeB extends NullsBefore {
    public static final NullsBeforeB INSTANCE = new NullsBeforeB();

    private NullsBeforeB() {
      super("b");
    }
  }

  public static final class NullsBeforeTwo extends NullsBefore {
    public static final NullsBeforeTwo INSTANCE = new NullsBeforeTwo();

    private NullsBeforeTwo() {