private List<E> values;
  private E a;
  private E b;
  private E c;

  @Override
  public void setUp() throws Exception {
    super.setUp();
    navigableSet = (NavigableSet<E>) getSet();
    values =
        copyToList(
            getSubjectGenerator()
                .getSampleElements(getSubjectGenerator().getCollectionSize().getNumElements()));
    sort(values, navigableSet.comparator());

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

        Map<String, String> map = new HashMap<String, String>();
        map.put("key1", "value1");
        map.put("key2", "value2");
        StreamUtil.stream(map).of(s -> s.forEach(m -> assertEquals(map.get(m.getKey()), m.getValue())));
    }

  private static final Predicate<@Nullable Integer> EVEN = input -> input == null || input % 2 == 0;
  static final Predicate<Entry<String, Integer>> CORRECT_LENGTH =
      input -> input.getKey().length() == input.getValue();

  abstract Map<String, Integer> createUnfiltered();

  public void testFilteredKeysIllegalPut() {
    Map<String, Integer> unfiltered = createUnfiltered();

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

                                + repository.getId() + " (" + repository.getUrl() + ")");
            }

            return false;
        }

        if (getLogger().isDebugEnabled()) {
            getLogger()
                    .debug("Determining update check for " + metadata.getKey() + " (" + file + ") from "

            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];

            }

            try {
                for (int i = 0; i < tokens.size(); i++) {
                    final AnalyzeToken token = tokens.get(i);
                    final String word = token.getTerm();
                    if (StringUtil.isBlank(word)) {
                        continue;
                    }
                    final String[] words = { word };