ImmutableRangeSet.<Integer>builder()
            .add(Range.closed(5, 8))
            .add(Range.closedOpen(1, 3))
            .build();

    assertThrows(UnsupportedOperationException.class, () -> rangeSet.remove(Range.closed(6, 7)));
  }

  @SuppressWarnings("DoNotCall")
  public void testRemoveAllUnsupported() {
    RangeSet<Integer> rangeSet =
        ImmutableRangeSet.<Integer>builder()

   * @deprecated Unsupported operation.
   */
  @CanIgnoreReturnValue
  @Deprecated
  @Override
  @DoNotCall("Always throws UnsupportedOperationException")
  public final @Nullable V remove(@Nullable Object rowKey, @Nullable Object columnKey) {
    throw new UnsupportedOperationException();
  }

  /**
   * Serialized type for all ImmutableTable instances. It captures the logical contents and

    @Test
    @DisplayName("Canonical and UNC paths are computed and stable")
    void testCanonicalAndUNCPaths() {
        SmbResourceLocatorImpl a = locator("smb://server/share/dir/.././file");
        // canonicalization removes . and resolves ..
        assertEquals("/share/file", a.getURLPath());
        assertEquals("\\file", a.getUNCPath());
        assertEquals("share", a.getShare());

    if (bufs.isEmpty()) {
      return new byte[0];
    }
    byte[] result = bufs.remove();
    if (result.length == totalLen) {
      return result;
    }
    int remaining = totalLen - result.length;
    result = Arrays.copyOf(result, totalLen);
    while (remaining > 0) {
      byte[] buf = bufs.remove();
      int bytesToCopy = min(remaining, buf.length);
      int resultOffset = totalLen - remaining;

      return connection.client == streamIsClient
    }

  val isSourceComplete: Boolean
    get() = withLock { source.finished && source.readBuffer.exhausted() }

  /**
   * Removes and returns the stream's received response headers, blocking if necessary until headers
   * have been received. If the returned list contains multiple blocks of headers the blocks will be
   * delimited by 'null'.
   *

                                    doc.get(fessConfig.getIndexFieldUrl()));
                        }
                        doc.remove(thumbnailField);
                    }
                });
            }
            final CrawlingConfigHelper crawlingConfigHelper = ComponentUtil.getCrawlingConfigHelper();

                SuggestItem.Kind.USER);
    }

    /**
     * Common method to delete words by kind.
     * @param freqField The frequency field name.
     * @param kindToRemove The kind to remove.
     * @param freqSetter The consumer to set frequency to 0.
     * @param excludeKinds The kinds to exclude from deletion.
     * @return The SuggestDeleteResponse.
     */

        // title
        if (!hasTitle(dataMap)) {
            final String titleField = fessConfig.getIndexFieldTitle();
            dataMap.remove(titleField);
            if (url.endsWith("/")) {
                if (StringUtil.isNotBlank(content)) {
                    putResultDataBody(dataMap, titleField, documentHelper.getDigest(responseData, body, dataMap,

            if (rule != null) {
                rules.add(index, rule);
            }
        }

        @Override
        public boolean removeRule(Rule rule) {
            return rules.remove(rule);
        }

        @Override
        public boolean hasRule(Rule rule) {
            return rules.contains(rule);
        }

        public List<Rule> getRules() {

 *     Reference<?> reference = new FinalizablePhantomReference<MyServer>(myServer, frq) {
 *       @Override
 *       public void finalizeReferent() {
 *         references.remove(this):
 *         if (!serverSocket.isClosed()) {
 *           ...log a message about how nobody called close()...
 *           try {
 *             serverSocket.close();
 *           } catch (IOException e) {