assertTrue(result);
        ArgumentCaptor<Integer> captor = ArgumentCaptor.forClass(Integer.class);
        verify(handle, times(1)).hasCapability(captor.capture());
        assertEquals(cap, captor.getValue());
    }

    @Test
    @DisplayName("hasCapability(cap): propagates CIFSException on failure")
    void hasCapability_throws() throws Exception {
        // Arrange

    // If it's an Entry, it may become invalid once it's removed from the Map. Copy it.
    if (element instanceof Entry) {
      Entry<?, ?> entry = (Entry<?, ?>) element;
      element = mapEntry(entry.getKey(), entry.getValue());
    }
    assertTrue(collection.contains(element)); // sanity check
    iterator.remove();
    assertFalse(collection.contains(element));
    assertEquals(originalSize - 1, collection.size());
  }

                    ListMultimap<String, String> multimap = ArrayListMultimap.create();
                    for (Entry<String, String> entry : entries) {
                      multimap.put(entry.getKey(), entry.getValue());
                    }
                    return multimap;
                  }
                })
            .named("ArrayListMultimap")
            .withFeatures(
                MapFeature.ALLOWS_NULL_KEYS,

        // - Memory usage
        // - System stats
        // etc.

        for (Map.Entry<String, Object> entry : res.entrySet()) {
            logger.info("Stats field: {} = {}", entry.getKey(), entry.getValue());
        }

        logger.info("[END] statsContentTest");
    }

    @Test
    void statsResponseFormatTest() {
        logger.info("[BEGIN] statsResponseFormatTest");

   * Returns a map view that associates each key with the corresponding values in the multimap.
   * Changes to the returned map, such as element removal, will update the underlying multimap. The
   * map does not support {@code setValue()} on its entries, {@code put}, or {@code putAll}.
   *
   * <p>When passed a key that is present in the map, {@code asMap().get(Object)} has the same

        // Extract artifact from all POMs in the project
        for (Map.Entry<Path, Document> entry : pomMap.entrySet()) {
            Path pomPath = entry.getKey();
            Document pomDocument = entry.getValue();

            Coordinates coordinate =
                    AbstractUpgradeStrategy.extractArtifactCoordinatesWithParentResolution(context, pomDocument);
            if (coordinate != null) {

  }

  private static void insertIntoReplica(Map<Integer, AtomicInteger> replica, int newValue) {
    if (replica.containsKey(newValue)) {
      replica.get(newValue).incrementAndGet();
    } else {
      replica.put(newValue, new AtomicInteger(1));
    }
  }

  private static void removeMinFromReplica(
      SortedMap<Integer, AtomicInteger> replica, int minValue) {

    assertThrows(UnsupportedOperationException.class, () -> fromIterator.setValue(2));
    Entry<String, Integer> fromToArray = (Entry<String, Integer>) unmod.entries().toArray()[0];
    assertThrows(UnsupportedOperationException.class, () -> fromToArray.setValue(2));
    Entry<String, Integer>[] array = (Entry<String, Integer>[]) new Entry<?, ?>[2];

        checkNotNull(cell.getColumnKey(), "column");
        checkNotNull(cell.getValue(), "value");
        @SuppressWarnings("unchecked") // all supported methods are covariant
        Cell<R, C, V> immutableCell = (Cell<R, C, V>) cell;
        cells.add(immutableCell);
      } else {
        put(cell.getRowKey(), cell.getColumnKey(), cell.getValue());
      }
      return this;
    }

    /**

   * underlying multimap, and vice versa. The map does not support {@code put} or {@code putAll},
   * nor do its entries support {@link Entry#setValue setValue}.
   */
  Map<K, Collection<V>> asMap();

  // Comparison and hashing

  /**
   * Compares the specified object with this multimap for equality. Two multimaps are equal when