Set<Feature<?>> features = computeMultimapAsMapGetFeatures(parentBuilder.getFeatures());
    if (Collections.disjoint(features, EnumSet.allOf(CollectionSize.class))) {
      return new TestSuite();
    } else {
      return SetTestSuiteBuilder.using(
              new MultimapAsMapGetGenerator<K, V>(parentBuilder.getSubjectGenerator()))
          .withFeatures(features)
          .named(parentBuilder.getName() + ".asMap[].get[key]")

  static <V extends @Nullable Object> TrustedListenableFutureTask<V> create(
      AsyncCallable<V> callable) {
    return new TrustedListenableFutureTask<>(callable);
  }

  static <V extends @Nullable Object> TrustedListenableFutureTask<V> create(Callable<V> callable) {
    return new TrustedListenableFutureTask<>(callable);
  }

  /**

@NullUnmarked
public class FunnelsTest extends TestCase {
  public void testForBytes() {
    PrimitiveSink primitiveSink = mock(PrimitiveSink.class);
    Funnels.byteArrayFunnel().funnel(new byte[] {4, 3, 2, 1}, primitiveSink);
    verify(primitiveSink).putBytes(new byte[] {4, 3, 2, 1});
  }

  public void testForBytes_null() {
    assertNullsThrowException(Funnels.byteArrayFunnel());
  }

  public void testForStrings() {

      enumConstantCache = new WeakHashMap<>();

  private static <T extends Enum<T>> Map<String, WeakReference<? extends Enum<?>>> populateCache(
      Class<T> enumClass) {
    Map<String, WeakReference<? extends Enum<?>>> result = new HashMap<>();
    for (T enumInstance : EnumSet.allOf(enumClass)) {
      result.put(enumInstance.name(), new WeakReference<Enum<?>>(enumInstance));
    }

        // Test that DcerpcException can be created and implements DcerpcError
        DcerpcException ex1 = new DcerpcException("Test error", null);
        assertTrue(ex1 instanceof DcerpcError, "DcerpcException should implement DcerpcError");

        // Test that DcerpcException can be created with string messages
        DcerpcException ex2 = new DcerpcException("Access denied error");

            rpc.retval = 0; // Simulate success
            return null;
        }).when(mockDcerpcHandle).sendrecv(any(MsrpcSamrOpenAlias.class));

        // Act
        SamrAliasHandle aliasHandle = new SamrAliasHandle(mockDcerpcHandle, mockSamrDomainHandle, access, rid);

        // Assert
        assertNotNull(aliasHandle);
        // Verify that sendrecv was called with the correct MsrpcSamrOpenAlias object

            return updateEntity(source, result);
        } catch (InstantiationException | IllegalAccessException e) {
            final String msg = "Cannot create a new instance: " + entityType.getName();
            throw new IllegalBehaviorStateException(msg, e);
        }
    }

    protected <RESULT extends UserInfo> RESULT updateEntity(Map<String, Object> source, RESULT result) {
        return result;
    }

            return updateEntity(source, result);
        } catch (InstantiationException | IllegalAccessException e) {
            final String msg = "Cannot create a new instance: " + entityType.getName();
            throw new IllegalBehaviorStateException(msg, e);
        }
    }

    protected <RESULT extends CrawlingInfoParam> RESULT updateEntity(Map<String, Object> source, RESULT result) {
        return result;

            return updateEntity(source, result);
        } catch (InstantiationException | IllegalAccessException e) {
            final String msg = "Cannot create a new instance: " + entityType.getName();
            throw new IllegalBehaviorStateException(msg, e);
        }
    }

    protected <RESULT extends RoleType> RESULT updateEntity(Map<String, Object> source, RESULT result) {
        return result;
    }

    private final RdmaBufferManager bufferManager;
    private final RdmaStatistics statistics;
    private RdmaConnection rdmaConnection;
    private final Object connectionLock = new Object();

    /**
     * Creates a new RDMA transport wrapping the given delegate transport.
     *
     * @param delegate the underlying SMB transport to wrap
     * @param context the CIFS context for configuration
     */