*
   * <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);

  /**

    assertFalse(future.isDone());
    assertFalse(future.isCancelled());
    assertThrows(TimeoutException.class, () -> future.get(0, MILLISECONDS));
    nested.set("foo");
    assertTrue(future.isDone());
    assertFalse(future.isCancelled());
    assertEquals("foo", future.get());
  }

  private static class Foo {}

  private static class FooChild extends Foo {}

        configField.setAccessible(true);
        assertSame(mockConfig, configField.get(response));

        // Verify queryAddress is set
        Field queryAddressField = NodeStatusResponse.class.getDeclaredField("queryAddress");
        queryAddressField.setAccessible(true);
        assertSame(mockQueryAddress, queryAddressField.get(response));

        // Verify recordName is initialized

              int index = keys().asList().indexOf(k);
              return values().asList().get(index + 1);
            });
    List<Entry<K, V>> expectedEntries = new ArrayList<>();
    for (Entry<K, V> entry : getSampleEntries()) {
      int index = keys().asList().indexOf(entry.getKey());
      expectedEntries.add(Helpers.mapEntry(entry.getKey(), values().asList().get(index + 1)));
    }
    expectContents(expectedEntries);
  }

    }

    /**
     * Get the file path
     * @return the path
     */
    public String getPath() {
        return path;
    }

    /**
     * Get the create GUID
     * @return the create GUID
     */
    public HandleGuid getCreateGuid() {
        return createGuid;
    }

    /**
     * Get the file ID
     * @return copy of the 16-byte file ID

            endpoint = val.toString();
            final String lep = endpoint.toLowerCase();
            if (lep.startsWith("\\pipe\\")) {
                final String iface = (String) INTERFACES.get(lep.substring(6));
                if (iface != null) {
                    int c, p;
                    c = iface.indexOf(':');
                    p = iface.indexOf('.', c + 1);

            result.setContent(DfTypeUtil.toString(source.get("content")));
            result.setCreatedBy(DfTypeUtil.toString(source.get("createdBy")));
            result.setCreatedTime(DfTypeUtil.toLong(source.get("createdTime")));
            result.setSortOrder(DfTypeUtil.toInteger(source.get("sortOrder")));
            result.setTerm(DfTypeUtil.toString(source.get("term")));

                active++;
            }
        }

        return Map.of("totalAllocated", totalAllocated.get(), "totalReleased", totalReleased.get(), "totalLeaks", totalLeaks.get(),
                "activeResources", active, "closedResources", closed, "trackedResources", activeResources.size());
    }

    /**
     * Get active resource information
     *
     * @return set of active resource descriptions
     */

  private val isConscryptPreferred: Boolean
    get() {
      val preferredProvider = Security.getProviders()[0].name
      return "Conscrypt" == preferredProvider
    }

  private val isOpenJSSEPreferred: Boolean
    get() {
      val preferredProvider = Security.getProviders()[0].name
      return "OpenJSSE" == preferredProvider
    }

  private val isBouncyCastlePreferred: Boolean
    get() {

  public void testGet_valid() {
    // This calls get() on each index and checks the result:
    expectContents(createOrderedArray());
  }

  public void testGet_negative() {
    assertThrows(IndexOutOfBoundsException.class, () -> getList().get(-1));
  }

  public void testGet_tooLarge() {
    assertThrows(IndexOutOfBoundsException.class, () -> getList().get(getNumElements()));
  }