.stream()
                            .filter(p -> Pattern.compile(p.getValue()).matcher(kv.getValue()).find())
                            .map(p -> "- " + p.getKey() + " on line " + kv.getKey() + " of " + path)
                    )
                    .collect(Collectors.toList())
            );
        }
        if (failures.isEmpty() == false) {

      super(HashBiMap.this);
    }

    @Override
    public boolean contains(@Nullable Object o) {
      if (o instanceof Entry) {
        Entry<?, ?> e = (Entry<?, ?>) o;
        Object k = e.getKey();
        Object v = e.getValue();
        int eIndex = findEntryByKey(k);
        return eIndex != ABSENT && Objects.equals(v, values[eIndex]);
      }
      return false;
    }

    super(delegate);

    ImmutableMap.Builder<V, K> builder = ImmutableMap.builder();
    for (Entry<K, V> entry : delegate.entrySet()) {
      builder.put(entry.getValue(), entry.getKey());
    }
    ImmutableMap<V, K> backwardMap = builder.build();
    this.inverse = new RegularImmutableBiMap<V, K>(backwardMap, this);
  }

            final String key = e.getKey();
            String value = e.getValue();
            for (final Map.Entry<String, String> entry : paramEnvMap.entrySet()) {
                value = value.replace("${" + entry.getKey() + "}", entry.getValue());
            }
            return new Pair<>(key, value);

        if (headers != null) {
            final Map<String, List<String>> map = new HashMap<>();
            headers.entrySet().stream().filter(e -> e.getKey() != null).forEach(
                    e -> map.put(e.getKey().toLowerCase(Locale.ROOT), e.getValue() == null ? List.of() : List.copyOf(e.getValue())));
            this.headers = Map.copyOf(map);
        }
    }

    /**

      protected Entry<Class<? extends @NonNull B>, B> delegate() {
        return entry;
      }

      @Override
      @ParametricNullness
      public B setValue(@ParametricNullness B value) {
        cast(getKey(), value);
        return super.setValue(value);
      }
    };
  }

  @Override
  public Set<Entry<Class<? extends @NonNull B>, B>> entrySet() {

            filterSplitPackages(splitPackages);

            // Finally, print out (and fail) if we have any split packages
            for (var entry : splitPackages.entrySet()) {
                String packageName = entry.getKey();
                List<File> deps = dependencyPackages.get(packageName);
                List<String> msg = new ArrayList<>();

  public void testPutDuplicateValue() {
    List<Entry<K, V>> entries = copyToList(multimap().entries());

    for (Entry<K, V> entry : entries) {
      resetContainer();

      K k = entry.getKey();
      V v = entry.getValue();

      List<V> values = multimap().get(k);
      List<V> expectedValues = copyToList(values);

      assertTrue(multimap().put(k, v));
      expectedValues.add(v);

                headersNode = new ObjectNode(jsonNodeFactory);
            }

            for (Map.Entry<String, String> entry : headers.entrySet()) {
                headersNode.set(entry.getKey(), TextNode.valueOf(entry.getValue()));
            }
            doNodeValue.set("headers", headersNode);
        }
    }

    private boolean shouldApplyHeaders(ObjectNode doNodeValue) {

    }
  }

  @Override
  final Iterator<E> elementIterator() {
    return new Itr<E>() {
      @Override
      @ParametricNullness
      E result(int entryIndex) {
        return backingMap.getKey(entryIndex);
      }
    };
  }

  @Override
  final Iterator<Entry<E>> entryIterator() {
    return new Itr<Entry<E>>() {
      @Override
      Entry<E> result(int entryIndex) {