assertTrue("containsValue(present) should return true", getMap().containsValue(v0()));
  }

  public void testContains_no() {
    assertFalse("containsValue(notPresent) should return false", getMap().containsValue(v3()));
  }

  @MapFeature.Require(ALLOWS_NULL_VALUE_QUERIES)
  public void testContains_nullNotContainedButAllowed() {
    assertFalse("containsValue(null) should return false", getMap().containsValue(null));
  }

        if (eventSpies.isEmpty()) {
            return listener;
        }
        return new EventSpyExecutionListener(this, listener);
    }

    public RepositoryListener chainListener(RepositoryListener listener) {
        if (eventSpies.isEmpty()) {
            return listener;
        }
        return new EventSpyRepositoryListener(this, listener);
    }

      this.gen = gen;
    }

    @Override
    public SampleElements<E> samples() {
      return gen.samples();
    }

    @Override
    public Collection<E> create(Object... elements) {
      return SerializableTester.reserialize(gen.create(elements));
    }

    @Override
    public E[] createArray(int length) {
      return gen.createArray(length);
    }

    @Override

            version.append(ls).append("Terminal: ").append(terminal);
        }
        return version.toString();
    }

    public static String showVersionMinimal() {
        Properties properties = getBuildProperties();
        String version = reduce(properties.getProperty(BUILD_VERSION_PROPERTY));
        return (version != null ? version : "<version unknown>");
    }

    /**

  }

  @Override
  int firstEntryIndex() {
    return firstEntry;
  }

  @Override
  int adjustAfterRemove(int indexBeforeRemove, int indexRemoved) {
    return (indexBeforeRemove >= size()) ? indexRemoved : indexBeforeRemove;
  }

  @Override
  public void clear() {
    if (needsAllocArrays()) {
      return;
    }
    this.firstEntry = ENDPOINT;
    this.lastEntry = ENDPOINT;

            return false;
        } else if (!a.getArtifactId().equals(getArtifactId())) {
            return false;
        } else if (!a.getVersion().equals(getVersion())) {
            return false;
        } else if (!a.getType().equals(getType())) {
            return false;
        } else {
            return a.getClassifier() == null
                    ? getClassifier() == null

     */
    @Override
    public final long getLastAccessTime () {
        return this.lastAccessTime;
    }


    /**
     * @return the lastWriteTime
     */
    @Override
    public final long getLastWriteTime () {
        return this.lastWriteTime;
    }


    /**
     * @return the changeTime
     */
    public final long getChangeTime () {

            this.id = id;
            myuniqueByProperty("_id");
            return this;
        }

        public String id() {
            return id;
        }

        public DocMeta version(Long version) {
            this.version = version;
            return this;
        }

        public Long version() {
            return version;
        }

        public DocMeta seqNo(Long seqNo) {

    if (object == null) {
      return false;
    }
    try {
      @SuppressWarnings("unchecked") // The worst case is usually CCE, which we catch.
      C c = (C) object;
      return range.contains(c);
    } catch (ClassCastException e) {
      return false;
    }
  }

  @Override
  public boolean containsAll(Collection<?> targets) {
    return Collections2.containsAllImpl(this, targets);
  }

    @Override
    public String asTableDbName() {
        return asEsIndexType();
    }

    @Override
    protected String asEsIndex() {
        return "fess_config.boost_document_rule";
    }

    @Override
    public String asEsIndexType() {
        return "boost_document_rule";
    }

    @Override
    public String asEsSearchType() {
        return "boost_document_rule";
    }

    @Override