*
   * @return {@code true} always
   */
  @CanIgnoreReturnValue
  @Override
  public boolean add(E element) {
    offer(element);
    return true;
  }

  @CanIgnoreReturnValue
  @Override
  public boolean addAll(Collection<? extends E> newElements) {
    boolean modified = false;
    for (E element : newElements) {
      offer(element);
      modified = true;
    }

    private static final String OR_ALT = " || ";

    private static final String OR = " OR ";

    private static final String SPACE = " ";

    private SearchRequestParams params;

    private boolean escape = false;

    private String sortField;

    protected String quote(final String value) {
        if (value.split("\\s").length > 1) {

   * @throws NullPointerException if the specified element is null
   */
  @CanIgnoreReturnValue // pushed down from class to method
  @Override
  public boolean offer(E e) {
    final Monitor monitor = this.monitor;
    monitor.enter();
    try {
      boolean ok = q.offer(e);
      if (!ok) {
        throw new AssertionError();
      }
      return true;
    } finally {
      monitor.leave();
    }
  }

  public void testRoundIntegralDoubleToInt() {
    for (double d : INTEGRAL_DOUBLE_CANDIDATES) {
      for (RoundingMode mode : ALL_SAFE_ROUNDING_MODES) {
        BigDecimal expected = new BigDecimal(d).setScale(0, mode);
        boolean isInBounds =
            expected.compareTo(MAX_INT_AS_BIG_DECIMAL) <= 0
                & expected.compareTo(MIN_INT_AS_BIG_DECIMAL) >= 0;

        try {

        entry = entry.nextInVToKBucket) {
      if (valueHash == entry.valueHash && Objects.equal(value, entry.value)) {
        return entry;
      }
    }
    return null;
  }

  @Override
  public boolean containsKey(@CheckForNull Object key) {
    return seekByKey(key, smearedHash(key)) != null;
  }

  /**
   * Returns {@code true} if this BiMap contains an entry whose value is equal to {@code value} (or,

public class FilteredMultimapTest extends TestCase {

  private static final Predicate<Entry<String, Integer>> ENTRY_PREDICATE =
      new Predicate<Entry<String, Integer>>() {
        @Override
        public boolean apply(Entry<String, Integer> entry) {
          return !"badkey".equals(entry.getKey()) && !((Integer) 55556).equals(entry.getValue());
        }
      };

  protected Multimap<String, Integer> create() {

      }

      @Override
      public boolean contains(@CheckForNull Object object) {
        return object != null && Collections2.safeContains(delegate, object);
      }

      @Override
      public boolean containsAll(Collection<?> collection) {
        return standardContainsAll(collection);
      }

      @Override
      public boolean remove(@CheckForNull Object object) {

      };
    }

    @Override
    public boolean contains(@CheckForNull Object object) {
      if (object instanceof Entry) {
        Entry<?, ?> entry = (Entry<?, ?>) object;
        Object k = entry.getKey();
        Object v = entry.getValue();
        return v != null && v.equals(map.get(k));
      }
      return false;
    }

    @Override
    boolean isPartialView() {
      return true;
    }

    }

    public String getPackageName() {
        return packageName;
    }

    public boolean isInterface() {
        return metaType == MetaType.INTERFACE;
    }

    public boolean isGroovy() {
        return isGroovy;
    }

    public boolean isEnum() {
        return metaType == MetaType.ENUM;
    }

    public String getSuperClassName() {
        return superClassName;

        // nothing
    }

    @Override
    public void invokeOrderBy(String columnFlexibleName, boolean isAsc) {
        // nothing
    }

    @Override
    public ConditionQuery invokeForeignCQ(String foreignPropertyName) {
        return null;
    }

    @Override
    public boolean invokeHasForeignCQ(String foreignPropertyName) {
        return false;
    }

    @Override