null,
                        "version of a plugin must be defined. ",
                        plugin);
            }

            String key = plugin.getKey();

            Plugin existing = index.get(key);

            if (existing != null) {
                addViolation(
                        problems,
                        errOn31,

    return (result == null) ? elementSet = new ElementSet() : result;
  }

  @WeakOuter
  private final class ElementSet extends IndexedImmutableSet<E> {

    @Override
    E get(int index) {
      return contents.getKey(index);
    }

    @Override
    public boolean contains(@Nullable Object object) {
      return RegularImmutableMultiset.this.contains(object);
    }

    @Override
    boolean isPartialView() {

        }

        LinkRenderer linkRenderer = new LinkRenderer(doc, model);
        for (Map.Entry<String, ClassDoc> entry : extensionDoc.getExtensionClasses().entrySet()) {
            String id = entry.getKey();
            ClassDoc type = entry.getValue();
            PropertyMetaData propertyMetaData = new PropertyMetaData(id, extensionDoc.getTargetClass().getClassMetaData());

        if (!this.handle.isValid()) {
            throw new SmbException("Watch was broken by tree disconnect");
        }
        try (SmbTreeHandleImpl th = this.handle.getTree()) {

            CommonServerMessageBlockRequest req;
            NotifyResponse resp = null;
            if (th.isSMB2()) {

    @Override
    protected Map<AnEnum, String> create(Entry<AnEnum, String>[] entries) {
      Map<AnEnum, String> map = new HashMap<>();
      for (Entry<AnEnum, String> entry : entries) {
        map.put(entry.getKey(), entry.getValue());
      }
      return Maps.immutableEnumMap(map);
    }
  }

  @J2ktIncompatible
  @GwtIncompatible // suite
  @AndroidIncompatible // test-suite builders
  public static Test suite() {

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

    switch (map.size()) {
      case 0:
        return ImmutableMap.of();
      case 1:
        Entry<K, V> entry = getOnlyElement(map.entrySet());
        return ImmutableMap.of(entry.getKey(), entry.getValue());
      default:
        return new ImmutableEnumMap<>(map);
    }
  }

  private final transient EnumMap<K, V> delegate;

  private ImmutableEnumMap(EnumMap<K, V> delegate) {

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

  private static <K extends @Nullable Object, V extends @Nullable Object> Entry<K, V> entry(
      K key, V value) {
    return new AbstractMapEntry<K, V>() {
      @Override
      public K getKey() {
        return key;
      }

      @Override
      public V getValue() {
        return value;
      }
    };
  }

            elementStack.addFirst(name);
            visitor.onStartHtmlElement(name);
            for (Map.Entry<String, String> entry : attributes.entrySet()) {
                visitor.onHtmlElementAttribute(entry.getKey(), entry.getValue());
            }
            attributes.clear();
            visitor.onStartHtmlElementComplete(name);
        }

        @Override
        public void onEndHtmlElement(String name) {