Collections.sort(list, (o1, o2) -> {
                final String k1 = o1.getKey();
                if (LANG_KEY.equals(k1)) {
                    return -1;
                }
                final String k2 = o2.getKey();
                if (LANG_KEY.equals(k2)) {
                    return -1;
                }
                return k1.compareTo(k2);

        final PrimaryCipher cipher = ComponentUtil.getPrimaryCipher();
        ParameterUtil.parse(value).entrySet().stream().map(e -> {
            final String k = e.getKey();
            final String v = e.getValue();
            if (properyPattern.matcher(k).matches() && !v.startsWith(CIPHER_PREFIX)) {
                return new Pair<>(k, CIPHER_PREFIX + cipher.encrypt(v));
            }

          reverse(samples.e3()),
          reverse(samples.e4()));
    }

    private Entry<V, K> reverse(Entry<K, V> entry) {
      checkNotNull(entry);
      return mapEntry(entry.getValue(), entry.getKey());
    }

    @SuppressWarnings("unchecked")
    @Override
    public BiMap<V, K> create(Object... elements) {
      Entry<?, ?>[] entries = new Entry<?, ?>[elements.length];

    newFirst = segment.removeEntryFromChain(entryThree, entryOne);
    assertThat(newFirst.getKey()).isSameInstanceAs(keyTwo);
    assertThat(newFirst.getValueReference().get()).isSameInstanceAs(valueTwo);
    assertThat(newFirst.getHash()).isEqualTo(hashTwo);
    newFirst = newFirst.getNext();
    assertThat(newFirst.getKey()).isSameInstanceAs(keyThree);
    assertThat(newFirst.getValueReference().get()).isSameInstanceAs(valueThree);

            plugin.setArtifactId(artifactId);
            plugin.setName(name);

            getMetadata().addPlugin(plugin);
        }
    }

    @Override
    public Object getKey() {
        return groupId;
    }

    @Override
    public boolean isSnapshot() {
        return false;
    }

    @Override
    public ArtifactRepository getRepository() {
        return null;

  }

  @MapFeature.Require(SUPPORTS_PUT)
  @CollectionSize.Require(absent = ZERO)
  public void testSetValue() {
    for (Entry<K, V> entry : getMap().entrySet()) {
      if (entry.getKey().equals(k0())) {
        assertEquals("entry.setValue() should return the old value", v0(), entry.setValue(v3()));
        break;
      }
    }
    expectReplacement(entry(k0(), v3()));
  }

  }

  @MapFeature.Require(SUPPORTS_PUT)
  @CollectionSize.Require(absent = ZERO)
  public void testSetValue() {
    for (Entry<K, V> entry : getMap().entrySet()) {
      if (entry.getKey().equals(k0())) {
        assertEquals("entry.setValue() should return the old value", v0(), entry.setValue(v3()));
        break;
      }
    }
    expectReplacement(entry(k0(), v3()));
  }

                            .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);
  }