assertTrue(descendingKeySet instanceof SynchronizedNavigableSet);
    assertSame(mutex, ((SynchronizedNavigableSet<String>) descendingKeySet).mutex);
  }

  public void testDescendingMap() {
    NavigableMap<String, Integer> map = create();
    NavigableMap<String, Integer> descendingMap = map.descendingMap();
    assertTrue(descendingMap instanceof SynchronizedNavigableMap);

        try {
            if (value instanceof String) {
                if ("Subject".equals(key)) {
                    data.putValue(key, getDecodeText(value.toString()));
                } else {
                    data.putValue(key, value.toString());
                }
            } else if (value instanceof String[]) {
                data.putValues(key, (String[]) value);

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

  /** Confirm that removeAll() returns a List implementing RandomAccess. */
  public void testRemoveAllRandomAccess() {
    Multimap<String, Integer> multimap = create();

     * @param f2
     * @throws CIFSException
     */
    private static void connectionMatches ( SmbResource f1, SmbResource f2 ) throws CIFSException {
        Assert.assertTrue(f1 instanceof SmbFile);
        Assert.assertTrue(f2 instanceof SmbFile);
        try ( SmbTreeHandleInternal th1 = (SmbTreeHandleInternal) ( (SmbFile) f1 ).getTreeHandle();

  @CollectionFeature.Require(SUPPORTS_ADD)
  public void testAddAll_nullCollectionReference() {
    assertThrows(NullPointerException.class, () -> collection.addAll(null));
  }

  /**
   * Returns the {@link Method} instance for {@link #testAddAll_nullUnsupported()} so that tests can
   * suppress it with {@code FeatureSpecificTestSuiteBuilder.suppressing()} until <a

      return new short[buckets];
    } else {
      return new int[buckets];
    }
  }

  static void tableClear(Object table) {
    if (table instanceof byte[]) {
      Arrays.fill((byte[]) table, (byte) 0);
    } else if (table instanceof short[]) {
      Arrays.fill((short[]) table, (short) 0);
    } else {
      Arrays.fill((int[]) table, 0);
    }
  }

  /**

 *
 * <p>However, when {@link CollectionSize.Require} is used to annotate a test it behaves normally
 * (i.e. it requires the collection instance under test to be a certain size for the test to run).
 * Note that this means a test should not require more than one CollectionSize, since a particular
 * collection instance can only be one size at once.
 *
 * @author George van den Driessche
 */

import org.checkerframework.checker.nullness.qual.NonNull;
import org.checkerframework.checker.nullness.qual.Nullable;

/**
 * A map, each entry of which maps a Java <a href="http://tinyurl.com/2cmwkz">raw type</a> to an
 * instance of that type. In addition to implementing {@code Map}, the additional type-safe
 * operations {@link #putInstance} and {@link #getInstance} are available.
 *

            if (update && getResponse.isExists()) {
                final IndexRequestBuilder indexRequestBuilder = new IndexRequestBuilder(client, IndexAction.INSTANCE, index);
                indexRequestBuilder.setId(item.getId()).setOpType(IndexRequest.OpType.INDEX)
                        .setSource(item.getUpdatedSource(getResponse.getSourceAsMap()));

  internal val delegate: RealConnectionPool,
) {
  internal constructor(
    maxIdleConnections: Int = 5,
    keepAliveDuration: Long = 5,
    timeUnit: TimeUnit = TimeUnit.MINUTES,
    taskRunner: TaskRunner = TaskRunner.INSTANCE,
    connectionListener: ConnectionListener = ConnectionListener.NONE,
    readTimeoutMillis: Int = 10_000,
    writeTimeoutMillis: Int = 10_000,
    socketConnectTimeoutMillis: Int = 10_000,