deserialized[0].definition.id.name == "id"
        deserialized[0].definition.id.displayName == "label"
        deserialized[0].additionalData instanceof GeneralData
        (deserialized[0].additionalData as GeneralData).asMap == ['foo' : 'bar']
    }

    def "can serialize deprecation additional data"() {
        given:
        def problem = problemReporter.create {
            it.id("id", "label")

        }

        private Set<String> getDuplicateNames() {
            Set<String> duplicates = new LinkedHashSet<>();
            for (Entry<String, Collection<T>> entry : elementsByName.asMap().entrySet()) {
                if (entry.getValue().size() > 1) {
                    duplicates.add(entry.getKey());
                }
            }
            return duplicates;
        }

    return graph.isDirected()
        ? DirectedGraphConnections.ofImmutable(node, graph.incidentEdges(node), edgeValueFn)
        : UndirectedGraphConnections.ofImmutable(
            Maps.asMap(graph.adjacentNodes(node), edgeValueFn));
  }

  @Override
  BaseGraph<N> delegate() {
    return backingGraph;
  }

  /**

        delegate.isEmpty()

    override fun remove(element: T): Boolean =
        delegate.remove(element)

    override fun getAsMap(): SortedMap<String, T> =
        delegate.asMap

    override fun getNames(): SortedSet<String> =
        delegate.names

    override fun getByName(name: String): T =
        delegate.getByName(name)

    throw new UnsupportedOperationException();
  }

  @Override
  public CacheStats stats() {
    throw new UnsupportedOperationException();
  }

  @Override
  public ConcurrentMap<K, V> asMap() {
    throw new UnsupportedOperationException();
  }

  /**
   * Accumulates statistics during the operation of a {@link Cache} for presentation by {@link

                DisableCachingByDefault.class,
                UntrackedTask.class,
                RegistersSoftwareTypes.class
            ),
            ModifierAnnotationCategory.asMap(builder.build()),
            ImmutableSet.of(
                "java",
                "groovy",
                "kotlin"
            ),
            ImmutableSet.of(

   * concurrent use, but if the cache is modified (including by eviction) after the iterator is
   * created, it is undefined which of the changes (if any) will be reflected in that iterator.
   */
  ConcurrentMap<K, V> asMap();

  /**
   * Performs any pending maintenance operations needed by the cache. Exactly which activities are
   * performed -- if any -- is implementation-dependent.
   */
  void cleanUp();

                });
    }

    @PreDestroy
    public void destroy() {
        if (logger.isDebugEnabled()) {
            logger.debug("cache stats: {}", statsCache.stats());
        }
        statsCache.asMap().entrySet().stream().forEach(e -> {
            final StatsObject data = e.getValue();
            final Long begin = data.remove(BEGIN_KEY);
            if (begin != null) {

    return graph.isDirected()
        ? DirectedGraphConnections.ofImmutable(
            node, graph.incidentEdges(node), successorNodeToValueFn)
        : UndirectedGraphConnections.ofImmutable(
            Maps.asMap(graph.adjacentNodes(node), successorNodeToValueFn));
  }

  /**
   * A builder for creating {@link ImmutableValueGraph} instances, especially {@code static final}
   * graphs. Example:
   *
   * <pre>{@code

  }

  public void testOrderedAsMapEntries() {
    TreeMultimap<@Nullable String, @Nullable Integer> multimap = createPopulate();
    Iterator<Entry<String, Collection<Integer>>> iterator = multimap.asMap().entrySet().iterator();
    Entry<String, Collection<Integer>> entry = iterator.next();
    assertEquals(null, entry.getKey());
    assertThat(entry.getValue()).containsExactly(7, 3, 1);
    entry = iterator.next();